+ Nie znaleziono interpretacji dla tych danych. Sprawdź, czy dodano bazę
+ zawierającą pasujące opisy.
+
+ {% endif %}
+{% endif %}
+{% endblock %}
diff --git a/services/astrodemo/app/templates/logowanie.html b/services/astrodemo/app/templates/logowanie.html
new file mode 100644
index 0000000..6af2388
--- /dev/null
+++ b/services/astrodemo/app/templates/logowanie.html
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+ {% if request.query_params.get('wylogowano') %}
+ Wylogowano.
+ {% endif %}
+ {% if blad %}{{ blad }}
{% endif %}
+
+
+
+
+ Nie masz konta albo nie pamiętasz hasła? Zgłoś się do osoby, która zakładała
+ Ci dostęp — kont nie da się odzyskać samodzielnie.
+
+
+
+
diff --git a/services/astrodemo/requirements-dev.txt b/services/astrodemo/requirements-dev.txt
new file mode 100644
index 0000000..a266747
--- /dev/null
+++ b/services/astrodemo/requirements-dev.txt
@@ -0,0 +1,2 @@
+-r requirements.txt
+pytest>=8.0
diff --git a/services/astrodemo/requirements.txt b/services/astrodemo/requirements.txt
new file mode 100644
index 0000000..1297467
--- /dev/null
+++ b/services/astrodemo/requirements.txt
@@ -0,0 +1,11 @@
+# CELOWO KRÓTSZA niż w warstwie prezentacji. Astroklient ma dwie funkcje, więc nie
+# potrzebuje ani Excela (brak eksportu), ani stref czasowych z lokalizacji (offset
+# podaje się wprost), ani niczego pod kosmogram — a każda zbędna zależność w obrazie
+# demo to kolejna rzecz do pilnowania i kolejna droga do środka.
+fastapi>=0.115
+uvicorn[standard]>=0.34
+httpx>=0.28
+jinja2>=3.1
+python-multipart>=0.0.20
+# Szyfrowanie łącza do warstwy logicznej (PRE-16): AES-256-GCM + HKDF
+cryptography>=44.0
diff --git a/services/astrodemo/tests/test_astrodemo.py b/services/astrodemo/tests/test_astrodemo.py
new file mode 100644
index 0000000..f5b4ea4
--- /dev/null
+++ b/services/astrodemo/tests/test_astrodemo.py
@@ -0,0 +1,301 @@
+"""astrodemo — wersja demonstracyjna (PRE-28).
+
+DWIE WŁASNOŚCI, KTÓRYCH PILNUJE TEN PLIK
+
+1. Demo ma DWIE funkcje i ani jednej więcej. Sprawdzamy to na trasach aplikacji,
+ nie w szablonie: trasa, o której nikt nie pamiętał, jest tu realnym ryzykiem,
+ bo ta usługa rozmawia z warstwą danych produkcji.
+
+2. „Dodać plik do bazy" znaczy, że plik ZACZYNA BYĆ UŻYWANY. W pełnej aplikacji
+ wgranie i włączenie to dwie decyzje (DAN-27); tutaj muszą być jedną, inaczej
+ po wgraniu nic się nie zmienia i demo wygląda na zepsute.
+"""
+import base64
+
+import pytest
+
+from app import security
+
+
+@pytest.fixture()
+def env(monkeypatch):
+ monkeypatch.setenv("ASTRODEMO_USERS", "demo:tajne-demo,klientA:hasloA,klientB:hasloB")
+ monkeypatch.delenv("ASTRODEMO_USER", raising=False)
+ monkeypatch.delenv("ASTRODEMO_PASSWORD", raising=False)
+ monkeypatch.setenv("RATE_LIMIT_PER_MIN", "0")
+ # Bez klucza podpisu usługa celowo nie wstaje (fail-closed, LOG-34).
+ monkeypatch.setenv("SESSION_SECRET", "t" * 64)
+ monkeypatch.setenv("COOKIES_INSECURE", "1") # TestClient jedzie po http
+
+
+def _auth(user="demo", password=""):
+ """Nagłówek z WAŻNĄ SESJĄ — odpowiednik bycia zalogowanym.
+
+ Po przejściu z Basic na sesje (LOG-34) „zalogowany" znaczy „ma podpisane
+ ciasteczko", nie „ma nagłówek z hasłem". Hasło przyjmowane tylko po to, żeby
+ nie przepisywać wszystkich wywołań — sprawdzanie poświadczeń ma własne testy."""
+ from app import security, session
+
+ return {"Cookie": f"{session.COOKIE}={security.issue_session(user)}"}
+
+
+REPORT = {
+ "engine": "test",
+ "objects": [{
+ "object": "Sun", "sign": "Taurus", "house": 11, "direction": "D",
+ "planet_token": "Su", "planet_total": 3,
+ "facets": [{"label": "w znaku Taurus", "token": "Su Tau", "count": 1, "score": 5.0,
+ "samples": [{"significator": "Su Tau", "expanded": "Sun in Taurus",
+ "effect": "wytrwały, praktyczny"}]}],
+ }],
+}
+
+
+def _client(monkeypatch, calls=None, upload=None):
+ """Podmieniamy METODY KLASY, nie obiekt modułowy: klient jest budowany per
+ żądanie, żeby pula wynikała z zalogowanego konta. Dzięki temu podglądamy
+ też `self.tenant`, czyli to, do której puli faktycznie poszło zapytanie."""
+ from starlette.testclient import TestClient
+
+ from app.clients.logic_client import LogicClient
+ from app.main import app
+
+ calls = calls if calls is not None else []
+ domyslny = {"path": "nowa.xlsx", "name": "nowa.xlsx", "accepted": True}
+
+ monkeypatch.setattr(LogicClient, "report",
+ lambda self, **kw: (calls.append(("report", self.tenant, kw)), REPORT)[1])
+ monkeypatch.setattr(LogicClient, "files_upload",
+ lambda self, *a, **kw: (calls.append(("upload", self.tenant, a)),
+ upload or domyslny)[1])
+ monkeypatch.setattr(LogicClient, "files_status",
+ lambda self, *a, **kw: (calls.append(("status", self.tenant, a)), {})[1])
+ return TestClient(app), calls
+
+
+FORM = {"date": "1984-04-30", "time": "11:20", "tz_offset": "2",
+ "lat": "50.06", "lon": "19.94"}
+
+
+# ── powierzchnia: dokładnie dwie funkcje ────────────────────────────────
+
+def test_the_service_exposes_nothing_beyond_its_two_functions():
+ """Trasa, o której nikt nie pamiętał, jest tu realnym ryzykiem — ta usługa
+ rozmawia z warstwą danych PRODUKCJI."""
+ from app.main import app
+
+ trasy = {(m, r.path) for r in app.routes for m in (getattr(r, "methods", None) or set())
+ if not r.path.startswith("/static") and m in {"GET", "POST"}}
+ assert trasy == {("GET", "/"), ("POST", "/"), ("POST", "/plik"), ("GET", "/health"),
+ ("GET", "/logowanie"), ("POST", "/logowanie"), ("POST", "/wyloguj")}
+
+
+def test_the_client_can_only_ask_for_what_the_demo_needs():
+ """Klient warstwy logicznej jest okrojony CELOWO: metody, której nie ma, nikt
+ przypadkiem nie zawoła i nie podpowie ona, że po drugiej stronie jest więcej."""
+ from app.clients.logic_client import LogicClient
+
+ publiczne = {n for n in dir(LogicClient) if not n.startswith("_")}
+ assert publiczne == {"report", "files_upload", "files_status", "health"}
+
+
+def test_api_docs_are_off():
+ """/docs wypisałoby komplet tras — demo ma nie zdradzać własnej powierzchni."""
+ from app.main import app
+
+ assert app.docs_url is None and app.openapi_url is None and app.redoc_url is None
+
+
+# ── logowanie ────────────────────────────────────────────────────────────
+
+def test_without_credentials_nothing_is_served(env, monkeypatch):
+ c, _ = _client(monkeypatch)
+ for method, path in (("get", "/"), ("post", "/"), ("post", "/plik")):
+ r = getattr(c, method)(path, follow_redirects=False)
+ assert r.status_code == 303, path
+ assert "/logowanie" in r.headers["location"], path
+ assert c.get("/health").status_code == 200, "sonda musi działać bez hasła"
+
+
+def test_demo_account_is_separate_from_the_main_application(env, monkeypatch):
+ """Konto astrodemo MUSI być własne: demo pracuje na tej samej warstwie
+ danych co produkcja, więc odcięcie go nie może wymagać zmiany haseł
+ w głównej aplikacji."""
+ monkeypatch.setenv("APP_USER", "astrololo")
+ monkeypatch.setenv("APP_PASSWORD", "haslo-glownej-aplikacji")
+ c, _ = _client(monkeypatch)
+ assert security.verify("astrololo", "haslo-glownej-aplikacji") is None
+ assert security.verify("demo", "tajne-demo") == "demo"
+
+
+def test_a_password_with_polish_letters_is_refused_not_crashed(env, monkeypatch):
+ monkeypatch.setenv("ASTRODEMO_USERS", "demo:zażółć-gęślą")
+ c, _ = _client(monkeypatch)
+
+
+
+# ── funkcja 1: dodanie pliku ─────────────────────────────────────────────
+
+def test_adding_a_file_uploads_AND_switches_it_on(env, monkeypatch):
+ """Sedno wymagania: jedna czynność, nie dwie."""
+ c, calls = _client(monkeypatch)
+ r = c.post("/plik", headers=_auth(), follow_redirects=False,
+ files={"upload": ("baza.xlsx", b"zawartosc", "application/vnd.ms-excel")})
+ assert r.status_code == 303
+ rodzaje = [k[0] for k in calls]
+ assert rodzaje == ["upload", "status"], f"oczekiwano wgrania i włączenia, było: {rodzaje}"
+ assert calls[1][2][1] == "active", "plik nie został włączony do użytku"
+
+
+def test_a_rejected_file_is_not_switched_on_and_the_reason_stays_hidden(env, monkeypatch):
+ """Walidacja zostaje, ale jej REGUŁY zna wyłącznie administrator (DAN-27) —
+ demo nie ma prawa ich zdradzić, nawet mimochodem."""
+ from urllib.parse import unquote_plus
+
+ c, calls = _client(monkeypatch, upload={"path": "zla.xlsx", "name": "zla.xlsx",
+ "accepted": False})
+ r = c.post("/plik", headers=_auth(), follow_redirects=False,
+ files={"upload": ("zla.xlsx", b"x", "text/plain")})
+ assert r.status_code == 303
+ assert [k[0] for k in calls] == ["upload"], "odrzucony plik został włączony do użytku"
+ komunikat = unquote_plus(r.headers["location"])
+ for slowo in ("walidacj", "reguł", "kolumn", "rozszerzeni", "rozmiar"):
+ assert slowo not in komunikat, f"komunikat zdradza mechanizm: „{slowo}”"
+
+
+def test_an_empty_file_is_refused_before_anything_is_sent(env, monkeypatch):
+ c, calls = _client(monkeypatch)
+ r = c.post("/plik", headers=_auth(), follow_redirects=False,
+ files={"upload": ("pusty.xlsx", b"", "application/vnd.ms-excel")})
+ assert r.status_code == 303 and calls == []
+
+
+# ── funkcja 2: interpretacja urodzeniowa ────────────────────────────────
+
+def test_asking_for_an_interpretation_returns_the_matches(env, monkeypatch):
+ c, calls = _client(monkeypatch)
+ r = c.post("/", headers=_auth(), data=FORM)
+ assert r.status_code == 200
+ assert "Sun in Taurus" in r.text and "wytrwały, praktyczny" in r.text
+ assert [k[0] for k in calls] == ["report"]
+
+
+def test_local_time_is_converted_to_utc_before_asking(env, monkeypatch):
+ """11:20 przy offsecie +2 to 09:20 UTC. Pomyłka tutaj przesuwa CAŁY horoskop,
+ a wynik nadal wygląda wiarygodnie — dlatego sprawdzamy wprost."""
+ c, calls = _client(monkeypatch)
+ c.post("/", headers=_auth(), data=FORM)
+ assert calls[0][2]["when_utc_iso"].startswith("1984-04-30T09:20")
+
+
+def test_a_malformed_date_is_explained_not_thrown(env, monkeypatch):
+ c, calls = _client(monkeypatch)
+ r = c.post("/", headers=_auth(), data={**FORM, "date": "30 kwietnia"})
+ assert r.status_code == 200 and "RRRR-MM-DD" in r.text
+ assert calls == [], "poszło zapytanie mimo błędnych danych"
+
+
+def test_a_broken_logic_layer_is_reported_not_crashed(env, monkeypatch):
+ import httpx
+
+ from app.clients.logic_client import LogicClient
+
+ c, _ = _client(monkeypatch)
+ monkeypatch.setattr(LogicClient, "report", lambda self, **kw: (_ for _ in ()).throw(
+ httpx.ConnectError("brak połączenia")))
+ r = c.post("/", headers=_auth(), data=FORM)
+ # Komunikat jest CELOWO nieinformacyjny: treść wyjątku niosła nazwę usługi,
+ # jej port i nazwy tras, czyli mapę tego, co stoi za tym ekranem.
+ assert r.status_code == 200
+ assert "Nie udało się teraz wykonać tej operacji" in r.text
+ assert "Warstwa logiczna" not in r.text and "8001" not in r.text
+
+
+def test_the_page_never_offers_anything_it_cannot_do(env, monkeypatch):
+ """Demo ma wyglądać na KOMPLETNE w swojej postaci — żadnych śladów funkcji,
+ których nie ma (ta sama zasada, co przy uprawnieniach w PRE-27)."""
+ c, _ = _client(monkeypatch)
+ html = c.get("/", headers=_auth()).text
+ for slowo in ("Kosmogram", "Synastria", "Kalendarz", "Skompiluj", "Ustawienia",
+ "Konta", "PDF", "Excel", "prompt", "model"):
+ assert slowo not in html, f"strona wspomina o „{slowo}”, czego demo nie umie"
+
+
+# ── pule kont: izolacja (PRE-29) ─────────────────────────────────────────
+# Demo jest udostępniane szeroko i różnym osobom, więc pula musi wynikać
+# z tego, KTO SIĘ ZALOGOWAŁ — i z niczego innego. Wyciek byłby cichy: klient
+# zobaczyłby cudze bazy jako własne.
+
+def test_the_pool_is_taken_from_the_login(env, monkeypatch):
+ c, calls = _client(monkeypatch)
+ c.post("/", headers=_auth("klientA", "hasloA"), data=FORM)
+ c.post("/", headers=_auth("klientB", "hasloB"), data=FORM)
+ assert [k[1] for k in calls] == ["klientA", "klientB"]
+
+
+def test_uploads_go_to_the_pool_of_the_account_that_sent_them(env, monkeypatch):
+ c, calls = _client(monkeypatch)
+ c.post("/plik", headers=_auth("klientA", "hasloA"), follow_redirects=False,
+ files={"upload": ("baza.xlsx", b"x", "application/vnd.ms-excel")})
+ assert {k[1] for k in calls} == {"klientA"}, "wgranie trafiło do cudzej puli"
+
+
+def test_the_pool_cannot_be_chosen_from_the_form(env, monkeypatch):
+ """Gdyby pula przychodziła z żądania, wystarczyłoby podstawić cudzy login."""
+ c, calls = _client(monkeypatch)
+ c.post("/", headers=_auth("klientA", "hasloA"),
+ data={**FORM, "tenant": "klientB", "user": "klientB", "login": "klientB"})
+ assert [k[1] for k in calls] == ["klientA"], "pula dała się podmienić z formularza"
+
+
+def test_every_account_has_its_own_pool_by_construction(env, monkeypatch):
+ """Każdy login = inna pula. Dwa konta nie mogą dzielić zbioru baz."""
+ c, calls = _client(monkeypatch)
+ for login, haslo in (("demo", "tajne-demo"), ("klientA", "hasloA"), ("klientB", "hasloB")):
+ c.post("/", headers=_auth(login, haslo), data=FORM)
+ pule = [k[1] for k in calls]
+ assert len(set(pule)) == len(pule) == 3
+
+
+def test_an_unknown_account_gets_nothing(env, monkeypatch):
+ """Bez ważnej sesji żądanie nie schodzi niżej — nie wystarczy, że skończy
+ się przekierowaniem: nie może po drodze dotknąć warstwy logicznej."""
+ c, calls = _client(monkeypatch)
+ r = c.post("/", data=FORM, follow_redirects=False)
+ assert r.status_code == 303 and "/logowanie" in r.headers["location"]
+ assert calls == [], "poszło zapytanie mimo braku sesji"
+
+
+def test_logging_in_and_out_of_the_demo(env, monkeypatch):
+ """Pełny obieg: demo bywa używane na cudzych komputerach, więc wyjście musi
+ naprawdę kończyć sesję, a nie tylko tak wyglądać."""
+ from app import session
+
+ c, _ = _client(monkeypatch)
+ r = c.post("/logowanie", follow_redirects=False,
+ data={"login": "klientA", "haslo": "hasloA", "dokad": "/"})
+ assert r.status_code == 303 and session.COOKIE in r.cookies
+
+ wyjscie = c.post("/wyloguj", headers=_auth("klientA"), follow_redirects=False)
+ assert wyjscie.status_code == 303
+ ustawione = wyjscie.headers.get("set-cookie", "")
+ assert session.COOKIE in ustawione and "Max-Age=0" in ustawione
+
+
+def test_removing_an_account_kills_its_open_session(env, monkeypatch):
+ """Demo nie ma gdzie trwale zapisywać stanu, więc zdalne unieważnienie robi
+ się przez ASTRODEMO_USERS — usunięcie albo zmiana hasła ubija sesję odciskiem."""
+ c, _ = _client(monkeypatch)
+ ciasteczko = _auth("klientA")
+ assert c.get("/", headers=ciasteczko, follow_redirects=False).status_code == 200
+
+ monkeypatch.setenv("ASTRODEMO_USERS", "demo:tajne-demo,klientB:hasloB") # bez klientA
+ assert c.get("/", headers=ciasteczko, follow_redirects=False).status_code == 303
+
+
+def test_the_demo_login_cannot_be_turned_into_a_redirector(env, monkeypatch):
+ c, _ = _client(monkeypatch)
+ for zly in ("https://obcy.pl", "//obcy.pl", "http://obcy.pl/x"):
+ r = c.post("/logowanie", follow_redirects=False,
+ data={"login": "demo", "haslo": "tajne-demo", "dokad": zly})
+ assert r.headers["location"] == "/", f"przepuszczono: {zly}"
diff --git a/services/astrodemo/tests/test_slownik_zakazany.py b/services/astrodemo/tests/test_slownik_zakazany.py
new file mode 100644
index 0000000..1348b37
--- /dev/null
+++ b/services/astrodemo/tests/test_slownik_zakazany.py
@@ -0,0 +1,192 @@
+"""Zapora słownikowa astrodemo: czego użytkownik demo nie może zobaczyć.
+
+astrodemo stoi najniżej w drabinie trzech produktów (astrodemo → astroklient →
+astrololo) i jest dawane najszerzej. Ma dwie funkcje i ma wyglądać, jakby to
+było wszystko, co program potrafi.
+
+Test nie sprawdza pojedynczych miejsc, tylko przechodzi WSZYSTKO, co da się
+pobrać, i szuka słów, które nie mają prawa paść. Sprawdza też DRZEWO PLIKÓW
+usługi — bo „nie ma śladu w kodzie" znaczy, że `grep` po obrazie ma nic nie
+znaleźć, a nie tylko że odpowiedź jest czysta.
+
+Powód, dla którego to powstało: komentarz w pierwszej linii styles.css mówił
+„Nie kopiujemy stylów pełnej aplikacji", a arkusz pobierał anonim.
+"""
+import pathlib
+import re
+
+import pytest
+
+APP = pathlib.Path(__file__).resolve().parents[1] / "app"
+
+# (a) że istnieje wersja obszerniejsza i jak się nazywa
+WIEKSZY_BRAT = ["pełna aplikacja", "pełnej aplikacji", "pełna wersja", "pełnej wersji",
+ "astrololo", "astroklient", "wersji podstawowej", "upgrade", "rozszerzon"]
+# (b) że tekst pisze model językowy
+# Bez samego „token": w tej usłudze znaczy token sesji i token międzywarstwowy,
+# a nie jednostkę rozliczeniową modelu. Zamiast tego zwroty jednoznaczne.
+MODEL = ["LLM", "anthropic", "openai", "gpt", "claude", "prompt",
+ "generowanie tekstu", "sztuczn", "okno kontekstu", "model językow"]
+# (c) funkcje, których astrodemo nie ma
+INNE_FUNKCJE = ["kosmogram", "aspektarian", "synastri", "kalendarz", "predykcj",
+ "skompiluj", "system domów", "systemy domów", "deklinacj", "antyscj"]
+# (d) że jest ktoś, kto widzi więcej, i że produkt jest w budowie
+MECHANIZMY = ["administrator", "uprawnieni", "walidacj", "kwarantann", "roadmap",
+ "w budowie", "widok testowy", "warstwa logiczna", "layer"]
+# Dwa poziomy, bo dwie różne drogi wycieku.
+#
+# WSZĘDZIE — także w kodzie serwera, którego przeglądarka nigdy nie zobaczy.
+# Obraz tej usługi się KOMUŚ ODDAJE, więc kto go dostanie, przeczyta też
+# komentarze i docstringi. Zdanie „w pełnej aplikacji to działa inaczej" mówi mu
+# wprost, że istnieje pełna aplikacja — a to jest dokładnie to, czego ma nie
+# wiedzieć. Komentarz ma tłumaczyć TĘ usługę, bez powoływania się na rodzeństwo.
+WSZEDZIE = WIEKSZY_BRAT + MODEL + INNE_FUNKCJE
+# TYLKO DO PRZEGLĄDARKI — słownictwo inżynierskie opisujące własne działanie tej
+# usługi. W komentarzu serwera jest na miejscu; w odpowiedzi HTTP nie ma czego
+# szukać, bo mówi o mechanizmach, o których użytkownik nie ma wiedzieć.
+DO_PRZEGLADARKI = WSZEDZIE + MECHANIZMY
+ZAKAZANE = DO_PRZEGLADARKI
+WZORCE = [(r"(?i)\b(PRE|LOG|DAN)-\d+\b", "identyfikator wymagania"),
+ (r"(?i)\bfeat/[\w-]+", "nazwa gałęzi rozwojowej"),
+ (r"(?i)\bAI\b", "model językowy")]
+
+
+def _grzechy(tresc: str, gdzie: str, slownik: list[str] | None = None) -> list[str]:
+ out = []
+ for igla in (slownik if slownik is not None else ZAKAZANE):
+ if re.search(rf"(?i)(? Path:
+ """Katalog, w którym mieszka pula danego konta.
+
+ Puste `tenant` = cały udział, czyli zachowanie produkcji. Nazwa jest
+ OCZYSZCZANA, a nie sprawdzana i odrzucana: sito zamienia wszystko podejrzane
+ na podkreślenie, więc żadne wejście nie wyprowadzi ścieżki wyżej."""
+ root = Path(root)
+ name = _TENANT_OK.sub("_", (tenant or "").strip()).strip("._")
+ return root / name if name else root
USABLE = frozenset({ACTIVE})
# Stany, o których wolno wiedzieć osobie bez uprawnień administracyjnych.
diff --git a/services/data/app/link_crypto.py b/services/data/app/link_crypto.py
index 89ed3d8..da99bc2 100644
--- a/services/data/app/link_crypto.py
+++ b/services/data/app/link_crypto.py
@@ -153,7 +153,7 @@ class Link:
def open(self, direction: bytes, path: str, stamp: str, seq: int,
frame: bytes) -> bytes:
if not frame.startswith(MAGIC):
- raise LinkError("ramka bez znacznika astrololo")
+ raise LinkError("ramka bez znacznika protokołu")
body = frame[len(MAGIC):]
if len(body) <= NONCE_BYTES:
raise LinkError("ramka za krótka")
diff --git a/services/data/app/main.py b/services/data/app/main.py
index 0dfdbf7..6565986 100644
--- a/services/data/app/main.py
+++ b/services/data/app/main.py
@@ -71,29 +71,35 @@ def bases() -> dict:
class FilesQuery(BaseModel):
for_admin: bool = False
+ # Pula konta (PRE-29). Puste = cały udział — tak woła produkcja, która o pulach
+ # nic nie wie. Wersja demo podaje login, przez co widzi wyłącznie swój katalog.
+ tenant: str = ""
class FileAction(BaseModel):
path: str
status: str = ""
by: str = ""
+ tenant: str = ""
class FileUpload(BaseModel):
filename: str
content_b64: str
by: str = ""
+ tenant: str = ""
class RulesUpdate(BaseModel):
rules: dict
+ tenant: str = ""
@app.post("/files")
def files_list(q: FilesQuery) -> dict:
"""Rejestr plików. Kwarantanna WYCHODZI stąd tylko przy for_admin — filtrujemy
u źródła, żeby nie dało się jej odczytać z podglądu źródła strony."""
- root = settings.excel_dir
+ root = files.tenant_root(settings.excel_dir, q.tenant)
return {"files": files.registry(root, for_admin=q.for_admin),
"rules": files.rules(root) if q.for_admin else {},
"root": str(root)}
@@ -102,7 +108,8 @@ def files_list(q: FilesQuery) -> dict:
@app.post("/files/status")
def files_status(a: FileAction) -> dict:
try:
- row = files.set_status(settings.excel_dir, a.path, a.status, by=a.by)
+ row = files.set_status(files.tenant_root(settings.excel_dir, a.tenant),
+ a.path, a.status, by=a.by)
except ValueError as e:
raise HTTPException(422, str(e)) from e
return {"path": a.path, "status": row.get("status")}
@@ -117,13 +124,14 @@ def files_upload(u: FileUpload) -> dict:
raw = base64.b64decode(u.content_b64, validate=True)
except (binascii.Error, ValueError) as e:
raise HTTPException(422, "Nieczytelna zawartość pliku.") from e
- return files.store_upload(settings.excel_dir, u.filename, raw, by=u.by)
+ return files.store_upload(files.tenant_root(settings.excel_dir, u.tenant),
+ u.filename, raw, by=u.by)
@app.post("/files/delete")
def files_delete(a: FileAction) -> dict:
try:
- files.delete(settings.excel_dir, a.path)
+ files.delete(files.tenant_root(settings.excel_dir, a.tenant), a.path)
except ValueError as e:
raise HTTPException(422, str(e)) from e
return {"deleted": a.path}
@@ -131,7 +139,7 @@ def files_delete(a: FileAction) -> dict:
@app.post("/files/rules")
def files_rules(u: RulesUpdate) -> dict:
- return {"rules": files.set_rules(settings.excel_dir, u.rules)}
+ return {"rules": files.set_rules(files.tenant_root(settings.excel_dir, u.tenant), u.rules)}
@app.get("/health", response_model=HealthInfo)
diff --git a/services/data/app/models.py b/services/data/app/models.py
index ec0cdfb..74de050 100644
--- a/services/data/app/models.py
+++ b/services/data/app/models.py
@@ -25,6 +25,11 @@ class SearchQuery(BaseModel):
fields: list[str] | None = Field(
None, description="Lista pól kanonicznych do zwrócenia; None = wszystkie."
)
+ # PULA KONTA (PRE-29). Puste = cały udział, czyli zachowanie produkcji, która
+ # o pulach nic nie wie. Ustawione = wyszukiwanie widzi WYŁĄCZNIE podkatalog
+ # tego konta. Używa tego wersja demo, gdzie każde konto ma własny, niewidoczny
+ # dla pozostałych zbiór baz.
+ tenant: str = Field("", description="Pula plików konta; puste = cały udział.")
class SearchResult(BaseModel):
diff --git a/services/data/app/providers/excel_provider.py b/services/data/app/providers/excel_provider.py
index 8bb6dec..4f31d0c 100644
--- a/services/data/app/providers/excel_provider.py
+++ b/services/data/app/providers/excel_provider.py
@@ -91,7 +91,7 @@ class ExcelDataProvider(DataProvider):
base = Path(self.s.excel_dir)
return [str(p) for p in sorted(base.glob("**/*.xlsx")) if not p.name.startswith("~$")]
- def _enabled_files(self, paths: list[str]) -> list[str]:
+ def _enabled_files(self, paths: list[str], tenant: str = "") -> list[str]:
"""Bazy biorące udział w wyszukiwaniu.
Źródłem prawdy jest REJESTR PLIKÓW (DAN-27) — stan klikany z ekranu,
@@ -105,7 +105,7 @@ class ExcelDataProvider(DataProvider):
# przy KAŻDYM wyszukiwaniu, czyli 500 z warstwy danych.
from app import bases, files
- usable = set(files.usable_paths(self.s.excel_dir))
+ usable = set(files.usable_paths(files.tenant_root(self.s.excel_dir, tenant)))
out = [p for p in paths if p in usable]
entries = bases.disabled_entries()
if entries:
@@ -128,7 +128,11 @@ class ExcelDataProvider(DataProvider):
from app import bases
disabled = ",".join(bases.disabled_entries())
- cache_key = f"{query.key}|{query.value}|{query.exact}|{query.limit}|{query.fields}|{disabled}"
+ # PULA MUSI BYĆ W KLUCZU. Bez niej wynik policzony dla jednego konta
+ # trafiłby z cache do drugiego — czyli cicha wymiana treści baz między
+ # kontami, niewidoczna w logach i nie do wykrycia z zewnątrz.
+ cache_key = (f"{query.key}|{query.value}|{query.exact}|{query.limit}"
+ f"|{query.fields}|{disabled}|{query.tenant}")
hit = self.queries.get(cache_key) # poziom 3: wynik zapytania
if hit is not None:
@@ -140,7 +144,7 @@ class ExcelDataProvider(DataProvider):
# brak w indeksie (np. klucz nieindeksowany) -> przeszukaj wszystkie pliki
candidates = [(p, "0") for p in self._excel_files()]
# bazy wyłączone globalnie (DAN-15) pomijamy niezależnie od źródła kandydatów
- allowed = set(self._enabled_files([p for p, _ in candidates]))
+ allowed = set(self._enabled_files([p for p, _ in candidates], query.tenant))
candidates = [(p, s) for p, s in candidates if p in allowed]
rows: list[dict] = []
diff --git a/services/data/tests/test_rejestr_integracja.py b/services/data/tests/test_rejestr_integracja.py
index b56069d..e447202 100644
--- a/services/data/tests/test_rejestr_integracja.py
+++ b/services/data/tests/test_rejestr_integracja.py
@@ -110,3 +110,80 @@ def test_switching_a_base_off_is_visible_in_both_places(excel_dir):
p2.warmup()
assert p2.search(SearchQuery(key="significator", value="Ma Ari", limit=10)).total == 0
assert [b["enabled"] for b in p2.list_bases()] == [False]
+
+
+# ── pule kont: izolacja (PRE-29) ─────────────────────────────────────────
+# Najgroźniejsza rzecz w tej zmianie. Wyciek między pulami jest CICHY: klient
+# zobaczyłby cudze opisy jako własny wynik i nikt by się nie zorientował.
+
+def _pool(root, name, plik, tresc):
+ from app import files
+
+ pula = files.tenant_root(root, name)
+ pula.mkdir(parents=True, exist_ok=True)
+ _xlsx(pula / plik, rows=[(tresc, f"opis {tresc}")])
+ files.registry(pula) # przyjęcie zastanych
+ return pula
+
+
+def test_each_account_sees_only_its_own_files(excel_dir):
+ from app import files
+
+ _pool(excel_dir, "klientA", "a.xlsx", "Ma Ari")
+ _pool(excel_dir, "klientB", "b.xlsx", "Ve Tau")
+
+ a = [e["name"] for e in files.registry(files.tenant_root(excel_dir, "klientA"))]
+ b = [e["name"] for e in files.registry(files.tenant_root(excel_dir, "klientB"))]
+ assert a == ["a.xlsx"] and b == ["b.xlsx"]
+
+
+def test_search_never_reaches_another_account_pool(excel_dir):
+ from app.models import SearchQuery
+
+ _pool(excel_dir, "klientA", "a.xlsx", "Ma Ari")
+ _pool(excel_dir, "klientB", "b.xlsx", "Ve Tau")
+ p = _provider(excel_dir)
+ p.warmup()
+
+ swoje = p.search(SearchQuery(key="significator", value="Ma Ari", limit=10, tenant="klientA"))
+ cudze = p.search(SearchQuery(key="significator", value="Ve Tau", limit=10, tenant="klientA"))
+ assert swoje.total >= 1, "konto nie widzi własnej bazy"
+ assert cudze.total == 0, "konto sięgnęło do puli innego konta"
+
+
+def test_the_query_cache_cannot_serve_one_account_the_answer_of_another(excel_dir):
+ """Bez puli w kluczu cache wynik policzony dla jednego konta trafiłby do
+ drugiego — cicha wymiana treści baz, niewidoczna w logach."""
+ from app.models import SearchQuery
+
+ _pool(excel_dir, "klientA", "a.xlsx", "Ma Ari")
+ _pool(excel_dir, "klientB", "b.xlsx", "Ma Ari") # TA SAMA szukana wartość
+ p = _provider(excel_dir)
+ p.warmup()
+
+ a = p.search(SearchQuery(key="significator", value="Ma Ari", limit=10, tenant="klientA"))
+ b = p.search(SearchQuery(key="significator", value="Ma Ari", limit=10, tenant="klientB"))
+ assert a.total >= 1 and b.total >= 1
+ assert b.cache != "hit", "odpowiedź dla jednego konta wyszła z cache drugiego"
+
+
+def test_a_crafted_pool_name_cannot_escape_the_share(excel_dir):
+ """Nazwa puli przychodzi z zewnątrz (login), więc „../..” albo ukośnik
+ wyprowadziłyby zapytanie wprost do cudzych baz."""
+ from app import files
+
+ for zlosliwa in ("../..", "../klientB", "/etc", "a/../../b", "..", "."):
+ wynik = files.tenant_root(excel_dir, zlosliwa)
+ assert excel_dir in wynik.parents or wynik == excel_dir, f"ucieczka: {zlosliwa} → {wynik}"
+
+
+def test_no_pool_means_the_whole_share_so_production_is_untouched(excel_dir):
+ """Produkcja nie wie o pulach i ma działać dokładnie jak dotąd."""
+ from app import files
+ from app.models import SearchQuery
+
+ _xlsx(excel_dir / "produkcyjna.xlsx")
+ p = _provider(excel_dir)
+ p.warmup()
+ assert files.tenant_root(excel_dir, "") == excel_dir
+ assert p.search(SearchQuery(key="significator", value="Ma Ari", limit=10)).total >= 1
diff --git a/services/logic/app/clients/data_client.py b/services/logic/app/clients/data_client.py
index 88a0a29..b7f9e40 100644
--- a/services/logic/app/clients/data_client.py
+++ b/services/logic/app/clients/data_client.py
@@ -28,8 +28,18 @@ def _link() -> link_crypto.Link | None:
class DataClient:
- def __init__(self, base_url: str | None = None) -> None:
+ """Rozmówca warstwy danych, opcjonalnie ZWIĄZANY Z PULĄ KONTA (PRE-29).
+
+ Pula siedzi w INSTANCJI, nie w sygnaturach metod. Gdyby jechała argumentem,
+ trzeba by ją przeprowadzić przez protokół DataSource i przez build_report —
+ czyli przez kod, który o kontach nie ma prawa nic wiedzieć. A przy okazji
+ każde nowe wywołanie byłoby okazją, żeby o nią zapomnieć i sięgnąć nie tam.
+
+ Puste = cały udział, czyli zachowanie produkcji."""
+
+ def __init__(self, base_url: str | None = None, tenant: str = "") -> None:
self.base_url = (base_url or settings.data_url).rstrip("/")
+ self.tenant = tenant or ""
def search(
self,
@@ -39,7 +49,8 @@ class DataClient:
limit: int,
fields: list[str] | None = None,
) -> dict[str, Any]:
- payload = {"key": key, "value": value, "exact": exact, "limit": limit, "fields": fields}
+ payload = {"key": key, "value": value, "exact": exact, "limit": limit,
+ "fields": fields, "tenant": self.tenant}
with httpx.Client(timeout=max(settings.http_timeout, 30.0)) as client:
return link_crypto.call_json(client, "POST", f"{self.base_url}/search",
payload=payload, headers=_auth_headers(),
@@ -58,20 +69,20 @@ class DataClient:
# `call(path, payload)` zaciera tę różnicę dokładnie tam, gdzie jest ważna.
def files_list(self, for_admin: bool = False) -> dict[str, Any]:
- return self._files_post("/files", {"for_admin": for_admin})
+ return self._files_post("/files", {"for_admin": for_admin, "tenant": self.tenant})
def files_status(self, path: str, status: str, by: str = "") -> dict[str, Any]:
- return self._files_post("/files/status", {"path": path, "status": status, "by": by})
+ return self._files_post("/files/status", {"path": path, "status": status, "by": by, "tenant": self.tenant})
def files_upload(self, filename: str, content_b64: str, by: str = "") -> dict[str, Any]:
return self._files_post("/files/upload",
- {"filename": filename, "content_b64": content_b64, "by": by})
+ {"filename": filename, "content_b64": content_b64, "by": by, "tenant": self.tenant})
def files_delete(self, path: str) -> dict[str, Any]:
- return self._files_post("/files/delete", {"path": path})
+ return self._files_post("/files/delete", {"path": path, "tenant": self.tenant})
def files_rules(self, rules: dict) -> dict[str, Any]:
- return self._files_post("/files/rules", {"rules": rules})
+ return self._files_post("/files/rules", {"rules": rules, "tenant": self.tenant})
def _files_post(self, path: str, payload: dict) -> dict[str, Any]:
with httpx.Client(timeout=settings.http_timeout) as client:
diff --git a/services/logic/app/link_crypto.py b/services/logic/app/link_crypto.py
index 89ed3d8..da99bc2 100644
--- a/services/logic/app/link_crypto.py
+++ b/services/logic/app/link_crypto.py
@@ -153,7 +153,7 @@ class Link:
def open(self, direction: bytes, path: str, stamp: str, seq: int,
frame: bytes) -> bytes:
if not frame.startswith(MAGIC):
- raise LinkError("ramka bez znacznika astrololo")
+ raise LinkError("ramka bez znacznika protokołu")
body = frame[len(MAGIC):]
if len(body) <= NONCE_BYTES:
raise LinkError("ramka za krótka")
diff --git a/services/logic/app/main.py b/services/logic/app/main.py
index dc4e738..e6aa828 100644
--- a/services/logic/app/main.py
+++ b/services/logic/app/main.py
@@ -133,29 +133,33 @@ def bases() -> dict:
class FilesQuery(BaseModel):
for_admin: bool = False
+ tenant: str = ""
class FileAction(BaseModel):
path: str
status: str = ""
by: str = ""
+ tenant: str = ""
class FileUpload(BaseModel):
filename: str
content_b64: str
by: str = ""
+ tenant: str = ""
class RulesUpdate(BaseModel):
rules: dict
+ tenant: str = ""
-def _files_call(fn, *args, **kw) -> dict:
+def _files_call(fn, *args, tenant: str = "", **kw) -> dict:
from app.clients.data_client import DataClient
try:
- return fn(DataClient(), *args, **kw)
+ return fn(DataClient(tenant=tenant), *args, **kw)
except httpx.HTTPStatusError as e:
# 422 z warstwy danych to ODMOWA MERYTORYCZNA (np. plik nie przeszedł
# walidacji), nie awaria — ma dojść do prezentacji jako 422, żeby dało
@@ -175,27 +179,27 @@ def _detail(e: httpx.HTTPStatusError) -> str:
@app.post("/files")
def files_list(q: FilesQuery) -> dict:
- return _files_call(lambda c: c.files_list(q.for_admin))
+ return _files_call(lambda c: c.files_list(q.for_admin), tenant=q.tenant)
@app.post("/files/status")
def files_status(a: FileAction) -> dict:
- return _files_call(lambda c: c.files_status(a.path, a.status, a.by))
+ return _files_call(lambda c: c.files_status(a.path, a.status, a.by), tenant=a.tenant)
@app.post("/files/upload")
def files_upload(u: FileUpload) -> dict:
- return _files_call(lambda c: c.files_upload(u.filename, u.content_b64, u.by))
+ return _files_call(lambda c: c.files_upload(u.filename, u.content_b64, u.by), tenant=u.tenant)
@app.post("/files/delete")
def files_delete(a: FileAction) -> dict:
- return _files_call(lambda c: c.files_delete(a.path))
+ return _files_call(lambda c: c.files_delete(a.path), tenant=a.tenant)
@app.post("/files/rules")
def files_rules(u: RulesUpdate) -> dict:
- return _files_call(lambda c: c.files_rules(u.rules))
+ return _files_call(lambda c: c.files_rules(u.rules), tenant=u.tenant)
@app.post("/chart/synastry")
@@ -248,6 +252,10 @@ class ReportRequest(BaseModel):
lon: float = 0.0
limit: int = 5000
group: bool = False # grupowanie identycznych opisów
+ # Pula konta (PRE-29) — puste = cały udział. Warstwa logiczna niczego tu nie
+ # rozstrzyga, tylko przenosi: kto do jakiej puli ma prawo, wie warstwa
+ # prezentacji, bo to ona zna konta.
+ tenant: str = ""
@app.post("/chart/report")
@@ -263,7 +271,7 @@ def chart_report(req: ReportRequest) -> dict:
chart = build_chart(engine, moment) # pozycje z domami + aspekty
try:
report = build_report(
- chart["positions"], DataClient(),
+ chart["positions"], DataClient(tenant=req.tenant),
aspects=chart.get("aspects"), parallels=chart.get("parallels"),
per_object_limit=req.limit, group=req.group,
)
diff --git a/services/presentation/app/link_crypto.py b/services/presentation/app/link_crypto.py
index 89ed3d8..da99bc2 100644
--- a/services/presentation/app/link_crypto.py
+++ b/services/presentation/app/link_crypto.py
@@ -153,7 +153,7 @@ class Link:
def open(self, direction: bytes, path: str, stamp: str, seq: int,
frame: bytes) -> bytes:
if not frame.startswith(MAGIC):
- raise LinkError("ramka bez znacznika astrololo")
+ raise LinkError("ramka bez znacznika protokołu")
body = frame[len(MAGIC):]
if len(body) <= NONCE_BYTES:
raise LinkError("ramka za krótka")
diff --git a/services/render/app/link_crypto.py b/services/render/app/link_crypto.py
index 89ed3d8..da99bc2 100644
--- a/services/render/app/link_crypto.py
+++ b/services/render/app/link_crypto.py
@@ -153,7 +153,7 @@ class Link:
def open(self, direction: bytes, path: str, stamp: str, seq: int,
frame: bytes) -> bytes:
if not frame.startswith(MAGIC):
- raise LinkError("ramka bez znacznika astrololo")
+ raise LinkError("ramka bez znacznika protokołu")
body = frame[len(MAGIC):]
if len(body) <= NONCE_BYTES:
raise LinkError("ramka za krótka")