Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 gitea
|
5a7f7e1b13 |
@@ -9,12 +9,10 @@ jobs:
|
||||
- uses: actions/checkout@v4
|
||||
- name: Login
|
||||
run: echo "${{ secrets.REGISTRY_TOKEN }}" | docker login gitea.czernobog.pl -u gitea --password-stdin
|
||||
# astrodemo dołącza do tej samej pętli: dzieli warstwę logiczną i łącze,
|
||||
# więc jego obraz ma powstawać z tego samego commita co reszta produktu.
|
||||
- name: Build & push (data, logic, presentation, astrodemo)
|
||||
- name: Build & push (data, logic, presentation)
|
||||
run: |
|
||||
TAG=${GITHUB_SHA::8}
|
||||
for SVC in data logic presentation astrodemo; do
|
||||
for SVC in data logic presentation; do
|
||||
docker build -t gitea.czernobog.pl/gitea/astrololo-$SVC:$TAG ./services/$SVC
|
||||
docker push gitea.czernobog.pl/gitea/astrololo-$SVC:$TAG
|
||||
done
|
||||
|
||||
@@ -91,27 +91,6 @@ jobs:
|
||||
PYTHONPATH: .
|
||||
run: pytest tests -q -rs
|
||||
|
||||
astrodemo-tests:
|
||||
name: Testy astrodemo
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: "3.12"
|
||||
cache: pip
|
||||
cache-dependency-path: services/astrodemo/requirements-dev.txt
|
||||
- name: Instalacja zależności
|
||||
run: pip install -r services/astrodemo/requirements-dev.txt
|
||||
# Demo rozmawia z warstwą danych PRODUKCJI, więc jego powierzchnia musi być
|
||||
# pilnowana tak samo jak reszty: testy sprawdzają m.in., że nie przybyła
|
||||
# żadna trasa poza dwiema funkcjami.
|
||||
- name: Testy (pytest)
|
||||
working-directory: services/astrodemo
|
||||
env:
|
||||
PYTHONPATH: .
|
||||
run: pytest tests -q -rs
|
||||
|
||||
swisseph-image:
|
||||
name: Build obrazu silnika B (swisseph)
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
@@ -16,8 +16,6 @@ services/logic/.ephemeris/
|
||||
|
||||
# Dane wejściowe (duże pliki Excela trzymane poza repo)
|
||||
services/data/data_files/*.xlsx
|
||||
# Rejestr plików (DAN-27) powstaje przy uruchomieniu — to stan, nie kod.
|
||||
services/data/data_files/.files-state.json
|
||||
!services/data/data_files/.gitkeep
|
||||
|
||||
# Narzędzia
|
||||
|
||||
@@ -11,10 +11,8 @@ services:
|
||||
volumes:
|
||||
- ./services/data/data_files:/app/data_files
|
||||
- data_cache:/app/.cache
|
||||
# Bez `ports:` CELOWO. Ta usługa rozmawia wyłącznie po sieci wewnętrznej
|
||||
# compose, a opublikowana na hoście była osiągalna z pominięciem logowania
|
||||
# w prezentacji. Do diagnostyki: `docker compose exec` albo tymczasowe
|
||||
# `docker compose run --publish`.
|
||||
ports:
|
||||
- "8002:8002"
|
||||
|
||||
logic:
|
||||
image: gitea.czernobog.pl/gitea/astrololo-logic:latest
|
||||
@@ -27,10 +25,8 @@ services:
|
||||
ENGINE_SWISSEPH_URL: http://engine-swisseph:8003
|
||||
depends_on:
|
||||
- data
|
||||
# Bez `ports:` CELOWO. Ta usługa rozmawia wyłącznie po sieci wewnętrznej
|
||||
# compose, a opublikowana na hoście była osiągalna z pominięciem logowania
|
||||
# w prezentacji. Do diagnostyki: `docker compose exec` albo tymczasowe
|
||||
# `docker compose run --publish`.
|
||||
ports:
|
||||
- "8001:8001"
|
||||
|
||||
# Silnik B (AGPL) — OPCJONALNY, izolowany. Startuje tylko z profilem "comparison":
|
||||
# docker compose --profile comparison up
|
||||
@@ -40,10 +36,8 @@ services:
|
||||
container_name: astrololo-engine-swisseph
|
||||
restart: unless-stopped
|
||||
profiles: ["comparison"]
|
||||
# Bez `ports:` CELOWO. Ta usługa rozmawia wyłącznie po sieci wewnętrznej
|
||||
# compose, a opublikowana na hoście była osiągalna z pominięciem logowania
|
||||
# w prezentacji. Do diagnostyki: `docker compose exec` albo tymczasowe
|
||||
# `docker compose run --publish`.
|
||||
ports:
|
||||
- "8003:8003"
|
||||
|
||||
presentation:
|
||||
image: gitea.czernobog.pl/gitea/astrololo-presentation:latest
|
||||
|
||||
+6
-12
@@ -9,10 +9,8 @@ services:
|
||||
volumes:
|
||||
- ./services/data/data_files:/app/data_files
|
||||
- data_cache:/app/.cache
|
||||
# Bez `ports:` CELOWO. Ta usługa rozmawia wyłącznie po sieci wewnętrznej
|
||||
# compose, a opublikowana na hoście była osiągalna z pominięciem logowania
|
||||
# w prezentacji. Do diagnostyki: `docker compose exec` albo tymczasowe
|
||||
# `docker compose run --publish`.
|
||||
ports:
|
||||
- "8002:8002"
|
||||
|
||||
logic:
|
||||
build: ./services/logic
|
||||
@@ -23,10 +21,8 @@ services:
|
||||
ENGINE_SWISSEPH_URL: http://engine-swisseph:8003
|
||||
depends_on:
|
||||
- data
|
||||
# Bez `ports:` CELOWO. Ta usługa rozmawia wyłącznie po sieci wewnętrznej
|
||||
# compose, a opublikowana na hoście była osiągalna z pominięciem logowania
|
||||
# w prezentacji. Do diagnostyki: `docker compose exec` albo tymczasowe
|
||||
# `docker compose run --publish`.
|
||||
ports:
|
||||
- "8001:8001"
|
||||
|
||||
# Silnik B (AGPL) — OPCJONALNY, izolowany. Startuje tylko z profilem "comparison":
|
||||
# docker compose --profile comparison up
|
||||
@@ -34,10 +30,8 @@ services:
|
||||
engine-swisseph:
|
||||
build: ./services/engine-swisseph
|
||||
profiles: ["comparison"]
|
||||
# Bez `ports:` CELOWO. Ta usługa rozmawia wyłącznie po sieci wewnętrznej
|
||||
# compose, a opublikowana na hoście była osiągalna z pominięciem logowania
|
||||
# w prezentacji. Do diagnostyki: `docker compose exec` albo tymczasowe
|
||||
# `docker compose run --publish`.
|
||||
ports:
|
||||
- "8003:8003"
|
||||
|
||||
presentation:
|
||||
build: ./services/presentation
|
||||
|
||||
Binary file not shown.
@@ -64,92 +64,6 @@ jest niewidoczna do chwili, gdy ktoś ją znajdzie. Trasa bez wpisu w mapie wyma
|
||||
uprawnień administracyjnych: **przeoczenie ma zamykać, nie otwierać**. Test
|
||||
przechodzi po wszystkich trasach aplikacji i wymaga, by każda była opisana.
|
||||
|
||||
### Gdy jedna trasa robi kilka rzeczy
|
||||
|
||||
Mapa tras nie wystarcza tam, gdzie jedna trasa obsługuje kilka funkcji naraz.
|
||||
`POST /interpret` liczy horoskop, ale to samo pole `action` prosi o wygenerowanie
|
||||
promptu, napisanie horoskopu przez model albo eksport arkusza. Konto, które ma
|
||||
mieć Interpretacje bez generowania, musi dostać tę trasę — więc granica przebiega
|
||||
wewnątrz niej, po akcjach: `_AKCJE_POD_UPRAWNIENIEM` przypisuje akcji uprawnienie,
|
||||
a `_dozwolona_akcja()` sprowadza żądanie bez uprawnienia do akcji domyślnej ekranu.
|
||||
|
||||
Sprowadza — nie odrzuca. Komunikat „brak uprawnień do generowania" sam w sobie
|
||||
mówiłby, że taka funkcja istnieje, czyli łamałby zasadę drugą po to, żeby
|
||||
wyegzekwować pierwszą. Akcja bez uprawnienia ma wyglądać na literówkę w formularzu.
|
||||
|
||||
### Ślad to nie tylko przycisk
|
||||
|
||||
Wymaganie brzmi „nie może być śladu", i to jest mocniejsze niż schowanie kontrolki.
|
||||
Największym wyciekiem po stronie generowania nie był przycisk, tylko **katalog
|
||||
modeli** — nazwy dostawców, nazwy modeli i rozmiary okien kontekstu — wstrzykiwany
|
||||
w stronę blokiem JSON na każdym ekranie z generowaniem, niezależnie od uprawnień.
|
||||
Dlatego `_llm_catalog_for()` oddaje pusty katalog kontu bez uprawnienia, a szablony
|
||||
trzymają pod bramką także znaczniki (`natalNote`, `reportNatal`), pliki skryptów
|
||||
(`models.js`, `progress.js`, `natal.js`, `predictions.js`) i **zdania opisujące
|
||||
funkcję** — podtytuł ekranu Skompiluj wymieniał interpretację od AI z nazwy.
|
||||
|
||||
Testu na to nie da się napisać przez „sprawdź, czy przycisku nie ma": trzeba
|
||||
sprawdzić, że w źródle strony nie ma żadnego z tych śladów, i mieć kontrolę
|
||||
pozytywną, że przy uprawnieniu wszystkie są. Inaczej test przechodzi także wtedy,
|
||||
gdy generowanie jest zepsute dla wszystkich.
|
||||
|
||||
## Pełna paranoja: ukrywanie jest nadrzędne
|
||||
|
||||
Właściciel produktu postawił to wyżej niż wygodę i wyżej niż czytelność
|
||||
komunikatów: *„nie chcę, żeby osoba wrzucająca bazy wiedziała, po co to robi
|
||||
i jak będzie w przyszłości działał program, bo to rozgada"*. Persona nazywa się
|
||||
**wgrywacz** — konto z uprawnieniami `files` + `files_input` i niczym więcej.
|
||||
|
||||
Nie ma dowiedzieć się: jakie inne funkcje istnieją, że teksty pisze model
|
||||
językowy i u jakiego dostawcy, do czego służą wgrywane pliki, co jest planowane,
|
||||
że istnieje walidacja plików, ani że istnieje konto, które widzi więcej.
|
||||
|
||||
### Wyciek prawie nigdy nie siedzi tam, gdzie się go szuka
|
||||
|
||||
Audyt sześciu kanałów potwierdził 26 wycieków. Ani jeden nie był przyciskiem.
|
||||
|
||||
| Kanał | Co wyciekało |
|
||||
|---|---|
|
||||
| `/static/**` poza bramką | komplet skryptów i arkuszy dla **niezalogowanego** |
|
||||
| komentarze w CSS/JS | pełne zdania po polsku o funkcjach, o kwarantannie i o tym, że administrator widzi więcej |
|
||||
| `styles.css` jako jeden plik | nazwy selektorów = spis funkcji programu |
|
||||
| `base.html` | skrypty kosmogramu na **każdej** stronie, łącznie z „przyszłą zakładką" |
|
||||
| komunikaty błędu | nazwa trasy, nazwa podsystemu, nazwa gałęzi rozwojowej, wewnętrzny `host:port` |
|
||||
| komunikat po wgraniu | słowo „administrator" — i **dwie różne treści**, czyli wyrocznia do odgadywania reguł walidacji |
|
||||
| `/openapi.json` warstw wewnętrznych | katalog wszystkich funkcji, bez logowania |
|
||||
|
||||
### Trzy zasady, które z tego wynikają
|
||||
|
||||
**Zasób jest częścią funkcji.** Skrypt i arkusz przechodzą przez tę samą bramkę
|
||||
co ekran (`features.STATIC`). Nazwa pliku jest zgadywalna, więc plik publiczny
|
||||
opowiada o funkcji równie dokładnie jak przycisk. Publiczny został jeden
|
||||
`base.css` — bo potrzebuje go ekran logowania — i dlatego nie wolno w nim
|
||||
umieścić niczego, co nazywa funkcję.
|
||||
|
||||
**Komentarz nie jedzie na drut.** `_asset_body()` usuwa komentarze przy
|
||||
serwowaniu. Zostają w repozytorium, gdzie są potrzebne. Ta jedna zmiana zamyka
|
||||
cztery z sześciu kanałów naraz.
|
||||
|
||||
**Różnica jest informacją.** Dwa różne komunikaty po wgraniu pliku były
|
||||
wyrocznią: wystarczyło wgrywać spreparowane pliki i czytać odpowiedź. Teraz
|
||||
komunikat jest jeden, niezależnie od wyniku. Z tego samego powodu odmowa to
|
||||
404 identyczne z „nie ma takiej trasy", a akcja bez uprawnienia cofa się do
|
||||
domyślnej zamiast tłumaczyć, czego brakuje.
|
||||
|
||||
### Zapora słownikowa
|
||||
|
||||
Łatanie punkt po punkcie przegrywa z następną zmianą. Dlatego
|
||||
`test_slownik_zakazany.py` nie sprawdza miejsc, tylko przechodzi **wszystko**,
|
||||
co dane konto może pobrać, i szuka słów, które nie mają prawa paść.
|
||||
|
||||
Dwie z trzech list biorą się wprost z katalogu funkcji — nazwa funkcji, adres
|
||||
jej ekranu i nazwy jej zasobów — więc dopisanie funkcji automatycznie dopisuje
|
||||
je do tego, czego konto bez niej nie może zobaczyć. Trzecia lista, słownictwo
|
||||
dziedziny i mechanizmów, jest pisana ręcznie, bo katalog jej nie zna.
|
||||
|
||||
Test ma kontrolę pozytywną: dla administratora te same słowa **muszą** się
|
||||
pojawiać. Bez niej przechodziłby także wtedy, gdyby program był pusty.
|
||||
|
||||
## Gdzie leżą konta
|
||||
|
||||
Plik JSON wskazany przez `ACCOUNTS_FILE` (domyślnie `/app/state/accounts.json`),
|
||||
|
||||
@@ -1,14 +0,0 @@
|
||||
FROM python:3.12-slim
|
||||
|
||||
WORKDIR /app
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Do obrazu wchodzi WYŁĄCZNIE kod aplikacji. `COPY . .` wnosiło też katalog
|
||||
# tests/ — a leży w nim lista słów, które w tej usłudze nie mają prawa paść,
|
||||
# wypisanych wprost. Obraz tej usługi się KOMUŚ ODDAJE, więc niósłby dokładnie
|
||||
# to, co ten test ma pilnować. Przy okazji obraz jest mniejszy.
|
||||
COPY app ./app
|
||||
|
||||
EXPOSE 8005
|
||||
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8005"]
|
||||
@@ -1,91 +0,0 @@
|
||||
# astrodemo — wersja demonstracyjna (PRE-28)
|
||||
|
||||
Osobna warstwa prezentacji o **dwóch funkcjach**:
|
||||
|
||||
1. **dodanie pliku bazy** — wgranie i włączenie do użytku jedną czynnością,
|
||||
2. **zapytanie o interpretację urodzeniową** dla podanych danych wejściowych.
|
||||
|
||||
I na tym koniec. Nie ma tu kosmogramu, synastrii, kalendarza, promptów do modelu,
|
||||
eksportu ani kont — nie są ukryte, tylko **nie istnieją w tym obrazie**.
|
||||
|
||||
## Dlaczego osobna usługa, a nie konto z ograniczeniami
|
||||
|
||||
Mechanizm uprawnień z PRE-27 umiałby to ukryć w pełnej aplikacji. Ale **ukrycie
|
||||
a nieobecność to dwie różne rzeczy**: tutaj nie ma tras, nie ma szablonów, nie ma
|
||||
nawet metod w kliencie warstwy logicznej. Demo można komuś oddać, nie oddając przy
|
||||
okazji kodu reszty programu.
|
||||
|
||||
## Izolacja: własne dane, pula na konto
|
||||
|
||||
```
|
||||
astrodemo → logic-demo → data-demo → udział astrololo-demo (pusty na starcie)
|
||||
└── klientA/ ← pula konta
|
||||
└── klientB/ ← pula konta
|
||||
```
|
||||
|
||||
**Oryginalne bazy interpretacyjne są dla demo nieosiągalne.** Nie chodzi
|
||||
o uprawnienia: demo ma własną warstwę danych, pracującą na osobnym udziale.
|
||||
Osobna jest też warstwa logiczna, bo zna ona JEDEN adres warstwy danych — demo
|
||||
korzystające z produkcyjnej logiki i tak trafiłoby na produkcyjne bazy.
|
||||
|
||||
**Każde konto ma własną pulę** plików: swój podkatalog na tym udziale. Konta nie
|
||||
widzą swoich baz nawzajem ani w liście, ani w wynikach wyszukiwania. Dlatego demo
|
||||
można rozdawać szeroko.
|
||||
|
||||
Pula bierze się **z loginu zalogowanej osoby** i z niczego innego. Gdyby
|
||||
przychodziła z żądania, wystarczyłoby podstawić cudzy login, żeby czytać cudze
|
||||
bazy — osobny test wysyła `tenant`, `user` i `login` w formularzu i sprawdza, że
|
||||
nie mają na nią wpływu.
|
||||
|
||||
Nazwa puli przechodzi przez sito dopuszczające wyłącznie znaki bezpieczne
|
||||
w nazwie katalogu: `../..` czy ukośnik wyprowadziłyby zapytanie poza udział.
|
||||
|
||||
**Pula klienta to jeden katalog**, więc przejście na pełną wersję nie oznacza
|
||||
utraty wgrań — procedura importu jest w runbooku wdrożenia (repo `deploy`,
|
||||
`astrololo/README-astrodemo.md`).
|
||||
|
||||
## Konfiguracja
|
||||
|
||||
| zmienna | znaczenie |
|
||||
|---|---|
|
||||
| `LOGIC_URL` | adres warstwy logicznej (domyślnie `http://localhost:8001`) |
|
||||
| `ASTRODEMO_USERS` | konta jako `login:sekret`, po przecinku. Sekret jawny albo hash `scrypt$sól$hash`. Każdy login = osobna pula plików |
|
||||
| `ASTRODEMO_USER` / `ASTRODEMO_PASSWORD` | pojedyncze konto — zgodność wstecz, działa gdy `ASTRODEMO_USERS` jest puste. **Brak obu = aplikacja stoi otwarta** i mówi o tym głośno przy starcie |
|
||||
| `INTERNAL_TOKEN` | token międzywarstwowy (LOG-32) — ten sam co reszta usług |
|
||||
| `LINK_KEY_PRESENTATION_LOGIC` | klucz szyfrowanego łącza (PRE-16) — ten sam co prezentacja |
|
||||
| `RATE_LIMIT_PER_MIN` | limit żądań na adres, domyślnie 60; `0` wyłącza |
|
||||
| `REPORT_LIMIT` | górny limit rekordów w jednej odpowiedzi, domyślnie 2000 |
|
||||
| `TRUST_PROXY` | `true` za Ingressem — inaczej limit liczy wszystkich do jednego wiadra |
|
||||
|
||||
Hash hasła zrobisz tym samym skryptem, co dla głównej aplikacji:
|
||||
|
||||
```bash
|
||||
cd services/presentation && python scripts/make_user.py demo
|
||||
```
|
||||
|
||||
## Uruchomienie lokalne
|
||||
|
||||
```bash
|
||||
cd services/astrodemo
|
||||
pip install -r requirements-dev.txt
|
||||
ASTRODEMO_PASSWORD=tajne LOGIC_URL=http://localhost:8001 \
|
||||
uvicorn app.main:app --port 8005
|
||||
```
|
||||
|
||||
Testy:
|
||||
|
||||
```bash
|
||||
cd services/astrodemo && PYTHONPATH=. pytest tests -q
|
||||
```
|
||||
|
||||
## Co pilnują testy
|
||||
|
||||
Poza zwykłą poprawnością — dwie własności, które łatwo zepsuć bez zauważenia:
|
||||
|
||||
* **powierzchnia**: zbiór tras aplikacji musi być dokładnie taki, jak dwie funkcje
|
||||
wymagają; klient warstwy logicznej ma tylko te metody, których używa. Trasa,
|
||||
o której nikt nie pamiętał, jest tu realnym ryzykiem, bo ta usługa rozmawia
|
||||
z produkcyjną warstwą danych.
|
||||
* **milczenie o regułach walidacji**: plik odrzucony daje komunikat bez powodu.
|
||||
Reguły zna wyłącznie administrator w pełnej aplikacji (DAN-27), a demo nie ma
|
||||
prawa ich zdradzić nawet mimochodem.
|
||||
@@ -1,79 +0,0 @@
|
||||
"""Klient warstwy logicznej — CELOWO okrojony do dwóch funkcji (PRE-28).
|
||||
|
||||
Ma tu być wyłącznie to, czego ta usługa naprawdę używa. Metoda, której nie ma,
|
||||
nie zostanie przypadkiem zawołana ani nie podpowie, że po drugiej stronie jest
|
||||
coś więcej.
|
||||
|
||||
Rozmowa idzie tym samym szyfrowanym łączem co reszta (PRE-16) i pod tym samym
|
||||
tokenem międzywarstwowym (LOG-32) — demo nie jest furtką omijającą ochronę.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from typing import Any
|
||||
|
||||
import httpx
|
||||
|
||||
from app import link_crypto
|
||||
from app.config import settings
|
||||
|
||||
|
||||
def _auth_headers() -> dict[str, str]:
|
||||
token = os.getenv("INTERNAL_TOKEN", "")
|
||||
return {"X-Astrololo-Token": token} if token else {}
|
||||
|
||||
|
||||
def _link() -> link_crypto.Link | None:
|
||||
"""Klucz łącza czytany przy KAŻDYM wywołaniu — pod przeżywa rotację sekretu
|
||||
bez restartu, a brak klucza przy wymaganym szyfrowaniu ma zatrzymać żądanie
|
||||
ZANIM cokolwiek wyjdzie jawnym tekstem."""
|
||||
key = link_crypto.key_from_env(link_crypto.ENV_PRESENTATION_LOGIC)
|
||||
return link_crypto.Link(key) if key else None
|
||||
|
||||
|
||||
class LogicClient:
|
||||
"""Rozmówca warstwy logicznej ZWIĄZANY Z PULĄ KONTA (PRE-29).
|
||||
|
||||
Pulę podaje się przy tworzeniu klienta, a bierze się ją WYŁĄCZNIE z loginu
|
||||
zalogowanej osoby — nigdy z pola formularza. Gdyby przychodziła z żądania,
|
||||
wystarczyłoby podstawić cudzy login, żeby czytać cudze bazy."""
|
||||
|
||||
def __init__(self, tenant: str = "", base_url: str | None = None) -> None:
|
||||
self.base_url = (base_url or settings.logic_url).rstrip("/")
|
||||
self.tenant = tenant or ""
|
||||
|
||||
def report(self, when_utc_iso: str, lat: float, lon: float) -> dict[str, Any]:
|
||||
"""Interpretacja urodzeniowa: sygnifikatory z obliczeń szukane w bazach.
|
||||
|
||||
Jedyne pytanie, jakie astrodemo zadaje o treść — bez grupowania,
|
||||
bez grupowania i bez żadnej obróbki treści."""
|
||||
payload = {"when_utc": when_utc_iso, "lat": lat, "lon": lon,
|
||||
"limit": settings.report_limit, "group": False,
|
||||
"tenant": self.tenant}
|
||||
with httpx.Client(timeout=settings.http_timeout) as client:
|
||||
return link_crypto.call_json(client, "POST", f"{self.base_url}/chart/report",
|
||||
payload=payload, headers=_auth_headers(), link=_link())
|
||||
|
||||
def files_upload(self, filename: str, content_b64: str, by: str = "") -> dict[str, Any]:
|
||||
with httpx.Client(timeout=max(settings.http_timeout, 60.0)) as client:
|
||||
return link_crypto.call_json(
|
||||
client, "POST", f"{self.base_url}/files/upload",
|
||||
payload={"filename": filename, "content_b64": content_b64,
|
||||
"by": by, "tenant": self.tenant},
|
||||
headers=_auth_headers(), link=_link())
|
||||
|
||||
def files_status(self, path: str, status: str, by: str = "") -> dict[str, Any]:
|
||||
"""Włączenie wgranego pliku do użytku. W demo wgranie i włączenie to JEDNA
|
||||
czynność: „dodać do bazy" ma znaczyć, że plik od razu bierze udział
|
||||
w wyszukiwaniu — inaczej demo wyglądałoby na zepsute."""
|
||||
with httpx.Client(timeout=settings.http_timeout) as client:
|
||||
return link_crypto.call_json(
|
||||
client, "POST", f"{self.base_url}/files/status",
|
||||
payload={"path": path, "status": status, "by": by, "tenant": self.tenant},
|
||||
headers=_auth_headers(), link=_link())
|
||||
|
||||
def health(self) -> dict[str, Any]:
|
||||
with httpx.Client(timeout=settings.http_timeout) as client:
|
||||
r = client.get(f"{self.base_url}/health", headers=_auth_headers())
|
||||
r.raise_for_status()
|
||||
return r.json()
|
||||
@@ -1,22 +0,0 @@
|
||||
"""Konfiguracja astrodemo — wersji demonstracyjnej (PRE-28).
|
||||
|
||||
Zna WYŁĄCZNIE adres warstwy logicznej. Nie wie nic o bazach, Excelu ani SQL-u.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
|
||||
@dataclass
|
||||
class Settings:
|
||||
logic_url: str = field(default_factory=lambda: os.getenv("LOGIC_URL", "http://localhost:8001"))
|
||||
# Szukanie interpretacji potrafi zajrzeć do wszystkich baz naraz, więc limit
|
||||
# czasu jest wyższy niż domyślny dla zwykłego żądania.
|
||||
http_timeout: float = field(default_factory=lambda: float(os.getenv("HTTP_TIMEOUT", "30")))
|
||||
# Górny limit rekordów w jednej odpowiedzi. Nie jest to optymalizacja, tylko
|
||||
# ograniczenie, ile treści baz może wyjść jednym zapytaniem.
|
||||
report_limit: int = field(default_factory=lambda: int(os.getenv("REPORT_LIMIT", "2000")))
|
||||
|
||||
|
||||
settings = Settings()
|
||||
@@ -1,525 +0,0 @@
|
||||
"""Szyfrowanie łączy między warstwami (PRE-16 / LOG-33).
|
||||
|
||||
Do tej pory warstwy rozmawiały ze sobą zwykłym HTTP-em wewnątrz klastra. Token
|
||||
międzywarstwowy (LOG-32) mówił KTO pyta, ale nie ukrywał CZEGO dotyczy odpowiedź
|
||||
— a płyną nią surowe wiersze oryginalnych baz interpretacyjnych, czyli rdzeń
|
||||
produktu. Kto podsłuchał ruch wewnątrz sieci (drugi pod, port mirror na switchu,
|
||||
zrzut z węzła), miał je w całości.
|
||||
|
||||
Ten moduł zamyka tę drogę: **AES-256-GCM** na ciele każdego żądania i odpowiedzi.
|
||||
GCM daje jednocześnie poufność i uwierzytelnienie — cudzy albo podmieniony bajt
|
||||
nie odszyfruje się w ogóle, więc nie ma osobnego problemu „zaszyfrowane, ale
|
||||
podatne na modyfikację".
|
||||
|
||||
**Dwa niezależne klucze**, po jednym na parę rozmówców:
|
||||
* ``LINK_KEY_PRESENTATION_LOGIC`` — prezentacja ↔ logika,
|
||||
* ``LINK_KEY_LOGIC_DATA`` — logika ↔ dane.
|
||||
Dzięki temu przejęcie klucza prezentacji nie daje dostępu do warstwy danych,
|
||||
gdzie leżą całe bazy. Logika trzyma oba, bo rozmawia w obie strony.
|
||||
|
||||
Z każdego klucza łącza wyprowadzamy **osobne podklucze na kierunek** (HKDF).
|
||||
Żądanie i odpowiedź nigdy nie szyfrują się tym samym kluczem, więc powtórzenie
|
||||
losowej jednorazówki w jedną stronę nie osłabia drugiej.
|
||||
|
||||
Format ramki (bo strumień odpowiedzi może iść kawałkami — patrz okno postępu):
|
||||
|
||||
[4 bajty długości][magia "AL1"][12 bajtów jednorazówki][szyfrogram + znacznik]
|
||||
|
||||
Do materiału uwierzytelnianego (AAD) wchodzą kierunek, ścieżka, znacznik czasu
|
||||
i numer ramki. Skutek: ramki nie da się przekleić do innego endpointu, odtworzyć
|
||||
po czasie (dopuszczalny poślizg ``MAX_SKEW``) ani przestawić w strumieniu.
|
||||
|
||||
Bez ustawionego klucza moduł **przepuszcza ruch otwartym tekstem** (dev, zgodność
|
||||
wstecz) i krzyczy o tym przy starcie. Gdy klucz JEST ustawiony, warstwa serwerowa
|
||||
działa fail-closed: nieszyfrowane żądanie dostaje odmowę, żeby przypadkowa
|
||||
regresja po stronie klienta nie oznaczała cichego powrotu do jawnego ruchu.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
import logging
|
||||
import os
|
||||
import struct
|
||||
import time
|
||||
from typing import Iterable, Iterator
|
||||
|
||||
from cryptography.exceptions import InvalidTag
|
||||
from cryptography.hazmat.primitives import hashes
|
||||
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
|
||||
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
|
||||
|
||||
log = logging.getLogger("astrololo.link")
|
||||
|
||||
MAGIC = b"AL1"
|
||||
VERSION = "v1"
|
||||
NONCE_BYTES = 12
|
||||
KEY_BYTES = 32 # AES-256
|
||||
LENGTH_PREFIX = 4
|
||||
MAX_FRAME = 64 * 1024 * 1024 # zapora przed alokacją z podanej długości
|
||||
MAX_SKEW_SECONDS = 300.0
|
||||
|
||||
HEADER_ENC = "X-Astrololo-Enc"
|
||||
HEADER_TS = "X-Astrololo-Enc-Ts"
|
||||
CONTENT_TYPE = "application/vnd.astrololo.enc"
|
||||
|
||||
ENV_PRESENTATION_LOGIC = "LINK_KEY_PRESENTATION_LOGIC"
|
||||
ENV_LOGIC_DATA = "LINK_KEY_LOGIC_DATA"
|
||||
# Trzecia para: prezentacja ↔ render (PRE-24). Osobny klucz, jak przy pozostałych —
|
||||
# usługa render dostaje CAŁY raport (dane urodzeniowe + opisy z baz), więc przejęcie
|
||||
# jej klucza nie może otwierać łącza do logiki ani do danych.
|
||||
ENV_PRESENTATION_RENDER = "LINK_KEY_PRESENTATION_RENDER"
|
||||
ENV_REQUIRED = "LINK_ENCRYPTION_REQUIRED"
|
||||
|
||||
REQUEST, RESPONSE = b"req", b"res"
|
||||
|
||||
# Sondy k8s pukają tu bez klucza i tak ma zostać — inaczej pierwsza literówka
|
||||
# w sekrecie kładłaby pody zamiast pokazać błąd w aplikacji.
|
||||
PUBLIC_PATHS = frozenset({"/health"})
|
||||
|
||||
|
||||
class LinkError(Exception):
|
||||
"""Cokolwiek poszło nie tak z kopertą — celowo bez szczegółów na zewnątrz."""
|
||||
|
||||
|
||||
# --------------------------------------------------------------------- klucze
|
||||
|
||||
def parse_key(raw: str) -> bytes:
|
||||
"""Klucz z konfiguracji: hex (64 znaki) albo base64. Zawsze 32 bajty."""
|
||||
text = raw.strip()
|
||||
if not text:
|
||||
raise LinkError("pusty klucz łącza")
|
||||
try:
|
||||
key = bytes.fromhex(text)
|
||||
except ValueError:
|
||||
try:
|
||||
key = base64.b64decode(text, validate=True)
|
||||
except (binascii.Error, ValueError) as exc:
|
||||
raise LinkError("klucz łącza nie jest ani hexem, ani base64") from exc
|
||||
if len(key) != KEY_BYTES:
|
||||
raise LinkError(
|
||||
f"klucz łącza ma {len(key)} B zamiast {KEY_BYTES} — wygeneruj przez "
|
||||
f"`openssl rand -hex 32`"
|
||||
)
|
||||
return key
|
||||
|
||||
|
||||
def key_from_env(env_name: str) -> bytes | None:
|
||||
"""Klucz albo None. Zły klucz to wyjątek OD RAZU — nie przy pierwszym żądaniu."""
|
||||
raw = os.getenv(env_name, "")
|
||||
return parse_key(raw) if raw.strip() else None
|
||||
|
||||
|
||||
def encryption_required() -> bool:
|
||||
"""Czy brak klucza ma być błędem, a nie cichym powrotem do jawnego ruchu.
|
||||
|
||||
Serwer sam z siebie broni się fail-closed, ale to za mało: klient BEZ klucza
|
||||
wysyła pytanie otwartym tekstem i dopiero potem dostaje odmowę — czyli treść
|
||||
zapytania zdążyła już przelecieć przez sieć. Ta flaga zatrzymuje go, zanim
|
||||
cokolwiek opuści proces. Ustawiana razem z kluczami we wdrożeniu.
|
||||
"""
|
||||
return os.getenv(ENV_REQUIRED, "").strip().lower() in {"1", "true", "yes", "on"}
|
||||
|
||||
|
||||
def _subkey(link_key: bytes, direction: bytes) -> bytes:
|
||||
return HKDF(
|
||||
algorithm=hashes.SHA256(), length=KEY_BYTES, salt=None,
|
||||
info=b"astrololo/link/" + direction,
|
||||
).derive(link_key)
|
||||
|
||||
|
||||
class Link:
|
||||
"""Jedna para rozmówców: klucz plus wyprowadzone z niego podklucze."""
|
||||
|
||||
def __init__(self, link_key: bytes) -> None:
|
||||
self._by_direction = {
|
||||
REQUEST: AESGCM(_subkey(link_key, REQUEST)),
|
||||
RESPONSE: AESGCM(_subkey(link_key, RESPONSE)),
|
||||
}
|
||||
|
||||
# ---------------------------------------------------------- pojedyncza ramka
|
||||
|
||||
def _aad(self, direction: bytes, path: str, stamp: str, seq: int) -> bytes:
|
||||
return b"|".join([MAGIC, direction, path.encode("utf-8"),
|
||||
stamp.encode("ascii"), str(seq).encode("ascii")])
|
||||
|
||||
def seal(self, direction: bytes, path: str, stamp: str, seq: int,
|
||||
plaintext: bytes) -> bytes:
|
||||
nonce = os.urandom(NONCE_BYTES)
|
||||
sealed = self._by_direction[direction].encrypt(
|
||||
nonce, plaintext, self._aad(direction, path, stamp, seq))
|
||||
return MAGIC + nonce + sealed
|
||||
|
||||
def open(self, direction: bytes, path: str, stamp: str, seq: int,
|
||||
frame: bytes) -> bytes:
|
||||
if not frame.startswith(MAGIC):
|
||||
raise LinkError("ramka bez znacznika protokołu")
|
||||
body = frame[len(MAGIC):]
|
||||
if len(body) <= NONCE_BYTES:
|
||||
raise LinkError("ramka za krótka")
|
||||
nonce, sealed = body[:NONCE_BYTES], body[NONCE_BYTES:]
|
||||
try:
|
||||
return self._by_direction[direction].decrypt(
|
||||
nonce, sealed, self._aad(direction, path, stamp, seq))
|
||||
except InvalidTag as exc:
|
||||
# Jeden komunikat na wszystkie przypadki: zły klucz, podmieniony bajt,
|
||||
# przeklejenie z innej ścieżki, przestawiona ramka. Rozróżnianie ich
|
||||
# na zewnątrz podpowiadałoby atakującemu, w co trafił.
|
||||
raise LinkError("nie udało się odszyfrować — zły klucz albo naruszone dane") from exc
|
||||
|
||||
# ------------------------------------------------------------ strumień ramek
|
||||
|
||||
def seal_stream(self, direction: bytes, path: str, stamp: str,
|
||||
chunks: Iterable[bytes]) -> Iterator[bytes]:
|
||||
for seq, chunk in enumerate(chunks):
|
||||
yield frame_out(self.seal(direction, path, stamp, seq, chunk))
|
||||
|
||||
def open_stream(self, direction: bytes, path: str, stamp: str,
|
||||
raw: bytes) -> Iterator[bytes]:
|
||||
for seq, frame in enumerate(frames_in(raw)):
|
||||
yield self.open(direction, path, stamp, seq, frame)
|
||||
|
||||
def open_all(self, direction: bytes, path: str, stamp: str, raw: bytes) -> bytes:
|
||||
return b"".join(self.open_stream(direction, path, stamp, raw))
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- ramkowanie
|
||||
|
||||
def frame_out(payload: bytes) -> bytes:
|
||||
return struct.pack(">I", len(payload)) + payload
|
||||
|
||||
|
||||
def frames_in(raw: bytes) -> Iterator[bytes]:
|
||||
"""Rozbiera bufor na ramki. Ucięty strumień to błąd, nie cicha strata danych."""
|
||||
offset = 0
|
||||
while offset < len(raw):
|
||||
if offset + LENGTH_PREFIX > len(raw):
|
||||
raise LinkError("urwana ramka (brak nagłówka długości)")
|
||||
(size,) = struct.unpack(">I", raw[offset:offset + LENGTH_PREFIX])
|
||||
if size > MAX_FRAME:
|
||||
raise LinkError("ramka ponad dopuszczalny rozmiar")
|
||||
offset += LENGTH_PREFIX
|
||||
if offset + size > len(raw):
|
||||
raise LinkError("urwana ramka (za mało danych)")
|
||||
yield raw[offset:offset + size]
|
||||
offset += size
|
||||
|
||||
|
||||
def unframe_incremental(buffer: bytearray) -> Iterator[bytes]:
|
||||
"""Wyjmuje z bufora KOMPLETNE ramki i zjada je; resztę zostawia na później.
|
||||
|
||||
Dla odbioru na żywo: kawałki przychodzą podzielone dowolnie i ramka potrafi
|
||||
rozjechać się między dwa odczyty.
|
||||
"""
|
||||
while True:
|
||||
if len(buffer) < LENGTH_PREFIX:
|
||||
return
|
||||
(size,) = struct.unpack(">I", buffer[:LENGTH_PREFIX])
|
||||
if size > MAX_FRAME:
|
||||
raise LinkError("ramka ponad dopuszczalny rozmiar")
|
||||
if len(buffer) < LENGTH_PREFIX + size:
|
||||
return
|
||||
frame = bytes(buffer[LENGTH_PREFIX:LENGTH_PREFIX + size])
|
||||
del buffer[:LENGTH_PREFIX + size]
|
||||
yield frame
|
||||
|
||||
|
||||
# ------------------------------------------------------------- świeżość ruchu
|
||||
|
||||
def stamp_now() -> str:
|
||||
return f"{time.time():.3f}"
|
||||
|
||||
|
||||
def check_stamp(stamp: str) -> None:
|
||||
"""Odrzuca ramki spoza okna czasowego — inaczej podsłuchane żądanie dałoby się
|
||||
odtworzyć w dowolnym momencie w przyszłości."""
|
||||
try:
|
||||
sent = float(stamp)
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise LinkError("brak albo błędny znacznik czasu") from exc
|
||||
if abs(time.time() - sent) > MAX_SKEW_SECONDS:
|
||||
raise LinkError("znacznik czasu poza dopuszczalnym oknem")
|
||||
|
||||
|
||||
# =========================================================== strona serwerowa
|
||||
|
||||
class LinkCryptoMiddleware:
|
||||
"""Rozszyfrowuje wchodzące żądania i zaszyfrowuje wychodzące odpowiedzi.
|
||||
|
||||
Napisane jako czyste ASGI, nie ``@app.middleware("http")``, bo trzeba
|
||||
podmienić CIAŁO żądania jeszcze zanim zobaczy je FastAPI, oraz przepuścić
|
||||
odpowiedź strumieniową kawałek po kawałku, bez zbierania jej w pamięci.
|
||||
"""
|
||||
|
||||
def __init__(self, app, link: Link | None, layer: str) -> None:
|
||||
self.app = app
|
||||
self.link = link
|
||||
self.layer = layer
|
||||
|
||||
async def __call__(self, scope, receive, send):
|
||||
if scope["type"] != "http" or self.link is None or scope["path"] in PUBLIC_PATHS:
|
||||
return await self.app(scope, receive, send)
|
||||
|
||||
path = scope["path"]
|
||||
headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope["headers"]}
|
||||
|
||||
if headers.get(HEADER_ENC.lower()) != VERSION:
|
||||
# Fail-closed. Klucz jest ustawiony, więc jawne żądanie oznacza albo
|
||||
# pomyłkę w konfiguracji, albo kogoś obcego — w obu wypadkach nie
|
||||
# chcemy po cichu wrócić do jawnego ruchu.
|
||||
log.warning("warstwa %s: odrzucone żądanie bez szyfrowania łącza (%s)",
|
||||
self.layer, path)
|
||||
return await _refuse(send, "Łącze międzywarstwowe wymaga szyfrowania.")
|
||||
|
||||
stamp = headers.get(HEADER_TS.lower(), "")
|
||||
try:
|
||||
check_stamp(stamp)
|
||||
plaintext = self.link.open_all(REQUEST, path, stamp, await _read_body(receive))
|
||||
except LinkError as exc:
|
||||
log.warning("warstwa %s: %s (%s)", self.layer, exc, path)
|
||||
return await _refuse(send, "Nie udało się odczytać zaszyfrowanego żądania.")
|
||||
|
||||
scope = dict(scope)
|
||||
scope["headers"] = _rewritten_headers(scope["headers"], len(plaintext))
|
||||
await self.app(scope, _replay(plaintext, receive), self._sealing_send(send, path))
|
||||
|
||||
def _sealing_send(self, send, path: str):
|
||||
state: dict = {"stamp": "", "seq": 0}
|
||||
|
||||
async def sealing(message):
|
||||
if message["type"] == "http.response.start":
|
||||
state["stamp"] = stamp_now()
|
||||
keep = [(k, v) for k, v in message.get("headers", [])
|
||||
if k.lower() not in (b"content-length", b"content-type")]
|
||||
message = dict(message)
|
||||
message["headers"] = keep + [
|
||||
(b"content-type", CONTENT_TYPE.encode()),
|
||||
(HEADER_ENC.lower().encode(), VERSION.encode()),
|
||||
(HEADER_TS.lower().encode(), state["stamp"].encode()),
|
||||
]
|
||||
return await send(message)
|
||||
|
||||
if message["type"] == "http.response.body":
|
||||
chunk = message.get("body", b"")
|
||||
sealed = b""
|
||||
if chunk:
|
||||
sealed = frame_out(self.link.seal(
|
||||
RESPONSE, path, state["stamp"], state["seq"], chunk))
|
||||
state["seq"] += 1
|
||||
return await send({"type": "http.response.body", "body": sealed,
|
||||
"more_body": message.get("more_body", False)})
|
||||
|
||||
return await send(message)
|
||||
|
||||
return sealing
|
||||
|
||||
|
||||
def _rewritten_headers(raw: Iterable[tuple[bytes, bytes]], length: int):
|
||||
"""Po odszyfrowaniu ciało ma inną długość i zwykły typ — inaczej FastAPI
|
||||
próbowałby sparsować JSON o cudzej deklarowanej wielkości."""
|
||||
kept = [(k, v) for k, v in raw if k.lower() not in (b"content-length", b"content-type")]
|
||||
kept.append((b"content-length", str(length).encode()))
|
||||
if length:
|
||||
kept.append((b"content-type", b"application/json"))
|
||||
return kept
|
||||
|
||||
|
||||
async def _read_body(receive) -> bytes:
|
||||
body = bytearray()
|
||||
while True:
|
||||
message = await receive()
|
||||
if message["type"] == "http.disconnect":
|
||||
raise LinkError("rozłączenie w trakcie odbioru żądania")
|
||||
body += message.get("body", b"")
|
||||
if not message.get("more_body", False):
|
||||
return bytes(body)
|
||||
|
||||
|
||||
def _replay(body: bytes, original):
|
||||
"""Podstawia odszyfrowane ciało jako jedyną porcję wejścia dla aplikacji.
|
||||
|
||||
Po oddaniu ciała oddajemy głos ORYGINALNEMU `receive`, zamiast od razu
|
||||
zgłaszać rozłączenie. Odpowiedź strumieniowa nasłuchuje bowiem rozłączenia
|
||||
równolegle do wysyłania i przerywa się, gdy je zobaczy — na skróconej wersji
|
||||
okno postępu dostawało pustą odpowiedź, choć zwykłe żądania działały.
|
||||
"""
|
||||
delivered = False
|
||||
|
||||
async def receive():
|
||||
nonlocal delivered
|
||||
if delivered:
|
||||
return await original()
|
||||
delivered = True
|
||||
return {"type": "http.request", "body": body, "more_body": False}
|
||||
|
||||
return receive
|
||||
|
||||
|
||||
async def _refuse(send, detail: str) -> None:
|
||||
"""Odmowa leci JAWNIE — rozmówca właśnie pokazał, że nie umie odszyfrować,
|
||||
więc zaszyfrowany komunikat o błędzie byłby dla niego nieczytelny."""
|
||||
payload = f'{{"detail":"{detail}"}}'.encode("utf-8")
|
||||
await send({"type": "http.response.start", "status": 400, "headers": [
|
||||
(b"content-type", b"application/json"),
|
||||
(b"content-length", str(len(payload)).encode()),
|
||||
]})
|
||||
await send({"type": "http.response.body", "body": payload})
|
||||
|
||||
|
||||
def install(app, env_name: str, layer: str):
|
||||
"""Podpina szyfrowanie łącza. Wołać PO `security.install`, żeby także odmowa
|
||||
tokenowa (401) wracała zaszyfrowana — inaczej klient by jej nie odczytał."""
|
||||
link_key = key_from_env(env_name)
|
||||
if link_key is None and encryption_required():
|
||||
# Celowo wywracamy start. Ta sama zasada co przy sekrecie logowania:
|
||||
# wolimy widoczną awarię niż usługę, która wstała i po cichu nie chroni
|
||||
# niczego. Pod w CrashLoop widać od razu, jawny ruch — nie.
|
||||
raise LinkError(
|
||||
f"{ENV_REQUIRED} jest włączone, ale {env_name} nie ustawiony — "
|
||||
f"warstwa {layer} nie wystartuje bez klucza łącza"
|
||||
)
|
||||
if link_key is None:
|
||||
log.warning(
|
||||
"UWAGA: %s nie ustawiony — warstwa %s rozmawia z sąsiadem JAWNYM tekstem, "
|
||||
"więc treść baz interpretacyjnych jest widoczna dla każdego, kto podsłucha "
|
||||
"ruch wewnątrz sieci.", env_name, layer,
|
||||
)
|
||||
return None
|
||||
link = Link(link_key)
|
||||
app.add_middleware(LinkCryptoMiddleware, link=link, layer=layer)
|
||||
log.info("warstwa %s: łącze szyfrowane (AES-256-GCM, klucz z %s)", layer, env_name)
|
||||
return link
|
||||
|
||||
|
||||
# ============================================================ strona kliencka
|
||||
|
||||
def call(client, method: str, url: str, *, payload=None,
|
||||
headers: dict[str, str] | None = None, link: Link | None) -> bytes:
|
||||
"""Żądanie do sąsiedniej warstwy; zwraca odszyfrowane ciało odpowiedzi.
|
||||
|
||||
Ścieżkę do materiału uwierzytelnianego bierzemy Z URL-a, a nie z osobnego
|
||||
argumentu — gdyby klient i serwer liczyły ją inaczej, każde żądanie kończyłoby
|
||||
się niejasnym błędem odszyfrowania.
|
||||
"""
|
||||
import json as _json
|
||||
|
||||
import httpx
|
||||
|
||||
request_headers = dict(headers or {})
|
||||
if link is None:
|
||||
if encryption_required():
|
||||
# Zatrzymujemy się PRZED wysłaniem. Gdyby polecieć jawnie i dopiero
|
||||
# zebrać odmowę, pytanie byłoby już na kablu — a to właśnie ono niesie
|
||||
# sygnifikatory, o które pytamy bazę.
|
||||
raise LinkError(
|
||||
f"{ENV_REQUIRED} jest włączone, ale brak klucza łącza — żądanie "
|
||||
f"NIE zostało wysłane, żeby jego treść nie poszła jawnym tekstem"
|
||||
)
|
||||
response = client.request(method, url, json=payload, headers=request_headers)
|
||||
response.raise_for_status()
|
||||
return response.content
|
||||
|
||||
path = httpx.URL(url).path
|
||||
stamp = stamp_now()
|
||||
plaintext = b"" if payload is None else _json.dumps(payload).encode("utf-8")
|
||||
body = frame_out(link.seal(REQUEST, path, stamp, 0, plaintext))
|
||||
request_headers.update({HEADER_ENC: VERSION, HEADER_TS: stamp,
|
||||
"Content-Type": CONTENT_TYPE})
|
||||
|
||||
response = client.request(method, url, content=body, headers=request_headers)
|
||||
if response.status_code >= 400 and response.headers.get(HEADER_ENC) != VERSION:
|
||||
log.error("łącze %s odmówiło: %s", path, response.text[:200])
|
||||
response.raise_for_status()
|
||||
if response.headers.get(HEADER_ENC) != VERSION:
|
||||
raise LinkError("odpowiedź przyszła nieszyfrowana, choć klucz łącza jest ustawiony")
|
||||
reply_stamp = response.headers.get(HEADER_TS, "")
|
||||
check_stamp(reply_stamp)
|
||||
return link.open_all(RESPONSE, path, reply_stamp, response.content)
|
||||
|
||||
|
||||
def call_json(client, method: str, url: str, *, payload=None,
|
||||
headers: dict[str, str] | None = None, link: Link | None):
|
||||
import json as _json
|
||||
|
||||
return _json.loads(call(client, method, url, payload=payload,
|
||||
headers=headers, link=link))
|
||||
|
||||
|
||||
def open_response_stream(response, link: Link | None) -> Iterator[bytes]:
|
||||
"""Odbiór odpowiedzi płynącej kawałkami (okno postępu).
|
||||
|
||||
Ramka potrafi rozjechać się między dwa odczyty z gniazda, więc składamy ją
|
||||
w buforze zamiast zakładać, że każdy kawałek to komplet.
|
||||
"""
|
||||
if link is None:
|
||||
yield from response.iter_bytes()
|
||||
return
|
||||
if response.headers.get(HEADER_ENC) != VERSION:
|
||||
raise LinkError("strumień przyszedł nieszyfrowany, choć klucz łącza jest ustawiony")
|
||||
stamp = response.headers.get(HEADER_TS, "")
|
||||
check_stamp(stamp)
|
||||
path = response.request.url.path
|
||||
buffer = bytearray()
|
||||
seq = 0
|
||||
for chunk in response.iter_bytes():
|
||||
buffer += chunk
|
||||
for frame in unframe_incremental(buffer):
|
||||
yield link.open(RESPONSE, path, stamp, seq, frame)
|
||||
seq += 1
|
||||
if buffer:
|
||||
raise LinkError("strumień urwał się w połowie ramki")
|
||||
|
||||
|
||||
def stream_lines(client, url: str, *, payload, headers: dict[str, str] | None = None,
|
||||
link: Link | None) -> Iterator[str]:
|
||||
"""Strumieniowe POST zwracające kolejne NIEPUSTE linie NDJSON — na żywo.
|
||||
|
||||
Dla okna postępu: linie muszą docierać w trakcie pracy, nie na końcu, więc
|
||||
czytamy strumień, a nie całe ciało. Gdy łącze ma klucz, żądanie jest
|
||||
pieczętowane, a odpowiedź odszyfrowywana ramka po ramce; granice ramek NIE
|
||||
pokrywają się z granicami linii, więc sklejamy bajty w buforze i tniemy je
|
||||
dopiero na znakach nowej linii.
|
||||
|
||||
Bez klucza zachowuje się jak dotąd (surowy strumień), żeby dev bez sekretów
|
||||
działał bez zmian.
|
||||
"""
|
||||
import json as _json
|
||||
|
||||
import httpx as _httpx
|
||||
|
||||
request_headers = dict(headers or {})
|
||||
if link is None:
|
||||
if encryption_required():
|
||||
# Ten sam kontrakt co w `call`: nie wypuszczamy jawnego żądania, gdy
|
||||
# szyfrowanie jest wymagane. Bez tego serwer owszem odrzuca (400), ale
|
||||
# ciało żądania — tu dane urodzenia — zdążyłoby już pójść w eter.
|
||||
raise LinkError(
|
||||
f"{ENV_REQUIRED} jest włączone, ale brak klucza łącza — strumień "
|
||||
f"NIE został wysłany, żeby jego treść nie poszła jawnym tekstem"
|
||||
)
|
||||
with client.stream("POST", url, json=payload, headers=request_headers) as response:
|
||||
response.raise_for_status()
|
||||
for text_line in response.iter_lines():
|
||||
if text_line:
|
||||
yield text_line
|
||||
return
|
||||
|
||||
path = _httpx.URL(url).path
|
||||
stamp = stamp_now()
|
||||
body = frame_out(link.seal(REQUEST, path, stamp, 0, _json.dumps(payload).encode("utf-8")))
|
||||
request_headers.update({HEADER_ENC: VERSION, HEADER_TS: stamp, "Content-Type": CONTENT_TYPE})
|
||||
with client.stream("POST", url, content=body, headers=request_headers) as response:
|
||||
response.raise_for_status()
|
||||
buffer = bytearray()
|
||||
for plain in open_response_stream(response, link):
|
||||
buffer += plain
|
||||
while True:
|
||||
nl = buffer.find(b"\n")
|
||||
if nl < 0:
|
||||
break
|
||||
text_line = bytes(buffer[:nl])
|
||||
del buffer[:nl + 1]
|
||||
if text_line:
|
||||
yield text_line.decode("utf-8")
|
||||
if buffer:
|
||||
yield bytes(buffer).decode("utf-8")
|
||||
@@ -1,255 +0,0 @@
|
||||
"""astrodemo — wersja DEMONSTRACYJNA (PRE-28).
|
||||
|
||||
DWIE FUNKCJE I ANI JEDNEJ WIĘCEJ:
|
||||
1. dodanie pliku bazy (wgranie + włączenie do użytku),
|
||||
2. zapytanie o interpretację urodzeniową dla podanych danych wejściowych.
|
||||
|
||||
DLACZEGO OSOBNA USŁUGA, A NIE KONTO Z OGRANICZENIAMI. Ukrycie a nieobecność to
|
||||
dwie różne rzeczy. Tutaj niczego poza tymi dwiema funkcjami NIE MA W OBRAZIE: nie
|
||||
ma tras, nie ma szablonów, nie ma nawet metod w kliencie warstwy logicznej. Obraz
|
||||
tej usługi można komuś oddać i nie oddaje się przy tym niczego ponad to, co widać
|
||||
na ekranie — łącznie z komentarzami w tym pliku, bo one też jadą razem z obrazem.
|
||||
|
||||
PULE SĄ ROZDZIELONE (PRE-29). Każde konto ma własny, izolowany zbiór plików,
|
||||
niewidoczny dla pozostałych kont; pula bierze się WYŁĄCZNIE z loginu zalogowanej
|
||||
osoby, nigdy z pola formularza. Konta są osobne (ASTRODEMO_USERS) — żeby dało się
|
||||
odciąć tę usługę jedną zmienną, bez
|
||||
ruszania kont głównej aplikacji.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import logging
|
||||
import re
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import httpx
|
||||
from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
|
||||
from fastapi.responses import HTMLResponse, RedirectResponse, Response
|
||||
from fastapi.templating import Jinja2Templates
|
||||
|
||||
from app import link_crypto, security, session
|
||||
from app.clients.logic_client import LogicClient
|
||||
|
||||
# Automatyczna dokumentacja WYŁĄCZONA. /docs wypisałoby komplet tras, a ta usługa
|
||||
# ma nie zdradzać nawet własnej powierzchni.
|
||||
app = FastAPI(title="astrodemo", docs_url=None, redoc_url=None, openapi_url=None)
|
||||
security.install(app)
|
||||
|
||||
# ── zasoby (PRE-27) ────────────────────────────────────────────────────────
|
||||
# Katalog NIE jest montowany. Montowanie serwuje wszystko, co w nim leży, każdemu
|
||||
# i bez śladu w dzienniku — a komentarz w arkuszu stylów mówił wprost, że istnieje
|
||||
# więcej, niż widać na ekranie. Tu jest jawna lista: arkusz logowania jest
|
||||
# publiczny, bo
|
||||
# potrzebuje go strona logowania, a cokolwiek innego jest nieznane i nie istnieje.
|
||||
ZASOBY_PUBLICZNE = frozenset({"styles.css"})
|
||||
_KATALOG_ZASOBOW = Path("app/static")
|
||||
|
||||
|
||||
def _bez_komentarzy(tresc: str) -> str:
|
||||
"""Komentarz w pliku statycznym jedzie do przeglądarki bajt w bajt.
|
||||
W repozytorium zostaje — do odpowiedzi nie ma po co trafiać."""
|
||||
tresc = re.sub(r"/\*.*?\*/", "", tresc, flags=re.S)
|
||||
return re.sub(r"\n{3,}", "\n\n", tresc).strip() + "\n"
|
||||
|
||||
|
||||
@lru_cache(maxsize=None)
|
||||
def _zasob(nazwa: str) -> bytes | None:
|
||||
"""Treść zasobu tak, jak pójdzie na drut — albo None, gdy go nie ma."""
|
||||
if nazwa not in ZASOBY_PUBLICZNE:
|
||||
return None
|
||||
sciezka = (_KATALOG_ZASOBOW / nazwa).resolve()
|
||||
# Wyjście poza katalog: `..` w ścieżce albo dowiązanie na zewnątrz.
|
||||
if _KATALOG_ZASOBOW.resolve() not in sciezka.parents or not sciezka.is_file():
|
||||
return None
|
||||
if sciezka.suffix in (".css", ".js"):
|
||||
return _bez_komentarzy(sciezka.read_text(encoding="utf-8")).encode("utf-8")
|
||||
return sciezka.read_bytes()
|
||||
|
||||
|
||||
@app.get("/static/{nazwa:path}")
|
||||
def zasob(nazwa: str):
|
||||
tresc = _zasob(nazwa)
|
||||
if tresc is None:
|
||||
raise HTTPException(status_code=404)
|
||||
typ = "text/css; charset=utf-8" if nazwa.endswith(".css") else "application/octet-stream"
|
||||
return Response(tresc, media_type=typ,
|
||||
headers={"Cache-Control": "public, max-age=3600"})
|
||||
|
||||
templates = Jinja2Templates(directory="app/templates")
|
||||
# Szczegóły awarii idą TUTAJ, nie na ekran (patrz _blad).
|
||||
log = logging.getLogger("astrodemo")
|
||||
templates.env.globals["current_user"] = lambda request: getattr(request.state, "user", "") or ""
|
||||
templates.env.globals["auth_on"] = security.auth_enabled
|
||||
|
||||
def _logic(request: Request) -> LogicClient:
|
||||
"""Klient związany z pulą ZALOGOWANEGO konta.
|
||||
|
||||
Budowany PER ŻĄDANIE, nie raz na moduł: pula musi wynikać z tego, kto się
|
||||
zalogował, a nie z globalnego stanu procesu. Login bierzemy z request.state,
|
||||
które ustawia warstwa logowania — nigdy z pola formularza, bo wtedy
|
||||
wystarczyłoby podstawić cudzy login, żeby czytać cudze bazy."""
|
||||
return LogicClient(tenant=getattr(request.state, "user", "") or "")
|
||||
|
||||
# Stan pliku „w użyciu" — ta sama nazwa, co w warstwie danych (DAN-27). Wpisana
|
||||
# tutaj wprost, bo astrodemo nie importuje tamtej warstwy; literówka objawiłaby
|
||||
# się dopiero na żywo, więc pilnuje jej test.
|
||||
ACTIVE = "active"
|
||||
|
||||
|
||||
def _build_utc(date: str, time: str, tz_offset: float) -> tuple[str, str]:
|
||||
"""Data + godzina lokalna + offset → chwila w UTC.
|
||||
|
||||
Offset podaje się wprost, bez wyszukiwania strefy z współrzędnych — demo ma
|
||||
dwie funkcje, a strefy to trzecia."""
|
||||
try:
|
||||
local = datetime.strptime(f"{date} {time}", "%Y-%m-%d %H:%M")
|
||||
except ValueError as e:
|
||||
raise ValueError("Podaj datę jako RRRR-MM-DD i godzinę jako GG:MM.") from e
|
||||
moment = local.replace(tzinfo=timezone(timedelta(hours=tz_offset)))
|
||||
return moment.astimezone(timezone.utc).isoformat(), local.strftime("%Y-%m-%d %H:%M")
|
||||
|
||||
|
||||
# Jedno zdanie dla wszystkich awarii i CELOWO żadnego szczegółu. Treść wyjątku
|
||||
# niosła nazwę usługi, jej port i nazwy jej tras — czyli mapę tego, co stoi za tym
|
||||
# ekranem, podaną komuś, kto ma widzieć wyłącznie dwa formularze.
|
||||
_AWARIA = "Nie udało się teraz wykonać tej operacji. Spróbuj ponownie za chwilę."
|
||||
|
||||
|
||||
def _blad(e: Exception) -> str:
|
||||
"""Komunikat dla użytkownika. Diagnostyka idzie do dziennika, nie na ekran."""
|
||||
log.warning("operacja nieudana: %s: %s", type(e).__name__, e)
|
||||
return _AWARIA
|
||||
|
||||
|
||||
def _ile_rekordow(report: dict) -> int:
|
||||
return sum(len(s.get("samples") or []) for p in (report.get("positions") or [])
|
||||
for s in (p.get("significators") or []))
|
||||
|
||||
|
||||
@app.get("/", response_class=HTMLResponse)
|
||||
def formularz(request: Request, error: str = "", done: str = ""):
|
||||
return templates.TemplateResponse(request, "index.html",
|
||||
{"result": None, "form": {}, "error": error, "done": done})
|
||||
|
||||
|
||||
@app.post("/", response_class=HTMLResponse)
|
||||
def interpretacja(request: Request, date: str = Form(...), time: str = Form(...),
|
||||
tz_offset: float = Form(0.0), lat: float = Form(0.0), lon: float = Form(0.0)):
|
||||
"""Interpretacja urodzeniowa dla podanych danych. Jedyne pytanie o treść."""
|
||||
form = {"date": date, "time": time, "tz_offset": tz_offset, "lat": lat, "lon": lon}
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "done": "", "moment": None}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
ctx["result"] = _logic(request).report(when_utc_iso=iso_utc, lat=lat, lon=lon)
|
||||
# Ile treści baz wyszło jednym zapytaniem — sama liczba, nigdy treść (PRE-17).
|
||||
security.audit_records(request, _ile_rekordow(ctx["result"]))
|
||||
except ValueError as e:
|
||||
ctx["error"] = str(e)
|
||||
except (httpx.HTTPError, link_crypto.LinkError) as e:
|
||||
ctx["error"] = _blad(e)
|
||||
return templates.TemplateResponse(request, "index.html", ctx)
|
||||
|
||||
|
||||
@app.post("/plik")
|
||||
async def dodaj_plik(request: Request, upload: UploadFile = File(...)):
|
||||
"""Dodanie pliku bazy: wgranie ORAZ włączenie do użytku.
|
||||
|
||||
Jedna czynność, nie dwie: „dodać plik" ma tu znaczyć, że od razu bierze udział
|
||||
w wyszukiwaniu — inaczej po wgraniu nic by się nie zmieniło i wyglądałoby to
|
||||
na zepsute.
|
||||
|
||||
Plik o złym układzie nie wchodzi do użytku, ale NIE JEST tracony — zostaje
|
||||
zapisany i czeka."""
|
||||
raw = await upload.read()
|
||||
if not raw:
|
||||
return RedirectResponse("/?error=Pusty+plik.", status_code=303)
|
||||
|
||||
who = getattr(request.state, "user", "") or "demo"
|
||||
try:
|
||||
out = _logic(request).files_upload(upload.filename or "baza.xlsx",
|
||||
base64.b64encode(raw).decode("ascii"), by=who)
|
||||
except (httpx.HTTPError, link_crypto.LinkError) as e:
|
||||
return _wroc(error=_blad(e))
|
||||
|
||||
nazwa = out.get("name") or "plik"
|
||||
if not out.get("accepted"):
|
||||
# Bez słowa o regułach — te zna wyłącznie administrator (DAN-27).
|
||||
return _wroc(done=f"Plik „{nazwa}” został przyjęty, ale nie nadaje się "
|
||||
f"do użycia w tej postaci.")
|
||||
try:
|
||||
_logic(request).files_status(out["path"], ACTIVE, by=who)
|
||||
except (httpx.HTTPError, link_crypto.LinkError) as e:
|
||||
return _wroc(error=f"Plik „{nazwa}” wgrany, ale nie udało się go włączyć: {_blad(e)}")
|
||||
return _wroc(done=f"Dodano „{nazwa}”. Baza jest już używana przy wyszukiwaniu.")
|
||||
|
||||
|
||||
def _wroc(error: str = "", done: str = "") -> RedirectResponse:
|
||||
"""Po zapisie PRZEKIEROWANIE, nie render — odświeżenie strony nie może
|
||||
wgrać pliku drugi raz."""
|
||||
from urllib.parse import urlencode
|
||||
|
||||
q = urlencode({k: v for k, v in (("error", error), ("done", done)) if v})
|
||||
return RedirectResponse(f"/{'?' + q if q else ''}", status_code=303)
|
||||
|
||||
|
||||
# ---------------- Logowanie i wylogowanie (LOG-34) ----------------
|
||||
# Bez własnego wolumenu nie ma gdzie trzymać licznika pokolenia sesji, więc
|
||||
# „wyrzuć ze wszystkich urządzeń" robi się zmianą hasła w ASTRODEMO_USERS.
|
||||
# Wylogowanie działa natychmiast, bo polega na skasowaniu ciasteczka.
|
||||
|
||||
def _bezpieczne_dokad(dokad: str) -> str:
|
||||
"""Adres powrotu przepuszczony przez sito — bez tego `?dokad=https://obcy.pl`
|
||||
zamieniłby ekran logowania w narzędzie do wyłudzania haseł."""
|
||||
dokad = (dokad or "").strip()
|
||||
if not dokad.startswith("/") or dokad.startswith("//") or "\\" in dokad:
|
||||
return "/"
|
||||
return dokad.split("?", 1)[0].split("#", 1)[0] or "/"
|
||||
|
||||
|
||||
@app.get("/logowanie", response_class=HTMLResponse)
|
||||
def logowanie_form(request: Request, dokad: str = "/", blad: str = ""):
|
||||
if security.auth_enabled() and security.principal(request):
|
||||
return RedirectResponse(_bezpieczne_dokad(dokad), status_code=303)
|
||||
return templates.TemplateResponse(request, "logowanie.html",
|
||||
{"dokad": _bezpieczne_dokad(dokad), "blad": blad})
|
||||
|
||||
|
||||
@app.post("/logowanie")
|
||||
def logowanie(request: Request, login: str = Form(""), haslo: str = Form(""),
|
||||
dokad: str = Form("/")):
|
||||
cel = _bezpieczne_dokad(dokad)
|
||||
kto = security.verify(login.strip(), haslo)
|
||||
if kto is None:
|
||||
security.audit_login(request, login.strip(), udane=False)
|
||||
return templates.TemplateResponse(
|
||||
request, "logowanie.html",
|
||||
{"dokad": cel, "blad": "Nieprawidłowy login lub hasło.", "login": login},
|
||||
status_code=401)
|
||||
security.audit_login(request, kto, udane=True)
|
||||
odpowiedz = RedirectResponse(cel, status_code=303)
|
||||
odpowiedz.set_cookie(session.COOKIE, security.issue_session(kto),
|
||||
max_age=session.max_age(),
|
||||
**session.cookie_params(secure=security.cookies_secure()))
|
||||
return odpowiedz
|
||||
|
||||
|
||||
@app.post("/wyloguj")
|
||||
def wyloguj(request: Request):
|
||||
"""POST, nie odsyłacz: pod adresem GET wystarczyłby obrazek na obcej stronie,
|
||||
żeby wylogować kogoś bez jego wiedzy."""
|
||||
security.audit_logout(request)
|
||||
odpowiedz = RedirectResponse("/logowanie?wylogowano=1", status_code=303)
|
||||
odpowiedz.delete_cookie(session.COOKIE,
|
||||
**session.cookie_params(secure=security.cookies_secure()))
|
||||
return odpowiedz
|
||||
|
||||
|
||||
@app.get("/health")
|
||||
def health() -> dict:
|
||||
# Sama „ok". Nazwa warstwy mówiła, że warstw jest więcej i jak się nazywa;
|
||||
# kubernetes i compose czytają wyłącznie kod odpowiedzi.
|
||||
return {"status": "ok"}
|
||||
@@ -1,266 +0,0 @@
|
||||
"""Logowanie do astrodemo (PRE-28).
|
||||
|
||||
OSOBNE KONTO, NIE WSPÓŁDZIELONE Z GŁÓWNĄ APLIKACJĄ. Demo pracuje na tej samej
|
||||
warstwie danych co produkcja, więc kto ma do niego dostęp, czyta oryginalne bazy
|
||||
interpretacyjne. Własny login i hasło pozwalają odciąć demo jedną zmienną
|
||||
środowiskową, bez ruszania kont głównej aplikacji i bez zmiany hasła komukolwiek.
|
||||
|
||||
Mechanizm jest CELOWO prosty: jedno konto z konfiguracji, bez ekranu kont
|
||||
i bez uprawnień. Ta usługa ma dwie funkcje i obie są dla tego samego człowieka —
|
||||
model uprawnień z PRE-27 nie miałby tu czego dzielić.
|
||||
|
||||
Hasło może być jawne albo jako hash scrypt (`scrypt$sól$hash`), tym samym formatem
|
||||
co APP_USERS w głównej aplikacji — dzięki temu skrypt make_user.py działa na oba.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
import hashlib
|
||||
import hmac
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
from collections import deque
|
||||
|
||||
from fastapi import Request
|
||||
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
|
||||
|
||||
log = logging.getLogger("astrodemo.security")
|
||||
audit_log = logging.getLogger("astrodemo.audit")
|
||||
|
||||
_SCRYPT_N, _SCRYPT_R, _SCRYPT_P, _SCRYPT_LEN = 2**14, 8, 1, 32
|
||||
_HASH_PREFIX = "scrypt$"
|
||||
|
||||
# /logowanie i /wyloguj poza bramką: inaczej żeby się zalogować, trzeba by być
|
||||
# zalogowanym, a wyjście nie działałoby po wygaśnięciu sesji.
|
||||
PUBLIC_PATHS = frozenset({"/health", "/logowanie", "/wyloguj", "/static/styles.css"})
|
||||
# Pusto CELOWO. Prefiks "/static/" przepuszczał CAŁY katalog obok bramki: każdy
|
||||
# plik pobierał ktokolwiek, także niezalogowany, i nie zostawiało to śladu ani
|
||||
# w dzienniku, ani w limicie żądań. Publiczny jest jeden arkusz, wymieniony
|
||||
# z nazwy, bo potrzebuje go ekran logowania.
|
||||
PUBLIC_PREFIXES: tuple[str, ...] = ()
|
||||
|
||||
_hits: dict[str, deque[float]] = {}
|
||||
MAX_TRACKED_CLIENTS = 4096
|
||||
|
||||
|
||||
def accounts() -> dict[str, str]:
|
||||
"""Konta demo: `login:sekret`, po przecinku, ze zmiennej ASTRODEMO_USERS.
|
||||
|
||||
WIELE KONT, bo każde ma WŁASNĄ, niewidoczną dla pozostałych pulę baz (PRE-29).
|
||||
Wspólne konto oznaczałoby wspólną pulę, czyli klientów oglądających nawzajem
|
||||
swoje wgrania.
|
||||
|
||||
Sekret najlepiej jako hash scrypt (`scrypt$sól$hash`) — ten sam format i ten
|
||||
sam skrypt make_user.py, co w głównej aplikacji.
|
||||
|
||||
Zgodność wstecz: pojedyncze ASTRODEMO_USER/ASTRODEMO_PASSWORD działa, gdy ASTRODEMO_USERS
|
||||
jest puste."""
|
||||
out: dict[str, str] = {}
|
||||
for entry in os.getenv("ASTRODEMO_USERS", "").split(","):
|
||||
entry = entry.strip()
|
||||
if not entry:
|
||||
continue
|
||||
user, sep, secret = entry.partition(":")
|
||||
if sep and user.strip() and secret.strip():
|
||||
out[user.strip()] = secret.strip()
|
||||
if out:
|
||||
return out
|
||||
single = os.getenv("ASTRODEMO_PASSWORD", "")
|
||||
return {os.getenv("ASTRODEMO_USER", "demo"): single} if single else {}
|
||||
|
||||
|
||||
def rate_limit_per_min() -> int:
|
||||
return int(os.getenv("RATE_LIMIT_PER_MIN", "60"))
|
||||
|
||||
|
||||
def trust_proxy() -> bool:
|
||||
return os.getenv("TRUST_PROXY", "").strip().lower() in {"1", "true", "yes", "on"}
|
||||
|
||||
|
||||
def auth_enabled() -> bool:
|
||||
return bool(accounts())
|
||||
|
||||
|
||||
def _secret_matches(spec: str, password: str) -> bool:
|
||||
if spec.startswith(_HASH_PREFIX):
|
||||
try:
|
||||
_, salt_hex, hash_hex = spec.split("$", 2)
|
||||
salt, expected = bytes.fromhex(salt_hex), bytes.fromhex(hash_hex)
|
||||
except ValueError:
|
||||
return False
|
||||
actual = hashlib.scrypt(password.encode("utf-8"), salt=salt,
|
||||
n=_SCRYPT_N, r=_SCRYPT_R, p=_SCRYPT_P, dklen=_SCRYPT_LEN)
|
||||
return hmac.compare_digest(actual, expected)
|
||||
# BAJTY, nie tekst: compare_digest na stringach rzuca TypeError przy znakach
|
||||
# spoza ASCII, więc hasło z polskimi literami dawałoby 500 zamiast odmowy.
|
||||
return hmac.compare_digest(spec.encode("utf-8"), password.encode("utf-8"))
|
||||
|
||||
|
||||
def verify(login: str, password: str) -> str | None:
|
||||
"""Sprawdza login i hasło; zwraca login albo None.
|
||||
|
||||
Nieznany login i złe hasło traktujemy tak samo — odmowa nie mówi, które
|
||||
konto istnieje, a przy demo rozdawanym szeroko to realna informacja."""
|
||||
spec = accounts().get(login)
|
||||
if spec is None:
|
||||
return None
|
||||
return login if _secret_matches(spec, password) else None
|
||||
|
||||
|
||||
def issue_session(login: str) -> str:
|
||||
"""Zawartość ciasteczka dla właśnie zalogowanego konta.
|
||||
|
||||
W ciasteczku ląduje ODCISK poświadczenia, więc zmiana hasła albo usunięcie
|
||||
konta z ASTRODEMO_USERS unieważnia jego sesje samo z siebie. To jest tu jedyny
|
||||
sposób zdalnego unieważnienia: demo nie ma gdzie trwale zapisywać stanu,
|
||||
bo nie ma własnego wolumenu — a stan sesji na udziale z bazami klientów
|
||||
byłby pomieszaniem dwóch zupełnie różnych rzeczy."""
|
||||
from app import session
|
||||
|
||||
return session.issue(login, session.fingerprint(accounts().get(login) or ""), 0)
|
||||
|
||||
|
||||
def principal(request: Request) -> str | None:
|
||||
"""Ciasteczko → login zalogowanej osoby albo None."""
|
||||
from app import session
|
||||
|
||||
dane = session.read(request.cookies.get(session.COOKIE))
|
||||
if dane is None:
|
||||
return None
|
||||
spec = accounts().get(dane["login"])
|
||||
if spec is None or session.fingerprint(spec) != dane["odcisk"]:
|
||||
return None
|
||||
return dane["login"]
|
||||
|
||||
|
||||
def client_ip(request: Request) -> str:
|
||||
"""Adres do rozliczania limitu. Nagłówkom wierzymy WYŁĄCZNIE za proxy —
|
||||
inaczej wystarczyłoby podstawić własny X-Forwarded-For, żeby ominąć limit."""
|
||||
peer = request.client.host if request.client else "?"
|
||||
if not trust_proxy():
|
||||
return peer
|
||||
forwarded = request.headers.get("x-forwarded-for", "")
|
||||
if forwarded:
|
||||
last = forwarded.rsplit(",", 1)[-1].strip()
|
||||
if last:
|
||||
return last
|
||||
return request.headers.get("x-real-ip", "").strip() or peer
|
||||
|
||||
|
||||
def _rate_limited(client: str) -> bool:
|
||||
cap = rate_limit_per_min()
|
||||
if cap <= 0:
|
||||
return False
|
||||
now = time.monotonic()
|
||||
window = _hits.get(client)
|
||||
if window is None:
|
||||
if len(_hits) >= MAX_TRACKED_CLIENTS:
|
||||
_hits.clear()
|
||||
window = _hits[client] = deque()
|
||||
while window and now - window[0] > 60.0:
|
||||
window.popleft()
|
||||
if len(window) >= cap:
|
||||
return True
|
||||
window.append(now)
|
||||
return False
|
||||
|
||||
|
||||
def _setup_audit_logging() -> None:
|
||||
"""Własny handler na stdout. Domyślna konfiguracja uvicorna nie obsługuje
|
||||
naszych loggerów, więc wpisy INFO ginęły — dziennik istniał w kodzie, ale był
|
||||
pusty. Niewidoczny dziennik jest gorszy niż jego brak (błąd zastany w PRE-17)."""
|
||||
audit_log.setLevel(os.getenv("AUDIT_LEVEL", "INFO").upper())
|
||||
if not audit_log.handlers:
|
||||
handler = logging.StreamHandler()
|
||||
handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
|
||||
audit_log.addHandler(handler)
|
||||
audit_log.propagate = False
|
||||
|
||||
|
||||
def audit_records(request: Request, count: int) -> None:
|
||||
try:
|
||||
request.state.audit_records = int(count)
|
||||
except (TypeError, ValueError):
|
||||
pass
|
||||
|
||||
|
||||
def cookies_secure() -> bool:
|
||||
"""Ciasteczko tylko dla https. Wyłączane wyłącznie w pracy lokalnej po http —
|
||||
inaczej przeglądarka po prostu go nie zapamięta i logowanie „nie działa"
|
||||
bez żadnego komunikatu."""
|
||||
return os.getenv("COOKIES_INSECURE", "").strip().lower() not in {"1", "true", "yes", "on"}
|
||||
|
||||
|
||||
def audit_login(request: Request, login: str, udane: bool) -> None:
|
||||
"""Zdarzenie logowania. Nieudane próby są ważniejsze od udanych: pojedyncza
|
||||
nic nie znaczy, seria pod jednym adresem to ślad zgadywania haseł. Login tak,
|
||||
hasło NIGDY."""
|
||||
audit_log.info("AUDYT zdarzenie=%s user=%s ip=%s",
|
||||
"logowanie-ok" if udane else "logowanie-odmowa",
|
||||
login or "-", client_ip(request))
|
||||
|
||||
|
||||
def audit_logout(request: Request) -> None:
|
||||
audit_log.info("AUDYT zdarzenie=wylogowanie user=%s ip=%s",
|
||||
getattr(request.state, "user", "") or "-", client_ip(request))
|
||||
|
||||
|
||||
def install(app) -> None:
|
||||
from app import session
|
||||
|
||||
_setup_audit_logging()
|
||||
|
||||
# Fail-closed: konta bez klucza podpisu to sesje nie do odróżnienia od
|
||||
# podrobionych. Lepiej, żeby usługa nie wstała.
|
||||
if auth_enabled() and not session.available():
|
||||
raise session.SessionError(
|
||||
"Konta demo są skonfigurowane, ale brakuje SESSION_SECRET — bez klucza "
|
||||
"podpisu logowanie nie miałoby czym się bronić. openssl rand -hex 32")
|
||||
|
||||
if not auth_enabled():
|
||||
log.warning(
|
||||
"UWAGA: brak kont (ASTRODEMO_USERS / ASTRODEMO_PASSWORD) — astrodemo stoi OTWARTY. "
|
||||
"Bez logowania nie ma też PULI: wszyscy pracowaliby na jednym, wspólnym "
|
||||
"zbiorze baz, widząc nawzajem swoje wgrania."
|
||||
)
|
||||
|
||||
@app.middleware("http")
|
||||
async def _guard(request: Request, call_next):
|
||||
if request.url.path in PUBLIC_PATHS or request.url.path.startswith(PUBLIC_PREFIXES):
|
||||
return await call_next(request)
|
||||
|
||||
started = time.monotonic()
|
||||
if _rate_limited(client_ip(request)):
|
||||
return JSONResponse({"detail": "Zbyt wiele żądań — spróbuj za chwilę."},
|
||||
status_code=429, headers={"Retry-After": "60"})
|
||||
|
||||
user, odswiez = "", None
|
||||
if auth_enabled():
|
||||
user = principal(request) or ""
|
||||
if not user:
|
||||
from urllib.parse import quote
|
||||
|
||||
cel = request.url.path
|
||||
dokad = f"?dokad={quote(cel, safe='/')}" if request.method == "GET" and cel != "/" else ""
|
||||
return RedirectResponse(f"/logowanie{dokad}", status_code=303)
|
||||
from app import session as _s
|
||||
|
||||
dane = _s.read(request.cookies.get(_s.COOKIE))
|
||||
odswiez = _s.refresh(dane) if dane else None
|
||||
request.state.user = user
|
||||
|
||||
response = await call_next(request)
|
||||
if odswiez:
|
||||
from app import session as _s
|
||||
|
||||
response.set_cookie(_s.COOKIE, odswiez, max_age=_s.max_age(),
|
||||
**_s.cookie_params(secure=cookies_secure()))
|
||||
records = getattr(request.state, "audit_records", None)
|
||||
audit_log.info(
|
||||
"AUDYT user=%s ip=%s method=%s path=%s status=%s records=%s ms=%.0f",
|
||||
user or "-", client_ip(request), request.method, request.url.path,
|
||||
response.status_code, "-" if records is None else records,
|
||||
(time.monotonic() - started) * 1000)
|
||||
return response
|
||||
@@ -1,190 +0,0 @@
|
||||
"""Sesje logowania — podpisane ciasteczko (LOG-34).
|
||||
|
||||
Kopia modułu z warstwy prezentacji, tak samo jak link_crypto: usługi są osobnymi
|
||||
obrazami i nie importują się nawzajem. Różni je WYŁĄCZNIE nazwa ciasteczka.
|
||||
|
||||
|
||||
CO ZASTĘPUJE I DLACZEGO. HTTP Basic nie ma wylogowania: przeglądarka zapamiętuje
|
||||
hasło i dosyła je SAMA przy każdym żądaniu, więc serwer nie ma czego zapomnieć.
|
||||
Sesja odwraca tę zależność — to serwer decyduje, czy dana przeglądarka jest
|
||||
w środku, i może tę decyzję cofnąć.
|
||||
|
||||
TRZY POZIOMY UNIEWAŻNIENIA, celowo rozdzielone, bo każdy kosztuje co innego:
|
||||
|
||||
1. WYLOGOWANIE = skasowanie ciasteczka. Natychmiastowe, bez żadnego magazynu,
|
||||
działa wszędzie. To jest to, czego oczekuje człowiek klikający „Wyloguj".
|
||||
2. ZMIANA POŚWIADCZEŃ = odcisk hasła wpisany w ciasteczko przestaje pasować.
|
||||
Zmiana hasła albo skasowanie konta ubija jego sesje SAMO, bez pamiętania
|
||||
o tym — i też nie wymaga magazynu.
|
||||
3. WYLOGOWANIE ZDALNE („wyrzuć ze wszystkich urządzeń") = licznik wersji,
|
||||
który musi gdzieś leżeć. Wymaga zapisu, więc jest opcjonalny: gdy aplikacja
|
||||
nie poda licznika, poziomy 1 i 2 nadal działają.
|
||||
|
||||
Poziom 2 jest tu najważniejszy: bez niego odebranie komuś dostępu przez zmianę
|
||||
hasła zostawiałoby jego otwartą sesję żywą aż do wygaśnięcia — czyli odebranie
|
||||
dostępu nie odbierałoby dostępu.
|
||||
|
||||
KLUCZ JEST WYMAGANY i bez niego usługa się nie uruchamia. Losowanie przy starcie
|
||||
byłoby wygodne, ale oznaczałoby wylogowanie wszystkich przy każdym restarcie
|
||||
poda — co wygląda jak awaria i uczy ludzi ignorować ekran logowania.
|
||||
|
||||
Podpis: HMAC-SHA256 ze stdlib. Bez nowych zależności — ta sama linia co scrypt
|
||||
w PRE-27 i AES w PRE-16.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
|
||||
# Nazwa własna tej usługi. Gdyby dwie aplikacje pod jedną domeną używały
|
||||
# ciasteczka o tej samej nazwie, nadpisywałyby się nawzajem i człowiek wypadałby
|
||||
# z jednej, logując się do drugiej.
|
||||
COOKIE = "astrodemo_sesja"
|
||||
|
||||
# Twardy kres życia sesji i kres bezczynności. Oba w sekundach, oba z konfiguracji.
|
||||
DEFAULT_MAX_AGE = 30 * 24 * 3600 # 30 dni — po tylu i tak każe się zalogować
|
||||
DEFAULT_IDLE = 8 * 3600 # 8 godzin bez ruchu = koniec
|
||||
|
||||
# Co ile odświeżamy znacznik aktywności w ciasteczku. Bez tego progu każde
|
||||
# żądanie odsyłałoby Set-Cookie, także obrazki i arkusze stylów.
|
||||
REFRESH_AFTER = 300
|
||||
|
||||
|
||||
class SessionError(RuntimeError):
|
||||
"""Sesje nie mogą działać — brak klucza albo klucz nie do przyjęcia."""
|
||||
|
||||
|
||||
def _env_int(name: str, default: int) -> int:
|
||||
try:
|
||||
return int(os.getenv(name, "") or default)
|
||||
except ValueError:
|
||||
return default
|
||||
|
||||
|
||||
def max_age() -> int:
|
||||
return _env_int("SESSION_MAX_AGE", DEFAULT_MAX_AGE)
|
||||
|
||||
|
||||
def idle_timeout() -> int:
|
||||
return _env_int("SESSION_IDLE", DEFAULT_IDLE)
|
||||
|
||||
|
||||
def secret() -> bytes:
|
||||
"""Klucz podpisu. Brak = wyjątek, NIE cichy losowy klucz.
|
||||
|
||||
Fail-closed jest tu celowe: usługa bez klucza nie umie odróżnić ważnej sesji
|
||||
od podrobionej, więc lepiej, żeby nie wstała, niż żeby wpuszczała."""
|
||||
raw = os.getenv("SESSION_SECRET", "").strip()
|
||||
if not raw:
|
||||
raise SessionError(
|
||||
"Brak SESSION_SECRET — bez klucza podpisu sesje nie mogą działać. "
|
||||
"Wygeneruj: openssl rand -hex 32")
|
||||
if len(raw) < 32:
|
||||
raise SessionError(
|
||||
f"SESSION_SECRET ma {len(raw)} znaków — za krótki. Wymagane co najmniej 32; "
|
||||
f"krótki klucz da się odgadnąć, a wtedy podrobienie sesji jest trywialne.")
|
||||
return raw.encode("utf-8")
|
||||
|
||||
|
||||
def available() -> bool:
|
||||
"""Czy sesje da się w ogóle obsłużyć (do sprawdzenia przy starcie)."""
|
||||
try:
|
||||
secret()
|
||||
except SessionError:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def fingerprint(secret_spec: str) -> str:
|
||||
"""Odcisk poświadczenia konta — 16 znaków hasza z hasła (albo jego hasza).
|
||||
|
||||
NIE JEST to hasło ani nic, z czego da się je odtworzyć: bierzemy skrót
|
||||
zapisanego sekretu, a ten dla kont zarządzanych sam jest już haszem scrypt.
|
||||
Do ciasteczka trafia po to, żeby zmiana hasła albo skasowanie konta
|
||||
unieważniły jego sesje same z siebie."""
|
||||
return hashlib.sha256(("odcisk:" + (secret_spec or "")).encode("utf-8")).hexdigest()[:16]
|
||||
|
||||
|
||||
def _sign(payload: bytes) -> bytes:
|
||||
return hmac.new(secret(), payload, hashlib.sha256).digest()
|
||||
|
||||
|
||||
def _b64(raw: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def _unb64(text: str) -> bytes:
|
||||
return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
|
||||
|
||||
|
||||
def issue(login: str, odcisk: str, wersja: int = 0, *, now: float | None = None) -> str:
|
||||
"""Nowe ciasteczko sesji dla konta."""
|
||||
teraz = int(now if now is not None else time.time())
|
||||
payload = json.dumps(
|
||||
{"u": login, "f": odcisk, "v": int(wersja), "wyd": teraz, "akt": teraz},
|
||||
separators=(",", ":"), sort_keys=True).encode("utf-8")
|
||||
return f"{_b64(payload)}.{_b64(_sign(payload))}"
|
||||
|
||||
|
||||
def read(token: str | None, *, now: float | None = None) -> dict | None:
|
||||
"""Ciasteczko → zawartość albo None, gdy cokolwiek się nie zgadza.
|
||||
|
||||
None znaczy „nie wpuszczać" i nie mówi dlaczego — powód jest tu bez wartości
|
||||
dla wołającego, a rozróżnianie „zła sygnatura" od „wygasło" tylko pomaga
|
||||
zgadywać. Wygaśnięcie i tak kończy się tym samym ekranem logowania."""
|
||||
if not token or "." not in token:
|
||||
return None
|
||||
surowy, _, podpis = token.rpartition(".")
|
||||
try:
|
||||
payload = _unb64(surowy)
|
||||
oczekiwany = _sign(payload)
|
||||
podany = _unb64(podpis)
|
||||
except (ValueError, SessionError):
|
||||
return None
|
||||
# Porównanie w stałym czasie: zwykłe == przecieka informację o tym, ile
|
||||
# pierwszych bajtów podpisu się zgadza, a to wystarcza do podrobienia.
|
||||
if not hmac.compare_digest(oczekiwany, podany):
|
||||
return None
|
||||
try:
|
||||
dane = json.loads(payload.decode("utf-8"))
|
||||
login, odcisk = str(dane["u"]), str(dane["f"])
|
||||
wersja, wyd, akt = int(dane["v"]), int(dane["wyd"]), int(dane["akt"])
|
||||
except (ValueError, KeyError, TypeError):
|
||||
return None
|
||||
|
||||
teraz = int(now if now is not None else time.time())
|
||||
# Ciasteczko z przyszłości oznacza przestawiony zegar albo podrobienie —
|
||||
# w obu wypadkach nie ma powodu mu ufać.
|
||||
if wyd > teraz + 60:
|
||||
return None
|
||||
if teraz - wyd > max_age() or teraz - akt > idle_timeout():
|
||||
return None
|
||||
return {"login": login, "odcisk": odcisk, "wersja": wersja, "wydano": wyd, "aktywnosc": akt}
|
||||
|
||||
|
||||
def refresh(dane: dict, *, now: float | None = None) -> str | None:
|
||||
"""Odświeżone ciasteczko, gdy znacznik aktywności zdążył się zestarzeć.
|
||||
|
||||
None = nie ma potrzeby nic odsyłać. Bez tego progu każde żądanie zwracałoby
|
||||
Set-Cookie — także po arkusze stylów i obrazki."""
|
||||
teraz = int(now if now is not None else time.time())
|
||||
if teraz - dane["aktywnosc"] < REFRESH_AFTER:
|
||||
return None
|
||||
payload = json.dumps(
|
||||
{"u": dane["login"], "f": dane["odcisk"], "v": dane["wersja"],
|
||||
"wyd": dane["wydano"], "akt": teraz},
|
||||
separators=(",", ":"), sort_keys=True).encode("utf-8")
|
||||
return f"{_b64(payload)}.{_b64(_sign(payload))}"
|
||||
|
||||
|
||||
def cookie_params(secure: bool = True) -> dict:
|
||||
"""Ustawienia ciasteczka wspólne dla ustawiania i kasowania.
|
||||
|
||||
httponly — JavaScript nie ma po co go czytać, a bez tego jeden wstrzyknięty
|
||||
skrypt wynosi sesję. samesite=strict — odcina większość ataków polegających
|
||||
na tym, że obca strona wysyła żądanie w imieniu zalogowanego."""
|
||||
return {"httponly": True, "samesite": "strict", "secure": secure, "path": "/"}
|
||||
@@ -1,63 +0,0 @@
|
||||
/* Arkusz CELOWO minimalny: dwa formularze i tabela wyników. Każda klasa ponad to
|
||||
niosłaby nazwę funkcji, której tu nie ma. */
|
||||
:root {
|
||||
--bg: #11121b; --panel: #191b26; --line: #2b2e3d;
|
||||
--fg: #e8e9f0; --muted: #9aa0b4; --accent: #8ab4ff;
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body {
|
||||
margin: 0; background: var(--bg); color: var(--fg);
|
||||
font: 15px/1.5 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
|
||||
}
|
||||
main { max-width: 880px; margin: 0 auto; padding: 1.5rem 1rem 3rem; }
|
||||
.topbar { padding: .5rem 0 1rem; border-bottom: 1px solid var(--line);
|
||||
display: flex; align-items: baseline; justify-content: space-between; gap: 1rem; }
|
||||
.kto { display: flex; align-items: center; gap: .5rem; }
|
||||
.whoami { color: var(--muted); font-size: .85rem; }
|
||||
.wyloguj-form { display: inline; margin: 0; }
|
||||
button.wyloguj {
|
||||
background: none; border: 1px solid var(--line); color: var(--muted);
|
||||
font: inherit; font-weight: 400; padding: .35rem .8rem; border-radius: 8px; cursor: pointer;
|
||||
}
|
||||
button.wyloguj:hover { color: var(--fg); }
|
||||
|
||||
/* Ekran logowania — wąski, bez niczego poza formularzem. */
|
||||
.login-card label { display: block; margin-top: .75rem; }
|
||||
.login-card input { width: 100%; }
|
||||
h1 { margin: 0; font-size: 1.4rem; letter-spacing: .5px; }
|
||||
h2 { margin: 0 0 .3rem; font-size: 1.05rem; }
|
||||
h3 { margin: 0 0 .5rem; font-size: 1rem; }
|
||||
|
||||
.card {
|
||||
margin-top: 1.25rem; padding: 1rem 1.25rem;
|
||||
background: var(--panel); border: 1px solid var(--line); border-radius: 12px;
|
||||
}
|
||||
.row { display: flex; gap: .75rem; flex-wrap: wrap; align-items: flex-end; margin-top: .6rem; }
|
||||
label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 10rem; }
|
||||
input {
|
||||
width: 100%; padding: .45rem .6rem; background: #0e0f18; color: var(--fg);
|
||||
border: 1px solid var(--line); border-radius: 8px; font: inherit;
|
||||
}
|
||||
button {
|
||||
padding: .5rem 1.25rem; background: var(--accent); color: #10121a;
|
||||
border: none; border-radius: 8px; font: inherit; font-weight: 600; cursor: pointer;
|
||||
}
|
||||
|
||||
table { width: 100%; border-collapse: collapse; margin-top: .3rem; }
|
||||
td { padding: .35rem .5rem; border-bottom: 1px solid var(--line); vertical-align: top; font-size: .92rem; }
|
||||
td.key { color: var(--accent); white-space: nowrap; padding-right: 1rem; }
|
||||
tr:last-child td { border-bottom: none; }
|
||||
|
||||
.sig { margin-top: .75rem; }
|
||||
.sig-head { color: var(--muted); font-size: .85rem; }
|
||||
.meta { color: var(--muted); margin: 1.5rem 0 .5rem; font-size: .9rem; }
|
||||
.muted { color: var(--muted); }
|
||||
.small { font-size: .85rem; }
|
||||
.foot { margin-top: 2.5rem; color: var(--muted); font-size: .8rem; }
|
||||
|
||||
.alert, .ok {
|
||||
margin: 1rem 0; padding: .6rem .9rem; border-radius: 8px; font-size: .92rem;
|
||||
border: 1px solid var(--line); border-left-width: 4px;
|
||||
}
|
||||
.alert { border-left-color: #b8860b; background: rgba(184, 134, 11, .1); }
|
||||
.ok { border-left-color: var(--accent); background: rgba(138, 180, 255, .08); }
|
||||
@@ -1,30 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="pl">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>astrodemo · {% block title %}{% endblock %}</title>
|
||||
<link rel="stylesheet" href="/static/styles.css">
|
||||
</head>
|
||||
<body>
|
||||
<main>
|
||||
<header class="topbar">
|
||||
<h1>astrodemo</h1>
|
||||
{# Kto jest zalogowany i wyjście. Demo bywa używane na cudzych komputerach,
|
||||
więc bez tego pierwszy klient zostawia otwartą sesję drugiemu. #}
|
||||
{% if auth_on() %}
|
||||
<div class="kto">
|
||||
<span class="whoami">{{ current_user(request) }}</span>
|
||||
<form method="post" action="/wyloguj" class="wyloguj-form">
|
||||
<button type="submit" class="wyloguj">Wyloguj</button>
|
||||
</form>
|
||||
</div>
|
||||
{% endif %}
|
||||
{# CELOWO BEZ NAWIGACJI. Dwie funkcje mieszczą się na jednym ekranie,
|
||||
a pasek zakładek z jedną pozycją tylko sugerowałby, że są inne. #}
|
||||
</header>
|
||||
{% block content %}{% endblock %}
|
||||
<footer class="foot">wersja demonstracyjna</footer>
|
||||
</main>
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,87 +0,0 @@
|
||||
{% extends "base.html" %}
|
||||
{% block title %}Interpretacja{% endblock %}
|
||||
|
||||
{% block content %}
|
||||
{% if error %}<p class="alert">{{ error }}</p>{% endif %}
|
||||
{% if done %}<p class="ok">{{ done }}</p>{% endif %}
|
||||
|
||||
<section class="card">
|
||||
<h2>Dodaj bazę</h2>
|
||||
<p class="muted small">
|
||||
Wgrany plik zaczyna być używany od razu przy wyszukiwaniu interpretacji.
|
||||
</p>
|
||||
<form method="post" action="/plik" enctype="multipart/form-data">
|
||||
<div class="row">
|
||||
<label>Plik <input type="file" name="upload" required></label>
|
||||
<button type="submit">Dodaj</button>
|
||||
</div>
|
||||
</form>
|
||||
</section>
|
||||
|
||||
<section class="card">
|
||||
<h2>Zapytaj o interpretację urodzeniową</h2>
|
||||
<form method="post" action="/">
|
||||
<div class="row">
|
||||
<label>Data urodzenia
|
||||
<input type="date" name="date" value="{{ form.date or '' }}" required></label>
|
||||
<label>Godzina (lokalna)
|
||||
<input type="time" name="time" value="{{ form.time or '' }}" required></label>
|
||||
<label>Offset względem GMT (h)
|
||||
<input type="number" name="tz_offset" step="0.5" value="{{ form.tz_offset if form.tz_offset is not none else 0 }}"></label>
|
||||
</div>
|
||||
<div class="row">
|
||||
<label>Szerokość (lat, + N)
|
||||
<input type="number" name="lat" step="0.0001" value="{{ form.lat if form.lat is not none else 0 }}" required></label>
|
||||
<label>Długość (lon, + E)
|
||||
<input type="number" name="lon" step="0.0001" value="{{ form.lon if form.lon is not none else 0 }}" required></label>
|
||||
<button type="submit">Szukaj interpretacji</button>
|
||||
</div>
|
||||
</form>
|
||||
</section>
|
||||
|
||||
{% if result %}
|
||||
<p class="meta">
|
||||
Moment: <strong>{{ moment }}</strong>
|
||||
{% if result.engine %}· silnik: {{ result.engine }}{% endif %}
|
||||
{% if result.objects %}· obiektów: {{ result.objects | length }}{% endif %}
|
||||
</p>
|
||||
|
||||
{# Kształt odpowiedzi: objects[] → facets[] → samples[]. Pytamy bez grupowania,
|
||||
więc `groups` tu nie wystąpi i nie ma czego obsługiwać. #}
|
||||
{% set znaleziono = namespace(ile=0) %}
|
||||
{% for o in result.objects or [] %}
|
||||
{% set trafienia = o.facets | selectattr('samples') | list %}
|
||||
{% if trafienia %}
|
||||
{% set znaleziono.ile = znaleziono.ile + trafienia | length %}
|
||||
<section class="card">
|
||||
<h3>{{ o.object }}
|
||||
<span class="muted">w {{ o.sign }}{% if o.house %}, {{ o.house }}. dom{% endif %}
|
||||
{%- if o.direction == 'Rx' %} · Rx{% endif %}</span>
|
||||
</h3>
|
||||
{% for f in trafienia %}
|
||||
<div class="sig">
|
||||
<div class="sig-head">{{ f.label }} <span class="muted small">— {{ f.count }} dopasowań</span></div>
|
||||
<table>
|
||||
<tbody>
|
||||
{% for s in f.samples %}
|
||||
<tr>
|
||||
<td class="key" title="{{ s.significator }}">{{ s.expanded }}</td>
|
||||
<td>{{ s.effect }}</td>
|
||||
</tr>
|
||||
{% endfor %}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
{% endfor %}
|
||||
</section>
|
||||
{% endif %}
|
||||
{% endfor %}
|
||||
|
||||
{% if znaleziono.ile == 0 %}
|
||||
<p class="muted">
|
||||
Nie znaleziono interpretacji dla tych danych. Sprawdź, czy dodano bazę
|
||||
zawierającą pasujące opisy.
|
||||
</p>
|
||||
{% endif %}
|
||||
{% endif %}
|
||||
{% endblock %}
|
||||
@@ -1,36 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="pl">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>astrodemo · logowanie</title>
|
||||
<link rel="stylesheet" href="/static/styles.css">
|
||||
</head>
|
||||
<body>
|
||||
<main class="login-main">
|
||||
<header class="topbar"><h1>astrodemo</h1></header>
|
||||
|
||||
{% if request.query_params.get('wylogowano') %}
|
||||
<p class="ok">Wylogowano.</p>
|
||||
{% endif %}
|
||||
{% if blad %}<p class="alert">{{ blad }}</p>{% endif %}
|
||||
|
||||
<form method="post" action="/logowanie" class="card login-card">
|
||||
{# Adres powrotu jedzie w ukrytym polu, ale i tak przechodzi przez sito
|
||||
po stronie serwera — pole formularza jest wejściem od użytkownika. #}
|
||||
<input type="hidden" name="dokad" value="{{ dokad }}">
|
||||
<label>Login
|
||||
<input type="text" name="login" value="{{ login or '' }}" required
|
||||
autocomplete="username" autofocus></label>
|
||||
<label>Hasło
|
||||
<input type="password" name="haslo" required autocomplete="current-password"></label>
|
||||
<div class="actions"><button type="submit">Zaloguj</button></div>
|
||||
</form>
|
||||
|
||||
<p class="muted small login-note">
|
||||
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.
|
||||
</p>
|
||||
</main>
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,2 +0,0 @@
|
||||
-r requirements.txt
|
||||
pytest>=8.0
|
||||
@@ -1,11 +0,0 @@
|
||||
# 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
|
||||
@@ -1,301 +0,0 @@
|
||||
"""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}"
|
||||
@@ -1,192 +0,0 @@
|
||||
"""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)(?<![\w-]){re.escape(igla)}", tresc):
|
||||
out.append(f"{gdzie}: „{igla}”")
|
||||
for wzor, powod in (WZORCE if slownik is None else WZORCE[-1:]):
|
||||
m = re.search(wzor, tresc)
|
||||
if m:
|
||||
out.append(f"{gdzie}: „{m.group(0)}” — {powod}")
|
||||
return out
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def klient(monkeypatch):
|
||||
monkeypatch.setenv("ASTRODEMO_USERS", "demo:tajne-demo")
|
||||
monkeypatch.setenv("SESSION_SECRET", "t" * 64)
|
||||
monkeypatch.setenv("COOKIES_INSECURE", "1")
|
||||
monkeypatch.setenv("RATE_LIMIT_PER_MIN", "0")
|
||||
from starlette.testclient import TestClient
|
||||
|
||||
from app.main import app
|
||||
|
||||
return TestClient(app, follow_redirects=False)
|
||||
|
||||
|
||||
def test_nothing_forbidden_reaches_an_anonymous_visitor(klient):
|
||||
grzechy, obejrzane = [], 0
|
||||
for adres in ("/logowanie", "/health", "/static/styles.css"):
|
||||
r = klient.get(adres)
|
||||
assert r.status_code == 200, f"{adres}: {r.status_code}"
|
||||
obejrzane += 1
|
||||
grzechy += _grzechy(r.text, adres)
|
||||
assert obejrzane == 3
|
||||
assert not grzechy, "\n" + "\n".join(grzechy)
|
||||
|
||||
|
||||
def test_nothing_forbidden_reaches_a_logged_in_visitor(klient, monkeypatch):
|
||||
from app import security, session
|
||||
|
||||
naglowki = {"Cookie": f"{session.COOKIE}={security.issue_session('demo')}"}
|
||||
# Warstwa logiczna niedostępna CELOWO: ekran idzie wtedy ścieżką błędu,
|
||||
# a to komunikaty o awarii wypisywały nazwy warstw i tras.
|
||||
import httpx
|
||||
|
||||
from app.main import LogicClient
|
||||
|
||||
monkeypatch.setattr(LogicClient, "report",
|
||||
lambda *a, **k: (_ for _ in ()).throw(httpx.ConnectError("nie da rady")))
|
||||
grzechy = []
|
||||
for adres in ("/", "/static/styles.css"):
|
||||
r = klient.get(adres, headers=naglowki)
|
||||
assert r.status_code == 200, f"{adres}: {r.status_code}"
|
||||
grzechy += _grzechy(r.text, adres)
|
||||
r = klient.post("/", headers=naglowki,
|
||||
data={"date": "1984-04-30", "time": "11:20", "tz_offset": "2",
|
||||
"lat": "50.06", "lon": "19.94"})
|
||||
grzechy += _grzechy(r.text, "POST /")
|
||||
assert not grzechy, "\n" + "\n".join(grzechy)
|
||||
|
||||
|
||||
# Stałe protokołu łącza (nagłówki, typ treści, etykieta HKDF) niosą nazwę rodziny
|
||||
# produktów, ale są WSPÓLNE z warstwą logiczną: zmiana wymaga jednoczesnej zmiany
|
||||
# we wszystkich usługach i rotacji, więc to osobna decyzja. Nie idą do przeglądarki.
|
||||
BEZ_KONTROLI = {"app/link_crypto.py"}
|
||||
|
||||
|
||||
def test_the_source_tree_itself_carries_no_trace():
|
||||
"""„Bez śladu w kodzie" znaczy: grep po obrazie ma nic nie znaleźć.
|
||||
|
||||
Odpowiedź może być czysta, a plik i tak nieść komentarz — dokładnie tak
|
||||
wyciekał arkusz stylów, zanim komentarze zaczęły być zdejmowane."""
|
||||
# Identyfikatory wymagań (PRE-28, LOG-34) zostają: to notatki inżynierskie
|
||||
# o tej usłudze, nie informacja o istnieniu czegoś większego.
|
||||
grzechy = []
|
||||
for f in APP.rglob("*"):
|
||||
wzgledna = str(f.relative_to(APP.parent))
|
||||
if (not f.is_file() or "__pycache__" in str(f) or f.suffix == ".pyc"
|
||||
or wzgledna in BEZ_KONTROLI):
|
||||
continue
|
||||
try:
|
||||
grzechy += _grzechy(f.read_text(encoding="utf-8"),
|
||||
str(f.relative_to(APP.parent)), WSZEDZIE)
|
||||
except UnicodeDecodeError:
|
||||
continue
|
||||
assert not grzechy, "\n" + "\n".join(grzechy)
|
||||
|
||||
|
||||
def test_an_unknown_asset_is_indistinguishable_from_one_that_never_existed(klient):
|
||||
from app import security, session
|
||||
|
||||
naglowki = {"Cookie": f"{session.COOKIE}={security.issue_session('demo')}"}
|
||||
nieistniejacy = klient.get("/static/nie-ma-takiego.js", headers=naglowki)
|
||||
for adres in ("/static/main.py", "/static/../app/config.py", "/static/vendor/cokolwiek.js"):
|
||||
r = klient.get(adres, headers=naglowki)
|
||||
assert r.status_code == nieistniejacy.status_code == 404, f"{adres}: {r.status_code}"
|
||||
assert r.text == nieistniejacy.text
|
||||
|
||||
|
||||
def test_the_protocol_constants_are_the_one_known_exception():
|
||||
"""Świadomie zostawiona dziura — opisana, żeby nie była przypadkiem.
|
||||
|
||||
Stałe łącza międzywarstwowego (`X-Astrololo-Token`, `X-Astrololo-Enc`, typ
|
||||
treści, etykieta HKDF) niosą nazwę rodziny produktów. Są WSPÓLNE z warstwą
|
||||
logiczną, więc zmiana wymaga jednoczesnej podmiany we wszystkich usługach
|
||||
i rotacji sekretów — to osobna decyzja, nie efekt uboczny tej zmiany.
|
||||
|
||||
Warunek, pod jakim to zostaje: te stałe nie mają prawa dotrzeć do
|
||||
przeglądarki. Idą wyłącznie w nagłówkach żądań DO warstwy logicznej.
|
||||
Ten test pilnuje właśnie tego warunku, a nie samego istnienia stałych.
|
||||
"""
|
||||
rdzen = "astrololo"
|
||||
protokol = [f for f in APP.rglob("*.py")
|
||||
if f.is_file() and rdzen in f.read_text(encoding="utf-8").lower()]
|
||||
assert protokol, "stałe zniknęły — jeśli je przemianowano, ten wyjątek jest zbędny"
|
||||
for f in protokol:
|
||||
tresc = f.read_text(encoding="utf-8").lower()
|
||||
for linia in tresc.splitlines():
|
||||
if rdzen not in linia:
|
||||
continue
|
||||
# Każde wystąpienie musi być stałą protokołu albo nazwą kanału logów —
|
||||
# nigdy tekstem, który mógłby trafić do szablonu.
|
||||
assert any(z in linia for z in ("x-astrololo", "vnd.astrololo",
|
||||
"astrololo/link/", 'getlogger("astrololo')), \
|
||||
f"{f.name}: „{linia.strip()[:70]}” to nie jest stała protokołu"
|
||||
|
||||
|
||||
def test_only_the_application_code_ships_in_the_image():
|
||||
"""Obraz nie może wieźć tego testu.
|
||||
|
||||
Ironia, którą łatwo przeoczyć: plik pilnujący, żeby pewne słowa nie padły,
|
||||
sam je wypisuje — więc gdy trafi do obrazu, staje się tym wyciekiem, przed
|
||||
którym broni. `COPY . .` wnosiło cały katalog usługi, razem z tests/.
|
||||
"""
|
||||
# Same instrukcje, bez komentarzy: komentarz obok tej linii CYTUJE dawną
|
||||
# postać, więc szukanie po całym pliku zgłaszałoby własne wyjaśnienie.
|
||||
instrukcje = [l for l in (APP.parent / "Dockerfile").read_text(encoding="utf-8").splitlines()
|
||||
if l.strip() and not l.lstrip().startswith("#")]
|
||||
assert not any(l.strip() == "COPY . ." for l in instrukcje), "obraz wnosi wszystko, w tym testy"
|
||||
assert any(l.strip() == "COPY app ./app" for l in instrukcje)
|
||||
@@ -37,9 +37,6 @@ class Settings:
|
||||
query_cache_ttl: int = field(default_factory=lambda: int(os.getenv("QUERY_CACHE_TTL", "300")))
|
||||
|
||||
# Warstwa SQL (po migracji)
|
||||
# Domyślnie SQLite w cache — do testów i pracy lokalnej, bez stawiania bazy.
|
||||
# Na klastrze SQL_URL wskazuje Postgresa i przychodzi z SEKRETU, bo niesie
|
||||
# hasło (patrz deploy: astrololo/README-postgres.md).
|
||||
sql_url: str = field(
|
||||
default_factory=lambda: os.getenv("SQL_URL", "sqlite:///./.cache/astrololo.db")
|
||||
)
|
||||
|
||||
@@ -1,379 +0,0 @@
|
||||
"""Rejestr plików baz: stan użycia, wgrywanie, archiwizacja, walidacja (DAN-27).
|
||||
|
||||
CO SIĘ ZMIENIA WZGLĘDEM DAN-15. Dotąd włączanie i wyłączanie baz szło przez
|
||||
zmienną `DISABLED_BASES` — deklaratywnie, bo warstwa danych nie miała gdzie
|
||||
zapisywać stanu (udział read-only, cache jako emptyDir). Teraz stan jest KLIKANY,
|
||||
więc musi być trwały: udział jest zapisywalny, a stan leży w pliku obok baz.
|
||||
|
||||
STANY PLIKU
|
||||
active — bierze udział w wyszukiwaniu,
|
||||
ready — sprawny, ale świadomie odstawiony; można włączyć jednym kliknięciem,
|
||||
archived — ZAMROŻONY: nie bierze udziału, ma znacznik czasu archiwizacji,
|
||||
sam plik zostaje nietknięty. To jedyna forma „usuwania" dostępna
|
||||
osobie wgrywającej dane,
|
||||
quarantine — wgrany, ale nie przeszedł walidacji. NIE JEST TRACONY; decyzję,
|
||||
czy go skasować, podejmuje wyłącznie administrator.
|
||||
|
||||
DLACZEGO KWARANTANNA JEST NIEWIDOCZNA POZA ADMINISTRATOREM. Zasada z PRE-27 mówi,
|
||||
że konto ograniczone nie ma skąd wiedzieć o mechanizmach, których nie obsługuje.
|
||||
Gdyby plik w kwarantannie był widoczny z powodem odrzucenia, każdy wgrywający
|
||||
poznałby reguły walidacji — a te są narzędziem administratora. Osoba wgrywająca
|
||||
widzi więc plik jako „oczekuje na zatwierdzenie", bez powodu i bez reguł.
|
||||
|
||||
REGUŁY WALIDACJI są danymi, nie kodem: administrator ustawia je z ekranu. Trzymamy
|
||||
je w tym samym pliku stanu, bo stan i reguły zmieniają się razem i muszą przetrwać
|
||||
restart tak samo.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import tempfile
|
||||
import threading
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
ACTIVE, READY, ARCHIVED, QUARANTINE = "active", "ready", "archived", "quarantine"
|
||||
|
||||
# Nazwa puli może przyjść z zewnątrz (login konta w wersji demo), więc przechodzi
|
||||
# przez sito: wyłącznie znaki bezpieczne w nazwie katalogu. Bez tego „../..” albo
|
||||
# ukośnik wyprowadziłyby zapytanie poza udział — czyli wprost do cudzych baz.
|
||||
_TENANT_OK = re.compile(r"[^A-Za-z0-9._-]")
|
||||
|
||||
|
||||
def tenant_root(root: Path | str, tenant: str = "") -> 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.
|
||||
# Kwarantanna świadomie poza listą — patrz nagłówek modułu.
|
||||
VISIBLE_TO_EVERYONE = frozenset({ACTIVE, READY, ARCHIVED})
|
||||
|
||||
_lock = threading.Lock()
|
||||
|
||||
DEFAULT_RULES: dict = {
|
||||
"extensions": [".xlsx"],
|
||||
"max_size_mb": 50,
|
||||
"min_rows": 1,
|
||||
"required_columns": [], # puste = bez wymagań co do nagłówków
|
||||
"reject_duplicate_content": True,
|
||||
}
|
||||
|
||||
|
||||
def state_path(root: Path | str) -> Path:
|
||||
"""Plik stanu — obok baz, chyba że wskazano inaczej.
|
||||
|
||||
Sprawdzamy NAPIS ze środowiska, nie Path(napis): Path("") to Path("."),
|
||||
czyli wartość PRAWDZIWA, więc `Path(os.getenv(...)) or domyślna` zawsze
|
||||
wybierało pustą zmienną i zapisywało stan do katalogu bieżącego."""
|
||||
override = os.getenv("FILES_STATE", "").strip()
|
||||
return Path(override) if override else Path(root) / ".files-state.json"
|
||||
|
||||
|
||||
def _now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat(timespec="seconds")
|
||||
|
||||
|
||||
def sha256_of(path: Path | str) -> str:
|
||||
"""Skrót treści pliku — tożsamość pliku niezależna od nazwy.
|
||||
|
||||
Przyda się też krokowi drugiemu (lustro w SQL): to po nim poznamy, że plik
|
||||
na dysku rozjechał się z tym, co wczytano do bazy."""
|
||||
h = hashlib.sha256()
|
||||
with open(path, "rb") as fh:
|
||||
for chunk in iter(lambda: fh.read(1024 * 1024), b""):
|
||||
h.update(chunk)
|
||||
return h.hexdigest()
|
||||
|
||||
|
||||
# ── stan ─────────────────────────────────────────────────────────────────
|
||||
|
||||
def _read_state(root: Path) -> dict:
|
||||
try:
|
||||
with open(state_path(root), encoding="utf-8") as fh:
|
||||
data = json.load(fh)
|
||||
except (FileNotFoundError, json.JSONDecodeError):
|
||||
data = {}
|
||||
files = data.get("files")
|
||||
rules = data.get("rules")
|
||||
return {
|
||||
"files": files if isinstance(files, dict) else {},
|
||||
"rules": {**DEFAULT_RULES, **(rules if isinstance(rules, dict) else {})},
|
||||
}
|
||||
|
||||
|
||||
def _write_state(root: Path, data: dict) -> None:
|
||||
path = state_path(root)
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
# Atomowo: plik stanu opisuje CAŁY zbiór baz, więc obcięcie go w połowie
|
||||
# zapisu skasowałoby wiedzę o wszystkich naraz.
|
||||
fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
|
||||
try:
|
||||
with os.fdopen(fd, "w", encoding="utf-8") as fh:
|
||||
json.dump(data, fh, ensure_ascii=False, indent=1, sort_keys=True)
|
||||
fh.flush()
|
||||
os.fsync(fh.fileno())
|
||||
os.replace(tmp, path)
|
||||
except BaseException:
|
||||
Path(tmp).unlink(missing_ok=True)
|
||||
raise
|
||||
|
||||
|
||||
def rules(root: Path | str) -> dict:
|
||||
return _read_state(Path(root))["rules"]
|
||||
|
||||
|
||||
def set_rules(root: Path | str, new: dict) -> dict:
|
||||
root = Path(root)
|
||||
with _lock:
|
||||
data = _read_state(root)
|
||||
merged = {**data["rules"]}
|
||||
for key, value in (new or {}).items():
|
||||
if key in DEFAULT_RULES:
|
||||
merged[key] = value
|
||||
data["rules"] = merged
|
||||
_write_state(root, data)
|
||||
return merged
|
||||
|
||||
|
||||
# ── walidacja ────────────────────────────────────────────────────────────
|
||||
|
||||
def validate(path: Path | str, root: Path | str, *, digest: str = "",
|
||||
known_digests: dict[str, str] | None = None) -> list[str]:
|
||||
"""Lista POWODÓW odrzucenia. Pusta lista = plik nadaje się do użytku.
|
||||
|
||||
Zwracamy powody, a nie samo „tak/nie", bo administrator ma zobaczyć, CZEGO
|
||||
plikowi brakuje — inaczej poprawianie bazy byłoby zgadywanką. Poza konto
|
||||
administracyjne ta lista nie wychodzi."""
|
||||
p, rs = Path(path), rules(root)
|
||||
why: list[str] = []
|
||||
|
||||
exts = [str(e).lower() for e in rs.get("extensions") or []]
|
||||
if exts and p.suffix.lower() not in exts:
|
||||
why.append(f"rozszerzenie {p.suffix or '(brak)'} spoza dozwolonych: {', '.join(exts)}")
|
||||
|
||||
try:
|
||||
size_mb = p.stat().st_size / (1024 * 1024)
|
||||
except OSError:
|
||||
return why + ["pliku nie da się odczytać"]
|
||||
cap = float(rs.get("max_size_mb") or 0)
|
||||
if cap and size_mb > cap:
|
||||
why.append(f"rozmiar {size_mb:.1f} MB przekracza limit {cap:g} MB")
|
||||
|
||||
if rs.get("reject_duplicate_content") and known_digests:
|
||||
digest = digest or sha256_of(p)
|
||||
twin = next((name for name, d in known_digests.items()
|
||||
if d == digest and name != p.name), None)
|
||||
if twin:
|
||||
why.append(f"treść identyczna z plikiem „{twin}”")
|
||||
|
||||
required = [str(c).strip() for c in (rs.get("required_columns") or []) if str(c).strip()]
|
||||
min_rows = int(rs.get("min_rows") or 0)
|
||||
if required or min_rows:
|
||||
why += _inspect_workbook(p, required, min_rows)
|
||||
return why
|
||||
|
||||
|
||||
def _inspect_workbook(path: Path, required: list[str], min_rows: int) -> list[str]:
|
||||
"""Zagląda do arkusza: nagłówki i liczba wierszy.
|
||||
|
||||
read_only + tylko pierwszy arkusz — plik bazy potrafi mieć kilkadziesiąt MB,
|
||||
a wczytanie go w całości przy każdym wgraniu zatkałoby usługę."""
|
||||
try:
|
||||
import openpyxl
|
||||
|
||||
wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
|
||||
except Exception as e: # noqa: BLE001 — każdy błąd = powód
|
||||
return [f"nie udało się otworzyć arkusza ({type(e).__name__})"]
|
||||
why: list[str] = []
|
||||
try:
|
||||
ws = wb[wb.sheetnames[0]]
|
||||
rows = ws.iter_rows(values_only=True)
|
||||
header = [str(c).strip().lower() for c in (next(rows, ()) or ()) if c is not None]
|
||||
missing = [c for c in required if c.strip().lower() not in header]
|
||||
if missing:
|
||||
why.append(f"brak wymaganych kolumn: {', '.join(missing)}")
|
||||
if min_rows:
|
||||
seen = sum(1 for i, _ in enumerate(rows) if i < min_rows)
|
||||
if seen < min_rows:
|
||||
why.append(f"za mało wierszy danych ({seen} < {min_rows})")
|
||||
finally:
|
||||
wb.close()
|
||||
return why
|
||||
|
||||
|
||||
# ── rejestr ──────────────────────────────────────────────────────────────
|
||||
|
||||
def _scan(root: Path) -> list[Path]:
|
||||
"""Pliki na udziale, bez śmieci technicznych.
|
||||
|
||||
Pomijamy nie tylko ukryte PLIKI, ale i wszystko, co leży w ukrytym KATALOGU:
|
||||
filtr po samej nazwie pliku wciągał do rejestru zawartość `.cache`, bo pliki
|
||||
w środku nie zaczynają się od kropki. Efekt: cache podawany jako baza, a przy
|
||||
pierwszym uruchomieniu jeszcze przyjmowany jako aktywny."""
|
||||
def ukryta_sciezka(p: Path) -> bool:
|
||||
return any(part.startswith(".") for part in p.relative_to(root).parts[:-1])
|
||||
|
||||
return [p for p in sorted(root.glob("**/*"))
|
||||
if p.is_file() and not p.name.startswith((".", "~$"))
|
||||
and not ukryta_sciezka(p)]
|
||||
|
||||
|
||||
def _adopt_existing(root: Path) -> dict:
|
||||
"""Pierwsze uruchomienie: bazy zastane na udziale są OD RAZU w użyciu.
|
||||
|
||||
Bez tego wdrożenie DAN-27 wyłączyłoby wyszukiwanie. Dotąd bazy działały
|
||||
domyślnie (wyłączało się je jawnie przez DISABLED_BASES); po przejściu na
|
||||
rejestr plik bez wpisu dostaje `ready`, czyli NIE w użyciu — więc pusty stan
|
||||
po wdrożeniu oznaczałby, że program nagle niczego nie znajduje. Ta cicha
|
||||
zmiana zachowania byłaby gorsza od awarii, bo wygląda jak pusta baza.
|
||||
|
||||
Rozróżnienie jest celowe: `ready` dotyczy plików WGRANYCH przez ekran (te
|
||||
ktoś musi świadomie włączyć), a nie zastanych przy przejściu na rejestr.
|
||||
|
||||
Zapis stanu może się nie udać (udział read-only) — wtedy trudno, przy każdym
|
||||
uruchomieniu przyjmiemy je na nowo. Zachowanie jest to samo, koszt żaden."""
|
||||
files = {str(p.relative_to(root)): {"status": ACTIVE, "adopted_at": _now()}
|
||||
for p in _scan(root)}
|
||||
data = {"files": files, "rules": {**DEFAULT_RULES}}
|
||||
try:
|
||||
_write_state(root, data)
|
||||
except OSError:
|
||||
pass
|
||||
return data
|
||||
|
||||
|
||||
def registry(root: Path | str, *, for_admin: bool = False) -> list[dict]:
|
||||
"""Pliki na udziale wraz ze stanem. `for_admin` odsłania kwarantannę i powody.
|
||||
|
||||
Filtrowanie siedzi TUTAJ, a nie w szablonie: gdyby pliki w kwarantannie
|
||||
dochodziły do przeglądarki i były tylko ukrywane stylem, wystarczyłby podgląd
|
||||
źródła strony, żeby poznać reguły walidacji."""
|
||||
root = Path(root)
|
||||
# Brak PLIKU stanu = pierwsze uruchomienie. Pusty słownik przy istniejącym
|
||||
# pliku to co innego: ktoś świadomie wszystko odstawił, więc nie wskrzeszamy.
|
||||
data = _read_state(root) if state_path(root).exists() else _adopt_existing(root)
|
||||
out: list[dict] = []
|
||||
for p in _scan(root):
|
||||
rel = str(p.relative_to(root))
|
||||
row = data["files"].get(rel, {})
|
||||
status = row.get("status") or READY
|
||||
if status == QUARANTINE and not for_admin:
|
||||
continue
|
||||
try:
|
||||
st = p.stat()
|
||||
size_mb = round(st.st_size / (1024 * 1024), 2)
|
||||
modified = datetime.fromtimestamp(st.st_mtime, tz=timezone.utc).strftime("%Y-%m-%d")
|
||||
except OSError:
|
||||
size_mb, modified = None, None
|
||||
entry = {
|
||||
"name": p.name, "path": rel, "size_mb": size_mb, "modified": modified,
|
||||
"status": status, "in_use": status in USABLE,
|
||||
# `enabled` to TA SAMA informacja pod nazwą, której używa reszta
|
||||
# świata: endpoint /bases, warstwa logiczna i ekran „Ustawienia"
|
||||
# (DAN-15/PRE-09). Rejestr wszedł w miejsce starej listy baz, więc
|
||||
# musi mówić jej językiem — inaczej każdy odbiorca dostaje KeyError,
|
||||
# a to była właśnie awaria /bases po wdrożeniu DAN-27.
|
||||
"enabled": status in USABLE,
|
||||
"archived_at": row.get("archived_at") or "",
|
||||
"uploaded_at": row.get("uploaded_at") or "",
|
||||
"uploaded_by": row.get("uploaded_by") or "",
|
||||
"sha256": row.get("sha256") or "",
|
||||
}
|
||||
if for_admin:
|
||||
entry["rejected_for"] = list(row.get("rejected_for") or [])
|
||||
out.append(entry)
|
||||
return out
|
||||
|
||||
|
||||
def usable_paths(root: Path | str) -> list[str]:
|
||||
"""Ścieżki baz, które FAKTYCZNIE biorą udział w wyszukiwaniu."""
|
||||
root = Path(root)
|
||||
return [str(root / e["path"]) for e in registry(root, for_admin=True) if e["in_use"]]
|
||||
|
||||
|
||||
def _touch(root: Path, rel: str, **fields) -> dict:
|
||||
with _lock:
|
||||
data = _read_state(root)
|
||||
row = {**data["files"].get(rel, {}), **fields}
|
||||
data["files"][rel] = row
|
||||
_write_state(root, data)
|
||||
return row
|
||||
|
||||
|
||||
def set_status(root: Path | str, rel: str, status: str, *, by: str = "") -> dict:
|
||||
"""Zmienia stan pliku. Włączyć do użytku można TYLKO plik, który przeszedł
|
||||
walidację — to jest właśnie ta bramka, o której mowa w wymaganiu."""
|
||||
root = Path(root)
|
||||
target = root / rel
|
||||
if not target.is_file():
|
||||
raise ValueError(f"Nie ma pliku „{rel}”.")
|
||||
if status not in {ACTIVE, READY, ARCHIVED, QUARANTINE}:
|
||||
raise ValueError(f"Nieznany stan: {status}")
|
||||
|
||||
data = _read_state(root)
|
||||
current = (data["files"].get(rel) or {}).get("status") or READY
|
||||
if status == ACTIVE:
|
||||
if current == QUARANTINE:
|
||||
raise ValueError("Plik nie może trafić do użytku.")
|
||||
known = {e["path"]: e["sha256"] for e in registry(root, for_admin=True) if e["sha256"]}
|
||||
why = validate(target, root, known_digests=known)
|
||||
if why:
|
||||
_touch(root, rel, status=QUARANTINE, rejected_for=why, checked_at=_now())
|
||||
raise ValueError("Plik nie może trafić do użytku.")
|
||||
|
||||
fields = {"status": status, "changed_at": _now(), "changed_by": by}
|
||||
if status == ARCHIVED:
|
||||
# Znacznik czasu archiwizacji to wymóg: „zamrożona forma z timestampem".
|
||||
fields["archived_at"] = _now()
|
||||
elif status == ACTIVE:
|
||||
fields["archived_at"] = ""
|
||||
fields["rejected_for"] = []
|
||||
return _touch(root, rel, **fields)
|
||||
|
||||
|
||||
def store_upload(root: Path | str, filename: str, content: bytes, *, by: str = "") -> dict:
|
||||
"""Zapisuje wgrany plik i od razu go sprawdza.
|
||||
|
||||
Plik zostaje NIEZALEŻNIE od wyniku walidacji — nie tracimy niczego, co ktoś
|
||||
wgrał. Zmienia się tylko to, czy da się go włączyć do użytku."""
|
||||
root = Path(root)
|
||||
safe = re.sub(r"[^A-Za-z0-9._ -]", "_", Path(filename or "").name).strip() or "plik"
|
||||
target = root / safe
|
||||
stem, suffix, n = Path(safe).stem, Path(safe).suffix, 1
|
||||
while target.exists(): # nie nadpisujemy cudzej bazy
|
||||
target = root / f"{stem}-{n}{suffix}"
|
||||
n += 1
|
||||
root.mkdir(parents=True, exist_ok=True)
|
||||
target.write_bytes(content)
|
||||
|
||||
rel = str(target.relative_to(root))
|
||||
digest = sha256_of(target)
|
||||
known = {e["path"]: e["sha256"] for e in registry(root, for_admin=True)
|
||||
if e["sha256"] and e["path"] != rel}
|
||||
why = validate(target, root, digest=digest, known_digests=known)
|
||||
_touch(root, rel, status=QUARANTINE if why else READY, rejected_for=why,
|
||||
sha256=digest, uploaded_at=_now(), uploaded_by=by, checked_at=_now())
|
||||
return {"path": rel, "name": target.name, "accepted": not why}
|
||||
|
||||
|
||||
def delete(root: Path | str, rel: str) -> None:
|
||||
"""Nieodwracalne skasowanie pliku — wyłącznie dla administratora."""
|
||||
root = Path(root)
|
||||
target = root / rel
|
||||
if not target.is_file():
|
||||
raise ValueError(f"Nie ma pliku „{rel}”.")
|
||||
target.unlink()
|
||||
with _lock:
|
||||
data = _read_state(root)
|
||||
data["files"].pop(rel, None)
|
||||
_write_state(root, data)
|
||||
@@ -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 protokołu")
|
||||
raise LinkError("ramka bez znacznika astrololo")
|
||||
body = frame[len(MAGIC):]
|
||||
if len(body) <= NONCE_BYTES:
|
||||
raise LinkError("ramka za krótka")
|
||||
|
||||
@@ -7,16 +7,13 @@ ani prezentacji.
|
||||
# build-marker: 2026-07-25 wymuszenie nowego obrazu po incydencie z tagiem :latest
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
from fastapi import FastAPI, HTTPException
|
||||
from fastapi import FastAPI
|
||||
|
||||
from app import canary, files, link_crypto, security
|
||||
from app import canary, link_crypto, security
|
||||
from app.config import settings
|
||||
from app.models import HealthInfo, SearchQuery, SearchResult
|
||||
from pydantic import BaseModel
|
||||
from app.providers.factory import build_provider
|
||||
|
||||
provider = build_provider(settings)
|
||||
@@ -28,12 +25,7 @@ async def lifespan(app: FastAPI):
|
||||
yield
|
||||
|
||||
|
||||
# Bez /docs, /redoc i /openapi.json: te trasy oddają KOMPLETNY katalog funkcji —
|
||||
# nazwy tras, kształty żądań, listę dostawców modeli — i to każdemu, kto potrafi
|
||||
# je otworzyć, bez żadnego logowania. Ochrona zakładek w prezentacji nic nie
|
||||
# daje, gdy obok stoi usługa, która sama się spisuje (PRE-27).
|
||||
app = FastAPI(title="astrololo · warstwa bazodanowa", lifespan=lifespan,
|
||||
docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app = FastAPI(title="astrololo · warstwa bazodanowa", lifespan=lifespan)
|
||||
security.install(app, "danych") # token międzywarstwowy (LOG-32)
|
||||
# Szyfrowanie łącza od logiki. PO `security.install`, żeby także odmowa
|
||||
# tokenowa wracała zaszyfrowana — inaczej klient nie umiałby jej odczytać.
|
||||
@@ -62,86 +54,6 @@ def bases() -> dict:
|
||||
return {"bases": items, "enabled": sum(1 for b in items if b["enabled"]), "total": len(items)}
|
||||
|
||||
|
||||
# ── zarządzanie plikami baz (DAN-27) ─────────────────────────────────────
|
||||
# Warstwa danych jest właścicielem plików, więc to ona nimi zarządza. Uprawnienia
|
||||
# rozstrzyga PREZENTACJA (PRE-27) i przekazuje tu wynik jako `for_admin` / `by` —
|
||||
# ta warstwa nie zna kont i nie ma jak ich znać. Nie jest to dziura: warstwa
|
||||
# danych stoi za tokenem międzywarstwowym i szyfrowanym łączem, więc rozmawia
|
||||
# z nią wyłącznie warstwa logiczna.
|
||||
|
||||
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 = 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)}
|
||||
|
||||
|
||||
@app.post("/files/status")
|
||||
def files_status(a: FileAction) -> dict:
|
||||
try:
|
||||
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")}
|
||||
|
||||
|
||||
@app.post("/files/upload")
|
||||
def files_upload(u: FileUpload) -> dict:
|
||||
"""Plik wędruje w base64 wewnątrz zaszyfrowanego łącza — tym samym kanałem,
|
||||
co reszta ruchu międzywarstwowego. Osobny, nieszyfrowany kanał na pliki
|
||||
byłby obejściem PRE-16."""
|
||||
try:
|
||||
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(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(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}
|
||||
|
||||
|
||||
@app.post("/files/rules")
|
||||
def files_rules(u: RulesUpdate) -> dict:
|
||||
return {"rules": files.set_rules(files.tenant_root(settings.excel_dir, u.tenant), u.rules)}
|
||||
|
||||
|
||||
@app.get("/health", response_model=HealthInfo)
|
||||
def health() -> HealthInfo:
|
||||
return provider.health()
|
||||
|
||||
@@ -25,11 +25,6 @@ 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):
|
||||
|
||||
@@ -91,34 +91,21 @@ 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], tenant: str = "") -> list[str]:
|
||||
"""Bazy biorące udział w wyszukiwaniu.
|
||||
def _enabled_files(self, paths: list[str]) -> list[str]:
|
||||
"""Odsiewa bazy WYŁĄCZONE globalnie (DAN-15) — nie biorą udziału
|
||||
w interpretacji, choć fizycznie leżą na udziale."""
|
||||
from app import bases
|
||||
|
||||
Źródłem prawdy jest REJESTR PLIKÓW (DAN-27) — stan klikany z ekranu,
|
||||
trwały na udziale. Zmienna DISABLED_BASES z DAN-15 zostaje jako awaryjne
|
||||
wyłączenie z konfiguracji: gdy jest ustawiona, odsiewa DODATKOWO. Nie
|
||||
odwrotnie — inaczej ktoś z dostępem do ekranu mógłby włączyć bazę
|
||||
wyłączoną świadomie na poziomie wdrożenia.
|
||||
"""
|
||||
# `bases` MUSI być zaimportowane tutaj — modułowego importu nie ma,
|
||||
# a przepisując tę funkcję pod rejestr usunąłem lokalny. Efekt: NameError
|
||||
# przy KAŻDYM wyszukiwaniu, czyli 500 z warstwy danych.
|
||||
from app import bases, files
|
||||
|
||||
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:
|
||||
out = [p for p in out if bases.is_enabled(p, self.s.excel_dir, entries)]
|
||||
return out
|
||||
if not entries:
|
||||
return paths
|
||||
return [p for p in paths if bases.is_enabled(p, self.s.excel_dir, entries)]
|
||||
|
||||
def list_bases(self) -> list[dict]:
|
||||
"""Bazy dostępne na udziale + metaopis + stan włączenia (DAN-15/PRE-09)."""
|
||||
from app import bases
|
||||
|
||||
from app import files
|
||||
|
||||
return files.registry(self.s.excel_dir, for_admin=True)
|
||||
return bases.list_bases(self.s.excel_dir, self._excel_files())
|
||||
|
||||
# ---- publiczne API ----
|
||||
def search(self, query: SearchQuery) -> SearchResult:
|
||||
@@ -128,11 +115,7 @@ class ExcelDataProvider(DataProvider):
|
||||
from app import bases
|
||||
|
||||
disabled = ",".join(bases.disabled_entries())
|
||||
# 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}")
|
||||
cache_key = f"{query.key}|{query.value}|{query.exact}|{query.limit}|{query.fields}|{disabled}"
|
||||
|
||||
hit = self.queries.get(cache_key) # poziom 3: wynik zapytania
|
||||
if hit is not None:
|
||||
@@ -144,7 +127,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], query.tenant))
|
||||
allowed = set(self._enabled_files([p for p, _ in candidates]))
|
||||
candidates = [(p, s) for p, s in candidates if p in allowed]
|
||||
|
||||
rows: list[dict] = []
|
||||
|
||||
@@ -6,11 +6,6 @@ pandas>=2.2
|
||||
openpyxl>=3.1
|
||||
pyarrow>=18.0
|
||||
SQLAlchemy>=2.0
|
||||
# Sterownik Postgresa (DAN-28). Sam SQLAlchemy nie rozmawia z bazą — bez tego
|
||||
# `postgresql+psycopg://…` wywala się dopiero przy PIERWSZYM połączeniu, już na
|
||||
# klastrze, komunikatem o braku modułu. [binary] = gotowe koło, bez kompilacji
|
||||
# libpq w obrazie.
|
||||
psycopg[binary]>=3.2
|
||||
pydantic>=2.10
|
||||
# Szyfrowanie łącza między warstwami (PRE-16): AES-256-GCM + HKDF
|
||||
cryptography>=44.0
|
||||
|
||||
@@ -1,214 +0,0 @@
|
||||
"""Rejestr plików baz: stany, walidacja, archiwizacja (DAN-27).
|
||||
|
||||
Testujemy tu RDZEŃ — bez HTTP i bez uprawnień, bo uprawnienia rozstrzyga
|
||||
prezentacja (patrz services/presentation/tests/test_pliki.py). Tutaj chodzi
|
||||
o to, żeby żadna operacja nie gubiła pliku i żeby bramka „do użytku tylko po
|
||||
walidacji" faktycznie trzymała.
|
||||
"""
|
||||
import pathlib
|
||||
|
||||
import pytest
|
||||
|
||||
from app import files
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def root(tmp_path, monkeypatch):
|
||||
monkeypatch.delenv("FILES_STATE", raising=False)
|
||||
return tmp_path
|
||||
|
||||
|
||||
def _xlsx(path, rows=3, header=("id", "opis")):
|
||||
import openpyxl
|
||||
|
||||
wb = openpyxl.Workbook()
|
||||
ws = wb.active
|
||||
ws.append(list(header))
|
||||
for i in range(rows):
|
||||
ws.append([i, f"treść {i}"])
|
||||
wb.save(path)
|
||||
return path
|
||||
|
||||
|
||||
# ── rejestr i stany ──────────────────────────────────────────────────────
|
||||
|
||||
def test_a_file_dropped_on_the_share_is_adopted_as_active(root):
|
||||
"""Baza położona na udziale poza aplikacją (np. przez NFS) ma działać —
|
||||
tak było przed DAN-27 i tak ma zostać. Plik WGRANY EKRANEM to inna sprawa:
|
||||
ten wymaga świadomego włączenia (patrz test niżej)."""
|
||||
_xlsx(root / "baza.xlsx")
|
||||
entry = files.registry(root)[0]
|
||||
assert entry["status"] == files.ACTIVE
|
||||
assert entry["in_use"] is True
|
||||
|
||||
|
||||
def test_only_active_files_reach_the_search(root):
|
||||
_xlsx(root / "a.xlsx")
|
||||
_xlsx(root / "b.xlsx")
|
||||
files.registry(root) # przyjęcie zastanych
|
||||
files.set_status(root, "b.xlsx", files.READY) # świadome odstawienie
|
||||
assert [pathlib.Path(p).name for p in files.usable_paths(root)] == ["a.xlsx"]
|
||||
files.set_status(root, "b.xlsx", files.ACTIVE)
|
||||
assert len(files.usable_paths(root)) == 2
|
||||
|
||||
|
||||
def test_state_survives_a_restart(root):
|
||||
"""Stan jest KLIKANY, więc musi być trwały — inaczej restart poda po cichu
|
||||
przywracałby bazy wyłączone świadomie."""
|
||||
_xlsx(root / "a.xlsx")
|
||||
files.set_status(root, "a.xlsx", files.ACTIVE)
|
||||
assert files.state_path(root).exists()
|
||||
assert files.registry(root)[0]["in_use"] is True
|
||||
|
||||
|
||||
# ── archiwizacja ─────────────────────────────────────────────────────────
|
||||
|
||||
def test_archiving_freezes_the_file_but_never_removes_it(root):
|
||||
"""To jest najdalej idąca operacja osoby wgrywającej dane: plik ZOSTAJE."""
|
||||
p = _xlsx(root / "stara.xlsx")
|
||||
files.set_status(root, "stara.xlsx", files.ACTIVE)
|
||||
files.set_status(root, "stara.xlsx", files.ARCHIVED, by="dane")
|
||||
entry = files.registry(root)[0]
|
||||
assert p.exists(), "plik zniknął z dysku — archiwizacja ma go zachować"
|
||||
assert entry["status"] == files.ARCHIVED
|
||||
assert entry["in_use"] is False
|
||||
assert entry["archived_at"], "brak znacznika czasu archiwizacji"
|
||||
|
||||
|
||||
def test_archived_file_cannot_slip_back_into_use_by_itself(root):
|
||||
_xlsx(root / "stara.xlsx")
|
||||
files.set_status(root, "stara.xlsx", files.ARCHIVED)
|
||||
assert files.usable_paths(root) == []
|
||||
|
||||
|
||||
# ── walidacja: bramka do użytku ──────────────────────────────────────────
|
||||
|
||||
def test_upload_keeps_a_file_that_fails_validation(root):
|
||||
"""Rzecz najważniejsza: wgranego pliku NIE TRACIMY, choćby nie przeszedł."""
|
||||
files.set_rules(root, {"extensions": [".xlsx"]})
|
||||
out = files.store_upload(root, "notatka.txt", "to nie jest baza".encode("utf-8"), by="dane")
|
||||
assert out["accepted"] is False
|
||||
assert (root / out["path"]).exists(), "plik odrzucony zniknął z dysku"
|
||||
admin_view = files.registry(root, for_admin=True)[0]
|
||||
assert admin_view["status"] == files.QUARANTINE
|
||||
assert admin_view["rejected_for"], "administrator ma widzieć powód"
|
||||
|
||||
|
||||
def test_a_held_file_is_invisible_without_admin_rights(root):
|
||||
"""Gdyby plik wstrzymany był widoczny z powodem odrzucenia, każdy wgrywający
|
||||
poznałby reguły walidacji — a te są narzędziem administratora."""
|
||||
files.store_upload(root, "notatka.txt", "nie baza".encode("utf-8"))
|
||||
assert files.registry(root, for_admin=False) == []
|
||||
assert len(files.registry(root, for_admin=True)) == 1
|
||||
|
||||
|
||||
def test_a_held_file_cannot_be_switched_into_use(root):
|
||||
files.store_upload(root, "notatka.txt", "nie baza".encode("utf-8"))
|
||||
rel = files.registry(root, for_admin=True)[0]["path"]
|
||||
with pytest.raises(ValueError):
|
||||
files.set_status(root, rel, files.ACTIVE)
|
||||
|
||||
|
||||
def test_activation_revalidates_and_holds_a_file_that_stopped_qualifying(root):
|
||||
"""Reguły mogą się zmienić PO wgraniu — bramka sprawdza w chwili włączania,
|
||||
a nie tylko przy wgrywaniu."""
|
||||
_xlsx(root / "mala.xlsx", rows=2)
|
||||
files.set_status(root, "mala.xlsx", files.ACTIVE)
|
||||
files.set_rules(root, {"min_rows": 500})
|
||||
files.set_status(root, "mala.xlsx", files.READY)
|
||||
with pytest.raises(ValueError):
|
||||
files.set_status(root, "mala.xlsx", files.ACTIVE)
|
||||
assert (root / "mala.xlsx").exists()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("rule,value,bad", [
|
||||
("extensions", [".xlsx"], "plik.csv"),
|
||||
("max_size_mb", 0.000001, "plik.xlsx"),
|
||||
])
|
||||
def test_rules_reject_what_they_are_meant_to(root, rule, value, bad):
|
||||
files.set_rules(root, {rule: value})
|
||||
out = files.store_upload(root, bad, b"x" * 2048)
|
||||
assert out["accepted"] is False
|
||||
|
||||
|
||||
def test_required_columns_are_checked_inside_the_workbook(root):
|
||||
files.set_rules(root, {"required_columns": ["id", "znaczenie"]})
|
||||
_xlsx(root / "tmp.xlsx", header=("id", "opis"))
|
||||
why = files.validate(root / "tmp.xlsx", root)
|
||||
assert why and "znaczenie" in why[0]
|
||||
|
||||
|
||||
def test_duplicate_content_is_rejected_by_hash_not_by_name(root):
|
||||
files.set_rules(root, {"reject_duplicate_content": True})
|
||||
data = _xlsx(root / "wzor.xlsx").read_bytes()
|
||||
first = files.store_upload(root, "pierwsza.xlsx", data)
|
||||
assert first["accepted"] is True
|
||||
second = files.store_upload(root, "inna-nazwa.xlsx", data)
|
||||
assert second["accepted"] is False
|
||||
|
||||
|
||||
def test_upload_never_overwrites_someone_elses_base(root):
|
||||
files.store_upload(root, "baza.xlsx", _xlsx(root / "w.xlsx").read_bytes())
|
||||
(root / "w.xlsx").unlink()
|
||||
files.set_rules(root, {"reject_duplicate_content": False})
|
||||
out = files.store_upload(root, "baza.xlsx", "inna treść".encode("utf-8"))
|
||||
assert out["name"] != "baza.xlsx"
|
||||
assert (root / "baza.xlsx").exists() and (root / out["path"]).exists()
|
||||
|
||||
|
||||
# ── kasowanie ────────────────────────────────────────────────────────────
|
||||
|
||||
def test_delete_removes_the_file_and_its_entry(root):
|
||||
_xlsx(root / "a.xlsx")
|
||||
files.set_status(root, "a.xlsx", files.ACTIVE)
|
||||
files.delete(root, "a.xlsx")
|
||||
assert not (root / "a.xlsx").exists()
|
||||
assert files.registry(root, for_admin=True) == []
|
||||
assert files.usable_paths(root) == []
|
||||
|
||||
|
||||
# ── przejście na rejestr nie może wyłączyć wyszukiwania ─────────────────
|
||||
|
||||
def test_bases_already_on_the_share_stay_in_use_after_the_switch(root):
|
||||
"""Dotąd bazy działały domyślnie (wyłączało się je przez DISABLED_BASES).
|
||||
Po przejściu na rejestr pusty stan oznaczałby, że program nagle niczego nie
|
||||
znajduje — cicha zmiana zachowania gorsza od awarii, bo wygląda jak pusta baza."""
|
||||
_xlsx(root / "main_base.xlsx")
|
||||
_xlsx(root / "zodiac_pl.xlsx")
|
||||
assert len(files.usable_paths(root)) == 2, "zastane bazy wypadły z wyszukiwania"
|
||||
assert all(e["in_use"] for e in files.registry(root))
|
||||
|
||||
|
||||
def test_adoption_happens_once_and_respects_later_decisions(root):
|
||||
"""Po przyjęciu stan jest zapisany, więc świadome odstawienie bazy ZOSTAJE —
|
||||
kolejny odczyt nie może jej wskrzesić."""
|
||||
_xlsx(root / "a.xlsx")
|
||||
_xlsx(root / "b.xlsx")
|
||||
files.registry(root) # przyjęcie
|
||||
files.set_status(root, "a.xlsx", files.READY) # świadome odstawienie
|
||||
assert [pathlib.Path(p).name for p in files.usable_paths(root)] == ["b.xlsx"]
|
||||
files.set_status(root, "b.xlsx", files.READY) # odstawiamy wszystko
|
||||
assert files.usable_paths(root) == [], "pusty wybór został wskrzeszony"
|
||||
|
||||
|
||||
def test_uploaded_files_still_need_an_explicit_switch_on(root):
|
||||
"""Przyjęcie dotyczy TYLKO baz zastanych. Plik wgrany ekranem ktoś musi
|
||||
świadomie włączyć — inaczej nowa baza wchodziłaby do wyników sama."""
|
||||
_xlsx(root / "zastana.xlsx")
|
||||
files.registry(root)
|
||||
out = files.store_upload(root, "nowa.xlsx", _xlsx(root / "tmp.xlsx").read_bytes())
|
||||
assert out["accepted"] is True
|
||||
names = [pathlib.Path(p).name for p in files.usable_paths(root)]
|
||||
assert "nowa.xlsx" not in names, "wgrana baza weszła do wyników bez decyzji"
|
||||
|
||||
|
||||
def test_adoption_survives_a_read_only_share(root, monkeypatch):
|
||||
"""Na udziale tylko do odczytu stanu nie da się zapisać — zachowanie ma
|
||||
zostać to samo, tylko przyjęcie powtórzy się przy każdym uruchomieniu."""
|
||||
_xlsx(root / "a.xlsx")
|
||||
|
||||
def boom(*a, **kw):
|
||||
raise OSError("read-only file system")
|
||||
|
||||
monkeypatch.setattr(files, "_write_state", boom)
|
||||
assert len(files.usable_paths(root)) == 1
|
||||
@@ -1,189 +0,0 @@
|
||||
"""Rejestr plików a RESZTA warstwy danych — punkty styku (DAN-27).
|
||||
|
||||
DLACZEGO OSOBNY PLIK. test_files.py sprawdza sam rejestr w izolacji i przechodził
|
||||
na zielono, podczas gdy na produkcji leżało wyszukiwanie (500) i lista baz (502).
|
||||
Rejestr wszedł w miejsce starego mechanizmu włączania baz, więc groźne jest nie
|
||||
to, co robi w środku, tylko czy MÓWI TYM SAMYM JĘZYKIEM, co jego odbiorcy.
|
||||
|
||||
Oba tamte błędy były jednolinijkowe i oba niewidoczne dla testów jednostkowych:
|
||||
* NameError, bo przepisując `_enabled_files` usunąłem lokalny import `bases`,
|
||||
* KeyError, bo rejestr oddawał `in_use`, a endpoint /bases czytał `enabled`.
|
||||
"""
|
||||
import pathlib
|
||||
|
||||
import pytest
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def excel_dir(tmp_path, monkeypatch):
|
||||
monkeypatch.setenv("EXCEL_DIR", str(tmp_path))
|
||||
monkeypatch.setenv("CACHE_DIR", str(tmp_path / ".cache"))
|
||||
monkeypatch.delenv("DISABLED_BASES", raising=False)
|
||||
monkeypatch.delenv("FILES_STATE", raising=False)
|
||||
return tmp_path
|
||||
|
||||
|
||||
def _xlsx(path, rows=(("Ma Ari", "odważny"), ("Ve Tau", "zgodny"))):
|
||||
import openpyxl
|
||||
|
||||
wb = openpyxl.Workbook()
|
||||
ws = wb.active
|
||||
ws.append(["significator", "effect"])
|
||||
for r in rows:
|
||||
ws.append(list(r))
|
||||
wb.save(path)
|
||||
return path
|
||||
|
||||
|
||||
def _provider(excel_dir):
|
||||
from app.config import Settings
|
||||
from app.providers.excel_provider import ExcelDataProvider
|
||||
|
||||
return ExcelDataProvider(Settings())
|
||||
|
||||
|
||||
def test_search_does_not_explode_on_the_registry(excel_dir):
|
||||
"""Regresja: `_enabled_files` wołało bases.disabled_entries() bez importu,
|
||||
więc KAŻDE wyszukiwanie kończyło się NameError → 500 z warstwy danych."""
|
||||
from app.models import SearchQuery
|
||||
|
||||
_xlsx(excel_dir / "baza.xlsx")
|
||||
p = _provider(excel_dir)
|
||||
p.warmup()
|
||||
out = p.search(SearchQuery(key="significator", value="Ma Ari", exact=False, limit=10))
|
||||
assert out.total >= 1, "zastana baza nie weszła do wyszukiwania"
|
||||
|
||||
|
||||
def test_search_still_works_with_disabled_bases_set(excel_dir, monkeypatch):
|
||||
"""DISABLED_BASES zostaje jako awaryjne wyłączenie i ma odsiewać DODATKOWO —
|
||||
to właśnie ta gałąź kodu wywalała się na braku importu."""
|
||||
from app.models import SearchQuery
|
||||
|
||||
_xlsx(excel_dir / "a.xlsx")
|
||||
_xlsx(excel_dir / "b.xlsx")
|
||||
monkeypatch.setenv("DISABLED_BASES", "b.xlsx")
|
||||
p = _provider(excel_dir)
|
||||
p.warmup()
|
||||
out = p.search(SearchQuery(key="significator", value="Ma Ari", exact=False, limit=10))
|
||||
assert out.total >= 1
|
||||
|
||||
|
||||
def test_registry_speaks_the_language_the_bases_endpoint_reads(excel_dir):
|
||||
"""Regresja: endpoint /bases liczy `b["enabled"]`, rejestr oddawał `in_use`.
|
||||
KeyError → 500 z danych → 502 z logiki → „Warstwa logiczna niedostępna"
|
||||
na ekranie Ustawienia."""
|
||||
_xlsx(excel_dir / "baza.xlsx")
|
||||
items = _provider(excel_dir).list_bases()
|
||||
assert items, "lista baz jest pusta"
|
||||
for row in items:
|
||||
for key in ("name", "path", "enabled", "in_use", "size_mb", "modified"):
|
||||
assert key in row, f"brak pola `{key}` — odbiorca dostanie KeyError"
|
||||
assert row["enabled"] == row["in_use"], "dwa pola, jedna prawda"
|
||||
|
||||
|
||||
def test_bases_endpoint_answers_end_to_end(excel_dir):
|
||||
"""Przez TRASĘ, nie przez dostawcę: to ona wywalała się na produkcji."""
|
||||
_xlsx(excel_dir / "baza.xlsx")
|
||||
import importlib
|
||||
|
||||
from app import main as data_main
|
||||
|
||||
importlib.reload(data_main)
|
||||
body = data_main.bases()
|
||||
assert body["total"] == 1
|
||||
assert body["enabled"] == 1, "zastana baza powinna być włączona po adopcji"
|
||||
assert body["bases"][0]["name"] == "baza.xlsx"
|
||||
|
||||
|
||||
def test_switching_a_base_off_is_visible_in_both_places(excel_dir):
|
||||
"""Odstawienie bazy ma zniknąć i z wyszukiwania, i z licznika na Ustawieniach."""
|
||||
from app import files
|
||||
from app.models import SearchQuery
|
||||
|
||||
_xlsx(excel_dir / "baza.xlsx")
|
||||
p = _provider(excel_dir)
|
||||
p.warmup()
|
||||
assert p.search(SearchQuery(key="significator", value="Ma Ari", limit=10)).total >= 1
|
||||
|
||||
files.set_status(excel_dir, "baza.xlsx", files.READY)
|
||||
p2 = _provider(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
|
||||
@@ -20,12 +20,7 @@ from pydantic import BaseModel
|
||||
|
||||
import swisseph as swe
|
||||
|
||||
# Bez /docs, /redoc i /openapi.json: te trasy oddają KOMPLETNY katalog funkcji —
|
||||
# nazwy tras, kształty żądań, listę dostawców modeli — i to każdemu, kto potrafi
|
||||
# je otworzyć, bez żadnego logowania. Ochrona zakładek w prezentacji nic nie
|
||||
# daje, gdy obok stoi usługa, która sama się spisuje (PRE-27).
|
||||
app = FastAPI(title="astrololo · engine-swisseph (AGPL, izolowany)",
|
||||
docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app = FastAPI(title="astrololo · engine-swisseph (AGPL, izolowany)")
|
||||
|
||||
# Tryb Moshiera: bez plików efemeryd, w pełni samowystarczalny (~0,1\" dokładności).
|
||||
_FLAGS = swe.FLG_MOSEPH | swe.FLG_SPEED
|
||||
|
||||
@@ -28,18 +28,8 @@ def _link() -> link_crypto.Link | None:
|
||||
|
||||
|
||||
class DataClient:
|
||||
"""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:
|
||||
def __init__(self, base_url: str | None = None) -> None:
|
||||
self.base_url = (base_url or settings.data_url).rstrip("/")
|
||||
self.tenant = tenant or ""
|
||||
|
||||
def search(
|
||||
self,
|
||||
@@ -49,8 +39,7 @@ class DataClient:
|
||||
limit: int,
|
||||
fields: list[str] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
payload = {"key": key, "value": value, "exact": exact, "limit": limit,
|
||||
"fields": fields, "tenant": self.tenant}
|
||||
payload = {"key": key, "value": value, "exact": exact, "limit": limit, "fields": fields}
|
||||
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(),
|
||||
@@ -62,33 +51,6 @@ class DataClient:
|
||||
return link_crypto.call_json(client, "GET", f"{self.base_url}/bases",
|
||||
headers=_auth_headers(), link=_link())
|
||||
|
||||
|
||||
# ── zarządzanie plikami baz (DAN-27) ────────────────────────────────
|
||||
# Jedna metoda na trasę, bez sprytnego generyka: te wywołania różnią się
|
||||
# skutkiem (odczyt / zapis / skasowanie), a ujednolicenie ich w jedno
|
||||
# `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, "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, "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, "tenant": self.tenant})
|
||||
|
||||
def files_delete(self, path: str) -> dict[str, Any]:
|
||||
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, "tenant": self.tenant})
|
||||
|
||||
def _files_post(self, path: str, payload: dict) -> dict[str, Any]:
|
||||
with httpx.Client(timeout=settings.http_timeout) as client:
|
||||
return link_crypto.call_json(client, "POST", f"{self.base_url}{path}",
|
||||
payload=payload, headers=_auth_headers(), link=_link())
|
||||
|
||||
def health(self) -> dict[str, Any]:
|
||||
# /health celowo poza szyfrowaniem — pukają tu sondy k8s, które klucza
|
||||
# nie mają, a nie przechodzi tędy nic z baz.
|
||||
|
||||
@@ -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 protokołu")
|
||||
raise LinkError("ramka bez znacznika astrololo")
|
||||
body = frame[len(MAGIC):]
|
||||
if len(body) <= NONCE_BYTES:
|
||||
raise LinkError("ramka za krótka")
|
||||
|
||||
@@ -18,12 +18,7 @@ from app.clients.data_client import DataClient
|
||||
from app.models import QueryRequest, QueryResponse
|
||||
from app.service import QueryService
|
||||
|
||||
# Bez /docs, /redoc i /openapi.json: te trasy oddają KOMPLETNY katalog funkcji —
|
||||
# nazwy tras, kształty żądań, listę dostawców modeli — i to każdemu, kto potrafi
|
||||
# je otworzyć, bez żadnego logowania. Ochrona zakładek w prezentacji nic nie
|
||||
# daje, gdy obok stoi usługa, która sama się spisuje (PRE-27).
|
||||
app = FastAPI(title="astrololo · warstwa logiczna",
|
||||
docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app = FastAPI(title="astrololo · warstwa logiczna")
|
||||
service = QueryService()
|
||||
security.install(app, "logiczna") # token międzywarstwowy (LOG-32)
|
||||
# Szyfrowanie łącza od prezentacji. PO `security.install`, żeby także odmowa
|
||||
@@ -126,82 +121,6 @@ def bases() -> dict:
|
||||
raise HTTPException(status_code=502, detail=f"Warstwa bazodanowa niedostępna: {e}")
|
||||
|
||||
|
||||
# ── zarządzanie plikami baz (DAN-27) — czysty przelot ───────────────────
|
||||
# Warstwa logiczna niczego tu nie rozstrzyga: uprawnienia zna PREZENTACJA
|
||||
# (PRE-27), właścicielem plików jest warstwa DANYCH. Ta warstwa tylko przenosi,
|
||||
# bo prezentacja nie ma prawa rozmawiać z danymi wprost.
|
||||
|
||||
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, tenant: str = "", **kw) -> dict:
|
||||
from app.clients.data_client import DataClient
|
||||
|
||||
try:
|
||||
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
|
||||
# się pokazać powód zamiast „usługa niedostępna".
|
||||
raise HTTPException(status_code=e.response.status_code,
|
||||
detail=_detail(e)) from e
|
||||
except httpx.HTTPError as e:
|
||||
raise HTTPException(status_code=502, detail=f"Warstwa bazodanowa niedostępna: {e}")
|
||||
|
||||
|
||||
def _detail(e: httpx.HTTPStatusError) -> str:
|
||||
try:
|
||||
return str(e.response.json().get("detail") or e)
|
||||
except Exception: # noqa: BLE001
|
||||
return str(e)
|
||||
|
||||
|
||||
@app.post("/files")
|
||||
def files_list(q: FilesQuery) -> dict:
|
||||
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), 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), tenant=u.tenant)
|
||||
|
||||
|
||||
@app.post("/files/delete")
|
||||
def files_delete(a: FileAction) -> dict:
|
||||
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), tenant=u.tenant)
|
||||
|
||||
|
||||
@app.post("/chart/synastry")
|
||||
def chart_synastry(req: SynastryRequest) -> dict:
|
||||
"""Synastria (PRE-04): dwa horoskopy natalne + aspekty MIĘDZY nimi (planeta
|
||||
@@ -252,10 +171,6 @@ 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")
|
||||
@@ -271,7 +186,7 @@ def chart_report(req: ReportRequest) -> dict:
|
||||
chart = build_chart(engine, moment) # pozycje z domami + aspekty
|
||||
try:
|
||||
report = build_report(
|
||||
chart["positions"], DataClient(tenant=req.tenant),
|
||||
chart["positions"], DataClient(),
|
||||
aspects=chart.get("aspects"), parallels=chart.get("parallels"),
|
||||
per_object_limit=req.limit, group=req.group,
|
||||
)
|
||||
|
||||
@@ -4,11 +4,7 @@ WORKDIR /app
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
# Do obrazu wchodzi WYŁĄCZNIE kod aplikacji. `COPY . .` wnosiło też testy,
|
||||
# README i skrypty pomocnicze — a plik testowy nazywa funkcje wprost, więc
|
||||
# w obrazie zbudowanym bez danego modułu byłby dokładnie tym śladem, którego
|
||||
# wydzielenie ma się pozbyć. Przy okazji obraz jest mniejszy.
|
||||
COPY app ./app
|
||||
COPY . .
|
||||
|
||||
EXPOSE 8000
|
||||
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
|
||||
|
||||
@@ -121,7 +121,6 @@ def all_users() -> dict[str, dict]:
|
||||
for login, row in _read()["users"].items():
|
||||
out[login] = {
|
||||
"features": sorted(features.normalise(row.get("features"))),
|
||||
"session_version": int(row.get("session_version") or 0),
|
||||
"note": str(row.get("note") or ""),
|
||||
"created": str(row.get("created") or ""),
|
||||
}
|
||||
@@ -132,31 +131,6 @@ def secret_of(login: str) -> str | None:
|
||||
return (_read()["users"].get(login) or {}).get("secret")
|
||||
|
||||
|
||||
def session_version(login: str) -> int:
|
||||
"""Numer pokolenia sesji konta (LOG-34).
|
||||
|
||||
Podbicie unieważnia WSZYSTKIE otwarte sesje tego konta, także na innych
|
||||
urządzeniach — bez zmiany hasła. Zmiana hasła robi to samo niejako przy
|
||||
okazji (zmienia się odcisk w ciasteczku), więc licznik jest potrzebny tylko
|
||||
do „wyrzuć zewsząd, ale hasło zostaw"."""
|
||||
try:
|
||||
return int((_read()["users"].get(login) or {}).get("session_version") or 0)
|
||||
except (TypeError, ValueError):
|
||||
return 0
|
||||
|
||||
|
||||
def bump_session(login: str) -> int:
|
||||
"""Unieważnia wszystkie sesje konta. Podnosi ValueError, gdy konta nie ma."""
|
||||
with _lock:
|
||||
data = _read()
|
||||
row = data["users"].get(login)
|
||||
if row is None:
|
||||
raise ValueError(f"Nie ma konta „{login}”.")
|
||||
row["session_version"] = session_version(login) + 1
|
||||
_write(data)
|
||||
return row["session_version"]
|
||||
|
||||
|
||||
def permissions_of(login: str) -> frozenset[str]:
|
||||
return features.normalise((_read()["users"].get(login) or {}).get("features"))
|
||||
|
||||
|
||||
@@ -40,29 +40,6 @@ class LogicClient:
|
||||
payload=payload, headers=_auth_headers(),
|
||||
link=_link())
|
||||
|
||||
# ── transport dla modułów opcjonalnych ─────────────────────────────────
|
||||
# Moduł nie może dopisywać sobie metod do tej klasy: jego nazwy siedziałyby
|
||||
# wtedy w pliku, który jedzie do KAŻDEGO obrazu. Dostaje więc samą drogę
|
||||
# w dół, a co nią wysyła, jest jego sprawą. Szyfrowanie łącza i token
|
||||
# międzywarstwowy obowiązują tak samo — to nie jest obejście ochrony.
|
||||
def wywolaj(self, sciezka: str, payload: dict[str, Any], timeout: float) -> dict[str, Any]:
|
||||
return self._post(sciezka, payload, timeout)
|
||||
|
||||
def pobierz(self, sciezka: str, timeout: float | None = None) -> dict[str, Any]:
|
||||
with httpx.Client(timeout=timeout or settings.http_timeout) as client:
|
||||
return link_crypto.call_json(client, "GET", f"{self.base_url}{sciezka}",
|
||||
headers=_auth_headers(), link=_link())
|
||||
|
||||
def strumien(self, sciezka: str, payload: dict[str, Any]):
|
||||
"""Strumień NDJSON w dół — przekazywany dalej ramka po ramce.
|
||||
|
||||
Idzie przez szyfrowane łącze jak reszta ruchu (PRE-16): bez tego przy
|
||||
włączonym LINK_ENCRYPTION_REQUIRED serwer odrzuciłby żądanie."""
|
||||
with httpx.Client(timeout=httpx.Timeout(None, connect=15.0)) as client:
|
||||
yield from link_crypto.stream_lines(
|
||||
client, f"{self.base_url}{sciezka}",
|
||||
payload=payload, headers=_auth_headers(), link=_link())
|
||||
|
||||
def query(self, query: str, field: str, exact: bool, limit: int) -> dict[str, Any]:
|
||||
payload = {"query": query, "field": field, "exact": exact, "limit": limit}
|
||||
return self._post("/api/query", payload, settings.http_timeout)
|
||||
@@ -120,38 +97,72 @@ class LogicClient:
|
||||
payload = {"when_utc": when_utc_iso, "lat": lat, "lon": lon, "limit": limit, "group": group}
|
||||
return self._post("/chart/report", payload, max(settings.http_timeout, 30.0))
|
||||
|
||||
def prompt(
|
||||
self, profile: str, when_utc_iso: str, lat: float, lon: float,
|
||||
budget: str = "medium", from_date: str | None = None, to_date: str | None = None,
|
||||
provider: str | None = None, model: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""Gotowy prompt do LLM z wyliczeń (LOG-29/30) — woła logic /chart/prompt.
|
||||
|
||||
`provider` jest potrzebny dla budżetu „maksymalny kontekst modelu": limit
|
||||
znaków zależy wtedy od okna kontekstu konkretnego modelu."""
|
||||
payload: dict[str, Any] = {
|
||||
"profile": profile, "when_utc": when_utc_iso,
|
||||
"lat": lat, "lon": lon, "budget": budget, "provider": provider,
|
||||
"model": model,
|
||||
}
|
||||
if from_date and to_date:
|
||||
payload["from_date"], payload["to_date"] = from_date, to_date
|
||||
return self._post("/chart/prompt", payload, max(settings.http_timeout, 60.0))
|
||||
|
||||
def horoscope(
|
||||
self, profile: str, when_utc_iso: str, lat: float, lon: float,
|
||||
budget: str = "medium", provider: str | None = None, model: str | None = None,
|
||||
from_date: str | None = None, to_date: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""Napisany horoskop (LOG-31) — woła logic /chart/horoscope.
|
||||
|
||||
Generowanie tekstu trwa (zwłaszcza na modelu lokalnym), stąd długi timeout.
|
||||
"""
|
||||
payload: dict[str, Any] = {
|
||||
"profile": profile, "when_utc": when_utc_iso,
|
||||
"lat": lat, "lon": lon, "budget": budget,
|
||||
}
|
||||
if provider:
|
||||
payload["provider"] = provider
|
||||
if model:
|
||||
payload["model"] = model
|
||||
if from_date and to_date:
|
||||
payload["from_date"], payload["to_date"] = from_date, to_date
|
||||
return self._post("/chart/horoscope", payload, max(settings.http_timeout, 300.0))
|
||||
|
||||
def horoscope_stream(self, payload: dict[str, Any]):
|
||||
"""Strumień postępu pisania horoskopu (NDJSON) — przekazywany do przeglądarki.
|
||||
|
||||
Timeout jest długi, bo generowanie trwa; strumień i tak niesie heartbeat,
|
||||
więc cisza na łączu nie zostanie wzięta za zerwanie.
|
||||
|
||||
Idzie przez szyfrowane łącze jak reszta ruchu w dół (PRE-16). Bez tego przy
|
||||
włączonym `LINK_ENCRYPTION_REQUIRED` serwer odrzuciłby nieszyfrowane żądanie
|
||||
i okno postępu przestałoby działać. `stream_lines` pieczętuje żądanie i
|
||||
odszyfrowuje odpowiedź ramka po ramce, zachowując dostarczanie na żywo.
|
||||
"""
|
||||
with httpx.Client(timeout=httpx.Timeout(None, connect=15.0)) as client:
|
||||
yield from link_crypto.stream_lines(
|
||||
client, f"{self.base_url}/chart/horoscope/stream",
|
||||
payload=payload, headers=_auth_headers(), link=_link())
|
||||
|
||||
def bases(self) -> dict[str, Any]:
|
||||
"""Bazy dostępne na udziale + metaopis i stan włączenia (DAN-15/PRE-09)."""
|
||||
with httpx.Client(timeout=settings.http_timeout) as client:
|
||||
return link_crypto.call_json(client, "GET", f"{self.base_url}/bases",
|
||||
headers=_auth_headers(), link=_link())
|
||||
|
||||
|
||||
# ── zarządzanie plikami baz (DAN-27) ────────────────────────────────
|
||||
# Jedna metoda na trasę, bez sprytnego generyka: te wywołania różnią się
|
||||
# skutkiem (odczyt / zapis / skasowanie), a ujednolicenie ich w jedno
|
||||
# `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})
|
||||
|
||||
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})
|
||||
|
||||
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})
|
||||
|
||||
def files_delete(self, path: str) -> dict[str, Any]:
|
||||
return self._files_post("/files/delete", {"path": path})
|
||||
|
||||
def files_rules(self, rules: dict) -> dict[str, Any]:
|
||||
return self._files_post("/files/rules", {"rules": rules})
|
||||
|
||||
def _files_post(self, path: str, payload: dict) -> dict[str, Any]:
|
||||
def llm_models(self) -> dict[str, Any]:
|
||||
"""Katalog modeli per dostawca (podpowiedzi do pola wyboru w UI)."""
|
||||
with httpx.Client(timeout=settings.http_timeout) as client:
|
||||
return link_crypto.call_json(client, "POST", f"{self.base_url}{path}",
|
||||
payload=payload, headers=_auth_headers(), link=_link())
|
||||
return link_crypto.call_json(client, "GET", f"{self.base_url}/llm/models",
|
||||
headers=_auth_headers(), link=_link())
|
||||
|
||||
def timeline(
|
||||
self, when_utc_iso: str, lat: float, lon: float,
|
||||
|
||||
@@ -1,10 +0,0 @@
|
||||
"""Ekrany aplikacji — jeden moduł na ekran.
|
||||
|
||||
Ekran to trasy plus szablon. Import modułu rejestruje jego trasy (dekoratory
|
||||
`@app.get`/`@app.post` wykonują się przy imporcie), więc o tym, CO aplikacja
|
||||
umie, decyduje lista importów w `main.py` — a nie warunki rozsiane po kodzie.
|
||||
|
||||
Dzięki temu produkt buduje się przez ZŁOŻENIE: inny zestaw importów i inny
|
||||
zestaw plików w obrazie to inny program, a nie ten sam program z wyłączonymi
|
||||
kawałkami. Ekranu, którego moduł nie wszedł do obrazu, nie ma jak włączyć.
|
||||
"""
|
||||
@@ -1,118 +0,0 @@
|
||||
"""Horoskop: pozycje, osie, domy, aspekty i kosmogram (strona główna)."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Form, Request
|
||||
from fastapi.responses import HTMLResponse, RedirectResponse
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features,
|
||||
app,
|
||||
templates,
|
||||
logic,
|
||||
chartwheel_mod,
|
||||
DEFAULT_LOCATION_LABEL,
|
||||
default_form,
|
||||
rozszerzenia,
|
||||
_perms,
|
||||
_limit_options,
|
||||
_landing,
|
||||
_build_utc,
|
||||
_logic_error,
|
||||
)
|
||||
|
||||
# ---------------- Horoskop: pozycje (strona główna) ----------------
|
||||
@app.get("/", response_class=HTMLResponse)
|
||||
def chart_form(request: Request):
|
||||
# Korzeń jest dostępny dla każdego zalogowanego, ale ekran „Horoskop" już nie.
|
||||
# Bez tego konto bez uprawnienia do horoskopu dostawałoby 404 pod adresem
|
||||
# głównym — czyli wyglądałoby to na zepsuty program, a nie na węższy zestaw.
|
||||
if "chart" not in _perms(request):
|
||||
target = _landing(request)
|
||||
if target:
|
||||
return RedirectResponse(target, status_code=303)
|
||||
# Ta sama odpowiedź co bramka dla trasy bez uprawnienia. Poprzednia treść
|
||||
# mówiła o „przypisanych funkcjach" i o „osobie, która zakładała konto",
|
||||
# czyli wprost: funkcje są komuś przydzielane, jest ktoś, kto to robi,
|
||||
# a twoje konto zostało okrojone.
|
||||
return HTMLResponse("<h1>404 — nie znaleziono</h1>", status_code=404)
|
||||
return templates.TemplateResponse(
|
||||
request, "chart.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
|
||||
**rozszerzenia.kontekst_szablonu(request)},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/", response_class=HTMLResponse)
|
||||
def chart_compute(
|
||||
request: Request,
|
||||
person: str = Form(""), # imie i nazwisko — do naglowka raportu (PRE-21/24)
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
house_system: str = Form("whole_sign"),
|
||||
house_systems: list[str] = Form([]), # PRE-05: dodatkowe systemy do porównania
|
||||
aspect_orb: float = Form(8.0), # PRE-06: konfigurowalny orb aspektów
|
||||
aspect_luminary_bonus: float = Form(2.0),
|
||||
aspect_minor: bool = Form(False),
|
||||
stations: bool = Form(False),
|
||||
zodiac: str = Form("tropical"),
|
||||
tables: bool = Form(False),
|
||||
wheel_orientation: str = Form(chartwheel_mod.ASC_LEFT),
|
||||
):
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
|
||||
"lat": lat, "lon": lon, "house_system": house_system,
|
||||
"house_systems": house_systems, "aspect_orb": aspect_orb,
|
||||
"aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor,
|
||||
"stations": stations, "zodiac": zodiac, "tables": tables,
|
||||
"wheel_orientation": wheel_orientation}
|
||||
form = _limit_options(request, form)
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
ctx["result"] = logic.positions(
|
||||
when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
house_system=form["house_system"], house_systems=form["house_systems"],
|
||||
aspect_orb=aspect_orb, aspect_luminary_bonus=aspect_luminary_bonus,
|
||||
aspect_minor=form["aspect_minor"],
|
||||
stations=form["stations"], zodiac=form["zodiac"], tables=form["tables"],
|
||||
)
|
||||
from app import chartwheel # kosmogram (PRE-12), SVG po stronie serwera
|
||||
ctx["wheel_svg"] = chartwheel.render(ctx["result"],
|
||||
orientation=form["wheel_orientation"])
|
||||
# Rysunki dodatkowe NIE POWSTAJĄ bez uprawnienia — nie chodzi o ukrycie
|
||||
# ich w szablonie, tylko o to, żeby nie było ich nawet w źródle strony.
|
||||
if "extra_charts" in _perms(request):
|
||||
ctx["aspectarian_svg"] = chartwheel.render_aspectarian(ctx["result"]) # PRE-18
|
||||
ctx["declination_svg"] = chartwheel.render_declination(ctx["result"]) # LOG-07
|
||||
ctx["antiscia_svg"] = chartwheel.render_antiscia(ctx["result"]) # LOG-07
|
||||
except (httpx.HTTPError,) as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "chart.html", ctx)
|
||||
|
||||
# ── zgłoszenie do katalogu ─────────────────────────────────────────────────
|
||||
# Ekran zgłasza siebie, swoje trasy i swoje zasoby. Wszystko o tym ekranie jest
|
||||
# w tym pliku — więc obraz bez tego pliku nie wie o nim NIC.
|
||||
features.zarejestruj(
|
||||
ekran=Feature("chart", "Horoskop", "Pozycje, osie, domy, aspekty, kosmogram.",
|
||||
"Ekrany", "/", kolejnosc=10),
|
||||
trasy={("GET", "/"): None, # korzeń przekierowuje na pierwszy dostępny ekran
|
||||
("POST", "/"): "chart"},
|
||||
zasoby={"s-chart.css": "chart"},
|
||||
)
|
||||
features.zarejestruj(rozszerzenie=Feature(
|
||||
"houses_compare", "Porównanie systemów domów",
|
||||
"Wybór systemu innego niż domyślny i zestawienie kilku obok siebie.",
|
||||
"Rozszerzenia", kolejnosc=10))
|
||||
features.zarejestruj(rozszerzenie=Feature(
|
||||
"extra_charts", "Wykresy dodatkowe",
|
||||
"Aspektarian, wykres deklinacji, oś antyscji.", "Rozszerzenia", kolejnosc=20))
|
||||
features.zarejestruj(rozszerzenie=Feature(
|
||||
"advanced_calc", "Obliczenia zaawansowane",
|
||||
"Stacje planet, tabele żywiołów i faz, aspekty poboczne, zodiaki syderyczne.",
|
||||
"Rozszerzenia", kolejnosc=30))
|
||||
@@ -1,81 +0,0 @@
|
||||
"""Interpretacje: wynik obliczeń szukany w bazach."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Depends, Form, Request
|
||||
from fastapi.responses import HTMLResponse, Response
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features,
|
||||
app,
|
||||
templates,
|
||||
logic,
|
||||
security,
|
||||
DEFAULT_LOCATION_LABEL,
|
||||
default_form,
|
||||
rozszerzenia,
|
||||
_build_utc,
|
||||
_dozwolona_akcja,
|
||||
_report_records,
|
||||
_logic_error,
|
||||
)
|
||||
|
||||
# ---------------- Interpretacje (wynik obliczeń szukany w bazie) ----------------
|
||||
@app.get("/interpret", response_class=HTMLResponse)
|
||||
def interpret_form(request: Request):
|
||||
return templates.TemplateResponse(
|
||||
request, "interpret.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
|
||||
**rozszerzenia.kontekst_szablonu(request)},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/interpret", response_class=HTMLResponse)
|
||||
def interpret_run(
|
||||
request: Request,
|
||||
person: str = Form(""), # imie i nazwisko — do naglowka raportu (PRE-21/24)
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
group: bool = Form(False),
|
||||
action: str = Form("report"),
|
||||
# Pola wnoszone przez moduły opcjonalne. FastAPI czyta pola z sygnatury, a ta
|
||||
# nie może ich wymieniać — w obrazie bez modułu byłyby nazwą nieistniejącej
|
||||
# funkcji wpisaną w kod. Zależność przenosi deklarację do modułu.
|
||||
dodatki: dict = Depends(rozszerzenia.pola_formularza()),
|
||||
):
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
|
||||
"lat": lat, "lon": lon, "group": group, **dodatki}
|
||||
action = _dozwolona_akcja(request, action, "report")
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None,
|
||||
**rozszerzenia.kontekst_szablonu(request)}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
# Akcja może należeć do modułu opcjonalnego. `None` znaczy „nie jego",
|
||||
# więc ekran robi to, co robi normalnie. Moduł może oddać słownik do
|
||||
# kontekstu albo gotową odpowiedź — na przykład plik do pobrania.
|
||||
wynik = rozszerzenia.obsluz(action, profil="natal", iso_utc=iso_utc,
|
||||
lat=lat, lon=lon, dodatki=dodatki,
|
||||
request=request, group=group)
|
||||
if isinstance(wynik, Response):
|
||||
return wynik
|
||||
if wynik is not None:
|
||||
ctx["wynik_dodatku"] = wynik
|
||||
else:
|
||||
ctx["result"] = logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
|
||||
security.audit_records(request, _report_records(ctx["result"]))
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "interpret.html", ctx)
|
||||
|
||||
features.zarejestruj(
|
||||
ekran=Feature("interpret", "Interpretacje", "Interpretacja natalna z baz.",
|
||||
"Ekrany", "/interpret", kolejnosc=20),
|
||||
trasy={("GET", "/interpret"): "interpret", ("POST", "/interpret"): "interpret"},
|
||||
zasoby={"s-interpret.css": "interpret"},
|
||||
)
|
||||
@@ -1,78 +0,0 @@
|
||||
"""Kalendarz: oś czasu z technik wraz z interpretacjami."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Depends, Form, Request
|
||||
from fastapi.responses import HTMLResponse
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features,
|
||||
app,
|
||||
templates,
|
||||
logic,
|
||||
DEFAULT_LOCATION_LABEL,
|
||||
default_form,
|
||||
rozszerzenia,
|
||||
_build_utc,
|
||||
_dozwolona_akcja,
|
||||
_logic_error,
|
||||
)
|
||||
|
||||
# ---------------- Kalendarz (oś czasu z technik + interpretacje) ----------------
|
||||
@app.get("/timeline", response_class=HTMLResponse)
|
||||
def timeline_form(request: Request):
|
||||
return templates.TemplateResponse(
|
||||
request, "timeline.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
|
||||
**rozszerzenia.kontekst_szablonu(request)},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/timeline", response_class=HTMLResponse)
|
||||
def timeline_run(
|
||||
request: Request,
|
||||
person: str = Form(""), # imie i nazwisko — do naglowka raportu (PRE-21/24)
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
from_date: str = Form(...),
|
||||
to_date: str = Form(...),
|
||||
action: str = Form("timeline"),
|
||||
# Pola wnoszone przez moduły opcjonalne. FastAPI czyta pola z sygnatury, a ta
|
||||
# nie może ich wymieniać — w obrazie bez modułu byłyby nazwą nieistniejącej
|
||||
# funkcji wpisaną w kod. Zależność przenosi deklarację do modułu.
|
||||
dodatki: dict = Depends(rozszerzenia.pola_formularza()),
|
||||
):
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
|
||||
"lat": lat, "lon": lon, "from_date": from_date, "to_date": to_date,
|
||||
**dodatki}
|
||||
action = _dozwolona_akcja(request, action, "timeline")
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None,
|
||||
**rozszerzenia.kontekst_szablonu(request)}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
wynik = rozszerzenia.obsluz(action, profil="period", iso_utc=iso_utc,
|
||||
lat=lat, lon=lon, dodatki=dodatki,
|
||||
od=from_date, do=to_date)
|
||||
if wynik is not None:
|
||||
ctx["wynik_dodatku"] = wynik
|
||||
else:
|
||||
ctx["result"] = logic.timeline(
|
||||
when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
from_date=from_date, to_date=to_date, interpret=True,
|
||||
)
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "timeline.html", ctx)
|
||||
|
||||
features.zarejestruj(
|
||||
ekran=Feature("timeline", "Kalendarz", "Predykcje na wybrany zakres dat.",
|
||||
"Ekrany", "/timeline", kolejnosc=30),
|
||||
trasy={("GET", "/timeline"): "timeline", ("POST", "/timeline"): "timeline"},
|
||||
zasoby={"s-timeline.css": "timeline"},
|
||||
)
|
||||
@@ -1,104 +0,0 @@
|
||||
"""Konta i uprawnienia (PRE-27) — ekran wyłącznie administracyjny."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Form, Request
|
||||
from fastapi.responses import HTMLResponse, RedirectResponse
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (app, templates, security, features, accounts_store)
|
||||
|
||||
# ---------------- Konta i uprawnienia (PRE-27) ----------------
|
||||
# Ochrona tych tras siedzi w features.ROUTES, nie w dekoratorze — jedna mapa
|
||||
# dla całej aplikacji, sprawdzana testem, który przechodzi po WSZYSTKICH trasach.
|
||||
|
||||
def _accounts_context(request: Request, error: str = "", done: str = "") -> dict:
|
||||
# Problem z magazynem NIE MOŻE dawać gołego 500: to jedyny ekran, z którego
|
||||
# administrator może go naprawić, więc musi na nim przeczytać, co i gdzie
|
||||
# jest nie tak.
|
||||
try:
|
||||
users = accounts_store.all_users()
|
||||
except accounts_store.AccountsUnavailable as e:
|
||||
users, error = {}, str(e)
|
||||
return {
|
||||
"users": users,
|
||||
"catalog": features.ALL,
|
||||
"screens": features.SCREENS,
|
||||
# Rejestr zawiera już wszystko, co ten obraz umie — łącznie z tym, co
|
||||
# wniosły moduły opcjonalne. Administrator ma nadawać uprawnienia do
|
||||
# funkcji, które REALNIE są, a nie do listy wpisanej kiedyś na sztywno.
|
||||
"extras": features.EXTRAS,
|
||||
"admin_login": security.app_user(),
|
||||
"store_path": accounts_store.store_path(),
|
||||
"error": error, "done": done,
|
||||
}
|
||||
|
||||
|
||||
@app.get("/accounts", response_class=HTMLResponse)
|
||||
def accounts_view(request: Request, error: str = "", done: str = ""):
|
||||
return templates.TemplateResponse(request, "accounts.html",
|
||||
_accounts_context(request, error, done))
|
||||
|
||||
|
||||
def _accounts_redirect(error: str = "", done: str = "") -> RedirectResponse:
|
||||
"""Po zapisie PRZEKIEROWANIE, nie render — odświeżenie strony nie może
|
||||
powtórzyć zakładania ani kasowania konta."""
|
||||
from urllib.parse import urlencode
|
||||
|
||||
q = urlencode({k: v for k, v in (("error", error), ("done", done)) if v})
|
||||
return RedirectResponse(f"/accounts{'?' + q if q else ''}", status_code=303)
|
||||
|
||||
|
||||
@app.post("/accounts/create")
|
||||
def accounts_create(request: Request, login: str = Form(""), password: str = Form(""),
|
||||
note: str = Form(""), granted: list[str] = Form([])):
|
||||
try:
|
||||
accounts_store.create(login, password, granted, note)
|
||||
except (ValueError, accounts_store.AccountsUnavailable) as e:
|
||||
return _accounts_redirect(error=str(e))
|
||||
return _accounts_redirect(done=f"Założono konto „{login.strip()}”.")
|
||||
|
||||
|
||||
@app.post("/accounts/update")
|
||||
def accounts_update(request: Request, login: str = Form(...), password: str = Form(""),
|
||||
note: str = Form(""), granted: list[str] = Form([])):
|
||||
try:
|
||||
accounts_store.update(login, granted=granted, password=password, note=note)
|
||||
except (ValueError, accounts_store.AccountsUnavailable) as e:
|
||||
return _accounts_redirect(error=str(e))
|
||||
changed = "uprawnienia i hasło" if password.strip() else "uprawnienia"
|
||||
return _accounts_redirect(done=f"Zapisano {changed} konta „{login}”.")
|
||||
|
||||
|
||||
@app.post("/accounts/sesje")
|
||||
def accounts_sesje(request: Request, login: str = Form(...)):
|
||||
"""Unieważnia WSZYSTKIE otwarte sesje konta, na każdym urządzeniu.
|
||||
|
||||
Zmiana hasła robi to samo przy okazji, więc ta operacja jest na wypadek
|
||||
„wyrzuć zewsząd, ale hasło zostaw" — na przykład gdy ktoś zostawił zalogowany
|
||||
komputer i nie chce wpisywać nowego hasła wszędzie."""
|
||||
try:
|
||||
accounts_store.bump_session(login)
|
||||
except (ValueError, accounts_store.AccountsUnavailable) as e:
|
||||
return _accounts_redirect(error=str(e))
|
||||
return _accounts_redirect(done=f"Zamknięto wszystkie sesje konta „{login}”.")
|
||||
|
||||
|
||||
@app.post("/accounts/delete")
|
||||
def accounts_delete(request: Request, login: str = Form(...)):
|
||||
try:
|
||||
accounts_store.delete(login)
|
||||
except (ValueError, accounts_store.AccountsUnavailable) as e:
|
||||
return _accounts_redirect(error=str(e))
|
||||
return _accounts_redirect(done=f"Skasowano konto „{login}”.")
|
||||
|
||||
# Ekran wyłącznie administracyjny — nie ma pozycji w katalogu funkcji, bo ADMIN
|
||||
# nie jest uprawnieniem do nadania (patrz features.GRANTABLE).
|
||||
features.zarejestruj(
|
||||
nawigacja_admina=("accounts", "/accounts", "Konta"),
|
||||
trasy={("GET", "/accounts"): features.ADMIN,
|
||||
("POST", "/accounts/create"): features.ADMIN,
|
||||
("POST", "/accounts/update"): features.ADMIN,
|
||||
("POST", "/accounts/delete"): features.ADMIN,
|
||||
("POST", "/accounts/sesje"): features.ADMIN},
|
||||
zasoby={"s-accounts.css": features.ADMIN},
|
||||
)
|
||||
@@ -1,79 +0,0 @@
|
||||
"""Logowanie i wylogowanie (LOG-34)."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Form, Request
|
||||
from fastapi.responses import HTMLResponse, RedirectResponse
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features, app, templates, security, session)
|
||||
|
||||
# ---------------- Logowanie i wylogowanie (LOG-34) ----------------
|
||||
# Zastępuje HTTP Basic, który nie miał wylogowania: przeglądarka zapamiętywała
|
||||
# hasło i dosyłała je sama, więc serwer nie miał czego zapomnieć. Teraz to serwer
|
||||
# decyduje, czy dana przeglądarka jest w środku — i może to cofnąć.
|
||||
|
||||
def _bezpieczne_dokad(dokad: str) -> str:
|
||||
"""Adres powrotu po zalogowaniu, przepuszczony przez sito.
|
||||
|
||||
Bez tego `?dokad=https://obcy.pl` zamieniłby nasz ekran logowania w narzędzie
|
||||
do przekierowywania ludzi gdzie indziej — klasyczna droga do wyłudzenia hasła,
|
||||
bo odsyłacz prowadzi z zaufanego adresu. Wpuszczamy wyłącznie ścieżki
|
||||
wewnętrzne: jeden ukośnik na początku i ani jednego znaku, który mógłby
|
||||
zacząć adres obcego serwera."""
|
||||
dokad = (dokad or "").strip()
|
||||
if not dokad.startswith("/") or dokad.startswith("//") or "\\" in dokad:
|
||||
return "/"
|
||||
return dokad.split("?", 1)[0].split("#", 1)[0] or "/"
|
||||
|
||||
|
||||
@app.get("/logowanie", response_class=HTMLResponse)
|
||||
def logowanie_form(request: Request, dokad: str = "/", blad: str = ""):
|
||||
# Zalogowanego nie ma po co pytać o hasło jeszcze raz.
|
||||
if security.auth_enabled() and security.principal(request) is not None:
|
||||
return RedirectResponse(_bezpieczne_dokad(dokad), status_code=303)
|
||||
return templates.TemplateResponse(request, "logowanie.html",
|
||||
{"dokad": _bezpieczne_dokad(dokad), "blad": blad})
|
||||
|
||||
|
||||
@app.post("/logowanie")
|
||||
def logowanie(request: Request, login: str = Form(""), haslo: str = Form(""),
|
||||
dokad: str = Form("/")):
|
||||
cel = _bezpieczne_dokad(dokad)
|
||||
who = security.verify(login.strip(), haslo)
|
||||
if who is None:
|
||||
# JEDEN komunikat na złe hasło i nieznany login. Rozróżnienie mówiłoby,
|
||||
# które konta istnieją — a to informacja warta czegoś dla zgadującego.
|
||||
security.audit_login(request, login.strip(), udane=False)
|
||||
return templates.TemplateResponse(
|
||||
request, "logowanie.html",
|
||||
{"dokad": cel, "blad": "Nieprawidłowy login lub hasło.", "login": login},
|
||||
status_code=401)
|
||||
|
||||
security.audit_login(request, who.login, udane=True)
|
||||
odpowiedz = RedirectResponse(cel, status_code=303)
|
||||
odpowiedz.set_cookie(session.COOKIE, security.issue_session(who.login),
|
||||
max_age=session.max_age(),
|
||||
**session.cookie_params(secure=security.cookies_secure()))
|
||||
return odpowiedz
|
||||
|
||||
|
||||
@app.post("/wyloguj")
|
||||
def wyloguj(request: Request):
|
||||
"""Kasuje ciasteczko sesji. To jest całe wylogowanie — natychmiastowe
|
||||
i bez żadnego magazynu, bo przeglądarka nie ma już czego dosyłać.
|
||||
|
||||
POST, nie GET: pod adresem GET wystarczyłby obrazek na obcej stronie, żeby
|
||||
wylogować kogoś bez jego wiedzy. Uciążliwość, nie włamanie — ale darmowa
|
||||
do uniknięcia."""
|
||||
security.audit_logout(request)
|
||||
odpowiedz = RedirectResponse("/logowanie?wylogowano=1", status_code=303)
|
||||
odpowiedz.delete_cookie(session.COOKIE, **session.cookie_params(
|
||||
secure=security.cookies_secure()))
|
||||
return odpowiedz
|
||||
|
||||
# Wyjście musi być dostępne dla każdego zalogowanego, niezależnie od tego, co mu
|
||||
# przyznano — konto bez ani jednego ekranu też ma prawo wyjść.
|
||||
features.zarejestruj(
|
||||
trasy={("GET", "/logowanie"): None, ("POST", "/logowanie"): None,
|
||||
("POST", "/wyloguj"): None},
|
||||
)
|
||||
@@ -1,58 +0,0 @@
|
||||
"""Wyszukiwarka miejsca i strefa czasowa (proxy OSM/Nominatim)."""
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import timezone
|
||||
from fastapi import HTTPException, Query
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features, app, geocode)
|
||||
|
||||
# ---------------- Geokoder (proxy OSM/Nominatim dla wyszukiwarki lokalizacji) ----------------
|
||||
@app.get("/geocode")
|
||||
def geocode_search(q: str = Query("", description="Nazwa / adres / POI do wyszukania")):
|
||||
"""Nazwa miejsca → kandydaci ze współrzędnymi (dla pola „Szukaj miejsca")."""
|
||||
try:
|
||||
return {"results": geocode.search(q)}
|
||||
except httpx.HTTPError as e:
|
||||
raise HTTPException(status_code=502, detail=f"Geokoder (OSM) niedostępny: {e}")
|
||||
|
||||
|
||||
@app.get("/reverse")
|
||||
def geocode_reverse(lat: float, lon: float):
|
||||
"""Punkt z mapy → nazwa miejsca (po przeciągnięciu pineski / kliknięciu)."""
|
||||
try:
|
||||
return geocode.reverse(lat, lon)
|
||||
except httpx.HTTPError as e:
|
||||
raise HTTPException(status_code=502, detail=f"Geokoder (OSM) niedostępny: {e}")
|
||||
|
||||
|
||||
@app.get("/timezone")
|
||||
def timezone_lookup(lat: float, lon: float, date: str = "", time: str = "12:00"):
|
||||
"""Współrzędne + data → strefa IANA i DST-świadomy offset GMT (PRE-03).
|
||||
|
||||
Liczone OFFLINE (tzfpy + zoneinfo), więc brak internetu nie przeszkadza. 404,
|
||||
gdy strefy nie da się ustalić — front zostawia wtedy ręczny offset."""
|
||||
from app import timezone as tzmod
|
||||
|
||||
res = tzmod.resolve(lat, lon, date, time)
|
||||
if not res:
|
||||
raise HTTPException(status_code=404, detail="Nie ustalono strefy dla tego punktu.")
|
||||
return res
|
||||
|
||||
# Wyszukiwarka miejsca siedzi na kilku ekranach naraz, więc jej zasoby otwiera
|
||||
# KTÓREKOLWIEK z nich — wymaganie wszystkich byłoby bez sensu.
|
||||
_LOKALIZACJA = frozenset({"chart", "interpret", "timeline"})
|
||||
_FORMULARZE = frozenset({"chart", "interpret", "timeline", "compile"})
|
||||
_KOLO = frozenset({"chart", "compile"})
|
||||
|
||||
features.zarejestruj(
|
||||
trasy={("GET", "/geocode"): None, ("GET", "/reverse"): None,
|
||||
("GET", "/timezone"): None},
|
||||
zasoby={"geo.js": _LOKALIZACJA, "now.js": _LOKALIZACJA,
|
||||
"vendor/leaflet/leaflet.js": _LOKALIZACJA,
|
||||
"vendor/leaflet/leaflet.css": _LOKALIZACJA,
|
||||
"formsync.js": _FORMULARZE,
|
||||
"wheelzoom.js": _KOLO, "wheeltip.js": _KOLO,
|
||||
"copy.js": frozenset({"interpret", "timeline"})},
|
||||
)
|
||||
@@ -1,164 +0,0 @@
|
||||
"""Pliki baz: wybór, wgrywanie, archiwizacja i reguły przyjmowania (DAN-27)."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import File, Form, Request, UploadFile
|
||||
from fastapi.responses import HTMLResponse, RedirectResponse
|
||||
import base64
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (app, templates, logic, features, files_state, _perms, _logic_error)
|
||||
|
||||
# ---------------- Pliki baz (DAN-27) ----------------
|
||||
# Trzy poziomy dostępu, opisane w features.ROUTES:
|
||||
# „files" — widzi listę i decyduje, z czego program korzysta,
|
||||
# „files_input" — dokłada wgrywanie i ARCHIWIZACJĘ (plik zostaje zamrożony
|
||||
# ze znacznikiem czasu, znika tylko z użytku),
|
||||
# administrator — kasowanie, przywracanie z archiwum i REGUŁY WALIDACJI.
|
||||
#
|
||||
# Kwarantanna (plik wgrany, ale odrzucony przez walidację) jest odsiewana W WARSTWIE
|
||||
# DANYCH przy `for_admin=False`. Nie filtrujemy jej tutaj ani w szablonie: gdyby
|
||||
# takie pliki dochodziły do przeglądarki, wystarczyłby podgląd źródła, żeby poznać
|
||||
# reguły — a te ma znać wyłącznie administrator.
|
||||
|
||||
def _files_context(request: Request, error: str = "", done: str = "") -> dict:
|
||||
is_admin = features.ADMIN in _perms(request)
|
||||
try:
|
||||
data = logic.files_list(for_admin=is_admin)
|
||||
except httpx.HTTPError as e:
|
||||
return {"files": [], "rules": {}, "is_admin": is_admin,
|
||||
"error": _logic_error(e), "done": ""}
|
||||
return {"files": data.get("files") or [], "rules": data.get("rules") or {},
|
||||
"is_admin": is_admin, "error": error, "done": done}
|
||||
|
||||
|
||||
@app.get("/files", response_class=HTMLResponse)
|
||||
def files_view(request: Request, error: str = "", done: str = ""):
|
||||
return templates.TemplateResponse(request, "files.html",
|
||||
_files_context(request, error, done))
|
||||
|
||||
|
||||
def _files_redirect(error: str = "", done: str = "") -> RedirectResponse:
|
||||
from urllib.parse import urlencode
|
||||
|
||||
q = urlencode({k: v for k, v in (("error", error), ("done", done)) if v})
|
||||
return RedirectResponse(f"/files{'?' + q if q else ''}", status_code=303)
|
||||
|
||||
|
||||
def _who(request: Request) -> str:
|
||||
return getattr(request.state, "user", "") or "-"
|
||||
|
||||
|
||||
@app.post("/files/use")
|
||||
def files_use(request: Request, path: str = Form(...), use: str = Form("")):
|
||||
"""Włącza albo odstawia bazę. Włączenie przechodzi przez bramkę walidacji
|
||||
w warstwie danych — odmowa wraca BEZ POWODU, bo powód zdradzałby reguły."""
|
||||
want = files_state.ACTIVE if use.strip().lower() in {"1", "true", "on", "tak"} \
|
||||
else files_state.READY
|
||||
try:
|
||||
logic.files_status(path, want, by=_who(request))
|
||||
except httpx.HTTPStatusError as e:
|
||||
detail = _http_detail(e)
|
||||
if features.ADMIN not in _perms(request):
|
||||
detail = "Tego pliku nie da się teraz włączyć do użytku."
|
||||
return _files_redirect(error=detail)
|
||||
except httpx.HTTPError as e:
|
||||
return _files_redirect(error=_logic_error(e))
|
||||
return _files_redirect(done="Zapisano." if want == files_state.READY
|
||||
else "Plik włączony do użytku.")
|
||||
|
||||
|
||||
@app.post("/files/upload")
|
||||
async def files_upload(request: Request, upload: UploadFile = File(...)):
|
||||
"""Wgranie nowej bazy. Plik zostaje NIEZALEŻNIE od wyniku walidacji —
|
||||
nie tracimy niczego, co ktoś wgrał."""
|
||||
raw = await upload.read()
|
||||
if not raw:
|
||||
return _files_redirect(error="Pusty plik.")
|
||||
try:
|
||||
out = logic.files_upload(upload.filename or "plik.xlsx",
|
||||
base64.b64encode(raw).decode("ascii"), by=_who(request))
|
||||
except httpx.HTTPError as e:
|
||||
return _files_redirect(error=_logic_error(e))
|
||||
# DOKŁADNIE ten sam komunikat niezależnie od wyniku sprawdzenia. Dwa różne
|
||||
# komunikaty były wyrocznią: wystarczyło wgrywać spreparowane pliki i czytać
|
||||
# odpowiedź, żeby odgadnąć reguły, które ma znać wyłącznie administrator.
|
||||
# Poprzednia treść mówiła przy tym wprost, że istnieje „administrator", który
|
||||
# musi plik „zatwierdzić" — czyli że konto wgrywającego jest ograniczone
|
||||
# i że plik przechodzi przez jakąś bramkę.
|
||||
return _files_redirect(done=f"Wgrano „{out.get('name')}”.")
|
||||
|
||||
|
||||
@app.post("/files/archive")
|
||||
def files_archive(request: Request, path: str = Form(...)):
|
||||
"""Archiwizacja: plik ZOSTAJE, zamrożony, ze znacznikiem czasu — znika tylko
|
||||
z użytku. To najdalej idąca operacja dostępna osobie wgrywającej dane."""
|
||||
try:
|
||||
logic.files_status(path, files_state.ARCHIVED, by=_who(request))
|
||||
except httpx.HTTPError as e:
|
||||
return _files_redirect(error=_logic_error(e))
|
||||
return _files_redirect(done=f"Zarchiwizowano „{path}”. Plik został zachowany.")
|
||||
|
||||
|
||||
@app.post("/files/restore")
|
||||
def files_restore(request: Request, path: str = Form(...)):
|
||||
try:
|
||||
logic.files_status(path, files_state.READY, by=_who(request))
|
||||
except httpx.HTTPError as e:
|
||||
return _files_redirect(error=_logic_error(e))
|
||||
return _files_redirect(done=f"Przywrócono „{path}” z archiwum.")
|
||||
|
||||
|
||||
@app.post("/files/delete")
|
||||
def files_delete(request: Request, path: str = Form(...)):
|
||||
try:
|
||||
logic.files_delete(path)
|
||||
except httpx.HTTPError as e:
|
||||
return _files_redirect(error=_logic_error(e))
|
||||
return _files_redirect(done=f"Skasowano „{path}” bezpowrotnie.")
|
||||
|
||||
|
||||
@app.post("/files/rules")
|
||||
def files_rules(request: Request, extensions: str = Form(".xlsx"),
|
||||
max_size_mb: float = Form(50), min_rows: int = Form(1),
|
||||
required_columns: str = Form(""),
|
||||
reject_duplicate_content: str = Form("")):
|
||||
rules = {
|
||||
"extensions": [e.strip() for e in extensions.split(",") if e.strip()],
|
||||
"max_size_mb": max_size_mb,
|
||||
"min_rows": min_rows,
|
||||
"required_columns": [c.strip() for c in required_columns.split(",") if c.strip()],
|
||||
"reject_duplicate_content": reject_duplicate_content.strip().lower()
|
||||
in {"1", "true", "on", "tak"},
|
||||
}
|
||||
try:
|
||||
logic.files_rules(rules)
|
||||
except httpx.HTTPError as e:
|
||||
return _files_redirect(error=_logic_error(e))
|
||||
return _files_redirect(done="Zapisano reguły walidacji.")
|
||||
|
||||
|
||||
def _http_detail(e: httpx.HTTPStatusError) -> str:
|
||||
try:
|
||||
return str(e.response.json().get("detail") or e)
|
||||
except Exception: # noqa: BLE001
|
||||
return str(e)
|
||||
|
||||
features.zarejestruj(
|
||||
ekran=Feature("files", "Pliki", "Wybór plików, z których korzysta program.",
|
||||
"Ekrany", "/files", kolejnosc=70),
|
||||
# Kasowanie, przywracanie i REGUŁY PRZYJMOWANIA to wyłącznie administrator —
|
||||
# o istnieniu reguł nikt poza nim nie ma skąd wiedzieć (DAN-27).
|
||||
trasy={("GET", "/files"): "files", ("POST", "/files/use"): "files",
|
||||
("POST", "/files/upload"): "files_input",
|
||||
("POST", "/files/archive"): "files_input",
|
||||
("POST", "/files/restore"): features.ADMIN,
|
||||
("POST", "/files/delete"): features.ADMIN,
|
||||
("POST", "/files/rules"): features.ADMIN},
|
||||
zasoby={"s-files.css": "files"},
|
||||
)
|
||||
features.zarejestruj(rozszerzenie=Feature(
|
||||
"files_input", "Wgrywanie i archiwizacja plików",
|
||||
"Dodawanie nowych plików i wycofywanie ich z użytku (plik zostaje, zamrożony, "
|
||||
"ze znacznikiem czasu). Kasować może wyłącznie administrator.",
|
||||
"Rozszerzenia", kolejnosc=40))
|
||||
@@ -1,96 +0,0 @@
|
||||
"""Skompiluj: zbiorczy raport z policzonych części (PRE-23), wraz z PDF-em."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Form, Request
|
||||
from fastapi.responses import HTMLResponse, JSONResponse, Response
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features,
|
||||
app,
|
||||
templates,
|
||||
logic,
|
||||
chartwheel_mod,
|
||||
DEFAULT_LOCATION_LABEL,
|
||||
default_form,
|
||||
_perms,
|
||||
_limit_options,
|
||||
_build_utc,
|
||||
_logic_error,
|
||||
)
|
||||
|
||||
# ---------------- Skompiluj: zbiorczy raport (PRE-23) ----------------
|
||||
@app.get("/compile", response_class=HTMLResponse)
|
||||
def compile_form(request: Request):
|
||||
return templates.TemplateResponse(
|
||||
request, "compile.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/compile", response_class=HTMLResponse)
|
||||
def compile_build(
|
||||
request: Request,
|
||||
person: str = Form(""),
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
house_system: str = Form("whole_sign"),
|
||||
house_systems: list[str] = Form([]), # PRE-05 — porównanie domów w podsumowaniu
|
||||
aspect_orb: float = Form(8.0), # PRE-06 — te same ustawienia aspektów
|
||||
aspect_luminary_bonus: float = Form(2.0),
|
||||
aspect_minor: bool = Form(False),
|
||||
stations: bool = Form(False), # LOG-03 — stacje też w podsumowaniu
|
||||
zodiac: str = Form("tropical"),
|
||||
tables: bool = Form(False), # LOG-23 — żywioły/faza/godziny w podsumowaniu
|
||||
wheel_orientation: str = Form(chartwheel_mod.ASC_LEFT), # LOG-05 — obrót koła
|
||||
):
|
||||
"""Składa raport: horoskop liczymy TU NA NOWO, a części z przeglądarki (interpretacja
|
||||
natalna i predykcje okresowe) dokłada przeglądarka z magazynu (PRE-22/23).
|
||||
|
||||
Horoskop liczymy ponownie (czysta funkcja wejścia — tanio powtórzyć, bez
|
||||
trzymania dużego wyniku w przeglądarce), ale z TYMI SAMYMI opcjami, które
|
||||
wybrano przy horoskopie (stacje, tabele, porównanie domów) — inaczej
|
||||
podsumowanie miałoby braki względem tego, co policzono. Opcje wędrują między
|
||||
zakładkami przez formsync.
|
||||
"""
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
|
||||
"lat": lat, "lon": lon, "house_system": house_system,
|
||||
"house_systems": house_systems, "aspect_orb": aspect_orb,
|
||||
"aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor,
|
||||
"stations": stations, "zodiac": zodiac, "tables": tables,
|
||||
"wheel_orientation": wheel_orientation}
|
||||
form = _limit_options(request, form)
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
ctx["result"] = logic.positions(
|
||||
when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
house_system=form["house_system"], house_systems=form["house_systems"],
|
||||
aspect_orb=aspect_orb, aspect_luminary_bonus=aspect_luminary_bonus,
|
||||
aspect_minor=form["aspect_minor"],
|
||||
stations=form["stations"], zodiac=form["zodiac"], tables=form["tables"],
|
||||
)
|
||||
from app import chartwheel
|
||||
ctx["wheel_svg"] = chartwheel.render(ctx["result"],
|
||||
orientation=form["wheel_orientation"])
|
||||
if "extra_charts" in _perms(request):
|
||||
ctx["aspectarian_svg"] = chartwheel.render_aspectarian(ctx["result"]) # PRE-18
|
||||
ctx["declination_svg"] = chartwheel.render_declination(ctx["result"]) # LOG-07
|
||||
ctx["antiscia_svg"] = chartwheel.render_antiscia(ctx["result"]) # LOG-07
|
||||
except (httpx.HTTPError,) as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "compile.html", ctx)
|
||||
|
||||
|
||||
features.zarejestruj(
|
||||
ekran=Feature("compile", "Skompiluj", "Złożenie raportu z policzonych części.",
|
||||
"Ekrany", "/compile", kolejnosc=60),
|
||||
trasy={("GET", "/compile"): "compile", ("POST", "/compile"): "compile"},
|
||||
zasoby={"s-compile.css": "compile", "compile.js": "compile"},
|
||||
)
|
||||
@@ -1,41 +0,0 @@
|
||||
"""Sygnifikatory: wyszukiwarka po bazach."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Form, Request
|
||||
from fastapi.responses import HTMLResponse
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features, app, templates, logic, security, _logic_error)
|
||||
|
||||
# ---------------- Sygnifikatory (wyszukiwarka w bazach) ----------------
|
||||
@app.get("/significators", response_class=HTMLResponse)
|
||||
def significators_form(request: Request):
|
||||
return templates.TemplateResponse(request, "significators.html", {"result": None, "form": {}})
|
||||
|
||||
|
||||
@app.post("/significators", response_class=HTMLResponse)
|
||||
def significators_search(
|
||||
request: Request,
|
||||
query: str = Form(...),
|
||||
field: str = Form("name"),
|
||||
exact: bool = Form(False),
|
||||
limit: int = Form(25),
|
||||
):
|
||||
form = {"query": query, "field": field, "exact": exact, "limit": limit}
|
||||
ctx: dict = {"form": form, "result": None, "error": None}
|
||||
try:
|
||||
ctx["result"] = logic.query(query=query, field=field, exact=exact, limit=limit)
|
||||
# ile rekordów baz oddaliśmy — do dziennika audytowego (PRE-17), bez treści
|
||||
security.audit_records(request, len((ctx["result"] or {}).get("rows") or []))
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
return templates.TemplateResponse(request, "significators.html", ctx)
|
||||
|
||||
features.zarejestruj(
|
||||
ekran=Feature("significators", "Sygnifikatory", "Wyszukiwarka po bazach.",
|
||||
"Ekrany", "/significators", kolejnosc=50),
|
||||
trasy={("GET", "/significators"): "significators",
|
||||
("POST", "/significators"): "significators"},
|
||||
zasoby={"s-significators.css": "significators"},
|
||||
)
|
||||
@@ -1,58 +0,0 @@
|
||||
"""Synastria: porównanie dwóch horoskopów."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Form, Request
|
||||
from fastapi.responses import HTMLResponse
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features, app, templates, logic, _build_utc, _logic_error)
|
||||
|
||||
# ---------------- Synastria (technika relacyjna) ----------------
|
||||
@app.get("/synastry", response_class=HTMLResponse)
|
||||
def synastry_form(request: Request):
|
||||
# domyślne liczby, żeby pola number nie były puste (puste → błąd przy wysyłce)
|
||||
form = {"a_tz_offset": 0, "a_lat": 0, "a_lon": 0, "b_tz_offset": 0, "b_lat": 0, "b_lon": 0,
|
||||
"aspect_orb": 8, "aspect_luminary_bonus": 2}
|
||||
return templates.TemplateResponse(request, "synastry.html", {"result": None, "form": form})
|
||||
|
||||
|
||||
@app.post("/synastry", response_class=HTMLResponse)
|
||||
def synastry_run(
|
||||
request: Request,
|
||||
a_person: str = Form(""), a_date: str = Form(...), a_time: str = Form(...),
|
||||
a_tz_offset: float = Form(0.0), a_lat: float = Form(0.0), a_lon: float = Form(0.0),
|
||||
b_person: str = Form(""), b_date: str = Form(...), b_time: str = Form(...),
|
||||
b_tz_offset: float = Form(0.0), b_lat: float = Form(0.0), b_lon: float = Form(0.0),
|
||||
zodiac: str = Form("tropical"),
|
||||
aspect_orb: float = Form(8.0), aspect_luminary_bonus: float = Form(2.0),
|
||||
aspect_minor: bool = Form(False),
|
||||
):
|
||||
"""Synastria (PRE-04): dwie osoby → aspekty między ich horoskopami."""
|
||||
form = {"a_person": a_person, "a_date": a_date, "a_time": a_time, "a_tz_offset": a_tz_offset,
|
||||
"a_lat": a_lat, "a_lon": a_lon, "b_person": b_person, "b_date": b_date,
|
||||
"b_time": b_time, "b_tz_offset": b_tz_offset, "b_lat": b_lat, "b_lon": b_lon,
|
||||
"zodiac": zodiac, "aspect_orb": aspect_orb,
|
||||
"aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor}
|
||||
ctx: dict = {"form": form, "result": None, "error": None}
|
||||
try:
|
||||
iso_a, _ = _build_utc(a_date, a_time, a_tz_offset)
|
||||
iso_b, _ = _build_utc(b_date, b_time, b_tz_offset)
|
||||
ctx["result"] = logic.synastry(
|
||||
{"when_utc": iso_a, "lat": a_lat, "lon": a_lon},
|
||||
{"when_utc": iso_b, "lat": b_lat, "lon": b_lon},
|
||||
zodiac=zodiac, aspect_orb=aspect_orb,
|
||||
aspect_luminary_bonus=aspect_luminary_bonus, aspect_minor=aspect_minor,
|
||||
)
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "synastry.html", ctx)
|
||||
|
||||
features.zarejestruj(
|
||||
ekran=Feature("synastry", "Synastria", "Porównanie dwóch horoskopów.",
|
||||
"Ekrany", "/synastry", kolejnosc=40),
|
||||
trasy={("GET", "/synastry"): "synastry", ("POST", "/synastry"): "synastry"},
|
||||
zasoby={"s-synastry.css": "synastry"},
|
||||
)
|
||||
@@ -1,32 +0,0 @@
|
||||
"""Ustawienia: podgląd baz widocznych na udziale (DAN-15/PRE-09)."""
|
||||
from __future__ import annotations
|
||||
|
||||
from fastapi import Request
|
||||
from fastapi.responses import HTMLResponse
|
||||
import httpx
|
||||
|
||||
from app.features import Feature
|
||||
from app.podstawa import (features, app, templates, logic, _logic_error)
|
||||
|
||||
# ---------------- Ustawienia: bazy na udziale (DAN-15/PRE-09) ----------------
|
||||
@app.get("/settings", response_class=HTMLResponse)
|
||||
def settings_view(request: Request):
|
||||
"""Podgląd baz dostępnych na udziale + które biorą udział w interpretacji.
|
||||
|
||||
Same metadane (nazwa, rozmiar, data) — bez treści baz. Przełączniki są
|
||||
DEKLARATYWNE (`DISABLED_BASES`), bo warstwa danych nie ma trwałego zapisu:
|
||||
udział jest read-only, a cache to emptyDir. Zapis do pliku ginąłby po
|
||||
restarcie, po cichu włączając z powrotem wyłączoną bazę."""
|
||||
ctx: dict = {"result": None, "error": None}
|
||||
try:
|
||||
ctx["result"] = logic.bases()
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
return templates.TemplateResponse(request, "settings.html", ctx)
|
||||
|
||||
features.zarejestruj(
|
||||
ekran=Feature("settings", "Ustawienia", "Podgląd plików widocznych na udziale.",
|
||||
"Ekrany", "/settings", kolejnosc=80),
|
||||
trasy={("GET", "/settings"): "settings"},
|
||||
zasoby={"s-settings.css": "settings"},
|
||||
)
|
||||
@@ -21,8 +21,6 @@ from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from app import rozszerzenia
|
||||
|
||||
ADMIN = "admin" # zakładanie kont i nadawanie uprawnień — nie do nadania z UI
|
||||
|
||||
|
||||
@@ -33,116 +31,86 @@ class Feature:
|
||||
hint: str
|
||||
group: str
|
||||
href: str = "" # tylko ekrany; rozszerzenia nie mają własnej zakładki
|
||||
kolejnosc: int = 0 # pozycja w nawigacji; nie zależy od kolejności importów
|
||||
|
||||
|
||||
# ── rejestr: katalog składa się z tego, co zgłoszą ekrany ────────────────
|
||||
# Dawniej wszystkie funkcje były wypisane TUTAJ. To znaczyło, że obraz produktu,
|
||||
# który części z nich nie ma, i tak niósł ich nazwy — czyli spis funkcji, których
|
||||
# nie ma jak włączyć. Teraz ekran zgłasza siebie sam, przy imporcie swojego
|
||||
# modułu, więc katalog opisuje dokładnie ten produkt, który się zbudowało.
|
||||
#
|
||||
# `kolejnosc` jest jawna, bo o zawartości decyduje lista importów w `main.py`,
|
||||
# a kolejność importów nie może rządzić kolejnością zakładek w nawigacji.
|
||||
SCREENS: list[Feature] = []
|
||||
# Pozycje nawigacji dla administratora. Osobno od SCREENS, bo ADMIN nie jest
|
||||
# uprawnieniem do nadania — a wpisane na sztywno w szablonie zostawiały nazwę
|
||||
# ekranu (i martwy odsyłacz) w produkcie, który tego ekranu nie ma.
|
||||
NAWIGACJA_ADMINA: list[tuple[str, str, str]] = [] # (klucz, adres, etykieta)
|
||||
EXTRAS: list[Feature] = []
|
||||
ALL: tuple[Feature, ...] = ()
|
||||
BY_KEY: dict[str, Feature] = {}
|
||||
GRANTABLE: frozenset[str] = frozenset()
|
||||
# ── ekrany (zakładki) ────────────────────────────────────────────────────
|
||||
SCREENS: tuple[Feature, ...] = (
|
||||
Feature("chart", "Horoskop", "Pozycje, osie, domy, aspekty, kosmogram.", "Ekrany", "/"),
|
||||
Feature("interpret", "Interpretacje", "Interpretacja natalna z baz i od modelu.", "Ekrany", "/interpret"),
|
||||
Feature("timeline", "Kalendarz", "Predykcje na wybrany zakres dat.", "Ekrany", "/timeline"),
|
||||
Feature("synastry", "Synastria", "Porównanie dwóch horoskopów.", "Ekrany", "/synastry"),
|
||||
Feature("significators", "Sygnifikatory", "Wyszukiwarka po bazach interpretacyjnych.", "Ekrany", "/significators"),
|
||||
Feature("compile", "Skompiluj", "Złożenie raportu z policzonych części.", "Ekrany", "/compile"),
|
||||
Feature("settings", "Ustawienia", "Podgląd baz i konfiguracji modelu.", "Ekrany", "/settings"),
|
||||
)
|
||||
|
||||
ROUTES: dict[tuple[str, str], str | None] = {}
|
||||
STATIC: dict[str, frozenset[str] | str | None] = {}
|
||||
# ── rozszerzenia (poziomy złożoności wewnątrz ekranów) ───────────────────
|
||||
EXTRAS: tuple[Feature, ...] = (
|
||||
Feature("houses_compare", "Porównanie systemów domów",
|
||||
"Wybór systemu innego niż domyślny i zestawienie kilku obok siebie.",
|
||||
"Rozszerzenia"),
|
||||
Feature("extra_charts", "Wykresy dodatkowe",
|
||||
"Aspektarian, wykres deklinacji, oś antyscji.", "Rozszerzenia"),
|
||||
Feature("advanced_calc", "Obliczenia zaawansowane",
|
||||
"Stacje planet, tabele żywiołów i faz, aspekty poboczne, zodiaki syderyczne.",
|
||||
"Rozszerzenia"),
|
||||
Feature("ai", "Generowanie tekstu przez model",
|
||||
"Horoskopy pisane przez model językowy. UWAGA: każde użycie kosztuje.",
|
||||
"Rozszerzenia"),
|
||||
Feature("export", "Eksport plików",
|
||||
"Pobieranie raportu jako PDF i wyników jako Excel.", "Rozszerzenia"),
|
||||
)
|
||||
|
||||
|
||||
def _przelicz() -> None:
|
||||
global ALL, BY_KEY, GRANTABLE
|
||||
SCREENS.sort(key=lambda f: f.kolejnosc)
|
||||
EXTRAS.sort(key=lambda f: f.kolejnosc)
|
||||
ALL = tuple(SCREENS) + tuple(EXTRAS)
|
||||
BY_KEY = {f.key: f for f in ALL}
|
||||
GRANTABLE = frozenset(BY_KEY) # ADMIN celowo poza tym zbiorem
|
||||
|
||||
|
||||
def zarejestruj(*, ekran: Feature | None = None, rozszerzenie: Feature | None = None,
|
||||
trasy: dict[tuple[str, str], str | None] | None = None,
|
||||
zasoby: dict | None = None,
|
||||
nawigacja_admina: tuple[str, str, str] | None = None) -> None:
|
||||
"""Zgłoszenie funkcji, jej tras i jej zasobów.
|
||||
|
||||
Idempotentne po kluczu: `export` zgłaszają dwa ekrany (raport do PDF-a
|
||||
i wyniki do arkusza), a wpis ma powstać raz."""
|
||||
for pozycja, zbior in ((ekran, SCREENS), (rozszerzenie, EXTRAS)):
|
||||
if pozycja and pozycja.key not in {f.key for f in zbior}:
|
||||
zbior.append(pozycja)
|
||||
if nawigacja_admina and nawigacja_admina[0] not in {p[0] for p in NAWIGACJA_ADMINA}:
|
||||
NAWIGACJA_ADMINA.append(nawigacja_admina)
|
||||
ROUTES.update(trasy or {})
|
||||
STATIC.update(zasoby or {})
|
||||
_przelicz()
|
||||
|
||||
|
||||
# Funkcje wnoszone przez moduły opcjonalne — zgłaszane tak samo jak ekrany,
|
||||
# tylko przez neutralny most, żeby katalog nie musiał ich wymieniać z nazwy.
|
||||
for _krotka in rozszerzenia.funkcje():
|
||||
zarejestruj(rozszerzenie=Feature(*_krotka))
|
||||
zarejestruj(trasy=rozszerzenia.trasy(), zasoby=rozszerzenia.zasoby())
|
||||
ALL: tuple[Feature, ...] = SCREENS + EXTRAS
|
||||
BY_KEY: dict[str, Feature] = {f.key: f for f in ALL}
|
||||
GRANTABLE: frozenset[str] = frozenset(BY_KEY) # ADMIN celowo poza tym zbiorem
|
||||
|
||||
|
||||
# ── mapa trasa → wymagane uprawnienie ────────────────────────────────────
|
||||
# None = dostępne każdemu zalogowanemu. Dotyczy to pomocników (geokoder, strefa
|
||||
# czasowa, health), które same w sobie NICZEGO nie zdradzają o funkcjach programu.
|
||||
ROUTES: dict[tuple[str, str], str | None] = {
|
||||
("GET", "/"): None, # korzeń przekierowuje na pierwszy dostępny ekran
|
||||
("POST", "/"): "chart",
|
||||
("GET", "/interpret"): "interpret",
|
||||
("POST", "/interpret"): "interpret",
|
||||
("GET", "/timeline"): "timeline",
|
||||
("POST", "/timeline"): "timeline",
|
||||
("GET", "/synastry"): "synastry",
|
||||
("POST", "/synastry"): "synastry",
|
||||
("GET", "/significators"): "significators",
|
||||
("POST", "/significators"): "significators",
|
||||
("GET", "/compile"): "compile",
|
||||
("POST", "/compile"): "compile",
|
||||
("POST", "/compile/pdf"): "export",
|
||||
("GET", "/settings"): "settings",
|
||||
("POST", "/horoscope/stream"): "ai",
|
||||
("GET", "/accounts"): ADMIN,
|
||||
("POST", "/accounts/create"): ADMIN,
|
||||
("POST", "/accounts/update"): ADMIN,
|
||||
("POST", "/accounts/delete"): ADMIN,
|
||||
("GET", "/geocode"): None,
|
||||
("GET", "/reverse"): None,
|
||||
("GET", "/timezone"): None,
|
||||
("GET", "/health"): None,
|
||||
}
|
||||
|
||||
|
||||
# ── zasoby statyczne ─────────────────────────────────────────────────────
|
||||
# Skrypt i arkusz stylów są CZĘŚCIĄ funkcji, nie jej dekoracją. Nazwa pliku jest
|
||||
# zgadywalna, a treść opowiada o funkcji dokładniej niż przycisk: `compile.js`
|
||||
# zdradza składanie raportu, a `wheelzoom.js` — istnienie kosmogramu. Dlatego każdy
|
||||
# zasób przechodzi przez tę samą bramkę co ekrany.
|
||||
#
|
||||
# Wartość to ZBIÓR uprawnień, z których wystarczy JEDNO: wyszukiwarka lokalizacji
|
||||
# siedzi na trzech ekranach i konto z którymkolwiek z nich musi ją dostać.
|
||||
# `None` = każdy zalogowany. Zasób spoza mapy wymaga admina — jak trasa.
|
||||
_FORMULARZE = frozenset({"chart", "interpret", "timeline", "compile"})
|
||||
_LOKALIZACJA = frozenset({"chart", "interpret", "timeline"})
|
||||
_KOLO = frozenset({"chart", "compile"})
|
||||
|
||||
|
||||
|
||||
def static_required(name: str) -> frozenset[str] | str | None:
|
||||
"""Uprawnienie dla zasobu. Nieznany zasób → admin, jak nieznana trasa."""
|
||||
return STATIC.get(name, ADMIN)
|
||||
|
||||
|
||||
def required(method: str, path: str) -> frozenset[str] | str | None:
|
||||
def required(method: str, path: str) -> str | None:
|
||||
"""Uprawnienie wymagane przez trasę. Nieznana trasa → wymaga admina.
|
||||
|
||||
Domyślną odpowiedzią jest NAJWĘŻSZE uprawnienie, nie najszersze: dopisanie
|
||||
trasy bez wpisu w ROUTES ma ją zamknąć, a nie otworzyć. Odwrotny domyślny
|
||||
wybór oznaczałby, że każde przeoczenie tworzy dziurę."""
|
||||
if path.startswith("/static/"):
|
||||
return static_required(path[len("/static/"):])
|
||||
return ROUTES.get((method.upper(), path), ADMIN)
|
||||
|
||||
|
||||
def can(perms: frozenset[str], feature: frozenset[str] | str | None) -> bool:
|
||||
"""Czy te uprawnienia otwierają tę funkcję.
|
||||
|
||||
Zbiór znaczy „wystarczy którekolwiek": jeden zasób bywa wspólny dla kilku
|
||||
ekranów i nie ma powodu wymagać ich wszystkich naraz."""
|
||||
if feature is None:
|
||||
return True
|
||||
if isinstance(feature, str):
|
||||
return feature in perms
|
||||
return bool(perms & feature)
|
||||
def can(perms: frozenset[str], feature: str | None) -> bool:
|
||||
return feature is None or feature in perms
|
||||
|
||||
|
||||
def screens_for(perms: frozenset[str]) -> list[Feature]:
|
||||
"""Zakładki do pokazania w nawigacji — w kolejności zadeklarowanej, nie w tej,
|
||||
w której akurat wykonały się importy."""
|
||||
"""Zakładki do pokazania w nawigacji — w stałej kolejności katalogu."""
|
||||
return [f for f in SCREENS if f.key in perms]
|
||||
|
||||
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
"""Nazwy stanów pliku bazy — wspólne dla prezentacji i warstwy danych (DAN-27).
|
||||
|
||||
Osobny, króciutki moduł, bo prezentacja NIE MOŻE importować warstwy danych (to
|
||||
inna usługa i inny obraz), a wpisanie tych napisów wprost w handlerach skończyłoby
|
||||
się literówką, która przejdzie testy i wyjdzie dopiero na produkcji.
|
||||
"""
|
||||
ACTIVE = "active"
|
||||
READY = "ready"
|
||||
ARCHIVED = "archived"
|
||||
QUARANTINE = "quarantine"
|
||||
|
||||
LABELS = {
|
||||
ACTIVE: "w użyciu",
|
||||
READY: "gotowa, odstawiona",
|
||||
ARCHIVED: "zarchiwizowana",
|
||||
QUARANTINE: "wstrzymana",
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
"""Katalog systemów domów dla warstwy prezentacji — JEDNO źródło nazw.
|
||||
|
||||
Nazwy były zaszyte w czterech szablonach naraz (selektor na „Horoskop", selektor
|
||||
w raporcie zbiorczym, checkboxy porównania, nagłówki tabeli). Przy trzech systemach
|
||||
na „Skompiluj", checkboxy porównania, nagłówki tabeli). Przy trzech systemach
|
||||
uchodziło to na sucho; przy dziesięciu rozjazd jest kwestią czasu — wystarczy
|
||||
dopisać system w jednym miejscu i zapomnieć o trzech pozostałych.
|
||||
|
||||
|
||||
@@ -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 protokołu")
|
||||
raise LinkError("ramka bez znacznika astrololo")
|
||||
body = frame[len(MAGIC):]
|
||||
if len(body) <= NONCE_BYTES:
|
||||
raise LinkError("ramka za krótka")
|
||||
|
||||
@@ -1,39 +1,745 @@
|
||||
"""Astrololo — ZŁOŻENIE aplikacji z ekranów i modułów opcjonalnych.
|
||||
"""Warstwa PREZENTACJI — usługa HTTP serwująca stronę WWW.
|
||||
|
||||
Ten plik nie zawiera już żadnej trasy. Odpowiada wyłącznie na pytanie „z czego
|
||||
składa się ten produkt": które ekrany wchodzą i co jest podpięte dodatkowo.
|
||||
W dół: przekazuje dane z formularza do warstwy logicznej i odbiera opracowane
|
||||
wyniki. Nie zawiera logiki biznesowej ani dostępu do danych — tylko UI.
|
||||
|
||||
Import ekranu rejestruje jego trasy, więc lista poniżej JEST definicją produktu.
|
||||
Inny produkt to inna lista i inny zestaw plików w obrazie — nie ten sam program
|
||||
z wyłączonymi kawałkami.
|
||||
Strona główna „/" = wprowadzenie danych horoskopu i podgląd policzonych pozycji
|
||||
(do ręcznego testowania aplikacji). Wyszukiwarka sygnifikatorów przeniesiona pod
|
||||
„/significators".
|
||||
"""
|
||||
# build-marker: 2026-07-25 wymuszenie nowego obrazu po incydencie z tagiem :latest
|
||||
from __future__ import annotations
|
||||
|
||||
from app import rozszerzenia
|
||||
from app.podstawa import (_asset_body, _asset_version, _build_utc, _logic_error,
|
||||
_report_records, app, logic, security, static_url,
|
||||
templates)
|
||||
from app.ekrany import ( # noqa: F401 - import rejestruje trasy
|
||||
horoskop,
|
||||
interpretacje,
|
||||
kalendarz,
|
||||
konta,
|
||||
logowanie,
|
||||
lokalizacja,
|
||||
pliki,
|
||||
skompiluj,
|
||||
sygnifikatory,
|
||||
synastria,
|
||||
ustawienia,
|
||||
)
|
||||
import hashlib
|
||||
import json
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
|
||||
# Nazwy przekazywane dalej dla wygody wołających (testy, uvicorn).
|
||||
__all__ = ["app", "logic", "templates", "static_url", "_asset_body", "_asset_version"]
|
||||
import httpx
|
||||
from fastapi import FastAPI, Form, HTTPException, Query, Request
|
||||
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
|
||||
from fastapi.staticfiles import StaticFiles
|
||||
from fastapi.templating import Jinja2Templates
|
||||
|
||||
# ── moduły opcjonalne ──────────────────────────────────────────────────────
|
||||
# Na końcu, bo moduł dostaje gotowe zależności, a te muszą już istnieć. Bez
|
||||
# modułu w obrazie to wywołanie nie robi nic i aplikacja nie ma pojęcia,
|
||||
# że czegoś brakuje.
|
||||
rozszerzenia.zamontuj(app, logic=logic, templates=templates,
|
||||
buduj_utc=_build_utc, blad=_logic_error,
|
||||
security=security, licz_rekordy=_report_records)
|
||||
from app import accounts as accounts_store
|
||||
from app import chartwheel as chartwheel_mod
|
||||
from app import features
|
||||
from app.house_systems import HOUSE_SYSTEMS, LIMITED as HOUSE_LIMITED, label as house_label
|
||||
|
||||
from app import geocode, security
|
||||
from app.clients.logic_client import LogicClient
|
||||
from app.config import DEFAULT_LOCATION_LABEL, default_form
|
||||
|
||||
# Automatyczna dokumentacja WYŁĄCZONA. /docs, /redoc i /openapi.json wypisują
|
||||
# KOMPLET tras aplikacji — czyli spis wszystkich funkcji, łącznie z tymi, o których
|
||||
# konto ograniczone nie ma prawa wiedzieć (PRE-27). Ochrona zakładek nic by nie dała,
|
||||
# gdyby obok leżał ich katalog. Znalezione testem przechodzącym po trasach aplikacji.
|
||||
app = FastAPI(title="astrololo · warstwa prezentacji",
|
||||
docs_url=None, redoc_url=None, openapi_url=None)
|
||||
app.mount("/static", StaticFiles(directory="app/static"), name="static")
|
||||
templates = Jinja2Templates(directory="app/templates")
|
||||
logic = LogicClient()
|
||||
security.install(app) # logowanie + limit żądań (LOG-32)
|
||||
|
||||
|
||||
# ── cache-busting statyki (PRE-27) ─────────────────────────────────────────
|
||||
# Po deployu przeglądarka trzymała stare styles.css / *.js (ten sam URL → cache).
|
||||
# Doklejamy do URL-a krótki HASH TREŚCI pliku: zmieni się plik → zmieni się URL →
|
||||
# przeglądarka pobierze nowy; bez zmian URL zostaje ten sam (cache działa dalej).
|
||||
# Hash liczony raz na proces (lru_cache) — nowy pod po deployu = świeży hash.
|
||||
_STATIC_DIR = Path("app/static")
|
||||
|
||||
|
||||
@lru_cache(maxsize=None)
|
||||
def _asset_version(name: str) -> str:
|
||||
try:
|
||||
return hashlib.md5((_STATIC_DIR / name).read_bytes()).hexdigest()[:8]
|
||||
except OSError:
|
||||
return "0" # brak pliku nie może wywrócić strony
|
||||
|
||||
|
||||
def static_url(name: str) -> str:
|
||||
return f"/static/{name}?v={_asset_version(name)}"
|
||||
|
||||
|
||||
templates.env.globals["static"] = static_url
|
||||
# Katalog systemów domów — jedno źródło nazw dla wszystkich szablonów.
|
||||
templates.env.globals["HOUSE_SYSTEMS"] = HOUSE_SYSTEMS
|
||||
templates.env.globals["house_label"] = house_label
|
||||
templates.env.globals["HOUSE_LIMITED"] = HOUSE_LIMITED
|
||||
templates.env.globals["WHEEL_ORIENTATIONS"] = chartwheel_mod.ORIENTATIONS
|
||||
|
||||
|
||||
def _perms(request: Request) -> frozenset[str]:
|
||||
"""Uprawnienia zalogowanego konta — pusty zbiór, gdy nie wiadomo kto to."""
|
||||
who = getattr(request.state, "principal", None)
|
||||
return who.permissions if who is not None else frozenset()
|
||||
|
||||
|
||||
# Szablony pytają o uprawnienia PRZEZ TE DWIE FUNKCJE, nigdy o konto wprost.
|
||||
# Dzięki temu nie da się w szablonie napisać warunku na login — a to jest
|
||||
# dokładnie ten rodzaj sprytu, który po roku zostawia kogoś z dostępem, o którym
|
||||
# nikt już nie pamięta.
|
||||
templates.env.globals["nav_screens"] = lambda request: features.screens_for(_perms(request))
|
||||
templates.env.globals["can"] = lambda request, key: key in _perms(request)
|
||||
|
||||
|
||||
def _limit_options(request: Request, opts: dict) -> dict:
|
||||
"""Ścina opcje, których konto nie ma prawa użyć — PO STRONIE SERWERA.
|
||||
|
||||
Ukrycie pola w formularzu chroni tylko przed przypadkiem. Kto zna nazwy pól,
|
||||
wyśle je wprost — a wtedy policzyłby funkcję, której mu nie przyznano, i to
|
||||
jeszcze zobaczyłby ją w wyniku. Granicą jest ta funkcja, nie szablon.
|
||||
|
||||
Wartości zastępcze są DOMYŚLNE, nie puste: konto ograniczone ma dostać
|
||||
działający horoskop w podstawowej postaci, a nie komunikat o braku czegoś.
|
||||
"""
|
||||
perms = _perms(request)
|
||||
if "advanced_calc" not in perms:
|
||||
opts.update(stations=False, tables=False, aspect_minor=False, zodiac="tropical")
|
||||
if "houses_compare" not in perms:
|
||||
opts.update(house_system="whole_sign", house_systems=[],
|
||||
wheel_orientation=chartwheel_mod.ASC_LEFT)
|
||||
return opts
|
||||
|
||||
|
||||
def _landing(request: Request) -> str | None:
|
||||
"""Pierwszy ekran dostępny dla konta — dokąd odesłać z korzenia."""
|
||||
allowed = features.screens_for(_perms(request))
|
||||
return allowed[0].href if allowed else None
|
||||
|
||||
|
||||
def _build_utc(date: str, time: str, tz_offset: float) -> tuple[str, str]:
|
||||
"""Z lokalnej daty/godziny + przesunięcia strefy → moment UTC.
|
||||
|
||||
Zwraca (iso_utc, etykieta_czytelna). UTC = czas lokalny − offset.
|
||||
"""
|
||||
local = datetime.fromisoformat(f"{date}T{time}")
|
||||
utc = (local - timedelta(hours=tz_offset)).replace(tzinfo=timezone.utc)
|
||||
label = utc.strftime("%Y-%m-%d %H:%M UTC")
|
||||
return utc.isoformat(), label
|
||||
|
||||
|
||||
def _llm_catalog() -> dict:
|
||||
"""Podpowiedzi modeli dla pola wyboru. Awaria logiki nie może wywrócić strony —
|
||||
pole modelu jest tekstowe, więc bez katalogu nadal da się wpisać model ręcznie."""
|
||||
try:
|
||||
return logic.llm_models()
|
||||
except httpx.HTTPError:
|
||||
return {"providers": {}, "defaults": {}}
|
||||
|
||||
|
||||
def _report_records(report: dict | None) -> int:
|
||||
"""Ile rekordów baz niesie raport — do dziennika audytowego (PRE-17).
|
||||
|
||||
Liczymy próbki we wszystkich fasetach: to one są treścią z baz. Sama liczba,
|
||||
nigdy treść — dziennik ma pokazywać SKALĘ dostępu, nie powielać danych."""
|
||||
total = 0
|
||||
for o in (report or {}).get("objects") or []:
|
||||
for f in o.get("facets") or []:
|
||||
total += len(f.get("samples") or [])
|
||||
return total
|
||||
|
||||
|
||||
def _logic_error(e: Exception) -> str:
|
||||
if isinstance(e, httpx.HTTPStatusError) and e.response.status_code == 404:
|
||||
return (
|
||||
"Warstwa logiczna działa, ale nie ma endpointu /chart/positions. "
|
||||
"Uruchom warstwę logiczną z silnikiem efemeryd (gałąź feat/logic-engine)."
|
||||
)
|
||||
return f"Warstwa logiczna niedostępna: {e}"
|
||||
|
||||
|
||||
# ---------------- Horoskop: pozycje (strona główna) ----------------
|
||||
@app.get("/", response_class=HTMLResponse)
|
||||
def chart_form(request: Request):
|
||||
# Korzeń jest dostępny dla każdego zalogowanego, ale ekran „Horoskop" już nie.
|
||||
# Bez tego konto bez uprawnienia do horoskopu dostawałoby 404 pod adresem
|
||||
# głównym — czyli wyglądałoby to na zepsuty program, a nie na węższy zestaw.
|
||||
if "chart" not in _perms(request):
|
||||
target = _landing(request)
|
||||
if target:
|
||||
return RedirectResponse(target, status_code=303)
|
||||
return HTMLResponse("<h1>Brak przypisanych funkcji</h1>"
|
||||
"<p>Skontaktuj się z osobą, która zakładała konto.</p>",
|
||||
status_code=200)
|
||||
return templates.TemplateResponse(
|
||||
request, "chart.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
|
||||
"llm_catalog": _llm_catalog()},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/", response_class=HTMLResponse)
|
||||
def chart_compute(
|
||||
request: Request,
|
||||
person: str = Form(""), # imie i nazwisko — do naglowka raportu (PRE-21/24)
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
house_system: str = Form("whole_sign"),
|
||||
house_systems: list[str] = Form([]), # PRE-05: dodatkowe systemy do porównania
|
||||
aspect_orb: float = Form(8.0), # PRE-06: konfigurowalny orb aspektów
|
||||
aspect_luminary_bonus: float = Form(2.0),
|
||||
aspect_minor: bool = Form(False),
|
||||
stations: bool = Form(False),
|
||||
zodiac: str = Form("tropical"),
|
||||
tables: bool = Form(False),
|
||||
wheel_orientation: str = Form(chartwheel_mod.ASC_LEFT),
|
||||
):
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
|
||||
"lat": lat, "lon": lon, "house_system": house_system,
|
||||
"house_systems": house_systems, "aspect_orb": aspect_orb,
|
||||
"aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor,
|
||||
"stations": stations, "zodiac": zodiac, "tables": tables,
|
||||
"wheel_orientation": wheel_orientation}
|
||||
form = _limit_options(request, form)
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
ctx["result"] = logic.positions(
|
||||
when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
house_system=form["house_system"], house_systems=form["house_systems"],
|
||||
aspect_orb=aspect_orb, aspect_luminary_bonus=aspect_luminary_bonus,
|
||||
aspect_minor=form["aspect_minor"],
|
||||
stations=form["stations"], zodiac=form["zodiac"], tables=form["tables"],
|
||||
)
|
||||
from app import chartwheel # kosmogram (PRE-12), SVG po stronie serwera
|
||||
ctx["wheel_svg"] = chartwheel.render(ctx["result"],
|
||||
orientation=form["wheel_orientation"])
|
||||
# Rysunki dodatkowe NIE POWSTAJĄ bez uprawnienia — nie chodzi o ukrycie
|
||||
# ich w szablonie, tylko o to, żeby nie było ich nawet w źródle strony.
|
||||
if "extra_charts" in _perms(request):
|
||||
ctx["aspectarian_svg"] = chartwheel.render_aspectarian(ctx["result"]) # PRE-18
|
||||
ctx["declination_svg"] = chartwheel.render_declination(ctx["result"]) # LOG-07
|
||||
ctx["antiscia_svg"] = chartwheel.render_antiscia(ctx["result"]) # LOG-07
|
||||
except (httpx.HTTPError,) as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "chart.html", ctx)
|
||||
|
||||
|
||||
# ---------------- Skompiluj: zbiorczy raport (PRE-23) ----------------
|
||||
@app.get("/compile", response_class=HTMLResponse)
|
||||
def compile_form(request: Request):
|
||||
return templates.TemplateResponse(
|
||||
request, "compile.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/compile", response_class=HTMLResponse)
|
||||
def compile_build(
|
||||
request: Request,
|
||||
person: str = Form(""),
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
house_system: str = Form("whole_sign"),
|
||||
house_systems: list[str] = Form([]), # PRE-05 — porównanie domów w podsumowaniu
|
||||
aspect_orb: float = Form(8.0), # PRE-06 — te same ustawienia aspektów
|
||||
aspect_luminary_bonus: float = Form(2.0),
|
||||
aspect_minor: bool = Form(False),
|
||||
stations: bool = Form(False), # LOG-03 — stacje też w podsumowaniu
|
||||
zodiac: str = Form("tropical"),
|
||||
tables: bool = Form(False), # LOG-23 — żywioły/faza/godziny w podsumowaniu
|
||||
wheel_orientation: str = Form(chartwheel_mod.ASC_LEFT), # LOG-05 — obrót koła
|
||||
):
|
||||
"""Składa raport: horoskop liczymy TU NA NOWO, a części od AI (interpretacja
|
||||
natalna i predykcje okresowe) dokłada przeglądarka z magazynu (PRE-22/23).
|
||||
|
||||
Horoskop liczymy ponownie (czysta funkcja wejścia — tanio powtórzyć, bez
|
||||
trzymania dużego wyniku w przeglądarce), ale z TYMI SAMYMI opcjami, które
|
||||
wybrano przy horoskopie (stacje, tabele, porównanie domów) — inaczej
|
||||
podsumowanie miałoby braki względem tego, co policzono. Opcje wędrują między
|
||||
zakładkami przez formsync.
|
||||
"""
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
|
||||
"lat": lat, "lon": lon, "house_system": house_system,
|
||||
"house_systems": house_systems, "aspect_orb": aspect_orb,
|
||||
"aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor,
|
||||
"stations": stations, "zodiac": zodiac, "tables": tables,
|
||||
"wheel_orientation": wheel_orientation}
|
||||
form = _limit_options(request, form)
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
ctx["result"] = logic.positions(
|
||||
when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
house_system=form["house_system"], house_systems=form["house_systems"],
|
||||
aspect_orb=aspect_orb, aspect_luminary_bonus=aspect_luminary_bonus,
|
||||
aspect_minor=form["aspect_minor"],
|
||||
stations=form["stations"], zodiac=form["zodiac"], tables=form["tables"],
|
||||
)
|
||||
from app import chartwheel
|
||||
ctx["wheel_svg"] = chartwheel.render(ctx["result"],
|
||||
orientation=form["wheel_orientation"])
|
||||
if "extra_charts" in _perms(request):
|
||||
ctx["aspectarian_svg"] = chartwheel.render_aspectarian(ctx["result"]) # PRE-18
|
||||
ctx["declination_svg"] = chartwheel.render_declination(ctx["result"]) # LOG-07
|
||||
ctx["antiscia_svg"] = chartwheel.render_antiscia(ctx["result"]) # LOG-07
|
||||
except (httpx.HTTPError,) as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "compile.html", ctx)
|
||||
|
||||
|
||||
@app.post("/compile/pdf")
|
||||
def compile_pdf(payload: dict):
|
||||
"""Składa raport PDF (PRE-24) — woła usługę render po szyfrowanym łączu.
|
||||
|
||||
Wejście z przeglądarki, bo części od AI (interpretacja natalna i predykcje)
|
||||
mieszkają w magazynie lokalnym. Kosmogram i tabele liczymy TU, żeby PDF
|
||||
zawierał dokładnie to, co widać na stronie.
|
||||
|
||||
Kosmogram idzie w motywie DRUKU: samodzielny konwerter SVG→PDF nie zna
|
||||
naszego arkusza, więc zmienne CSS i font glifów muszą być w samym rysunku.
|
||||
"""
|
||||
from fastapi.responses import Response
|
||||
|
||||
from app.clients.render_client import RenderClient
|
||||
|
||||
data = payload.get("data") or {}
|
||||
try:
|
||||
iso_utc, label = _build_utc(
|
||||
str(data.get("date") or ""), str(data.get("time") or ""),
|
||||
float(data.get("tz_offset") or 0.0),
|
||||
)
|
||||
except (ValueError, TypeError) as e:
|
||||
return JSONResponse({"detail": f"Niepoprawne dane wejściowe: {e}"}, status_code=422)
|
||||
|
||||
figures: list[dict] = []
|
||||
warnings: list[str] = []
|
||||
try:
|
||||
chart = logic.positions(
|
||||
when_utc_iso=iso_utc,
|
||||
lat=float(data.get("lat") or 0.0), lon=float(data.get("lon") or 0.0),
|
||||
house_system=str(data.get("house_system") or "whole_sign"),
|
||||
house_systems=[s for s in (data.get("house_systems") or []) if s],
|
||||
aspect_orb=float(data.get("aspect_orb") or 8.0),
|
||||
aspect_luminary_bonus=float(data.get("aspect_luminary_bonus") or 2.0),
|
||||
aspect_minor=bool(data.get("aspect_minor")),
|
||||
stations=bool(data.get("stations")), tables=bool(data.get("tables")),
|
||||
zodiac=str(data.get("zodiac") or "tropical"),
|
||||
)
|
||||
# Fallback systemu domów musi dojechać do PDF-a — z samego kosmogramu
|
||||
# nie da się poznać, że podział jest z innego systemu, niż zamówiono.
|
||||
warnings = [w for w in (chart.get("house_warnings") or []) if w]
|
||||
|
||||
from app import chartwheel
|
||||
|
||||
# Zasada: co pokazujemy na stronie, ma trafić do PDF-a. Wszystkie rysunki
|
||||
# w motywie DRUKU — samodzielny konwerter SVG→PDF nie zna arkusza, więc
|
||||
# zmienne CSS i font glifów muszą być wprost w rysunku.
|
||||
for svg, caption in (
|
||||
(chartwheel.render(chart, theme="print",
|
||||
orientation=str(data.get("wheel_orientation") or chartwheel_mod.ASC_LEFT)),
|
||||
"Kosmogram"),
|
||||
(chartwheel.render_aspectarian(chart, theme="print"), "Aspektarian — siatka aspektów"),
|
||||
(chartwheel.render_declination(chart, theme="print"), "Wykres deklinacji"),
|
||||
(chartwheel.render_antiscia(chart, theme="print"), "Oś antyscji"),
|
||||
):
|
||||
if svg:
|
||||
figures.append({"svg": svg, "caption": caption})
|
||||
except httpx.HTTPError as e:
|
||||
# Brak rysunków nie może zablokować raportu — tekst jest ważniejszy.
|
||||
data = {**data, "wheel_error": _logic_error(e)}
|
||||
|
||||
report = {
|
||||
"person": payload.get("person") or "",
|
||||
"data": {**data, "moment_utc": label},
|
||||
"figures": figures,
|
||||
"warnings": warnings,
|
||||
"natal": payload.get("natal") or {},
|
||||
"predictions": payload.get("predictions") or [],
|
||||
}
|
||||
try:
|
||||
pdf = RenderClient().pdf(report)
|
||||
except httpx.HTTPError as e:
|
||||
return JSONResponse(
|
||||
{"detail": f"Usługa render niedostępna albo nie złożyła PDF-a: {e}"},
|
||||
status_code=502,
|
||||
)
|
||||
return Response(content=pdf, media_type="application/pdf",
|
||||
headers={"Content-Disposition": 'attachment; filename="raport.pdf"'})
|
||||
|
||||
|
||||
# ---------------- Ustawienia: bazy na udziale (DAN-15/PRE-09) ----------------
|
||||
@app.get("/settings", response_class=HTMLResponse)
|
||||
def settings_view(request: Request):
|
||||
"""Podgląd baz dostępnych na udziale + które biorą udział w interpretacji.
|
||||
|
||||
Same metadane (nazwa, rozmiar, data) — bez treści baz. Przełączniki są
|
||||
DEKLARATYWNE (`DISABLED_BASES`), bo warstwa danych nie ma trwałego zapisu:
|
||||
udział jest read-only, a cache to emptyDir. Zapis do pliku ginąłby po
|
||||
restarcie, po cichu włączając z powrotem wyłączoną bazę."""
|
||||
ctx: dict = {"result": None, "error": None}
|
||||
try:
|
||||
ctx["result"] = logic.bases()
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
return templates.TemplateResponse(request, "settings.html", ctx)
|
||||
|
||||
|
||||
# ---------------- Synastria (technika relacyjna) ----------------
|
||||
@app.get("/synastry", response_class=HTMLResponse)
|
||||
def synastry_form(request: Request):
|
||||
# domyślne liczby, żeby pola number nie były puste (puste → błąd przy wysyłce)
|
||||
form = {"a_tz_offset": 0, "a_lat": 0, "a_lon": 0, "b_tz_offset": 0, "b_lat": 0, "b_lon": 0,
|
||||
"aspect_orb": 8, "aspect_luminary_bonus": 2}
|
||||
return templates.TemplateResponse(request, "synastry.html", {"result": None, "form": form})
|
||||
|
||||
|
||||
@app.post("/synastry", response_class=HTMLResponse)
|
||||
def synastry_run(
|
||||
request: Request,
|
||||
a_person: str = Form(""), a_date: str = Form(...), a_time: str = Form(...),
|
||||
a_tz_offset: float = Form(0.0), a_lat: float = Form(0.0), a_lon: float = Form(0.0),
|
||||
b_person: str = Form(""), b_date: str = Form(...), b_time: str = Form(...),
|
||||
b_tz_offset: float = Form(0.0), b_lat: float = Form(0.0), b_lon: float = Form(0.0),
|
||||
zodiac: str = Form("tropical"),
|
||||
aspect_orb: float = Form(8.0), aspect_luminary_bonus: float = Form(2.0),
|
||||
aspect_minor: bool = Form(False),
|
||||
):
|
||||
"""Synastria (PRE-04): dwie osoby → aspekty między ich horoskopami."""
|
||||
form = {"a_person": a_person, "a_date": a_date, "a_time": a_time, "a_tz_offset": a_tz_offset,
|
||||
"a_lat": a_lat, "a_lon": a_lon, "b_person": b_person, "b_date": b_date,
|
||||
"b_time": b_time, "b_tz_offset": b_tz_offset, "b_lat": b_lat, "b_lon": b_lon,
|
||||
"zodiac": zodiac, "aspect_orb": aspect_orb,
|
||||
"aspect_luminary_bonus": aspect_luminary_bonus, "aspect_minor": aspect_minor}
|
||||
ctx: dict = {"form": form, "result": None, "error": None}
|
||||
try:
|
||||
iso_a, _ = _build_utc(a_date, a_time, a_tz_offset)
|
||||
iso_b, _ = _build_utc(b_date, b_time, b_tz_offset)
|
||||
ctx["result"] = logic.synastry(
|
||||
{"when_utc": iso_a, "lat": a_lat, "lon": a_lon},
|
||||
{"when_utc": iso_b, "lat": b_lat, "lon": b_lon},
|
||||
zodiac=zodiac, aspect_orb=aspect_orb,
|
||||
aspect_luminary_bonus=aspect_luminary_bonus, aspect_minor=aspect_minor,
|
||||
)
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "synastry.html", ctx)
|
||||
|
||||
|
||||
# ---------------- Sygnifikatory (wyszukiwarka w bazach) ----------------
|
||||
@app.get("/significators", response_class=HTMLResponse)
|
||||
def significators_form(request: Request):
|
||||
return templates.TemplateResponse(request, "significators.html", {"result": None, "form": {}})
|
||||
|
||||
|
||||
@app.post("/significators", response_class=HTMLResponse)
|
||||
def significators_search(
|
||||
request: Request,
|
||||
query: str = Form(...),
|
||||
field: str = Form("name"),
|
||||
exact: bool = Form(False),
|
||||
limit: int = Form(25),
|
||||
):
|
||||
form = {"query": query, "field": field, "exact": exact, "limit": limit}
|
||||
ctx: dict = {"form": form, "result": None, "error": None}
|
||||
try:
|
||||
ctx["result"] = logic.query(query=query, field=field, exact=exact, limit=limit)
|
||||
# ile rekordów baz oddaliśmy — do dziennika audytowego (PRE-17), bez treści
|
||||
security.audit_records(request, len((ctx["result"] or {}).get("rows") or []))
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
return templates.TemplateResponse(request, "significators.html", ctx)
|
||||
|
||||
|
||||
# ---------------- Interpretacje (wynik obliczeń szukany w bazie) ----------------
|
||||
@app.get("/interpret", response_class=HTMLResponse)
|
||||
def interpret_form(request: Request):
|
||||
return templates.TemplateResponse(
|
||||
request, "interpret.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
|
||||
"llm_catalog": _llm_catalog()},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/interpret", response_class=HTMLResponse)
|
||||
def interpret_run(
|
||||
request: Request,
|
||||
person: str = Form(""), # imie i nazwisko — do naglowka raportu (PRE-21/24)
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
group: bool = Form(False),
|
||||
action: str = Form("report"),
|
||||
prompt_budget: str = Form("medium"),
|
||||
llm_provider: str = Form("local"),
|
||||
llm_model: str = Form(""),
|
||||
):
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset,
|
||||
"lat": lat, "lon": lon, "group": group, "prompt_budget": prompt_budget,
|
||||
"llm_provider": llm_provider, "llm_model": llm_model}
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None,
|
||||
"llm_catalog": _llm_catalog()}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
if action == "export":
|
||||
# Tabela robocza do Excela (DAN-23/PRE-10) — pobranie pliku, nie strona.
|
||||
from fastapi.responses import Response
|
||||
|
||||
from app.report_export import report_to_xlsx
|
||||
|
||||
report = logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
|
||||
# Eksport wynosi NAJWIĘCEJ treści baz naraz — tym bardziej ma zostawiać
|
||||
# ślad w dzienniku (PRE-17): sama liczba rekordów, nigdy treść.
|
||||
security.audit_records(request, _report_records(report))
|
||||
return Response(
|
||||
content=report_to_xlsx(report),
|
||||
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
||||
headers={"Content-Disposition": 'attachment; filename="interpretacje.xlsx"'},
|
||||
)
|
||||
if action == "prompt":
|
||||
ctx["prompt_result"] = logic.prompt(
|
||||
profile="natal", when_utc_iso=iso_utc, lat=lat, lon=lon, budget=prompt_budget,
|
||||
provider=llm_provider, model=llm_model,
|
||||
)
|
||||
elif action == "horoscope":
|
||||
ctx["prompt_result"] = logic.horoscope(
|
||||
profile="natal", when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
budget=prompt_budget, provider=llm_provider, model=llm_model,
|
||||
)
|
||||
else:
|
||||
ctx["result"] = logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
|
||||
security.audit_records(request, _report_records(ctx["result"]))
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "interpret.html", ctx)
|
||||
|
||||
|
||||
# ---------------- Kalendarz (oś czasu z technik + interpretacje) ----------------
|
||||
@app.get("/timeline", response_class=HTMLResponse)
|
||||
def timeline_form(request: Request):
|
||||
return templates.TemplateResponse(
|
||||
request, "timeline.html",
|
||||
{"result": None, "form": default_form(), "location_label": DEFAULT_LOCATION_LABEL,
|
||||
"llm_catalog": _llm_catalog()},
|
||||
)
|
||||
|
||||
|
||||
@app.post("/timeline", response_class=HTMLResponse)
|
||||
def timeline_run(
|
||||
request: Request,
|
||||
person: str = Form(""), # imie i nazwisko — do naglowka raportu (PRE-21/24)
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
from_date: str = Form(...),
|
||||
to_date: str = Form(...),
|
||||
action: str = Form("timeline"),
|
||||
prompt_budget: str = Form("medium"),
|
||||
llm_provider: str = Form("local"),
|
||||
llm_model: str = Form(""),
|
||||
):
|
||||
form = {"person": person, "date": date, "time": time, "tz_offset": tz_offset, "lat": lat, "lon": lon,
|
||||
"from_date": from_date, "to_date": to_date, "prompt_budget": prompt_budget,
|
||||
"llm_provider": llm_provider, "llm_model": llm_model}
|
||||
ctx: dict = {"form": form, "result": None, "error": None, "moment": None,
|
||||
"llm_catalog": _llm_catalog()}
|
||||
try:
|
||||
iso_utc, label = _build_utc(date, time, tz_offset)
|
||||
ctx["moment"] = label
|
||||
if action == "prompt":
|
||||
ctx["prompt_result"] = logic.prompt(
|
||||
profile="period", when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
budget=prompt_budget, from_date=from_date, to_date=to_date,
|
||||
provider=llm_provider, model=llm_model,
|
||||
)
|
||||
elif action == "horoscope":
|
||||
ctx["prompt_result"] = logic.horoscope(
|
||||
profile="period", when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
budget=prompt_budget, provider=llm_provider, model=llm_model,
|
||||
from_date=from_date, to_date=to_date,
|
||||
)
|
||||
else:
|
||||
ctx["result"] = logic.timeline(
|
||||
when_utc_iso=iso_utc, lat=lat, lon=lon,
|
||||
from_date=from_date, to_date=to_date, interpret=True,
|
||||
)
|
||||
except httpx.HTTPError as e:
|
||||
ctx["error"] = _logic_error(e)
|
||||
except ValueError as e:
|
||||
ctx["error"] = f"Niepoprawne dane wejściowe: {e}"
|
||||
return templates.TemplateResponse(request, "timeline.html", ctx)
|
||||
|
||||
|
||||
# ---------------- Postęp pisania horoskopu (strumień do okna z logiem) ----------------
|
||||
@app.post("/horoscope/stream")
|
||||
def horoscope_stream(
|
||||
profile: str = Form("natal"),
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
prompt_budget: str = Form("medium"),
|
||||
llm_provider: str = Form("local"),
|
||||
llm_model: str = Form(""),
|
||||
from_date: str = Form(""),
|
||||
to_date: str = Form(""),
|
||||
):
|
||||
"""Przekazuje strumień postępu z logiki i DOKLEJA gotowy HTML wyniku.
|
||||
|
||||
Dzięki temu okno postępu wstawia dokładnie ten sam widok, który wyrenderowałoby
|
||||
przeładowanie strony — jedno źródło prawdy dla wyglądu wyniku.
|
||||
"""
|
||||
from fastapi.responses import StreamingResponse
|
||||
|
||||
try:
|
||||
iso_utc, _ = _build_utc(date, time, tz_offset)
|
||||
except ValueError as e:
|
||||
return JSONResponse({"detail": f"Niepoprawne dane wejściowe: {e}"}, status_code=422)
|
||||
|
||||
payload: dict = {
|
||||
"profile": profile, "when_utc": iso_utc, "lat": lat, "lon": lon,
|
||||
"budget": prompt_budget, "provider": llm_provider, "model": llm_model,
|
||||
}
|
||||
if profile == "period" and from_date and to_date:
|
||||
payload["from_date"], payload["to_date"] = from_date, to_date
|
||||
|
||||
def relay():
|
||||
try:
|
||||
for raw in logic.horoscope_stream(payload):
|
||||
try:
|
||||
event = json.loads(raw)
|
||||
except ValueError:
|
||||
continue
|
||||
if event.get("type") == "result":
|
||||
html = templates.get_template("_prompt_result.html").render(
|
||||
prompt_result=event.get("result") or {}
|
||||
)
|
||||
event["html"] = html
|
||||
yield json.dumps(event, ensure_ascii=False) + "\n"
|
||||
except httpx.HTTPError as e:
|
||||
yield json.dumps({"type": "error", "message": _logic_error(e)},
|
||||
ensure_ascii=False) + "\n"
|
||||
|
||||
return StreamingResponse(relay(), media_type="application/x-ndjson",
|
||||
headers={"Cache-Control": "no-store", "X-Accel-Buffering": "no"})
|
||||
|
||||
|
||||
# ---------------- Geokoder (proxy OSM/Nominatim dla wyszukiwarki lokalizacji) ----------------
|
||||
@app.get("/geocode")
|
||||
def geocode_search(q: str = Query("", description="Nazwa / adres / POI do wyszukania")):
|
||||
"""Nazwa miejsca → kandydaci ze współrzędnymi (dla pola „Szukaj miejsca")."""
|
||||
try:
|
||||
return {"results": geocode.search(q)}
|
||||
except httpx.HTTPError as e:
|
||||
raise HTTPException(status_code=502, detail=f"Geokoder (OSM) niedostępny: {e}")
|
||||
|
||||
|
||||
@app.get("/reverse")
|
||||
def geocode_reverse(lat: float, lon: float):
|
||||
"""Punkt z mapy → nazwa miejsca (po przeciągnięciu pineski / kliknięciu)."""
|
||||
try:
|
||||
return geocode.reverse(lat, lon)
|
||||
except httpx.HTTPError as e:
|
||||
raise HTTPException(status_code=502, detail=f"Geokoder (OSM) niedostępny: {e}")
|
||||
|
||||
|
||||
@app.get("/timezone")
|
||||
def timezone_lookup(lat: float, lon: float, date: str = "", time: str = "12:00"):
|
||||
"""Współrzędne + data → strefa IANA i DST-świadomy offset GMT (PRE-03).
|
||||
|
||||
Liczone OFFLINE (tzfpy + zoneinfo), więc brak internetu nie przeszkadza. 404,
|
||||
gdy strefy nie da się ustalić — front zostawia wtedy ręczny offset."""
|
||||
from app import timezone as tzmod
|
||||
|
||||
res = tzmod.resolve(lat, lon, date, time)
|
||||
if not res:
|
||||
raise HTTPException(status_code=404, detail="Nie ustalono strefy dla tego punktu.")
|
||||
return res
|
||||
|
||||
|
||||
# ---------------- Konta i uprawnienia (PRE-27) ----------------
|
||||
# Ochrona tych tras siedzi w features.ROUTES, nie w dekoratorze — jedna mapa
|
||||
# dla całej aplikacji, sprawdzana testem, który przechodzi po WSZYSTKICH trasach.
|
||||
|
||||
def _accounts_context(request: Request, error: str = "", done: str = "") -> dict:
|
||||
# Problem z magazynem NIE MOŻE dawać gołego 500: to jedyny ekran, z którego
|
||||
# administrator może go naprawić, więc musi na nim przeczytać, co i gdzie
|
||||
# jest nie tak.
|
||||
try:
|
||||
users = accounts_store.all_users()
|
||||
except accounts_store.AccountsUnavailable as e:
|
||||
users, error = {}, str(e)
|
||||
return {
|
||||
"users": users,
|
||||
"catalog": features.ALL,
|
||||
"screens": features.SCREENS,
|
||||
"extras": features.EXTRAS,
|
||||
"admin_login": security.app_user(),
|
||||
"store_path": accounts_store.store_path(),
|
||||
"error": error, "done": done,
|
||||
}
|
||||
|
||||
|
||||
@app.get("/accounts", response_class=HTMLResponse)
|
||||
def accounts_view(request: Request, error: str = "", done: str = ""):
|
||||
return templates.TemplateResponse(request, "accounts.html",
|
||||
_accounts_context(request, error, done))
|
||||
|
||||
|
||||
def _accounts_redirect(error: str = "", done: str = "") -> RedirectResponse:
|
||||
"""Po zapisie PRZEKIEROWANIE, nie render — odświeżenie strony nie może
|
||||
powtórzyć zakładania ani kasowania konta."""
|
||||
from urllib.parse import urlencode
|
||||
|
||||
q = urlencode({k: v for k, v in (("error", error), ("done", done)) if v})
|
||||
return RedirectResponse(f"/accounts{'?' + q if q else ''}", status_code=303)
|
||||
|
||||
|
||||
@app.post("/accounts/create")
|
||||
def accounts_create(request: Request, login: str = Form(""), password: str = Form(""),
|
||||
note: str = Form(""), granted: list[str] = Form([])):
|
||||
try:
|
||||
accounts_store.create(login, password, granted, note)
|
||||
except (ValueError, accounts_store.AccountsUnavailable) as e:
|
||||
return _accounts_redirect(error=str(e))
|
||||
return _accounts_redirect(done=f"Założono konto „{login.strip()}”.")
|
||||
|
||||
|
||||
@app.post("/accounts/update")
|
||||
def accounts_update(request: Request, login: str = Form(...), password: str = Form(""),
|
||||
note: str = Form(""), granted: list[str] = Form([])):
|
||||
try:
|
||||
accounts_store.update(login, granted=granted, password=password, note=note)
|
||||
except (ValueError, accounts_store.AccountsUnavailable) as e:
|
||||
return _accounts_redirect(error=str(e))
|
||||
changed = "uprawnienia i hasło" if password.strip() else "uprawnienia"
|
||||
return _accounts_redirect(done=f"Zapisano {changed} konta „{login}”.")
|
||||
|
||||
|
||||
@app.post("/accounts/delete")
|
||||
def accounts_delete(request: Request, login: str = Form(...)):
|
||||
try:
|
||||
accounts_store.delete(login)
|
||||
except (ValueError, accounts_store.AccountsUnavailable) as e:
|
||||
return _accounts_redirect(error=str(e))
|
||||
return _accounts_redirect(done=f"Skasowano konto „{login}”.")
|
||||
|
||||
|
||||
@app.get("/health")
|
||||
def health() -> dict:
|
||||
return {"status": "ok", "layer": "presentation"}
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
"""Moduły opcjonalne — każdy podkatalog to jedna odłączalna część produktu.
|
||||
|
||||
O tym, co produkt umie, decyduje ZAWARTOŚĆ tego katalogu w obrazie. Most
|
||||
(`app.rozszerzenia`) odkrywa moduły, przechodząc po podkatalogach, i nie zna
|
||||
żadnej nazwy — gdyby znał, nazwa nieobecnego modułu i tak jechałaby do obrazu,
|
||||
w którym go nie ma.
|
||||
|
||||
Moduł może wnieść: pozycję do katalogu funkcji, trasy, zasoby, akcje formularza,
|
||||
pola formularza, wpisy do kontekstu szablonu, własne szablony i własne statyki.
|
||||
Wszystko jest opcjonalne — most pyta o to, czego moduł nie ma, i dostaje pusto.
|
||||
"""
|
||||
@@ -1,23 +0,0 @@
|
||||
"""Generowanie tekstu przez model językowy — moduł CAŁKOWICIE ODŁĄCZALNY.
|
||||
|
||||
DLACZEGO OSOBNY KATALOG, A NIE `{% if %}` W SZABLONACH. Warunek w szablonie
|
||||
wystarcza, żeby funkcji nie było WIDAĆ, ale nie żeby jej NIE BYŁO. Plik szablonu
|
||||
i tak leży w obrazie i i tak zawiera słowa opisujące funkcję — `grep` po
|
||||
kontenerze pokazuje wszystko, czego warunek nie pokazał na ekranie.
|
||||
|
||||
Astrololo zawiera ten katalog. Astroklient — nie, i to jest jedyna różnica
|
||||
między nimi po stronie funkcji astrologicznych. Dlatego granica MUSI być
|
||||
katalogiem: co jest w środku, znika razem z nim, a co jest na zewnątrz, zostaje.
|
||||
|
||||
ZASADA DLA KOGOŚ, KTO TU DOPISUJE. Poza tym katalogiem nie wolno napisać ani
|
||||
słowa o modelu, prompcie czy dostawcy — nawet w komentarzu, nawet zaprzeczając.
|
||||
Szablony wspólne mają neutralne gniazda (`_dodatki_*`), a plik wstawiany w
|
||||
gniazdo sam sprawdza uprawnienie. Pilnuje tego test `test_ai_tylko_w_module.py`.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from app.moduly.dodatki.katalog import AKCJE, FUNKCJA, TRASY, ZASOBY, katalog_dla, obsluz, pola
|
||||
from app.moduly.dodatki.trasy import zamontuj
|
||||
|
||||
__all__ = ["AKCJE", "FUNKCJA", "TRASY", "ZASOBY", "katalog_dla", "obsluz", "pola",
|
||||
"zamontuj"]
|
||||
@@ -1,91 +0,0 @@
|
||||
"""Co moduł wnosi do aplikacji: funkcję, trasy, zasoby, akcje i pola formularza.
|
||||
|
||||
Wszystko, co gdziekolwiek indziej musiałoby paść z nazwy, jest zebrane TUTAJ.
|
||||
Reszta aplikacji zna wyłącznie neutralny most (`app.rozszerzenia`) i pyta go
|
||||
o dane, nigdy o „generowanie" czy „model".
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
import httpx
|
||||
from fastapi import Form, Request
|
||||
|
||||
from app.moduly.dodatki import klient
|
||||
|
||||
# Pozycja w katalogu funkcji — surowa krotka, żeby nie importować `features`
|
||||
# (to zamknęłoby cykl features → most → moduł → features).
|
||||
FUNKCJA: tuple[tuple[str, str, str, str], ...] = (
|
||||
("ai", "Generowanie tekstu przez model",
|
||||
"Horoskopy pisane przez model językowy. UWAGA: każde użycie kosztuje.",
|
||||
"Rozszerzenia"),
|
||||
)
|
||||
|
||||
TRASY: dict[tuple[str, str], str] = {("POST", "/horoscope/stream"): "ai"}
|
||||
|
||||
ZASOBY: dict[str, str] = {
|
||||
"x-ai.css": "ai",
|
||||
"models.js": "ai",
|
||||
"progress.js": "ai",
|
||||
"natal.js": "ai",
|
||||
"predictions.js": "ai",
|
||||
}
|
||||
|
||||
# Akcje formularza wnoszone przez moduł: nazwa → wymagane uprawnienie.
|
||||
AKCJE: dict[str, str] = {"prompt": "ai", "horoscope": "ai"}
|
||||
|
||||
# Wstrzykiwane przez `zamontuj` z main.py — moduł nie importuje aplikacji,
|
||||
# bo to byłby cykl, a przy okazji zmusiłoby aplikację do wiedzy o module.
|
||||
_logic: Any = None
|
||||
_szablony: Any = None
|
||||
|
||||
|
||||
def ustaw_zaleznosci(*, logic: Any, templates: Any) -> None:
|
||||
global _logic, _szablony
|
||||
_logic, _szablony = logic, templates
|
||||
|
||||
|
||||
def pola(prompt_budget: str = Form("medium"),
|
||||
llm_provider: str = Form(""),
|
||||
llm_model: str = Form("")) -> dict:
|
||||
"""Pola formularza, których wspólny handler nie może wymienić w sygnaturze.
|
||||
|
||||
FastAPI czyta pola z sygnatury, więc zadeklarowanie ich we wspólnym handlerze
|
||||
wpisałoby nazwy `llm_provider` i `prompt_budget` w kod, który trafia także do
|
||||
obrazu bez tego modułu. Zależność przenosi deklarację tutaj."""
|
||||
return {"prompt_budget": prompt_budget, "llm_provider": llm_provider,
|
||||
"llm_model": llm_model}
|
||||
|
||||
|
||||
def _katalog() -> dict:
|
||||
"""Podpowiedzi modeli dla pola wyboru. Awaria logiki nie może wywrócić strony —
|
||||
pole modelu jest tekstowe, więc bez katalogu nadal da się wpisać model ręcznie."""
|
||||
try:
|
||||
return klient.modele(_logic)
|
||||
except httpx.HTTPError:
|
||||
return {"providers": {}, "defaults": {}}
|
||||
|
||||
|
||||
def katalog_dla(request: Request) -> dict:
|
||||
"""Katalog modeli do kontekstu szablonu — pusty, gdy konto nie ma uprawnienia.
|
||||
|
||||
Katalog trafia do strony jako blok JSON, więc bez tego ograniczenia nazwy
|
||||
dostawców, modeli i rozmiary okien kontekstu byłyby w źródle każdej strony,
|
||||
także dla kont, które o modelach nie mają prawa wiedzieć."""
|
||||
perms = getattr(getattr(request.state, "principal", None), "permissions", frozenset())
|
||||
return {"llm_catalog": _katalog() if "ai" in perms else {}}
|
||||
|
||||
|
||||
def obsluz(akcja: str, *, profil: str, iso_utc: str, lat: float, lon: float,
|
||||
dodatki: dict, od: str = "", do: str = "", **_reszta) -> dict | None:
|
||||
"""Wykonanie akcji modułu. None znaczy „to nie moja akcja"."""
|
||||
if akcja not in AKCJE:
|
||||
return None
|
||||
metoda = klient.prompt if akcja == "prompt" else klient.horoscope
|
||||
argumenty = {"logic": _logic, "profile": profil, "when_utc_iso": iso_utc, "lat": lat, "lon": lon,
|
||||
"budget": dodatki.get("prompt_budget", "medium"),
|
||||
"provider": dodatki.get("llm_provider", ""),
|
||||
"model": dodatki.get("llm_model", "")}
|
||||
if profil == "period":
|
||||
argumenty["from_date"], argumenty["to_date"] = od, do
|
||||
return metoda(**argumenty)
|
||||
@@ -1,62 +0,0 @@
|
||||
"""Rozmowa z warstwą logiczną w sprawach tego modułu.
|
||||
|
||||
Metody nie siedzą na wspólnym kliencie, tylko tutaj: gdyby siedziały tam, ich
|
||||
nazwy (`prompt`, `horoscope`, `llm_models`) byłyby w pliku, który jedzie do
|
||||
KAŻDEGO obrazu — także tam, gdzie tego modułu nie ma. Wspólny klient daje samą
|
||||
drogę w dół (`wywolaj`, `pobierz`, `strumien`), z szyfrowaniem łącza i tokenem
|
||||
międzywarstwowym; co nią pojedzie, jest sprawą modułu.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from app.config import settings
|
||||
|
||||
|
||||
def prompt(logic: Any, *, profile: str, when_utc_iso: str, lat: float, lon: float,
|
||||
budget: str = "medium", from_date: str | None = None,
|
||||
to_date: str | None = None, provider: str | None = None,
|
||||
model: str | None = None) -> dict[str, Any]:
|
||||
"""Gotowy prompt z wyliczeń (LOG-29/30).
|
||||
|
||||
`provider` jest potrzebny dla budżetu „maksymalny kontekst modelu": limit
|
||||
znaków zależy wtedy od okna kontekstu konkretnego modelu."""
|
||||
payload: dict[str, Any] = {
|
||||
"profile": profile, "when_utc": when_utc_iso, "lat": lat, "lon": lon,
|
||||
"budget": budget, "provider": provider, "model": model,
|
||||
}
|
||||
if from_date and to_date:
|
||||
payload["from_date"], payload["to_date"] = from_date, to_date
|
||||
return logic.wywolaj("/chart/prompt", payload, max(settings.http_timeout, 60.0))
|
||||
|
||||
|
||||
def horoscope(logic: Any, *, profile: str, when_utc_iso: str, lat: float, lon: float,
|
||||
budget: str = "medium", provider: str | None = None,
|
||||
model: str | None = None, from_date: str | None = None,
|
||||
to_date: str | None = None) -> dict[str, Any]:
|
||||
"""Napisany horoskop (LOG-31). Długi timeout, bo pisanie trwa —
|
||||
zwłaszcza na modelu lokalnym."""
|
||||
payload: dict[str, Any] = {
|
||||
"profile": profile, "when_utc": when_utc_iso, "lat": lat, "lon": lon,
|
||||
"budget": budget,
|
||||
}
|
||||
if provider:
|
||||
payload["provider"] = provider
|
||||
if model:
|
||||
payload["model"] = model
|
||||
if from_date and to_date:
|
||||
payload["from_date"], payload["to_date"] = from_date, to_date
|
||||
return logic.wywolaj("/chart/horoscope", payload, max(settings.http_timeout, 300.0))
|
||||
|
||||
|
||||
def strumien(logic: Any, payload: dict[str, Any]):
|
||||
"""Strumień postępu pisania (NDJSON), przekazywany do przeglądarki.
|
||||
|
||||
Strumień niesie heartbeat, więc cisza na łączu nie zostanie wzięta
|
||||
za zerwanie."""
|
||||
yield from logic.strumien("/chart/horoscope/stream", payload)
|
||||
|
||||
|
||||
def modele(logic: Any) -> dict[str, Any]:
|
||||
"""Katalog modeli per dostawca — podpowiedzi do pola wyboru."""
|
||||
return logic.pobierz("/llm/models")
|
||||
@@ -1,38 +0,0 @@
|
||||
/* Generowanie tekstu przez model — dokładany wyłącznie, gdy konto ma
|
||||
uprawnienie „ai”. Selektory nazywają funkcję, więc arkusz nie może
|
||||
wchodzić do arkuszy ekranów, na których ta funkcja bywa wyłączona. */
|
||||
|
||||
/* Okno postępu przy generowaniu horoskopu */
|
||||
/* z-index ponad Leaflet: jego kontrolki (.leaflet-top/.leaflet-bottom — zoom,
|
||||
atrybucja) siedzą na z-index:1000 i — bo .leaflet-container nie tworzy własnego
|
||||
kontekstu stackowania — trafiają wprost do korzenia. Przy z-index:50 mapa
|
||||
wychodziła NA WIERZCH modala. 1200 daje zapas nad 1000. */
|
||||
.progress-overlay { position: fixed; inset: 0; background: rgba(8,9,20,.72);
|
||||
display: flex; align-items: center; justify-content: center;
|
||||
z-index: 1200; padding: 1rem; }
|
||||
.progress-overlay[hidden] { display: none; }
|
||||
.progress-box { background: var(--panel); border: 1px solid var(--line); border-radius: 14px;
|
||||
padding: 1rem 1.1rem; width: min(38rem, 100%); box-shadow: 0 18px 48px rgba(0,0,0,.45); }
|
||||
.progress-head { display: flex; align-items: center; gap: .6rem; margin-bottom: .6rem; }
|
||||
.progress-clock { margin-left: auto; font-family: ui-monospace, Menlo, monospace;
|
||||
color: var(--muted); font-size: .9rem; }
|
||||
.progress-spinner { width: 14px; height: 14px; border-radius: 50%; flex: none;
|
||||
border: 2px solid var(--line); border-top-color: var(--accent);
|
||||
animation: spin .8s linear infinite; }
|
||||
@keyframes spin { to { transform: rotate(360deg); } }
|
||||
@media (prefers-reduced-motion: reduce) { .progress-spinner { animation: none; } }
|
||||
.progress-log { list-style: none; margin: 0 0 .6rem; padding: .6rem .7rem;
|
||||
background: #12132a; border: 1px solid var(--line); border-radius: 10px;
|
||||
max-height: 15rem; overflow-y: auto;
|
||||
font-family: ui-monospace, Menlo, monospace; font-size: .78rem; line-height: 1.6; }
|
||||
.progress-log li { color: var(--ink); white-space: pre-wrap; }
|
||||
.progress-log li.log-ok { color: #7fd18b; }
|
||||
.progress-log li.log-warn { color: #e0c060; }
|
||||
.progress-log li.log-err { color: #ef6b6b; }
|
||||
|
||||
/* Generator promptu do LLM (LOG-29/30) */
|
||||
textarea.prompt { width: 100%; margin-top: .5rem; padding: .7rem .8rem; box-sizing: border-box;
|
||||
background: #12132a; color: var(--ink); border: 1px solid var(--line);
|
||||
border-radius: 10px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
|
||||
font-size: .82rem; line-height: 1.45; resize: vertical; white-space: pre; }
|
||||
textarea.prompt:focus { outline: 2px solid var(--accent); outline-offset: 1px; }
|
||||
@@ -1,9 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}
|
||||
{# Magazyny wczytujemy dla ich API odczytu. Ich własne UI samo się wyłącza —
|
||||
każdy sprawdza, czy jego kontener jest na stronie. #}
|
||||
<script src="{{ static('natal.js') }}"></script>
|
||||
<script src="{{ static('predictions.js') }}"></script>
|
||||
{% endif %}
|
||||
@@ -1,4 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}
|
||||
@@ -1,8 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}
|
||||
{# Części od modelu — wstawia przeglądarka z magazynu lokalnego. #}
|
||||
<div id="reportNatal"></div>
|
||||
<div id="reportPredictions"></div>
|
||||
{% endif %}
|
||||
@@ -1,7 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}
|
||||
<button type="submit" name="action" value="prompt" class="ghost">Generuj prompt (AI)</button>
|
||||
<button type="submit" name="action" value="horoscope">Napisz horoskop (AI)</button>
|
||||
{% endif %}
|
||||
@@ -1,5 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}{% include "_prompt_block.html" %}
|
||||
<p class="muted small" id="natalNote"></p>{% endif %}
|
||||
@@ -1,9 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}
|
||||
<script src="{{ static('models.js') }}"></script>
|
||||
<script src="{{ static('progress.js') }}"></script>
|
||||
{# po progress.js — nasłuchuje zdarzenia o gotowej interpretacji (PRE-23) #}
|
||||
<script src="{{ static('natal.js') }}"></script>
|
||||
{% endif %}
|
||||
@@ -1,4 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}
|
||||
@@ -1,7 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}
|
||||
<button type="submit" name="action" value="prompt" class="ghost">Generuj prompt (AI)</button>
|
||||
<button type="submit" name="action" value="horoscope">Napisz horoskop (AI)</button>
|
||||
{% endif %}
|
||||
@@ -1,4 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}{% include "_prompt_block.html" %}{% endif %}
|
||||
@@ -1,9 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}
|
||||
<script src="{{ static('models.js') }}"></script>
|
||||
<script src="{{ static('progress.js') }}"></script>
|
||||
{# po progress.js — nasłuchuje zdarzenia, które tamten wysyła po gotowym horoskopie #}
|
||||
<script src="{{ static('predictions.js') }}"></script>
|
||||
{% endif %}
|
||||
@@ -1,4 +0,0 @@
|
||||
{# Wstawka modułu. Sprawdzenie uprawnienia siedzi TUTAJ, a nie w szablonie
|
||||
wspólnym: tam byłoby nazwą funkcji wpisaną w plik, który trafia także do
|
||||
obrazu bez tego modułu. #}
|
||||
{% if can(request, 'ai') %}<link rel="stylesheet" href="{{ static('x-ai.css') }}">{% endif %}
|
||||
@@ -1,85 +0,0 @@
|
||||
"""Trasy wnoszone przez moduł. Bez tego katalogu w obrazie nie istnieją."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from typing import Any
|
||||
|
||||
import httpx
|
||||
from fastapi import Form
|
||||
from fastapi.responses import JSONResponse, StreamingResponse
|
||||
|
||||
from app.moduly.dodatki import katalog, klient
|
||||
|
||||
_logic: Any = None
|
||||
_szablony: Any = None
|
||||
_buduj_utc: Any = None
|
||||
_blad: Any = None
|
||||
|
||||
|
||||
def zamontuj(app, *, logic: Any, templates: Any, buduj_utc: Any, blad: Any,
|
||||
**_reszta) -> None:
|
||||
"""Podpięcie tras i przekazanie modułowi tego, czego potrzebuje.
|
||||
|
||||
Zależności przychodzą z zewnątrz, zamiast być importowane: moduł nie może
|
||||
importować `app.main`, bo to cykl — a przede wszystkim dlatego, że zależność
|
||||
ma iść w JEDNĄ stronę. Aplikacja wie o istnieniu modułów opcjonalnych
|
||||
(przez neutralny most), moduł nie wie nic o aplikacji.
|
||||
"""
|
||||
# `**_reszta` CELOWO: most podaje wszystkim modułom ten sam zestaw zależności,
|
||||
# a każdy bierze z niego to, czego potrzebuje. Bez tego dołożenie zależności
|
||||
# dla jednego modułu wywracałoby pozostałe.
|
||||
global _logic, _szablony, _buduj_utc, _blad
|
||||
_logic, _szablony, _buduj_utc, _blad = logic, templates, buduj_utc, blad
|
||||
katalog.ustaw_zaleznosci(logic=logic, templates=templates)
|
||||
|
||||
@app.post("/horoscope/stream")
|
||||
def horoscope_stream( # noqa: ANN202
|
||||
profile: str = Form("natal"),
|
||||
date: str = Form(...),
|
||||
time: str = Form(...),
|
||||
tz_offset: float = Form(0.0),
|
||||
lat: float = Form(0.0),
|
||||
lon: float = Form(0.0),
|
||||
prompt_budget: str = Form("medium"),
|
||||
llm_provider: str = Form("local"),
|
||||
llm_model: str = Form(""),
|
||||
from_date: str = Form(""),
|
||||
to_date: str = Form(""),
|
||||
):
|
||||
"""Przekazuje strumień postępu z logiki i DOKLEJA gotowy HTML wyniku.
|
||||
|
||||
Dzięki temu okno postępu wstawia dokładnie ten sam widok, który
|
||||
wyrenderowałoby przeładowanie strony — jedno źródło prawdy dla wyglądu.
|
||||
"""
|
||||
try:
|
||||
iso_utc, _ = _buduj_utc(date, time, tz_offset)
|
||||
except ValueError as e:
|
||||
return JSONResponse({"detail": f"Niepoprawne dane wejściowe: {e}"},
|
||||
status_code=422)
|
||||
|
||||
payload: dict = {
|
||||
"profile": profile, "when_utc": iso_utc, "lat": lat, "lon": lon,
|
||||
"budget": prompt_budget, "provider": llm_provider, "model": llm_model,
|
||||
}
|
||||
if profile == "period" and from_date and to_date:
|
||||
payload["from_date"], payload["to_date"] = from_date, to_date
|
||||
|
||||
def relay():
|
||||
try:
|
||||
for raw in klient.strumien(_logic, payload):
|
||||
try:
|
||||
event = json.loads(raw)
|
||||
except ValueError:
|
||||
continue
|
||||
if event.get("type") == "result":
|
||||
event["html"] = _szablony.get_template("_prompt_result.html").render(
|
||||
prompt_result=event.get("result") or {}
|
||||
)
|
||||
yield json.dumps(event, ensure_ascii=False) + "\n"
|
||||
except httpx.HTTPError as e:
|
||||
yield json.dumps({"type": "error", "message": _blad(e)},
|
||||
ensure_ascii=False) + "\n"
|
||||
|
||||
return StreamingResponse(relay(), media_type="application/x-ndjson",
|
||||
headers={"Cache-Control": "no-store",
|
||||
"X-Accel-Buffering": "no"})
|
||||
@@ -1,13 +0,0 @@
|
||||
"""Wynoszenie treści na zewnątrz: arkusz z wynikami i raport w PDF-ie.
|
||||
|
||||
Moduł ODŁĄCZALNY. Jest w obrazie astrololo; w produktach, które nie mają wynosić
|
||||
treści baz poza program, nie ma go wcale — a nie ma go jak włączyć, bo nie ma
|
||||
czego. Eksport wynosi NAJWIĘCEJ treści naraz, więc „można, ale nie temu kontu"
|
||||
i „nie ma takiej możliwości" to dwie różne gwarancje.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from app.moduly.eksport.katalog import AKCJE, FUNKCJA, TRASY, obsluz
|
||||
from app.moduly.eksport.trasy import zamontuj
|
||||
|
||||
__all__ = ["AKCJE", "FUNKCJA", "TRASY", "obsluz", "zamontuj"]
|
||||
@@ -1,47 +0,0 @@
|
||||
"""Co moduł wnosi: funkcję, trasy i akcję formularza."""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from fastapi.responses import Response
|
||||
|
||||
FUNKCJA: tuple[tuple[str, str, str, str], ...] = (
|
||||
("export", "Eksport plików",
|
||||
"Pobieranie raportu jako PDF i wyników jako arkusz.", "Rozszerzenia"),
|
||||
)
|
||||
|
||||
TRASY: dict[tuple[str, str], str] = {("POST", "/compile/pdf"): "export"}
|
||||
|
||||
# Akcja formularza: nazwa → wymagane uprawnienie.
|
||||
AKCJE: dict[str, str] = {"export": "export"}
|
||||
|
||||
# Wstrzykiwane przy montowaniu — moduł nie importuje aplikacji.
|
||||
_logic: Any = None
|
||||
_security: Any = None
|
||||
_licz_rekordy: Any = None
|
||||
|
||||
|
||||
def ustaw_zaleznosci(*, logic: Any, security: Any, licz_rekordy: Any) -> None:
|
||||
global _logic, _security, _licz_rekordy
|
||||
_logic, _security, _licz_rekordy = logic, security, licz_rekordy
|
||||
|
||||
|
||||
def obsluz(akcja: str, *, iso_utc: str = "", lat: float = 0.0, lon: float = 0.0,
|
||||
request: Any = None, group: bool = False, **_reszta) -> Response | None:
|
||||
# Wszystko po `akcja` ma wartość domyślną CELOWO: most woła po kolei każdy
|
||||
# moduł, także z ekranu, który tych danych nie ma. Brakujący argument
|
||||
# wywracałby wtedy ekran, zamiast po prostu nie pasować do akcji.
|
||||
if akcja not in AKCJE:
|
||||
return None
|
||||
# Arkusz roboczy z wynikami (DAN-23/PRE-10) — pobranie pliku, nie strona.
|
||||
from app.moduly.eksport.arkusz import report_to_xlsx
|
||||
|
||||
report = _logic.report(when_utc_iso=iso_utc, lat=lat, lon=lon, group=group)
|
||||
# Eksport wynosi NAJWIĘCEJ treści baz naraz — tym bardziej ma zostawiać ślad
|
||||
# w dzienniku (PRE-17): sama liczba rekordów, nigdy treść.
|
||||
_security.audit_records(request, _licz_rekordy(report))
|
||||
return Response(
|
||||
content=report_to_xlsx(report),
|
||||
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
||||
headers={"Content-Disposition": 'attachment; filename="interpretacje.xlsx"'},
|
||||
)
|
||||
@@ -1,114 +0,0 @@
|
||||
"""Trasy wnoszone przez moduł. Bez tego katalogu w obrazie nie istnieją."""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
import httpx
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
|
||||
from app.moduly.eksport import katalog
|
||||
|
||||
_logic: Any = None
|
||||
_szablony: Any = None
|
||||
_buduj_utc: Any = None
|
||||
_blad: Any = None
|
||||
_kolo: Any = None
|
||||
|
||||
|
||||
def zamontuj(app, *, logic: Any, templates: Any, buduj_utc: Any, blad: Any,
|
||||
security: Any = None, licz_rekordy: Any = None, kolo: Any = None,
|
||||
**_reszta) -> None:
|
||||
"""Podpięcie trasy i przekazanie zależności. Idą z zewnątrz, bo zależność ma
|
||||
biec w JEDNĄ stronę: aplikacja wie o modułach opcjonalnych (przez neutralny
|
||||
most), moduł nie wie nic o aplikacji."""
|
||||
global _logic, _szablony, _buduj_utc, _blad, _kolo
|
||||
_logic, _szablony, _buduj_utc, _blad = logic, templates, buduj_utc, blad
|
||||
_kolo = kolo
|
||||
katalog.ustaw_zaleznosci(logic=logic, security=security, licz_rekordy=licz_rekordy)
|
||||
|
||||
# Nazwy, których używa przeniesiona trasa. `chartwheel` to czysty rysownik
|
||||
# bez stanu, więc importujemy go wprost — wstrzykiwanie ma sens dla rzeczy
|
||||
# związanych z aplikacją (klient, szablony), nie dla funkcji rysujących.
|
||||
from app import chartwheel as chartwheel_mod
|
||||
|
||||
_build_utc = buduj_utc
|
||||
_logic_error = blad
|
||||
|
||||
@app.post("/compile/pdf")
|
||||
def compile_pdf(payload: dict):
|
||||
"""Składa raport PDF (PRE-24) — woła usługę render po szyfrowanym łączu.
|
||||
|
||||
Wejście z przeglądarki, bo część kawałków (interpretacja natalna i predykcje)
|
||||
mieszkają w magazynie lokalnym. Kosmogram i tabele liczymy TU, żeby PDF
|
||||
zawierał dokładnie to, co widać na stronie.
|
||||
|
||||
Kosmogram idzie w motywie DRUKU: samodzielny konwerter SVG→PDF nie zna
|
||||
naszego arkusza, więc zmienne CSS i font glifów muszą być w samym rysunku.
|
||||
"""
|
||||
from fastapi.responses import Response
|
||||
|
||||
from app.clients.render_client import RenderClient
|
||||
|
||||
data = payload.get("data") or {}
|
||||
try:
|
||||
iso_utc, label = _build_utc(
|
||||
str(data.get("date") or ""), str(data.get("time") or ""),
|
||||
float(data.get("tz_offset") or 0.0),
|
||||
)
|
||||
except (ValueError, TypeError) as e:
|
||||
return JSONResponse({"detail": f"Niepoprawne dane wejściowe: {e}"}, status_code=422)
|
||||
|
||||
figures: list[dict] = []
|
||||
warnings: list[str] = []
|
||||
try:
|
||||
chart = logic.positions(
|
||||
when_utc_iso=iso_utc,
|
||||
lat=float(data.get("lat") or 0.0), lon=float(data.get("lon") or 0.0),
|
||||
house_system=str(data.get("house_system") or "whole_sign"),
|
||||
house_systems=[s for s in (data.get("house_systems") or []) if s],
|
||||
aspect_orb=float(data.get("aspect_orb") or 8.0),
|
||||
aspect_luminary_bonus=float(data.get("aspect_luminary_bonus") or 2.0),
|
||||
aspect_minor=bool(data.get("aspect_minor")),
|
||||
stations=bool(data.get("stations")), tables=bool(data.get("tables")),
|
||||
zodiac=str(data.get("zodiac") or "tropical"),
|
||||
)
|
||||
# Fallback systemu domów musi dojechać do PDF-a — z samego kosmogramu
|
||||
# nie da się poznać, że podział jest z innego systemu, niż zamówiono.
|
||||
warnings = [w for w in (chart.get("house_warnings") or []) if w]
|
||||
|
||||
from app import chartwheel
|
||||
|
||||
# Zasada: co pokazujemy na stronie, ma trafić do PDF-a. Wszystkie rysunki
|
||||
# w motywie DRUKU — samodzielny konwerter SVG→PDF nie zna arkusza, więc
|
||||
# zmienne CSS i font glifów muszą być wprost w rysunku.
|
||||
for svg, caption in (
|
||||
(chartwheel.render(chart, theme="print",
|
||||
orientation=str(data.get("wheel_orientation") or chartwheel_mod.ASC_LEFT)),
|
||||
"Kosmogram"),
|
||||
(chartwheel.render_aspectarian(chart, theme="print"), "Aspektarian — siatka aspektów"),
|
||||
(chartwheel.render_declination(chart, theme="print"), "Wykres deklinacji"),
|
||||
(chartwheel.render_antiscia(chart, theme="print"), "Oś antyscji"),
|
||||
):
|
||||
if svg:
|
||||
figures.append({"svg": svg, "caption": caption})
|
||||
except httpx.HTTPError as e:
|
||||
# Brak rysunków nie może zablokować raportu — tekst jest ważniejszy.
|
||||
data = {**data, "wheel_error": _logic_error(e)}
|
||||
|
||||
report = {
|
||||
"person": payload.get("person") or "",
|
||||
"data": {**data, "moment_utc": label},
|
||||
"figures": figures,
|
||||
"warnings": warnings,
|
||||
"natal": payload.get("natal") or {},
|
||||
"predictions": payload.get("predictions") or [],
|
||||
}
|
||||
try:
|
||||
pdf = RenderClient().pdf(report)
|
||||
except httpx.HTTPError as e:
|
||||
return JSONResponse(
|
||||
{"detail": f"Usługa render niedostępna albo nie złożyła PDF-a: {e}"},
|
||||
status_code=502,
|
||||
)
|
||||
return Response(content=pdf, media_type="application/pdf",
|
||||
headers={"Content-Disposition": 'attachment; filename="raport.pdf"'})
|
||||
@@ -1,275 +0,0 @@
|
||||
"""Podstawa aplikacji: wspólne obiekty i pomocnicy, z których korzystają ekrany.
|
||||
|
||||
Tu mieszka to, co ma KAŻDY produkt zbudowany z tego kodu: obiekt aplikacji,
|
||||
szablony, klient warstwy logicznej, serwowanie zasobów i garść funkcji
|
||||
pomocniczych. Ani jednej trasy ekranu — te są w `app/ekrany/*.py`, po jednym
|
||||
module na ekran, a o tym, które wchodzą, decyduje lista importów w `main.py`.
|
||||
|
||||
Dlaczego tak: dopóki wszystko siedziało w jednym pliku, „produkt bez tego ekranu"
|
||||
znaczyło „produkt z ekranem, tylko zablokowanym". Plik i tak jechał do obrazu,
|
||||
razem z nazwami funkcji, których nie było jak włączyć.
|
||||
"""
|
||||
# build-marker: 2026-07-25 wymuszenie nowego obrazu po incydencie z tagiem :latest
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import logging
|
||||
import re
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import FastAPI, HTTPException, Request
|
||||
from fastapi.responses import Response
|
||||
from fastapi.templating import Jinja2Templates
|
||||
|
||||
|
||||
from app import accounts as accounts_store
|
||||
from app import rozszerzenia
|
||||
from app import chartwheel as chartwheel_mod
|
||||
from app import features
|
||||
from app import session
|
||||
from app import files_state
|
||||
from app.house_systems import HOUSE_SYSTEMS, LIMITED as HOUSE_LIMITED, label as house_label
|
||||
|
||||
from app import geocode, security
|
||||
from app.clients.logic_client import LogicClient
|
||||
from app.config import DEFAULT_LOCATION_LABEL, default_form
|
||||
|
||||
# Automatyczna dokumentacja WYŁĄCZONA. /docs, /redoc i /openapi.json wypisują
|
||||
# KOMPLET tras aplikacji — czyli spis wszystkich funkcji, łącznie z tymi, o których
|
||||
# konto ograniczone nie ma prawa wiedzieć (PRE-27). Ochrona zakładek nic by nie dała,
|
||||
# gdyby obok leżał ich katalog. Znalezione testem przechodzącym po trasach aplikacji.
|
||||
app = FastAPI(title="astrololo · warstwa prezentacji",
|
||||
docs_url=None, redoc_url=None, openapi_url=None)
|
||||
# Katalogi modułów opcjonalnych idą PRZED wspólnym: moduł może dołożyć szablon,
|
||||
# którego wspólny zestaw nie ma. Wspólne szablony wołają je przez neutralne
|
||||
# gniazda `{% include "_dodatki_*" ignore missing %}` — bez modułu gniazdo jest
|
||||
# po prostu puste, a nie „wyłączone".
|
||||
templates = Jinja2Templates(directory=[*rozszerzenia.katalog_szablonow(), "app/templates"])
|
||||
# Szczegóły awarii idą TUTAJ, nie na ekran (patrz _logic_error).
|
||||
log = logging.getLogger("astrololo.prezentacja")
|
||||
logic = LogicClient()
|
||||
security.install(app) # logowanie + limit żądań (LOG-32)
|
||||
|
||||
|
||||
# ── cache-busting statyki (PRE-27) ─────────────────────────────────────────
|
||||
# Po deployu przeglądarka trzymała stare styles.css / *.js (ten sam URL → cache).
|
||||
# Doklejamy do URL-a krótki HASH TREŚCI pliku: zmieni się plik → zmieni się URL →
|
||||
# przeglądarka pobierze nowy; bez zmian URL zostaje ten sam (cache działa dalej).
|
||||
# Hash liczony raz na proces (lru_cache) — nowy pod po deployu = świeży hash.
|
||||
_STATIC_DIR = Path("app/static")
|
||||
|
||||
|
||||
_TYPY_ZASOBOW = {
|
||||
".css": "text/css; charset=utf-8",
|
||||
".js": "application/javascript; charset=utf-8",
|
||||
".svg": "image/svg+xml",
|
||||
".png": "image/png",
|
||||
".woff2": "font/woff2",
|
||||
}
|
||||
|
||||
|
||||
def _bez_komentarzy(tresc: str, sufiks: str) -> str:
|
||||
"""Usuwa komentarze z arkusza albo skryptu przed wysłaniem.
|
||||
|
||||
Komentarz w pliku statycznym jedzie do przeglądarki bajt w bajt, a te
|
||||
komentarze opisują funkcje pełnym zdaniem po polsku — łącznie z tym, czego
|
||||
konto ograniczone NIE widzi i kto to widzi. Zostają w repozytorium, bo tam
|
||||
są potrzebne; do odpowiedzi nie mają po co trafiać.
|
||||
|
||||
Kasujemy tylko komentarze blokowe i CAŁE wiersze `//`. Komentarz na końcu
|
||||
wiersza zostaje CELOWO: żeby go usunąć, trzeba rozpoznać, czy `//` nie jest
|
||||
w napisie albo w wyrażeniu regularnym — a pomyłka tutaj psuje skrypt po
|
||||
cichu. Test pilnuje słownika zakazanych słów, więc reszta by i tak wyszła.
|
||||
"""
|
||||
tresc = re.sub(r"/\*.*?\*/", "", tresc, flags=re.S)
|
||||
if sufiks == ".js":
|
||||
tresc = re.sub(r"(?m)^[ \t]*//.*$\n?", "", tresc)
|
||||
return re.sub(r"\n{3,}", "\n\n", tresc).strip() + "\n"
|
||||
|
||||
|
||||
@lru_cache(maxsize=None)
|
||||
def _asset_body(name: str) -> bytes | None:
|
||||
"""Treść zasobu tak, jak pójdzie na drut — albo None, gdy go nie ma."""
|
||||
for katalog in (*rozszerzenia.katalog_zasobow(), str(_STATIC_DIR)):
|
||||
korzen = Path(katalog).resolve()
|
||||
sciezka = (Path(katalog) / name).resolve()
|
||||
# Wyjście poza katalog zasobów: `..` w ścieżce albo dowiązanie na zewnątrz.
|
||||
if korzen in sciezka.parents and sciezka.is_file():
|
||||
break
|
||||
else:
|
||||
return None
|
||||
surowe = sciezka.read_bytes()
|
||||
sufiks = sciezka.suffix.lower()
|
||||
# Kod obcy zostaje nietknięty: minifikowany plik potrafi mieć `//` w napisie
|
||||
# albo w wyrażeniu regularnym, a on i tak nie mówi nic o naszym programie.
|
||||
if sufiks in (".css", ".js") and not name.startswith("vendor/"):
|
||||
try:
|
||||
return _bez_komentarzy(surowe.decode("utf-8"), sufiks).encode("utf-8")
|
||||
except UnicodeDecodeError:
|
||||
return surowe
|
||||
return surowe
|
||||
|
||||
|
||||
@lru_cache(maxsize=None)
|
||||
def _asset_version(name: str) -> str:
|
||||
tresc = _asset_body(name)
|
||||
# Hash liczony z treści WYSYŁANEJ, nie z pliku na dysku: inaczej zmiana
|
||||
# samego komentarza podbijałaby adres, choć odpowiedź jest ta sama.
|
||||
return hashlib.md5(tresc).hexdigest()[:8] if tresc is not None else "0"
|
||||
|
||||
|
||||
def static_url(name: str) -> str:
|
||||
return f"/static/{name}?v={_asset_version(name)}"
|
||||
|
||||
|
||||
@app.get("/static/{nazwa:path}")
|
||||
def static_file(nazwa: str):
|
||||
"""Zasoby idą przez bramkę uprawnień jak każda inna trasa.
|
||||
|
||||
Dopóki `/static/` było w PUBLIC_PREFIXES, katalog omijał całe sprawdzanie:
|
||||
ukrycie przycisku w szablonie nic nie dawało, bo obok leżał skrypt tej samej
|
||||
funkcji, pod nazwą, którą wystarczyło zgadnąć. Uprawnienie zasobu sprawdza
|
||||
middleware (features.static_required); tutaj zostaje samo wydanie pliku.
|
||||
"""
|
||||
tresc = _asset_body(nazwa)
|
||||
if tresc is None:
|
||||
raise HTTPException(status_code=404)
|
||||
return Response(
|
||||
tresc,
|
||||
media_type=_TYPY_ZASOBOW.get(Path(nazwa).suffix.lower(), "application/octet-stream"),
|
||||
# Adres niesie hash treści, więc wersja pod danym adresem jest niezmienna.
|
||||
headers={"Cache-Control": "public, max-age=31536000, immutable"},
|
||||
)
|
||||
|
||||
|
||||
templates.env.globals["static"] = static_url
|
||||
templates.env.globals["nav_admin"] = lambda: features.NAWIGACJA_ADMINA
|
||||
# Katalog systemów domów — jedno źródło nazw dla wszystkich szablonów.
|
||||
templates.env.globals["HOUSE_SYSTEMS"] = HOUSE_SYSTEMS
|
||||
templates.env.globals["house_label"] = house_label
|
||||
templates.env.globals["HOUSE_LIMITED"] = HOUSE_LIMITED
|
||||
templates.env.globals["WHEEL_ORIENTATIONS"] = chartwheel_mod.ORIENTATIONS
|
||||
templates.env.globals["STATUS_LABELS"] = files_state.LABELS
|
||||
|
||||
|
||||
def _perms(request: Request) -> frozenset[str]:
|
||||
"""Uprawnienia zalogowanego konta — pusty zbiór, gdy nie wiadomo kto to."""
|
||||
who = getattr(request.state, "principal", None)
|
||||
return who.permissions if who is not None else frozenset()
|
||||
|
||||
|
||||
# Szablony pytają o uprawnienia PRZEZ TE DWIE FUNKCJE, nigdy o konto wprost.
|
||||
# Dzięki temu nie da się w szablonie napisać warunku na login — a to jest
|
||||
# dokładnie ten rodzaj sprytu, który po roku zostawia kogoś z dostępem, o którym
|
||||
# nikt już nie pamięta.
|
||||
templates.env.globals["nav_screens"] = lambda request: features.screens_for(_perms(request))
|
||||
# Kto jest zalogowany i czy logowanie w ogóle działa — pod przycisk wyjścia.
|
||||
templates.env.globals["current_user"] = lambda request: getattr(request.state, "user", "") or ""
|
||||
templates.env.globals["auth_on"] = security.auth_enabled
|
||||
templates.env.globals["can"] = lambda request, key: key in _perms(request)
|
||||
|
||||
|
||||
def _limit_options(request: Request, opts: dict) -> dict:
|
||||
"""Ścina opcje, których konto nie ma prawa użyć — PO STRONIE SERWERA.
|
||||
|
||||
Ukrycie pola w formularzu chroni tylko przed przypadkiem. Kto zna nazwy pól,
|
||||
wyśle je wprost — a wtedy policzyłby funkcję, której mu nie przyznano, i to
|
||||
jeszcze zobaczyłby ją w wyniku. Granicą jest ta funkcja, nie szablon.
|
||||
|
||||
Wartości zastępcze są DOMYŚLNE, nie puste: konto ograniczone ma dostać
|
||||
działający horoskop w podstawowej postaci, a nie komunikat o braku czegoś.
|
||||
"""
|
||||
perms = _perms(request)
|
||||
if "advanced_calc" not in perms:
|
||||
opts.update(stations=False, tables=False, aspect_minor=False, zodiac="tropical")
|
||||
if "houses_compare" not in perms:
|
||||
opts.update(house_system="whole_sign", house_systems=[],
|
||||
wheel_orientation=chartwheel_mod.ASC_LEFT)
|
||||
return opts
|
||||
|
||||
|
||||
def _landing(request: Request) -> str | None:
|
||||
"""Pierwszy ekran dostępny dla konta — dokąd odesłać z korzenia."""
|
||||
allowed = features.screens_for(_perms(request))
|
||||
return allowed[0].href if allowed else None
|
||||
|
||||
|
||||
def _build_utc(date: str, time: str, tz_offset: float) -> tuple[str, str]:
|
||||
"""Z lokalnej daty/godziny + przesunięcia strefy → moment UTC.
|
||||
|
||||
Zwraca (iso_utc, etykieta_czytelna). UTC = czas lokalny − offset.
|
||||
"""
|
||||
local = datetime.fromisoformat(f"{date}T{time}")
|
||||
utc = (local - timedelta(hours=tz_offset)).replace(tzinfo=timezone.utc)
|
||||
label = utc.strftime("%Y-%m-%d %H:%M UTC")
|
||||
return utc.isoformat(), label
|
||||
|
||||
|
||||
# Akcja formularza → uprawnienie, którego wymaga. Akcji spoza tej mapy nie
|
||||
# ograniczamy; akcja Z mapy, na którą konto nie ma prawa, jest traktowana jak
|
||||
# NIEZNANA — czyli wraca do zachowania domyślnego ekranu.
|
||||
# Akcje własne tego ekranu plus te, które wnoszą moduły opcjonalne. Aplikacja
|
||||
# nie wypisuje ich z nazwy — gdyby wypisywała, nazwa funkcji byłaby w kodzie
|
||||
# także tam, gdzie modułu nie ma.
|
||||
_AKCJE_POD_UPRAWNIENIEM = {"export": "export", **rozszerzenia.akcje()}
|
||||
|
||||
|
||||
def _dozwolona_akcja(request: Request, action: str, domyslna: str) -> str:
|
||||
"""Akcja, której konto nie ma prawa użyć, zachowuje się jak literówka.
|
||||
|
||||
NIE zwracamy błędu ani 404: komunikat „brak uprawnień do generowania" sam
|
||||
w sobie mówiłby, że taka funkcja istnieje (PRE-27). Ukrycie przycisku chroni
|
||||
tylko przed przypadkiem — kto zna nazwę pola, wyśle ją wprost, i to TU musi
|
||||
się zatrzymać."""
|
||||
wymagane = _AKCJE_POD_UPRAWNIENIEM.get(action)
|
||||
if wymagane and wymagane not in _perms(request):
|
||||
return domyslna
|
||||
return action
|
||||
|
||||
|
||||
def _report_records(report: dict | None) -> int:
|
||||
"""Ile rekordów baz niesie raport — do dziennika audytowego (PRE-17).
|
||||
|
||||
Liczymy próbki we wszystkich fasetach: to one są treścią z baz. Sama liczba,
|
||||
nigdy treść — dziennik ma pokazywać SKALĘ dostępu, nie powielać danych."""
|
||||
total = 0
|
||||
for o in (report or {}).get("objects") or []:
|
||||
for f in o.get("facets") or []:
|
||||
total += len(f.get("samples") or [])
|
||||
return total
|
||||
|
||||
|
||||
# Jedno zdanie dla wszystkich awarii — i CELOWO żadnego szczegółu.
|
||||
# Poprzednia treść wypisywała na ekran nazwę endpointu (/chart/positions), nazwę
|
||||
# podsystemu („silnik efemeryd"), nazwę gałęzi rozwojowej i — przez str(wyjątku
|
||||
# httpx) — wewnętrzny adres z portem sąsiedniej usługi. Dla konta, które ma
|
||||
# widzieć wyłącznie Pliki, to był komplet: co program liczy, że stoi za nim
|
||||
# łańcuch usług, i gdzie zapukać.
|
||||
_AWARIA = "Nie udało się teraz wykonać tej operacji. Spróbuj ponownie za chwilę."
|
||||
|
||||
|
||||
def _logic_error(e: Exception) -> str:
|
||||
"""Komunikat dla użytkownika. Diagnostyka idzie do dziennika, nie na ekran.
|
||||
|
||||
Odsiew siedzi TUTAJ, a nie w siedemnastu miejscach wywołania: gdyby zależał
|
||||
od tego, czy ktoś pamiętał przekazać uprawnienia, prędzej czy później jedno
|
||||
wywołanie zostałoby pominięte — i nie byłoby tego jak zauważyć.
|
||||
"""
|
||||
log.warning("warstwa logiczna: %s: %s", type(e).__name__, e)
|
||||
return _AWARIA
|
||||
|
||||
|
||||
|
||||
|
||||
features.zarejestruj(trasy={("GET", "/health"): None})
|
||||
|
||||
|
||||
@app.get("/health")
|
||||
def health() -> dict:
|
||||
# Sama „ok" — nazwa warstwy mówiła, że warstw jest więcej i jak się nazywa.
|
||||
# Kubernetes i compose czytają wyłącznie kod odpowiedzi.
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@@ -1,136 +0,0 @@
|
||||
"""Most do modułów opcjonalnych — CELOWO nie zna ani jednej ich nazwy.
|
||||
|
||||
Ten plik jest w KAŻDYM obrazie, także tam, gdzie nie ma żadnego modułu. Gdyby
|
||||
wymieniał moduły z nazwy, nazwa nieobecnej funkcji i tak jechałaby do obrazu,
|
||||
w którym tej funkcji nie ma — czyli dokładnie ten ślad, którego całe wydzielanie
|
||||
ma się pozbyć. Dlatego moduły są ODKRYWANE: most przechodzi po podkatalogach
|
||||
`app/moduly/` i pyta każdy, co wnosi.
|
||||
|
||||
Gdy nie ma żadnego, wszystkie odpowiedzi są puste, a aplikacja zachowuje się
|
||||
tak, jakby takiego pojęcia nigdy nie było — nie jak aplikacja z wyłączoną
|
||||
funkcją.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib
|
||||
import pkgutil
|
||||
from typing import Any
|
||||
|
||||
|
||||
def _znalezione() -> list[Any]:
|
||||
"""Moduły obecne w tym obrazie, w kolejności alfabetycznej katalogów.
|
||||
|
||||
Kolejność jest stała, żeby dwa obrazy z tym samym zestawem zachowywały się
|
||||
identycznie — inaczej wynik zależałby od kolejności odczytu katalogu."""
|
||||
try:
|
||||
paczka = importlib.import_module("app.moduly")
|
||||
except ImportError:
|
||||
return []
|
||||
znalezione = []
|
||||
for info in sorted(pkgutil.iter_modules(paczka.__path__), key=lambda i: i.name):
|
||||
znalezione.append(importlib.import_module(f"app.moduly.{info.name}"))
|
||||
return znalezione
|
||||
|
||||
|
||||
_MODULY = _znalezione()
|
||||
DOSTEPNE = bool(_MODULY)
|
||||
|
||||
|
||||
def _zbierz(nazwa: str, domyslne):
|
||||
"""Wartość atrybutu z każdego modułu, który go ma."""
|
||||
return [getattr(m, nazwa) for m in _MODULY if hasattr(m, nazwa)] or domyslne
|
||||
|
||||
|
||||
def funkcje() -> tuple[tuple[str, str, str, str], ...]:
|
||||
"""Pozycje do katalogu funkcji — jako surowe krotki, nie obiekty.
|
||||
|
||||
Surowe, bo katalog buduje `features`, a gdyby moduł importował stamtąd klasę,
|
||||
powstałby cykl: features → most → moduł → features."""
|
||||
out: list[tuple[str, str, str, str]] = []
|
||||
for wartosc in _zbierz("FUNKCJA", []):
|
||||
out.extend(wartosc)
|
||||
return tuple(out)
|
||||
|
||||
|
||||
def trasy() -> dict[tuple[str, str], str]:
|
||||
out: dict[tuple[str, str], str] = {}
|
||||
for wartosc in _zbierz("TRASY", []):
|
||||
out.update(wartosc)
|
||||
return out
|
||||
|
||||
|
||||
def zasoby() -> dict[str, Any]:
|
||||
out: dict[str, Any] = {}
|
||||
for wartosc in _zbierz("ZASOBY", []):
|
||||
out.update(wartosc)
|
||||
return out
|
||||
|
||||
|
||||
def akcje() -> dict[str, str]:
|
||||
"""Akcje formularza wnoszone przez moduły: nazwa → wymagane uprawnienie."""
|
||||
out: dict[str, str] = {}
|
||||
for wartosc in _zbierz("AKCJE", []):
|
||||
out.update(wartosc)
|
||||
return out
|
||||
|
||||
|
||||
def pola_formularza():
|
||||
"""Zależność FastAPI deklarująca dodatkowe pola formularza.
|
||||
|
||||
Pola muszą być w SYGNATURZE, żeby FastAPI je odczytało, a sygnatura wspólnego
|
||||
handlera nie może ich wymieniać. Zależność przenosi deklarację do modułu.
|
||||
|
||||
Gdy pola deklaruje więcej niż jeden moduł, trzeba je złożyć — a składanie
|
||||
sygnatur w locie to kod, który psuje się cicho. Póki nikt tego nie potrzebuje,
|
||||
mówimy o tym wprost przy starcie, zamiast budować machinerię na zapas.
|
||||
"""
|
||||
deklarujace = _zbierz("pola", [])
|
||||
if not deklarujace:
|
||||
return lambda: {}
|
||||
if len(deklarujace) > 1:
|
||||
raise RuntimeError(
|
||||
"Więcej niż jeden moduł deklaruje pola formularza. Trzeba je złożyć "
|
||||
"w jedną zależność — patrz komentarz w app/rozszerzenia.py.")
|
||||
return deklarujace[0]
|
||||
|
||||
|
||||
def kontekst_szablonu(request) -> dict:
|
||||
"""Co moduły dokładają do kontekstu szablonu. Bez modułów — nic."""
|
||||
out: dict = {}
|
||||
for funkcja in _zbierz("katalog_dla", []):
|
||||
out.update(funkcja(request))
|
||||
return out
|
||||
|
||||
|
||||
def obsluz(akcja: str, **dane):
|
||||
"""Wykonanie akcji modułu. None = żaden się do niej nie przyznaje.
|
||||
|
||||
Moduł może oddać słownik (trafi do kontekstu szablonu) albo gotową
|
||||
odpowiedź HTTP — na przykład plik do pobrania, który nie jest stroną."""
|
||||
for funkcja in _zbierz("obsluz", []):
|
||||
wynik = funkcja(akcja, **dane)
|
||||
if wynik is not None:
|
||||
return wynik
|
||||
return None
|
||||
|
||||
|
||||
def zamontuj(app, **zaleznosci) -> None:
|
||||
"""Podpięcie tras modułów i przekazanie im tego, czego potrzebują."""
|
||||
for funkcja in _zbierz("zamontuj", []):
|
||||
funkcja(app, **zaleznosci)
|
||||
|
||||
|
||||
def _katalogi(nazwa: str) -> list[str]:
|
||||
import pathlib
|
||||
|
||||
return [str(pathlib.Path(m.__file__).parent / nazwa) for m in _MODULY
|
||||
if (pathlib.Path(m.__file__).parent / nazwa).is_dir()]
|
||||
|
||||
|
||||
def katalog_szablonow() -> list[str]:
|
||||
"""Katalogi szablonów modułów — nakładane PRZED wspólnymi."""
|
||||
return _katalogi("templates")
|
||||
|
||||
|
||||
def katalog_zasobow() -> list[str]:
|
||||
return _katalogi("static")
|
||||
@@ -1,7 +1,7 @@
|
||||
"""Ochrona dostępu do aplikacji (LOG-32).
|
||||
|
||||
Rdzeniem produktu są oryginalne bazy interpretacyjne. Aplikacja podaje ich treść
|
||||
na wielu ścieżkach (`/significators`, `/interpret` i dalszych), więc BRAK
|
||||
na wielu ścieżkach (`/significators`, `/interpret`, generator promptu), więc BRAK
|
||||
uwierzytelnienia oznacza, że każdy w sieci może je wypompować — bez udziału
|
||||
jakiegokolwiek modelu językowego. Ten moduł zamyka tę drogę.
|
||||
|
||||
@@ -24,7 +24,7 @@ DZIENNIK AUDYTOWY (PRE-17). Każde żądanie do chronionej ścieżki zostawia wp
|
||||
kto, kiedy, jaka ścieżka, status, ile rekordów (gdy handler to poda przez
|
||||
`audit_records`). To jedyny sposób, by zauważyć POWOLNE wypompowywanie bazy przez
|
||||
osobę uprawnioną — pojedyncze zapytanie wygląda niewinnie, suma już nie.
|
||||
Świadomie NIE logujemy treści żądań ani rekordów — logi to kolejny
|
||||
Świadomie NIE logujemy treści żądań, promptów ani rekordów — logi to kolejny
|
||||
nośnik wycieku; liczby i metadane wystarczą do wykrycia nadużycia.
|
||||
|
||||
UWAGA: bez kont ochrona jest WYŁĄCZONA (zgodność wstecz i wygoda dev). Wtedy przy
|
||||
@@ -45,7 +45,7 @@ from collections import deque
|
||||
from dataclasses import dataclass
|
||||
|
||||
from fastapi import Request
|
||||
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
|
||||
from fastapi.responses import HTMLResponse, JSONResponse
|
||||
|
||||
log = logging.getLogger("astrololo.security")
|
||||
|
||||
@@ -114,35 +114,12 @@ def rate_limit_per_min() -> int:
|
||||
return int(os.getenv("RATE_LIMIT_PER_MIN", "120"))
|
||||
|
||||
|
||||
def cookies_secure() -> bool:
|
||||
"""Czy ciasteczko sesji ma być wyłącznie dla https.
|
||||
|
||||
Domyślnie TAK. Wyłączamy jedynie w pracy lokalnej po http — inaczej
|
||||
przeglądarka po prostu nie zapamięta ciasteczka i logowanie „nie działa"
|
||||
bez żadnego komunikatu, co jest wyjątkowo mylącą awarią."""
|
||||
return os.getenv("COOKIES_INSECURE", "").strip().lower() not in {"1", "true", "yes", "on"}
|
||||
|
||||
|
||||
def trust_proxy() -> bool:
|
||||
return os.getenv("TRUST_PROXY", "").strip().lower() in {"1", "true", "yes", "on"}
|
||||
|
||||
|
||||
# /wyloguj jest „publiczna" tylko technicznie: przechodzi obok bramki, żeby móc
|
||||
# odpowiedzieć 401 CELOWO, zamiast dostać 200 od zalogowanej sesji. Bez tego
|
||||
# wylogowanie byłoby niemożliwe — przeglądarka dosyła zapamiętane dane przy każdym
|
||||
# żądaniu, więc handler i tak widziałby zalogowaną osobę.
|
||||
# /logowanie MUSI stać poza bramką — inaczej żeby się zalogować, trzeba by być
|
||||
# zalogowanym. /wyloguj też: ma działać także wtedy, gdy sesja już wygasła.
|
||||
# Ekran logowania musi się wyświetlić PRZED zalogowaniem, więc jego arkusz jest
|
||||
# jedynym publicznym zasobem — i dlatego nie wolno w nim trzymać niczego, co
|
||||
# nazywa funkcję (patrz features.STATIC).
|
||||
PUBLIC_PATHS = frozenset({"/health", "/logowanie", "/wyloguj", "/static/base.css"})
|
||||
# Pusto CELOWO. Dopóki był tu "/static/", cały katalog omijał bramkę: każdy plik
|
||||
# JS i arkusz stylów pobierał ktokolwiek, także niezalogowany, pod zgadywalnym
|
||||
# adresem — a ich treść wymienia ekrany, dostawców modeli i przeznaczenie baz.
|
||||
# Ruch do zasobów nie trafiał przy tym ani do dziennika, ani pod limit żądań,
|
||||
# więc wyciek był dla właściciela niewidoczny.
|
||||
PUBLIC_PREFIXES: tuple[str, ...] = ()
|
||||
PUBLIC_PATHS = frozenset({"/health"})
|
||||
PUBLIC_PREFIXES = ("/static/",)
|
||||
|
||||
_hits: dict[str, deque[float]] = {}
|
||||
|
||||
@@ -165,99 +142,53 @@ class Principal:
|
||||
|
||||
|
||||
def _admin_permissions() -> frozenset[str]:
|
||||
"""Administrator widzi wszystko — z definicji, bez wypisywania listy ręcznie.
|
||||
"""Administrator widzi wszystko — z definicji, bez wpisywania listy ręcznie.
|
||||
|
||||
Liczone z katalogu, więc dopisanie funkcji NIE wymaga pamiętania o koncie
|
||||
administracyjnym. Przeciwnie byłoby cichą pułapką: nowa funkcja byłaby
|
||||
niewidoczna dla jedynej osoby, która ma ją komu nadać."""
|
||||
Liczone z katalogu, więc dopisanie nowej funkcji NIE wymaga pamiętania
|
||||
o koncie administracyjnym. Przeciwnie byłoby cichą pułapką: nowa funkcja
|
||||
byłaby niewidoczna dla jedynej osoby, która ma ją komu nadać."""
|
||||
from app import features
|
||||
|
||||
return frozenset(features.GRANTABLE) | {features.ADMIN}
|
||||
|
||||
|
||||
def _admin_spec(login: str) -> str | None:
|
||||
"""Sekret konta administracyjnego z KONFIGURACJI ŚRODOWISKA albo None.
|
||||
def principal(header: str | None) -> Principal | None:
|
||||
"""Nagłówek Basic → kto to jest i co mu wolno; None, gdy dane nie pasują.
|
||||
|
||||
Sprawdzane ZAWSZE PIERWSZE i bez dotykania pliku kont — to jest cała
|
||||
separacja konta administracyjnego (LOG-34):
|
||||
|
||||
* konto z pliku o tym samym loginie nie przesłoni administratora, bo do
|
||||
pliku w ogóle nie zaglądamy, gdy login pasuje do konfiguracji,
|
||||
* administrator zaloguje się nawet wtedy, gdy plik kont jest uszkodzony
|
||||
albo nieczytelny — czyli w jedynej sytuacji, w której ktoś musi wejść,
|
||||
żeby to naprawić. Trzymanie jego stanu w tym samym pliku dawałoby
|
||||
zakleszczenie: nie da się naprawić, bo nie da się wejść.
|
||||
"""
|
||||
return accounts().get(login)
|
||||
|
||||
|
||||
def verify(login: str, password: str) -> Principal | None:
|
||||
"""Sprawdza login i hasło. None = odmowa, bez podawania powodu.
|
||||
|
||||
Nieznany login i złe hasło dają ten sam wynik: rozróżnienie mówiłoby, które
|
||||
konta istnieją, a to informacja warta czegoś dla zgadującego."""
|
||||
spec = _admin_spec(login)
|
||||
if spec is not None:
|
||||
return Principal(login, _admin_permissions(), True) if _secret_matches(spec, password) else None
|
||||
|
||||
from app import accounts as store
|
||||
Kolejność: najpierw konta z KONFIGURACJI ŚRODOWISKA (administracyjne, pełne
|
||||
uprawnienia), potem konta zarządzane z ekranu. Nie odwrotnie — inaczej
|
||||
założenie w pliku konta o loginie administratora przesłoniłoby konto
|
||||
administracyjne i odebrało mu uprawnienia.
|
||||
|
||||
Nieznany login i złe hasło traktujemy tak samo: odmowa nie mówi, które konto
|
||||
istnieje."""
|
||||
if not header or not header.lower().startswith("basic "):
|
||||
return None
|
||||
try:
|
||||
zapisany = store.secret_of(login)
|
||||
except store.AccountsUnavailable:
|
||||
# Magazyn kont niedostępny — konta zarządzane nie mogą się zalogować,
|
||||
# ale administrator (wyżej) już przeszedł, więc jest kto to naprawi.
|
||||
raw = base64.b64decode(header.split(" ", 1)[1]).decode("utf-8")
|
||||
user, _, password = raw.partition(":")
|
||||
except (binascii.Error, UnicodeDecodeError, IndexError):
|
||||
return None
|
||||
if zapisany is None or not _secret_matches(zapisany, password):
|
||||
return None
|
||||
return Principal(login, store.permissions_of(login), False)
|
||||
|
||||
|
||||
def issue_session(login: str) -> str:
|
||||
"""Zawartość ciasteczka dla właśnie zalogowanego konta.
|
||||
|
||||
W ciasteczku ląduje ODCISK poświadczenia, dzięki czemu zmiana hasła albo
|
||||
skasowanie konta unieważnia jego sesje same z siebie — bez pamiętania o tym
|
||||
i bez żadnego magazynu sesji."""
|
||||
from app import accounts as store
|
||||
from app import session
|
||||
|
||||
spec = _admin_spec(login)
|
||||
spec = accounts().get(user)
|
||||
if spec is not None:
|
||||
return session.issue(login, session.fingerprint(spec), 0)
|
||||
return session.issue(login, session.fingerprint(store.secret_of(login) or ""),
|
||||
store.session_version(login))
|
||||
|
||||
|
||||
def principal(request: Request) -> Principal | None:
|
||||
"""Ciasteczko → kto to jest i co mu wolno. None = nie wpuszczać."""
|
||||
from app import session
|
||||
|
||||
dane = session.read(request.cookies.get(session.COOKIE))
|
||||
if dane is None:
|
||||
return None
|
||||
login = dane["login"]
|
||||
|
||||
spec = _admin_spec(login)
|
||||
if spec is not None:
|
||||
# Zmiana APP_PASSWORD ubija sesje administratora — to jest jego
|
||||
# odpowiednik „wyloguj mnie ze wszystkich urządzeń".
|
||||
if session.fingerprint(spec) != dane["odcisk"]:
|
||||
return None
|
||||
return Principal(login, _admin_permissions(), True)
|
||||
return (Principal(user, _admin_permissions(), True)
|
||||
if _secret_matches(spec, password) else None)
|
||||
|
||||
from app import accounts as store
|
||||
|
||||
try:
|
||||
zapisany = store.secret_of(login)
|
||||
wersja = store.session_version(login)
|
||||
except store.AccountsUnavailable:
|
||||
managed = store.secret_of(user)
|
||||
if managed is None:
|
||||
return None
|
||||
if zapisany is None or session.fingerprint(zapisany) != dane["odcisk"]:
|
||||
if not _secret_matches(managed, password):
|
||||
return None
|
||||
if wersja != dane["wersja"]:
|
||||
return None
|
||||
return Principal(login, store.permissions_of(login), False)
|
||||
return Principal(user, store.permissions_of(user), False)
|
||||
|
||||
|
||||
def authenticate(header: str | None) -> str | None:
|
||||
"""Sam LOGIN — do dziennika audytowego (PRE-17) i zgodności wstecz."""
|
||||
who = principal(header)
|
||||
return who.login if who else None
|
||||
|
||||
|
||||
def client_ip(request: Request) -> str:
|
||||
@@ -335,22 +266,6 @@ def audit_records(request: Request, count: int) -> None:
|
||||
pass
|
||||
|
||||
|
||||
def audit_login(request: Request, login: str, udane: bool) -> None:
|
||||
"""Zdarzenie logowania w dzienniku (PRE-17).
|
||||
|
||||
Nieudane próby są tu ważniejsze od udanych: pojedyncza nic nie znaczy, ale
|
||||
seria pod jednym adresem to jedyny widoczny ślad zgadywania haseł. Logujemy
|
||||
LOGIN, nigdy hasła ani jego fragmentu — dziennik to kolejny nośnik wycieku."""
|
||||
audit_log.info("AUDYT zdarzenie=%s user=%s ip=%s",
|
||||
"logowanie-ok" if udane else "logowanie-odmowa",
|
||||
login or "-", client_ip(request))
|
||||
|
||||
|
||||
def audit_logout(request: Request) -> None:
|
||||
audit_log.info("AUDYT zdarzenie=wylogowanie user=%s ip=%s",
|
||||
getattr(request.state, "user", "") or "-", client_ip(request))
|
||||
|
||||
|
||||
def _audit(request: Request, user: str, status: int, ms: float) -> None:
|
||||
records = getattr(request.state, "audit_records", None)
|
||||
audit_log.info(
|
||||
@@ -361,20 +276,8 @@ def _audit(request: Request, user: str, status: int, ms: float) -> None:
|
||||
|
||||
|
||||
def install(app) -> None:
|
||||
"""Podpina ochronę pod wszystkie ścieżki poza publicznymi."""
|
||||
from app import session
|
||||
|
||||
"""Podpina ochronę pod wszystkie ścieżki poza /health i /static."""
|
||||
_setup_audit_logging()
|
||||
|
||||
# FAIL-CLOSED. Usługa z kontami, ale bez klucza podpisu, nie umiałaby odróżnić
|
||||
# ważnej sesji od podrobionej. Lepiej, żeby nie wstała, niż żeby wpuszczała —
|
||||
# i lepiej teraz, przy starcie, niż przy pierwszym logowaniu człowieka.
|
||||
if auth_enabled() and not session.available():
|
||||
raise session.SessionError(
|
||||
"Konta są skonfigurowane, ale brakuje SESSION_SECRET — bez klucza "
|
||||
"podpisu sesje nie działają, a logowanie nie miałoby czym się bronić. "
|
||||
"Wygeneruj: openssl rand -hex 32")
|
||||
|
||||
if not auth_enabled():
|
||||
log.warning(
|
||||
"UWAGA: brak kont (APP_USERS / APP_PASSWORD) — aplikacja jest OTWARTA "
|
||||
@@ -404,27 +307,16 @@ def install(app) -> None:
|
||||
|
||||
from app import features
|
||||
|
||||
user, who, odswiez = "", None, None
|
||||
user, who = "", None
|
||||
if auth_enabled():
|
||||
who = principal(request)
|
||||
who = principal(request.headers.get("authorization"))
|
||||
if who is None:
|
||||
_audit(request, "-", 303, (time.monotonic() - started) * 1000)
|
||||
# Przekierowanie na ekran logowania, nie 401: 401 z Basic otwierało
|
||||
# okienko systemowe, którego nie da się ani opisać, ani z niego wyjść.
|
||||
# Zapamiętujemy, dokąd ktoś zmierzał — po zalogowaniu wraca na miejsce.
|
||||
from urllib.parse import quote
|
||||
|
||||
cel = request.url.path
|
||||
dokad = f"?dokad={quote(cel, safe='/')}" if request.method == "GET" and cel != "/" else ""
|
||||
return RedirectResponse(f"/logowanie{dokad}", status_code=303)
|
||||
_audit(request, "-", 401, (time.monotonic() - started) * 1000)
|
||||
return HTMLResponse(
|
||||
"<h1>401 — wymagane logowanie</h1>", status_code=401,
|
||||
headers={"WWW-Authenticate": 'Basic realm="astrololo"'},
|
||||
)
|
||||
user = who.login
|
||||
# Ruch przedłuża sesję, ale ciasteczko odsyłamy tylko wtedy, gdy
|
||||
# znacznik zdążył się zestarzeć — inaczej Set-Cookie leciałby przy
|
||||
# każdym obrazku i arkuszu stylów.
|
||||
from app import session as _s
|
||||
|
||||
dane = _s.read(request.cookies.get(_s.COOKIE))
|
||||
odswiez = _s.refresh(dane) if dane else None
|
||||
else:
|
||||
# Bez kont ochrona jest wyłączona (dev), więc widać wszystko — inaczej
|
||||
# deweloper zobaczyłby pustą aplikację i szukałby błędu tam, gdzie go nie ma.
|
||||
@@ -440,10 +332,5 @@ def install(app) -> None:
|
||||
_audit(request, user, 404, (time.monotonic() - started) * 1000)
|
||||
return HTMLResponse("<h1>404 — nie znaleziono</h1>", status_code=404)
|
||||
response = await call_next(request)
|
||||
if odswiez:
|
||||
from app import session as _s
|
||||
|
||||
response.set_cookie(_s.COOKIE, odswiez, max_age=_s.max_age(),
|
||||
**_s.cookie_params(secure=cookies_secure()))
|
||||
_audit(request, user, response.status_code, (time.monotonic() - started) * 1000)
|
||||
return response
|
||||
|
||||
@@ -1,183 +0,0 @@
|
||||
"""Sesje logowania — podpisane ciasteczko (LOG-34).
|
||||
|
||||
CO ZASTĘPUJE I DLACZEGO. HTTP Basic nie ma wylogowania: przeglądarka zapamiętuje
|
||||
hasło i dosyła je SAMA przy każdym żądaniu, więc serwer nie ma czego zapomnieć.
|
||||
Sesja odwraca tę zależność — to serwer decyduje, czy dana przeglądarka jest
|
||||
w środku, i może tę decyzję cofnąć.
|
||||
|
||||
TRZY POZIOMY UNIEWAŻNIENIA, celowo rozdzielone, bo każdy kosztuje co innego:
|
||||
|
||||
1. WYLOGOWANIE = skasowanie ciasteczka. Natychmiastowe, bez żadnego magazynu,
|
||||
działa wszędzie. To jest to, czego oczekuje człowiek klikający „Wyloguj".
|
||||
2. ZMIANA POŚWIADCZEŃ = odcisk hasła wpisany w ciasteczko przestaje pasować.
|
||||
Zmiana hasła albo skasowanie konta ubija jego sesje SAMO, bez pamiętania
|
||||
o tym — i też nie wymaga magazynu.
|
||||
3. WYLOGOWANIE ZDALNE („wyrzuć ze wszystkich urządzeń") = licznik wersji,
|
||||
który musi gdzieś leżeć. Wymaga zapisu, więc jest opcjonalny: gdy aplikacja
|
||||
nie poda licznika, poziomy 1 i 2 nadal działają.
|
||||
|
||||
Poziom 2 jest tu najważniejszy: bez niego odebranie komuś dostępu przez zmianę
|
||||
hasła zostawiałoby jego otwartą sesję żywą aż do wygaśnięcia — czyli odebranie
|
||||
dostępu nie odbierałoby dostępu.
|
||||
|
||||
KLUCZ JEST WYMAGANY i bez niego usługa się nie uruchamia. Losowanie przy starcie
|
||||
byłoby wygodne, ale oznaczałoby wylogowanie wszystkich przy każdym restarcie
|
||||
poda — co wygląda jak awaria i uczy ludzi ignorować ekran logowania.
|
||||
|
||||
Podpis: HMAC-SHA256 ze stdlib. Bez nowych zależności — ta sama linia co scrypt
|
||||
w PRE-27 i AES w PRE-16.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
|
||||
COOKIE = "astrololo_sesja"
|
||||
|
||||
# Twardy kres życia sesji i kres bezczynności. Oba w sekundach, oba z konfiguracji.
|
||||
DEFAULT_MAX_AGE = 30 * 24 * 3600 # 30 dni — po tylu i tak każe się zalogować
|
||||
DEFAULT_IDLE = 8 * 3600 # 8 godzin bez ruchu = koniec
|
||||
|
||||
# Co ile odświeżamy znacznik aktywności w ciasteczku. Bez tego progu każde
|
||||
# żądanie odsyłałoby Set-Cookie, także obrazki i arkusze stylów.
|
||||
REFRESH_AFTER = 300
|
||||
|
||||
|
||||
class SessionError(RuntimeError):
|
||||
"""Sesje nie mogą działać — brak klucza albo klucz nie do przyjęcia."""
|
||||
|
||||
|
||||
def _env_int(name: str, default: int) -> int:
|
||||
try:
|
||||
return int(os.getenv(name, "") or default)
|
||||
except ValueError:
|
||||
return default
|
||||
|
||||
|
||||
def max_age() -> int:
|
||||
return _env_int("SESSION_MAX_AGE", DEFAULT_MAX_AGE)
|
||||
|
||||
|
||||
def idle_timeout() -> int:
|
||||
return _env_int("SESSION_IDLE", DEFAULT_IDLE)
|
||||
|
||||
|
||||
def secret() -> bytes:
|
||||
"""Klucz podpisu. Brak = wyjątek, NIE cichy losowy klucz.
|
||||
|
||||
Fail-closed jest tu celowe: usługa bez klucza nie umie odróżnić ważnej sesji
|
||||
od podrobionej, więc lepiej, żeby nie wstała, niż żeby wpuszczała."""
|
||||
raw = os.getenv("SESSION_SECRET", "").strip()
|
||||
if not raw:
|
||||
raise SessionError(
|
||||
"Brak SESSION_SECRET — bez klucza podpisu sesje nie mogą działać. "
|
||||
"Wygeneruj: openssl rand -hex 32")
|
||||
if len(raw) < 32:
|
||||
raise SessionError(
|
||||
f"SESSION_SECRET ma {len(raw)} znaków — za krótki. Wymagane co najmniej 32; "
|
||||
f"krótki klucz da się odgadnąć, a wtedy podrobienie sesji jest trywialne.")
|
||||
return raw.encode("utf-8")
|
||||
|
||||
|
||||
def available() -> bool:
|
||||
"""Czy sesje da się w ogóle obsłużyć (do sprawdzenia przy starcie)."""
|
||||
try:
|
||||
secret()
|
||||
except SessionError:
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def fingerprint(secret_spec: str) -> str:
|
||||
"""Odcisk poświadczenia konta — 16 znaków hasza z hasła (albo jego hasza).
|
||||
|
||||
NIE JEST to hasło ani nic, z czego da się je odtworzyć: bierzemy skrót
|
||||
zapisanego sekretu, a ten dla kont zarządzanych sam jest już haszem scrypt.
|
||||
Do ciasteczka trafia po to, żeby zmiana hasła albo skasowanie konta
|
||||
unieważniły jego sesje same z siebie."""
|
||||
return hashlib.sha256(("odcisk:" + (secret_spec or "")).encode("utf-8")).hexdigest()[:16]
|
||||
|
||||
|
||||
def _sign(payload: bytes) -> bytes:
|
||||
return hmac.new(secret(), payload, hashlib.sha256).digest()
|
||||
|
||||
|
||||
def _b64(raw: bytes) -> str:
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def _unb64(text: str) -> bytes:
|
||||
return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
|
||||
|
||||
|
||||
def issue(login: str, odcisk: str, wersja: int = 0, *, now: float | None = None) -> str:
|
||||
"""Nowe ciasteczko sesji dla konta."""
|
||||
teraz = int(now if now is not None else time.time())
|
||||
payload = json.dumps(
|
||||
{"u": login, "f": odcisk, "v": int(wersja), "wyd": teraz, "akt": teraz},
|
||||
separators=(",", ":"), sort_keys=True).encode("utf-8")
|
||||
return f"{_b64(payload)}.{_b64(_sign(payload))}"
|
||||
|
||||
|
||||
def read(token: str | None, *, now: float | None = None) -> dict | None:
|
||||
"""Ciasteczko → zawartość albo None, gdy cokolwiek się nie zgadza.
|
||||
|
||||
None znaczy „nie wpuszczać" i nie mówi dlaczego — powód jest tu bez wartości
|
||||
dla wołającego, a rozróżnianie „zła sygnatura" od „wygasło" tylko pomaga
|
||||
zgadywać. Wygaśnięcie i tak kończy się tym samym ekranem logowania."""
|
||||
if not token or "." not in token:
|
||||
return None
|
||||
surowy, _, podpis = token.rpartition(".")
|
||||
try:
|
||||
payload = _unb64(surowy)
|
||||
oczekiwany = _sign(payload)
|
||||
podany = _unb64(podpis)
|
||||
except (ValueError, SessionError):
|
||||
return None
|
||||
# Porównanie w stałym czasie: zwykłe == przecieka informację o tym, ile
|
||||
# pierwszych bajtów podpisu się zgadza, a to wystarcza do podrobienia.
|
||||
if not hmac.compare_digest(oczekiwany, podany):
|
||||
return None
|
||||
try:
|
||||
dane = json.loads(payload.decode("utf-8"))
|
||||
login, odcisk = str(dane["u"]), str(dane["f"])
|
||||
wersja, wyd, akt = int(dane["v"]), int(dane["wyd"]), int(dane["akt"])
|
||||
except (ValueError, KeyError, TypeError):
|
||||
return None
|
||||
|
||||
teraz = int(now if now is not None else time.time())
|
||||
# Ciasteczko z przyszłości oznacza przestawiony zegar albo podrobienie —
|
||||
# w obu wypadkach nie ma powodu mu ufać.
|
||||
if wyd > teraz + 60:
|
||||
return None
|
||||
if teraz - wyd > max_age() or teraz - akt > idle_timeout():
|
||||
return None
|
||||
return {"login": login, "odcisk": odcisk, "wersja": wersja, "wydano": wyd, "aktywnosc": akt}
|
||||
|
||||
|
||||
def refresh(dane: dict, *, now: float | None = None) -> str | None:
|
||||
"""Odświeżone ciasteczko, gdy znacznik aktywności zdążył się zestarzeć.
|
||||
|
||||
None = nie ma potrzeby nic odsyłać. Bez tego progu każde żądanie zwracałoby
|
||||
Set-Cookie — także po arkusze stylów i obrazki."""
|
||||
teraz = int(now if now is not None else time.time())
|
||||
if teraz - dane["aktywnosc"] < REFRESH_AFTER:
|
||||
return None
|
||||
payload = json.dumps(
|
||||
{"u": dane["login"], "f": dane["odcisk"], "v": dane["wersja"],
|
||||
"wyd": dane["wydano"], "akt": teraz},
|
||||
separators=(",", ":"), sort_keys=True).encode("utf-8")
|
||||
return f"{_b64(payload)}.{_b64(_sign(payload))}"
|
||||
|
||||
|
||||
def cookie_params(secure: bool = True) -> dict:
|
||||
"""Ustawienia ciasteczka wspólne dla ustawiania i kasowania.
|
||||
|
||||
httponly — JavaScript nie ma po co go czytać, a bez tego jeden wstrzyknięty
|
||||
skrypt wynosi sesję. samesite=strict — odcina większość ataków polegających
|
||||
na tym, że obca strona wysyła żądanie w imieniu zalogowanego."""
|
||||
return {"httponly": True, "samesite": "strict", "secure": secure, "path": "/"}
|
||||
@@ -1,87 +0,0 @@
|
||||
/* Powłoka strony i ekran logowania — JEDYNY arkusz publiczny.
|
||||
Nie wolno tu wstawić niczego, co nazywa funkcję: ten plik pobiera
|
||||
każdy, także niezalogowany, bo potrzebuje go ekran logowania. */
|
||||
|
||||
:root {
|
||||
--bg: #0f1020;
|
||||
--panel: #1a1c33;
|
||||
--ink: #e8e8f0;
|
||||
--muted: #9aa0c0;
|
||||
--accent: #8b7bf0;
|
||||
--line: #2a2d4a;
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body {
|
||||
margin: 0; min-height: 100vh; background: var(--bg); color: var(--ink);
|
||||
font: 15px/1.5 system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
|
||||
display: flex; justify-content: center; padding: 3rem 1rem;
|
||||
}
|
||||
main { width: 100%; max-width: 880px; }
|
||||
h1 { margin: 0; font-size: 2rem; letter-spacing: .5px; }
|
||||
.topbar { display: flex; align-items: baseline; justify-content: space-between; gap: 1rem; flex-wrap: wrap; margin-bottom: .25rem; }
|
||||
.topbar nav { display: flex; gap: .25rem; }
|
||||
.topbar nav a { color: var(--muted); text-decoration: none; padding: .4rem .8rem; border-radius: 8px; border: 1px solid transparent; }
|
||||
.topbar nav a:hover { color: var(--ink); }
|
||||
.topbar nav a.active { color: #fff; background: var(--panel); border-color: var(--line); }
|
||||
.foot { color: var(--muted); font-size: .8rem; margin-top: 2.5rem; opacity: .7; }
|
||||
.actions { display: flex; gap: .5rem; margin-top: 1rem; }
|
||||
form { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 1.25rem; }
|
||||
input, select, button {
|
||||
font: inherit; padding: .6rem .75rem; border-radius: 8px;
|
||||
border: 1px solid var(--line); background: #12132a; color: var(--ink);
|
||||
}
|
||||
button { background: var(--accent); color: #fff; border: none; cursor: pointer; padding-inline: 1.25rem; }
|
||||
button:hover { filter: brightness(1.1); }
|
||||
.opts { display: flex; gap: 1.5rem; margin-top: .75rem; color: var(--muted); align-items: center; }
|
||||
.meta { color: var(--muted); margin: 1.5rem 0 .5rem; font-size: .9rem; }
|
||||
/* Fallback systemu domów. Celowo NIE jest to dyskretny „muted" — po fallbacku
|
||||
kosmogram wygląda bezbłędnie, więc ten akapit jest jedynym sygnałem, że
|
||||
podział domów pochodzi z innego systemu, niż zamówiono. */
|
||||
.notice-warn {
|
||||
margin: 1rem 0; padding: .75rem 1rem; font-size: .92rem; line-height: 1.45;
|
||||
border: 1px solid var(--warn-border, #b8860b);
|
||||
border-left-width: 4px;
|
||||
border-radius: 4px;
|
||||
background: var(--warn-bg, rgba(184, 134, 11, .10));
|
||||
color: var(--warn-fg, inherit);
|
||||
}
|
||||
table { width: 100%; border-collapse: collapse; margin-top: .5rem; background: var(--panel); border-radius: 12px; overflow: hidden; }
|
||||
th, td { text-align: left; padding: .6rem .8rem; border-bottom: 1px solid var(--line); }
|
||||
th { color: var(--accent); font-size: .8rem; text-transform: uppercase; letter-spacing: .5px; }
|
||||
tr:last-child td { border-bottom: none; }
|
||||
.muted { color: var(--muted); }
|
||||
.small { font-size: .85rem; }
|
||||
.nowrap { white-space: nowrap; }
|
||||
/* ── ekran kont (PRE-26) ────────────────────────────────────────────── */
|
||||
.card {
|
||||
margin-top: 1rem; padding: 1rem 1.25rem;
|
||||
background: var(--panel); border: 1px solid var(--line); border-radius: 12px;
|
||||
}
|
||||
.card .actions { margin-top: .9rem; }
|
||||
/* Potwierdzenie operacji. Odróżnia się od .notice-warn, bo tamto ostrzega,
|
||||
a to tylko potwierdza — pomylenie ich uczy ignorować oba. */
|
||||
.done-note {
|
||||
margin: 1rem 0; padding: .6rem .9rem; font-size: .9rem;
|
||||
border: 1px solid var(--line); border-left: 4px solid var(--accent);
|
||||
border-radius: 4px; background: rgba(255, 255, 255, .03);
|
||||
}
|
||||
/* ── wyjście z aplikacji (LOG-32) ───────────────────────────────────── */
|
||||
/* Odsunięte od zakładek i wyglądające inaczej niż one: to czynność, nie miejsce,
|
||||
a pomylenie go z zakładką kosztuje przypadkowe wylogowania. Odstęp robimy
|
||||
marginesem, nie rozpychaczem — `nav` ma szerokość treści, więc nie ma czego
|
||||
rozpychać. */
|
||||
.whoami { color: var(--muted); font-size: .85rem; align-self: center;
|
||||
margin-left: 1rem; padding-left: 1rem; border-left: 1px solid var(--line); }
|
||||
/* Wylogowanie idzie POST-em, więc jest przyciskiem — ale ma wyglądać jak
|
||||
reszta paska, nie jak przycisk akcji w formularzu. */
|
||||
.wyloguj-form { display: inline; margin: 0; padding: 0; background: none; border: none; }
|
||||
button.wyloguj {
|
||||
background: none; border: 1px solid transparent; color: var(--muted);
|
||||
font: inherit; padding: .4rem .8rem; border-radius: 8px; cursor: pointer;
|
||||
}
|
||||
button.wyloguj:hover { color: var(--ink); }
|
||||
/* Ekran logowania — wąski, bez nawigacji: nie ma dokąd iść przed zalogowaniem. */
|
||||
.login-main { max-width: 26rem; }
|
||||
.login-card label { display: block; margin-top: .75rem; }
|
||||
.login-card input { width: 100%; }
|
||||
.login-note { margin-top: 1.25rem; }
|
||||
@@ -2,10 +2,8 @@
|
||||
//
|
||||
// Raport ma trzy kawałki liczone w różnych miejscach:
|
||||
// 1. horoskop — liczy serwer przy wysłaniu tego formularza,
|
||||
// 2. interpretacja natalna — z zakładki Interpretacje,
|
||||
// 3. predykcje okresowe — z zakładki Kalendarz.
|
||||
// Kawałki 2 i 3 wnosi moduł opcjonalny. Gdy go nie ma, magazynów nie ma również
|
||||
// i czytanie ich zwraca pusto — raport składa się wtedy z samego horoskopu.
|
||||
// 2. interpretacja natalna — z zakładki Interpretacje (natal.js),
|
||||
// 3. predykcje okresowe — z zakładki Kalendarz (predictions.js).
|
||||
//
|
||||
// Punkty 2 i 3 mieszkają w magazynie przeglądarki, więc to tutaj je dokładamy.
|
||||
// Odczytujemy je przez API tamtych modułów, a nie sięgając wprost do
|
||||
@@ -88,7 +86,7 @@
|
||||
}
|
||||
|
||||
// ── PDF (PRE-24) ────────────────────────────────────────────────────
|
||||
// Te kawałki mieszkają w przeglądarce, więc raport składamy TU i wysyłamy
|
||||
// Części od AI mieszkają w przeglądarce, więc raport składamy TU i wysyłamy
|
||||
// do serwera, który dokłada kosmogram i woła usługę render.
|
||||
function formData() {
|
||||
function v(name) {
|
||||
|
||||
@@ -23,7 +23,7 @@
|
||||
// type: brak = zwykła wartość (.value); 'check' = pojedynczy checkbox (.checked);
|
||||
// 'multi' = kilka checkboxów o tej samej nazwie (lista zaznaczonych wartości).
|
||||
// Opcje (stacje, tabele, porównanie domów) są tu, żeby wybór z „Horoskopu"
|
||||
// wędrował na kolejny ekran — inaczej podsumowanie liczyłoby się bez nich.
|
||||
// wędrował na „Skompiluj" — inaczej podsumowanie liczyłoby się bez nich.
|
||||
var FIELDS = [
|
||||
{ key: 'person', sel: 'input[name=person]' },
|
||||
{ key: 'date', sel: 'input[name=date]' },
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
/* Arkusz ekranu „admin” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
.loc { margin-top: .8rem; }
|
||||
.loc summary { color: var(--muted); cursor: pointer; font-size: .85rem; margin-bottom: .6rem; }
|
||||
button.ghost { background: transparent; color: var(--accent); border: 1px solid var(--line); }
|
||||
.row { display: flex; gap: .5rem; }
|
||||
.row input[type=text] { flex: 1; }
|
||||
/* Lista systemów domów urosła z 3 do 13 pozycji. Na flexie zawijały się w cztery
|
||||
poszarpane wiersze o różnej długości; siatka o stałej szerokości kolumny ustawia
|
||||
nazwy w pionie i daje się przeczytać wzrokiem. auto-fill, więc na wąskim ekranie
|
||||
kolumn jest po prostu mniej. */
|
||||
.opts.systems { display: grid; grid-template-columns: repeat(auto-fill, minmax(11.5rem, 1fr));
|
||||
gap: .35rem 1rem; align-items: start; }
|
||||
.opts.systems > .opts-label { grid-column: 1 / -1; margin-bottom: .1rem; }
|
||||
.opts.systems label { display: flex; align-items: center; gap: .35rem; }
|
||||
.opts .hint { font-style: normal; opacity: .75; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
.account-head { display: flex; align-items: baseline; gap: .75rem; margin-bottom: .5rem; }
|
||||
.account-note input { width: 100%; }
|
||||
button.danger { background: #8b2f2f; }
|
||||
@@ -1,119 +0,0 @@
|
||||
/* Arkusz ekranu „chart” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
.loc { margin-top: .8rem; }
|
||||
.loc summary { color: var(--muted); cursor: pointer; font-size: .85rem; margin-bottom: .6rem; }
|
||||
button.ghost { background: transparent; color: var(--accent); border: 1px solid var(--line); }
|
||||
.mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .92em; }
|
||||
td.retro { color: #ff9b6a; font-weight: 600; }
|
||||
/* Glify astrologiczne (LOG-22). Trzy warstwy obrony przed prezentacją emoji
|
||||
(DAN-18: kolorowe kwadraty są nieczytelne i niesterowalne kolorem):
|
||||
1) selektor wariantu U+FE0E w samych danych (glyphs.py),
|
||||
2) font-variant-emoji:text — nowsza własność CSS,
|
||||
3) font-family celujący w MONOCHROMATYCZNE fonty symboli PRZED jakimkolwiek
|
||||
fontem emoji. Bez tego macOS/Chromium i tak sięga po Apple Color Emoji dla
|
||||
znaków zodiaku (♈–♓), mimo VS15 — potwierdzone wizualnie. „Apple Symbols",
|
||||
„Segoe UI Symbol", „Noto Sans Symbols2" mają te glify w wersji tekstowej. */
|
||||
.glyph { font-size: 1.15em; line-height: 1; font-variant-emoji: text;
|
||||
font-family: "Apple Symbols", "Segoe UI Symbol", "Noto Sans Symbols2",
|
||||
"DejaVu Sans", sans-serif; }
|
||||
td.glyph { color: var(--accent); white-space: nowrap; }
|
||||
/* Kosmogram (PRE-12) — SVG skaluje się do szerokości, ale nie rośnie w nieskończoność. */
|
||||
.wheel-fig { margin: 1.5rem 0 .5rem; text-align: center; }
|
||||
.wheel-fig svg.wheel { width: 100%; max-width: 460px; height: auto; }
|
||||
.wheel-fig figcaption { margin-top: .4rem; }
|
||||
/* glify wewnątrz SVG dziedziczą monochromatyczny stack fontów (DAN-18) */
|
||||
svg.wheel text.glyph { font-size: inherit; }
|
||||
/* Aspektarian (PRE-18) — trójkątna siatka aspektów, węższa od koła. */
|
||||
.aspectarian-fig { margin: .25rem 0 1.25rem; text-align: center; }
|
||||
.aspectarian-fig svg.aspectarian { width: 100%; max-width: 380px; height: auto; }
|
||||
.aspectarian-fig figcaption { margin-top: .4rem; }
|
||||
svg.aspectarian text.glyph { font-size: inherit; }
|
||||
/* Wykres deklinacji i oś antyscji (LOG-07, etap 6) — szersze, pełna szerokość. */
|
||||
.declination-fig, .antiscia-fig { margin: 1.25rem 0 .75rem; text-align: center; }
|
||||
.declination-fig svg.declination { width: 100%; max-width: 560px; height: auto; }
|
||||
.antiscia-fig svg.antiscia { width: 100%; max-width: 560px; height: auto; }
|
||||
.declination-fig figcaption, .antiscia-fig figcaption { margin-top: .4rem; }
|
||||
svg.declination text.glyph, svg.antiscia text.glyph { font-size: inherit; }
|
||||
/* Powiększenie na pełne okno (PRE-25). Kliknięcie rozciąga wykres na cały ekran,
|
||||
ponowne wraca. z-index 1100 CELOWO pomiędzy: ponad kontrolki Leafleta (1000),
|
||||
ale PONIŻEJ okna postępu (1200) — gdy trwa pisanie horoskopu, log operacji ma
|
||||
zostać na wierzchu. */
|
||||
.wheel-fig svg.wheel { cursor: zoom-in; }
|
||||
.wheel-fig svg.wheel:focus-visible { outline: 2px solid var(--accent); outline-offset: 4px; }
|
||||
.wheel-fig.zoomed {
|
||||
position: fixed; inset: 0; z-index: 1100; margin: 0;
|
||||
display: flex; flex-direction: column; align-items: center; justify-content: center;
|
||||
gap: .5rem; padding: 1rem; background: var(--bg);
|
||||
}
|
||||
/* min() po obu wymiarach: koło jest kwadratowe, więc ograniczamy je krótszym
|
||||
bokiem okna — inaczej na szerokim ekranie wystawałoby w pionie. */
|
||||
.wheel-fig.zoomed svg.wheel {
|
||||
max-width: min(96vw, 92vh); width: min(96vw, 92vh); height: auto; cursor: zoom-out;
|
||||
}
|
||||
body.wheel-zoom-open { overflow: hidden; }
|
||||
/* nie przewijaj treści pod spodem */
|
||||
/* Dymek kosmogramu. z-index 1150 CELOWO pomiędzy: ponad nakładką powiększonego
|
||||
koła (1100), żeby działał także po powiększeniu, ale PONIŻEJ okna postępu
|
||||
(1200), które ma zostać na wierzchu. pointer-events: none — dymek chodzi za
|
||||
kursorem i nie może sam siebie zasłonić ani przechwycić najechania. */
|
||||
.wheel-tip {
|
||||
position: fixed; z-index: 1150; pointer-events: none;
|
||||
max-width: 22rem; padding: .4rem .6rem;
|
||||
background: var(--panel); color: var(--fg, inherit);
|
||||
border: 1px solid var(--line); border-radius: 8px;
|
||||
font-size: .85rem; line-height: 1.35;
|
||||
box-shadow: 0 4px 14px rgba(0, 0, 0, .45);
|
||||
}
|
||||
.wheel-tip[hidden] { display: none; }
|
||||
/* Lista systemów domów urosła z 3 do 13 pozycji. Na flexie zawijały się w cztery
|
||||
poszarpane wiersze o różnej długości; siatka o stałej szerokości kolumny ustawia
|
||||
nazwy w pionie i daje się przeczytać wzrokiem. auto-fill, więc na wąskim ekranie
|
||||
kolumn jest po prostu mniej. */
|
||||
.opts.systems { display: grid; grid-template-columns: repeat(auto-fill, minmax(11.5rem, 1fr));
|
||||
gap: .35rem 1rem; align-items: start; }
|
||||
.opts.systems > .opts-label { grid-column: 1 / -1; margin-bottom: .1rem; }
|
||||
.opts.systems label { display: flex; align-items: center; gap: .35rem; }
|
||||
.opts .hint { font-style: normal; opacity: .75; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
/* Tabela porównania systemów domów ma tyle kolumn, ile zaznaczono systemów —
|
||||
przy komplecie trzynastu robi się 1520 px i ROZPYCHAŁA CAŁĄ STRONĘ (dokument
|
||||
1713 px przy oknie 1280 px, poziomy pasek przewijania na body). Przewijać ma
|
||||
się sama tabela, nigdy strona. */
|
||||
.table-scroll { overflow-x: auto; margin-top: .5rem; border-radius: 12px; }
|
||||
.table-scroll > table { margin-top: 0; border-radius: 0; }
|
||||
.table-scroll th, .table-scroll td { white-space: nowrap; }
|
||||
/* Numer domu przyklejony do lewej krawędzi: bez tego po przewinięciu w prawo
|
||||
nie wiadomo, który to wiersz. */
|
||||
.table-scroll th:first-child, .table-scroll td:first-child {
|
||||
position: sticky; left: 0; background: var(--panel); z-index: 1;
|
||||
box-shadow: 1px 0 0 var(--line);
|
||||
}
|
||||
.badge { display: inline-block; font-size: .72rem; padding: .05rem .4rem; border-radius: 6px;
|
||||
background: #2a2d4a; color: var(--accent); margin-left: .3rem; }
|
||||
/* Wyszukiwarka lokalizacji + mapa (OSM/Leaflet) */
|
||||
.geo { margin-top: .9rem; }
|
||||
.geo-search { display: flex; gap: .5rem; flex-wrap: wrap; }
|
||||
.geo-search input[type=search] { flex: 1; min-width: 12rem; }
|
||||
.geo-results { list-style: none; margin: .4rem 0 0; padding: 0; border: 1px solid var(--line);
|
||||
border-radius: 8px; overflow: hidden; background: #12132a; max-height: 14rem; overflow-y: auto; }
|
||||
.geo-results li { padding: .5rem .75rem; cursor: pointer; border-bottom: 1px solid var(--line); font-size: .9rem; }
|
||||
.geo-results li:last-child { border-bottom: none; }
|
||||
.geo-results li:hover { background: var(--panel); color: #fff; }
|
||||
.geo-map { height: 320px; margin-top: .6rem; border: 1px solid var(--line); border-radius: 10px; }
|
||||
.geo-map[hidden] { display: none; }
|
||||
.geo-attrib { margin: .4rem 0 0; }
|
||||
.geo-attrib a { color: var(--accent); }
|
||||
.geo-pin { font-size: 20px; line-height: 24px; text-align: center; }
|
||||
/* kafelki OSM są jasne — trzymamy kontrolki czytelne na ciemnym tle */
|
||||
.leaflet-control-attribution { font-size: .68rem; }
|
||||
button.toggle {
|
||||
background: none; border: 1px solid var(--line); border-radius: 50%;
|
||||
width: 1.9rem; height: 1.9rem; padding: 0; font-size: 1rem; line-height: 1;
|
||||
}
|
||||
button.toggle.on { color: var(--accent); border-color: var(--accent); }
|
||||
button.toggle.off { color: var(--muted); }
|
||||
@@ -1,114 +0,0 @@
|
||||
/* Arkusz ekranu „compile” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
.loc { margin-top: .8rem; }
|
||||
.loc summary { color: var(--muted); cursor: pointer; font-size: .85rem; margin-bottom: .6rem; }
|
||||
button.ghost { background: transparent; color: var(--accent); border: 1px solid var(--line); }
|
||||
.mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .92em; }
|
||||
td.retro { color: #ff9b6a; font-weight: 600; }
|
||||
/* Glify astrologiczne (LOG-22). Trzy warstwy obrony przed prezentacją emoji
|
||||
(DAN-18: kolorowe kwadraty są nieczytelne i niesterowalne kolorem):
|
||||
1) selektor wariantu U+FE0E w samych danych (glyphs.py),
|
||||
2) font-variant-emoji:text — nowsza własność CSS,
|
||||
3) font-family celujący w MONOCHROMATYCZNE fonty symboli PRZED jakimkolwiek
|
||||
fontem emoji. Bez tego macOS/Chromium i tak sięga po Apple Color Emoji dla
|
||||
znaków zodiaku (♈–♓), mimo VS15 — potwierdzone wizualnie. „Apple Symbols",
|
||||
„Segoe UI Symbol", „Noto Sans Symbols2" mają te glify w wersji tekstowej. */
|
||||
.glyph { font-size: 1.15em; line-height: 1; font-variant-emoji: text;
|
||||
font-family: "Apple Symbols", "Segoe UI Symbol", "Noto Sans Symbols2",
|
||||
"DejaVu Sans", sans-serif; }
|
||||
td.glyph { color: var(--accent); white-space: nowrap; }
|
||||
/* Kosmogram (PRE-12) — SVG skaluje się do szerokości, ale nie rośnie w nieskończoność. */
|
||||
.wheel-fig { margin: 1.5rem 0 .5rem; text-align: center; }
|
||||
.wheel-fig svg.wheel { width: 100%; max-width: 460px; height: auto; }
|
||||
.wheel-fig figcaption { margin-top: .4rem; }
|
||||
/* glify wewnątrz SVG dziedziczą monochromatyczny stack fontów (DAN-18) */
|
||||
svg.wheel text.glyph { font-size: inherit; }
|
||||
/* Aspektarian (PRE-18) — trójkątna siatka aspektów, węższa od koła. */
|
||||
.aspectarian-fig { margin: .25rem 0 1.25rem; text-align: center; }
|
||||
.aspectarian-fig svg.aspectarian { width: 100%; max-width: 380px; height: auto; }
|
||||
.aspectarian-fig figcaption { margin-top: .4rem; }
|
||||
svg.aspectarian text.glyph { font-size: inherit; }
|
||||
/* Wykres deklinacji i oś antyscji (LOG-07, etap 6) — szersze, pełna szerokość. */
|
||||
.declination-fig, .antiscia-fig { margin: 1.25rem 0 .75rem; text-align: center; }
|
||||
.declination-fig svg.declination { width: 100%; max-width: 560px; height: auto; }
|
||||
.antiscia-fig svg.antiscia { width: 100%; max-width: 560px; height: auto; }
|
||||
.declination-fig figcaption, .antiscia-fig figcaption { margin-top: .4rem; }
|
||||
svg.declination text.glyph, svg.antiscia text.glyph { font-size: inherit; }
|
||||
/* Powiększenie na pełne okno (PRE-25). Kliknięcie rozciąga wykres na cały ekran,
|
||||
ponowne wraca. z-index 1100 CELOWO pomiędzy: ponad kontrolki Leafleta (1000),
|
||||
ale PONIŻEJ okna postępu (1200) — gdy trwa pisanie horoskopu, log operacji ma
|
||||
zostać na wierzchu. */
|
||||
.wheel-fig svg.wheel { cursor: zoom-in; }
|
||||
.wheel-fig svg.wheel:focus-visible { outline: 2px solid var(--accent); outline-offset: 4px; }
|
||||
.wheel-fig.zoomed {
|
||||
position: fixed; inset: 0; z-index: 1100; margin: 0;
|
||||
display: flex; flex-direction: column; align-items: center; justify-content: center;
|
||||
gap: .5rem; padding: 1rem; background: var(--bg);
|
||||
}
|
||||
/* min() po obu wymiarach: koło jest kwadratowe, więc ograniczamy je krótszym
|
||||
bokiem okna — inaczej na szerokim ekranie wystawałoby w pionie. */
|
||||
.wheel-fig.zoomed svg.wheel {
|
||||
max-width: min(96vw, 92vh); width: min(96vw, 92vh); height: auto; cursor: zoom-out;
|
||||
}
|
||||
body.wheel-zoom-open { overflow: hidden; }
|
||||
/* nie przewijaj treści pod spodem */
|
||||
/* Dymek kosmogramu. z-index 1150 CELOWO pomiędzy: ponad nakładką powiększonego
|
||||
koła (1100), żeby działał także po powiększeniu, ale PONIŻEJ okna postępu
|
||||
(1200), które ma zostać na wierzchu. pointer-events: none — dymek chodzi za
|
||||
kursorem i nie może sam siebie zasłonić ani przechwycić najechania. */
|
||||
.wheel-tip {
|
||||
position: fixed; z-index: 1150; pointer-events: none;
|
||||
max-width: 22rem; padding: .4rem .6rem;
|
||||
background: var(--panel); color: var(--fg, inherit);
|
||||
border: 1px solid var(--line); border-radius: 8px;
|
||||
font-size: .85rem; line-height: 1.35;
|
||||
box-shadow: 0 4px 14px rgba(0, 0, 0, .45);
|
||||
}
|
||||
.wheel-tip[hidden] { display: none; }
|
||||
/* Lista systemów domów urosła z 3 do 13 pozycji. Na flexie zawijały się w cztery
|
||||
poszarpane wiersze o różnej długości; siatka o stałej szerokości kolumny ustawia
|
||||
nazwy w pionie i daje się przeczytać wzrokiem. auto-fill, więc na wąskim ekranie
|
||||
kolumn jest po prostu mniej. */
|
||||
.opts.systems { display: grid; grid-template-columns: repeat(auto-fill, minmax(11.5rem, 1fr));
|
||||
gap: .35rem 1rem; align-items: start; }
|
||||
.opts.systems > .opts-label { grid-column: 1 / -1; margin-bottom: .1rem; }
|
||||
.opts.systems label { display: flex; align-items: center; gap: .35rem; }
|
||||
.opts .hint { font-style: normal; opacity: .75; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
/* Tabela porównania systemów domów ma tyle kolumn, ile zaznaczono systemów —
|
||||
przy komplecie trzynastu robi się 1520 px i ROZPYCHAŁA CAŁĄ STRONĘ (dokument
|
||||
1713 px przy oknie 1280 px, poziomy pasek przewijania na body). Przewijać ma
|
||||
się sama tabela, nigdy strona. */
|
||||
.table-scroll { overflow-x: auto; margin-top: .5rem; border-radius: 12px; }
|
||||
.table-scroll > table { margin-top: 0; border-radius: 0; }
|
||||
.table-scroll th, .table-scroll td { white-space: nowrap; }
|
||||
/* Numer domu przyklejony do lewej krawędzi: bez tego po przewinięciu w prawo
|
||||
nie wiadomo, który to wiersz. */
|
||||
.table-scroll th:first-child, .table-scroll td:first-child {
|
||||
position: sticky; left: 0; background: var(--panel); z-index: 1;
|
||||
box-shadow: 1px 0 0 var(--line);
|
||||
}
|
||||
.badge { display: inline-block; font-size: .72rem; padding: .05rem .4rem; border-radius: 6px;
|
||||
background: #2a2d4a; color: var(--accent); margin-left: .3rem; }
|
||||
/* Zakładka „Skompiluj" (PRE-23) — składanie raportu z trzech źródeł. */
|
||||
.readiness { list-style: none; margin: .3rem 0 1rem; padding: 0; }
|
||||
.readiness li { padding: .2rem 0; }
|
||||
.readiness .rdy-ok { color: #7fd18b; }
|
||||
.readiness .rdy-missing { color: #e0c060; }
|
||||
.report-head { margin: 1.5rem 0 .5rem; }
|
||||
.report-head h2 { margin: 0; font-size: 1.4rem; }
|
||||
/* Bloki tekstu bywają długie — white-space:pre-wrap zachowuje akapity
|
||||
bez przepisywania ich na HTML. */
|
||||
.report-text { white-space: pre-wrap; background: var(--panel); border: 1px solid var(--line);
|
||||
border-radius: 10px; padding: .8rem 1rem; margin-top: .4rem; line-height: 1.6; }
|
||||
button.toggle {
|
||||
background: none; border: 1px solid var(--line); border-radius: 50%;
|
||||
width: 1.9rem; height: 1.9rem; padding: 0; font-size: 1rem; line-height: 1;
|
||||
}
|
||||
button.toggle.on { color: var(--accent); border-color: var(--accent); }
|
||||
button.toggle.off { color: var(--muted); }
|
||||
@@ -1,36 +0,0 @@
|
||||
/* Arkusz ekranu „files” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
button.ghost { background: transparent; color: var(--accent); border: 1px solid var(--line); }
|
||||
.mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .92em; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
/* Tabela porównania systemów domów ma tyle kolumn, ile zaznaczono systemów —
|
||||
przy komplecie trzynastu robi się 1520 px i ROZPYCHAŁA CAŁĄ STRONĘ (dokument
|
||||
1713 px przy oknie 1280 px, poziomy pasek przewijania na body). Przewijać ma
|
||||
się sama tabela, nigdy strona. */
|
||||
.table-scroll { overflow-x: auto; margin-top: .5rem; border-radius: 12px; }
|
||||
.table-scroll > table { margin-top: 0; border-radius: 0; }
|
||||
.table-scroll th, .table-scroll td { white-space: nowrap; }
|
||||
/* Numer domu przyklejony do lewej krawędzi: bez tego po przewinięciu w prawo
|
||||
nie wiadomo, który to wiersz. */
|
||||
.table-scroll th:first-child, .table-scroll td:first-child {
|
||||
position: sticky; left: 0; background: var(--panel); z-index: 1;
|
||||
box-shadow: 1px 0 0 var(--line);
|
||||
}
|
||||
button.danger { background: #8b2f2f; }
|
||||
/* ── ekran plików (DAN-27) ──────────────────────────────────────────── */
|
||||
form.inline { display: inline; }
|
||||
td.ops form.inline + form.inline { margin-left: .4rem; }
|
||||
button.toggle {
|
||||
background: none; border: 1px solid var(--line); border-radius: 50%;
|
||||
width: 1.9rem; height: 1.9rem; padding: 0; font-size: 1rem; line-height: 1;
|
||||
}
|
||||
button.toggle.on { color: var(--accent); border-color: var(--accent); }
|
||||
button.toggle.off { color: var(--muted); }
|
||||
tr.row-archived td { opacity: .55; }
|
||||
/* Wstrzymane widzi tylko administrator — dla reszty tych wierszy nie ma
|
||||
w ogóle w odpowiedzi, więc ten styl nigdy nie dotyczy ich strony. */
|
||||
tr.row-held td { background: rgba(184, 134, 11, .07); }
|
||||
@@ -1,36 +0,0 @@
|
||||
/* Arkusz ekranu „interpret” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
button.ghost { background: transparent; color: var(--accent); border: 1px solid var(--line); }
|
||||
td.retro { color: #ff9b6a; font-weight: 600; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
.sig-item { margin-top: 1.25rem; }
|
||||
.sig-head { padding: .5rem 0; }
|
||||
.samples { margin-top: .3rem; }
|
||||
.samples td { font-size: .92rem; vertical-align: top; }
|
||||
.samples td.nowrap { color: var(--accent); padding-right: 1rem; }
|
||||
.facet { margin: .4rem 0 .6rem 1rem; }
|
||||
.facet-head { color: var(--ink); font-size: .9rem; }
|
||||
.badge { display: inline-block; font-size: .72rem; padding: .05rem .4rem; border-radius: 6px;
|
||||
background: #2a2d4a; color: var(--accent); margin-left: .3rem; }
|
||||
.samples td.sig { color: var(--accent); padding-right: 1rem; cursor: help; }
|
||||
/* Wyszukiwarka lokalizacji + mapa (OSM/Leaflet) */
|
||||
.geo { margin-top: .9rem; }
|
||||
.geo-search { display: flex; gap: .5rem; flex-wrap: wrap; }
|
||||
.geo-search input[type=search] { flex: 1; min-width: 12rem; }
|
||||
.geo-results { list-style: none; margin: .4rem 0 0; padding: 0; border: 1px solid var(--line);
|
||||
border-radius: 8px; overflow: hidden; background: #12132a; max-height: 14rem; overflow-y: auto; }
|
||||
.geo-results li { padding: .5rem .75rem; cursor: pointer; border-bottom: 1px solid var(--line); font-size: .9rem; }
|
||||
.geo-results li:last-child { border-bottom: none; }
|
||||
.geo-results li:hover { background: var(--panel); color: #fff; }
|
||||
.geo-map { height: 320px; margin-top: .6rem; border: 1px solid var(--line); border-radius: 10px; }
|
||||
.geo-map[hidden] { display: none; }
|
||||
.geo-attrib { margin: .4rem 0 0; }
|
||||
.geo-attrib a { color: var(--accent); }
|
||||
.geo-pin { font-size: 20px; line-height: 24px; text-align: center; }
|
||||
/* kafelki OSM są jasne — trzymamy kontrolki czytelne na ciemnym tle */
|
||||
.leaflet-control-attribution { font-size: .68rem; }
|
||||
@@ -1,7 +0,0 @@
|
||||
/* Arkusz ekranu „settings” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
.mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .92em; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
.badge { display: inline-block; font-size: .72rem; padding: .05rem .4rem; border-radius: 6px;
|
||||
background: #2a2d4a; color: var(--accent); margin-left: .3rem; }
|
||||
@@ -1,8 +0,0 @@
|
||||
/* Arkusz ekranu „significators” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
.row { display: flex; gap: .5rem; }
|
||||
.row input[type=text] { flex: 1; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
.empty { color: var(--muted); }
|
||||
@@ -1,23 +0,0 @@
|
||||
/* Arkusz ekranu „synastry” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
.mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .92em; }
|
||||
td.retro { color: #ff9b6a; font-weight: 600; }
|
||||
/* Glify astrologiczne (LOG-22). Trzy warstwy obrony przed prezentacją emoji
|
||||
(DAN-18: kolorowe kwadraty są nieczytelne i niesterowalne kolorem):
|
||||
1) selektor wariantu U+FE0E w samych danych (glyphs.py),
|
||||
2) font-variant-emoji:text — nowsza własność CSS,
|
||||
3) font-family celujący w MONOCHROMATYCZNE fonty symboli PRZED jakimkolwiek
|
||||
fontem emoji. Bez tego macOS/Chromium i tak sięga po Apple Color Emoji dla
|
||||
znaków zodiaku (♈–♓), mimo VS15 — potwierdzone wizualnie. „Apple Symbols",
|
||||
„Segoe UI Symbol", „Noto Sans Symbols2" mają te glify w wersji tekstowej. */
|
||||
.glyph { font-size: 1.15em; line-height: 1; font-variant-emoji: text;
|
||||
font-family: "Apple Symbols", "Segoe UI Symbol", "Noto Sans Symbols2",
|
||||
"DejaVu Sans", sans-serif; }
|
||||
td.glyph { color: var(--accent); white-space: nowrap; }
|
||||
svg.aspectarian text.glyph { font-size: inherit; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
@@ -1,33 +0,0 @@
|
||||
/* Arkusz ekranu „timeline” — dokładany tylko dla konta z tym uprawnieniem. */
|
||||
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
button.ghost { background: transparent; color: var(--accent); border: 1px solid var(--line); }
|
||||
td.retro { color: #ff9b6a; font-weight: 600; }
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
.sig-item { margin-top: 1.25rem; }
|
||||
.sig-head { padding: .5rem 0; }
|
||||
.samples { margin-top: .3rem; }
|
||||
.samples td { font-size: .92rem; vertical-align: top; }
|
||||
.samples td.nowrap { color: var(--accent); padding-right: 1rem; }
|
||||
.badge { display: inline-block; font-size: .72rem; padding: .05rem .4rem; border-radius: 6px;
|
||||
background: #2a2d4a; color: var(--accent); margin-left: .3rem; }
|
||||
.samples td.sig { color: var(--accent); padding-right: 1rem; cursor: help; }
|
||||
/* Wyszukiwarka lokalizacji + mapa (OSM/Leaflet) */
|
||||
.geo { margin-top: .9rem; }
|
||||
.geo-search { display: flex; gap: .5rem; flex-wrap: wrap; }
|
||||
.geo-search input[type=search] { flex: 1; min-width: 12rem; }
|
||||
.geo-results { list-style: none; margin: .4rem 0 0; padding: 0; border: 1px solid var(--line);
|
||||
border-radius: 8px; overflow: hidden; background: #12132a; max-height: 14rem; overflow-y: auto; }
|
||||
.geo-results li { padding: .5rem .75rem; cursor: pointer; border-bottom: 1px solid var(--line); font-size: .9rem; }
|
||||
.geo-results li:last-child { border-bottom: none; }
|
||||
.geo-results li:hover { background: var(--panel); color: #fff; }
|
||||
.geo-map { height: 320px; margin-top: .6rem; border: 1px solid var(--line); border-radius: 10px; }
|
||||
.geo-map[hidden] { display: none; }
|
||||
.geo-attrib { margin: .4rem 0 0; }
|
||||
.geo-attrib a { color: var(--accent); }
|
||||
.geo-pin { font-size: 20px; line-height: 24px; text-align: center; }
|
||||
/* kafelki OSM są jasne — trzymamy kontrolki czytelne na ciemnym tle */
|
||||
.leaflet-control-attribution { font-size: .68rem; }
|
||||
@@ -0,0 +1,249 @@
|
||||
:root {
|
||||
--bg: #0f1020;
|
||||
--panel: #1a1c33;
|
||||
--ink: #e8e8f0;
|
||||
--muted: #9aa0c0;
|
||||
--accent: #8b7bf0;
|
||||
--line: #2a2d4a;
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body {
|
||||
margin: 0; min-height: 100vh; background: var(--bg); color: var(--ink);
|
||||
font: 15px/1.5 system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
|
||||
display: flex; justify-content: center; padding: 3rem 1rem;
|
||||
}
|
||||
main { width: 100%; max-width: 880px; }
|
||||
h1 { margin: 0; font-size: 2rem; letter-spacing: .5px; }
|
||||
.sub { color: var(--muted); margin: .25rem 0 2rem; }
|
||||
|
||||
.topbar { display: flex; align-items: baseline; justify-content: space-between; gap: 1rem; flex-wrap: wrap; margin-bottom: .25rem; }
|
||||
.topbar nav { display: flex; gap: .25rem; }
|
||||
.topbar nav a { color: var(--muted); text-decoration: none; padding: .4rem .8rem; border-radius: 8px; border: 1px solid transparent; }
|
||||
.topbar nav a:hover { color: var(--ink); }
|
||||
.topbar nav a.active { color: #fff; background: var(--panel); border-color: var(--line); }
|
||||
.foot { color: var(--muted); font-size: .8rem; margin-top: 2.5rem; opacity: .7; }
|
||||
|
||||
.grid { display: flex; gap: .6rem; flex-wrap: wrap; }
|
||||
.grid label { display: flex; flex-direction: column; gap: .25rem; color: var(--muted); font-size: .85rem; flex: 1; min-width: 9rem; }
|
||||
.grid input { width: 100%; }
|
||||
.loc { margin-top: .8rem; }
|
||||
.loc summary { color: var(--muted); cursor: pointer; font-size: .85rem; margin-bottom: .6rem; }
|
||||
.actions { display: flex; gap: .5rem; margin-top: 1rem; }
|
||||
button.ghost { background: transparent; color: var(--accent); border: 1px solid var(--line); }
|
||||
.mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .92em; }
|
||||
td.retro { color: #ff9b6a; font-weight: 600; }
|
||||
/* Glify astrologiczne (LOG-22). Trzy warstwy obrony przed prezentacją emoji
|
||||
(DAN-18: kolorowe kwadraty są nieczytelne i niesterowalne kolorem):
|
||||
1) selektor wariantu U+FE0E w samych danych (glyphs.py),
|
||||
2) font-variant-emoji:text — nowsza własność CSS,
|
||||
3) font-family celujący w MONOCHROMATYCZNE fonty symboli PRZED jakimkolwiek
|
||||
fontem emoji. Bez tego macOS/Chromium i tak sięga po Apple Color Emoji dla
|
||||
znaków zodiaku (♈–♓), mimo VS15 — potwierdzone wizualnie. „Apple Symbols",
|
||||
„Segoe UI Symbol", „Noto Sans Symbols2" mają te glify w wersji tekstowej. */
|
||||
.glyph { font-size: 1.15em; line-height: 1; font-variant-emoji: text;
|
||||
font-family: "Apple Symbols", "Segoe UI Symbol", "Noto Sans Symbols2",
|
||||
"DejaVu Sans", sans-serif; }
|
||||
td.glyph { color: var(--accent); white-space: nowrap; }
|
||||
/* Kosmogram (PRE-12) — SVG skaluje się do szerokości, ale nie rośnie w nieskończoność. */
|
||||
.wheel-fig { margin: 1.5rem 0 .5rem; text-align: center; }
|
||||
.wheel-fig svg.wheel { width: 100%; max-width: 460px; height: auto; }
|
||||
.wheel-fig figcaption { margin-top: .4rem; }
|
||||
/* glify wewnątrz SVG dziedziczą monochromatyczny stack fontów (DAN-18) */
|
||||
svg.wheel text.glyph { font-size: inherit; }
|
||||
|
||||
/* Aspektarian (PRE-18) — trójkątna siatka aspektów, węższa od koła. */
|
||||
.aspectarian-fig { margin: .25rem 0 1.25rem; text-align: center; }
|
||||
.aspectarian-fig svg.aspectarian { width: 100%; max-width: 380px; height: auto; }
|
||||
.aspectarian-fig figcaption { margin-top: .4rem; }
|
||||
svg.aspectarian text.glyph { font-size: inherit; }
|
||||
|
||||
/* Wykres deklinacji i oś antyscji (LOG-07, etap 6) — szersze, pełna szerokość. */
|
||||
.declination-fig, .antiscia-fig { margin: 1.25rem 0 .75rem; text-align: center; }
|
||||
.declination-fig svg.declination { width: 100%; max-width: 560px; height: auto; }
|
||||
.antiscia-fig svg.antiscia { width: 100%; max-width: 560px; height: auto; }
|
||||
.declination-fig figcaption, .antiscia-fig figcaption { margin-top: .4rem; }
|
||||
svg.declination text.glyph, svg.antiscia text.glyph { font-size: inherit; }
|
||||
|
||||
/* Powiększenie na pełne okno (PRE-25). Kliknięcie rozciąga wykres na cały ekran,
|
||||
ponowne wraca. z-index 1100 CELOWO pomiędzy: ponad kontrolki Leafleta (1000),
|
||||
ale PONIŻEJ okna postępu (1200) — gdy trwa pisanie horoskopu, log operacji ma
|
||||
zostać na wierzchu. */
|
||||
.wheel-fig svg.wheel { cursor: zoom-in; }
|
||||
.wheel-fig svg.wheel:focus-visible { outline: 2px solid var(--accent); outline-offset: 4px; }
|
||||
.wheel-fig.zoomed {
|
||||
position: fixed; inset: 0; z-index: 1100; margin: 0;
|
||||
display: flex; flex-direction: column; align-items: center; justify-content: center;
|
||||
gap: .5rem; padding: 1rem; background: var(--bg);
|
||||
}
|
||||
/* min() po obu wymiarach: koło jest kwadratowe, więc ograniczamy je krótszym
|
||||
bokiem okna — inaczej na szerokim ekranie wystawałoby w pionie. */
|
||||
.wheel-fig.zoomed svg.wheel {
|
||||
max-width: min(96vw, 92vh); width: min(96vw, 92vh); height: auto; cursor: zoom-out;
|
||||
}
|
||||
body.wheel-zoom-open { overflow: hidden; } /* nie przewijaj treści pod spodem */
|
||||
|
||||
/* Dymek kosmogramu. z-index 1150 CELOWO pomiędzy: ponad nakładką powiększonego
|
||||
koła (1100), żeby działał także po powiększeniu, ale PONIŻEJ okna postępu
|
||||
(1200), które ma zostać na wierzchu. pointer-events: none — dymek chodzi za
|
||||
kursorem i nie może sam siebie zasłonić ani przechwycić najechania. */
|
||||
.wheel-tip {
|
||||
position: fixed; z-index: 1150; pointer-events: none;
|
||||
max-width: 22rem; padding: .4rem .6rem;
|
||||
background: var(--panel); color: var(--fg, inherit);
|
||||
border: 1px solid var(--line); border-radius: 8px;
|
||||
font-size: .85rem; line-height: 1.35;
|
||||
box-shadow: 0 4px 14px rgba(0, 0, 0, .45);
|
||||
}
|
||||
.wheel-tip[hidden] { display: none; }
|
||||
form { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 1.25rem; }
|
||||
.row { display: flex; gap: .5rem; }
|
||||
.row input[type=text] { flex: 1; }
|
||||
input, select, button {
|
||||
font: inherit; padding: .6rem .75rem; border-radius: 8px;
|
||||
border: 1px solid var(--line); background: #12132a; color: var(--ink);
|
||||
}
|
||||
button { background: var(--accent); color: #fff; border: none; cursor: pointer; padding-inline: 1.25rem; }
|
||||
button:hover { filter: brightness(1.1); }
|
||||
.opts { display: flex; gap: 1.5rem; margin-top: .75rem; color: var(--muted); align-items: center; }
|
||||
|
||||
/* Lista systemów domów urosła z 3 do 13 pozycji. Na flexie zawijały się w cztery
|
||||
poszarpane wiersze o różnej długości; siatka o stałej szerokości kolumny ustawia
|
||||
nazwy w pionie i daje się przeczytać wzrokiem. auto-fill, więc na wąskim ekranie
|
||||
kolumn jest po prostu mniej. */
|
||||
.opts.systems { display: grid; grid-template-columns: repeat(auto-fill, minmax(11.5rem, 1fr));
|
||||
gap: .35rem 1rem; align-items: start; }
|
||||
.opts.systems > .opts-label { grid-column: 1 / -1; margin-bottom: .1rem; }
|
||||
.opts.systems label { display: flex; align-items: center; gap: .35rem; }
|
||||
.opts .hint { font-style: normal; opacity: .75; }
|
||||
.opts input[type=number] { width: 5rem; }
|
||||
.meta { color: var(--muted); margin: 1.5rem 0 .5rem; font-size: .9rem; }
|
||||
|
||||
/* Fallback systemu domów. Celowo NIE jest to dyskretny „muted" — po fallbacku
|
||||
kosmogram wygląda bezbłędnie, więc ten akapit jest jedynym sygnałem, że
|
||||
podział domów pochodzi z innego systemu, niż zamówiono. */
|
||||
.house-warning {
|
||||
margin: 1rem 0; padding: .75rem 1rem; font-size: .92rem; line-height: 1.45;
|
||||
border: 1px solid var(--warn-border, #b8860b);
|
||||
border-left-width: 4px;
|
||||
border-radius: 4px;
|
||||
background: var(--warn-bg, rgba(184, 134, 11, .10));
|
||||
color: var(--warn-fg, inherit);
|
||||
}
|
||||
.error { background: #3a1320; border: 1px solid #6a2233; color: #ffb3c0; padding: .75rem 1rem; border-radius: 8px; margin-top: 1.5rem; }
|
||||
.empty { color: var(--muted); }
|
||||
table { width: 100%; border-collapse: collapse; margin-top: .5rem; background: var(--panel); border-radius: 12px; overflow: hidden; }
|
||||
|
||||
/* Tabela porównania systemów domów ma tyle kolumn, ile zaznaczono systemów —
|
||||
przy komplecie trzynastu robi się 1520 px i ROZPYCHAŁA CAŁĄ STRONĘ (dokument
|
||||
1713 px przy oknie 1280 px, poziomy pasek przewijania na body). Przewijać ma
|
||||
się sama tabela, nigdy strona. */
|
||||
.table-scroll { overflow-x: auto; margin-top: .5rem; border-radius: 12px; }
|
||||
.table-scroll > table { margin-top: 0; border-radius: 0; }
|
||||
.table-scroll th, .table-scroll td { white-space: nowrap; }
|
||||
|
||||
/* Numer domu przyklejony do lewej krawędzi: bez tego po przewinięciu w prawo
|
||||
nie wiadomo, który to wiersz. */
|
||||
.table-scroll th:first-child, .table-scroll td:first-child {
|
||||
position: sticky; left: 0; background: var(--panel); z-index: 1;
|
||||
box-shadow: 1px 0 0 var(--line);
|
||||
}
|
||||
th, td { text-align: left; padding: .6rem .8rem; border-bottom: 1px solid var(--line); }
|
||||
th { color: var(--accent); font-size: .8rem; text-transform: uppercase; letter-spacing: .5px; }
|
||||
tr:last-child td { border-bottom: none; }
|
||||
|
||||
.muted { color: var(--muted); }
|
||||
.small { font-size: .85rem; }
|
||||
.nowrap { white-space: nowrap; }
|
||||
.sig-item { margin-top: 1.25rem; }
|
||||
.sig-head { padding: .5rem 0; }
|
||||
.samples { margin-top: .3rem; }
|
||||
.samples td { font-size: .92rem; vertical-align: top; }
|
||||
.samples td.nowrap { color: var(--accent); padding-right: 1rem; }
|
||||
.facet { margin: .4rem 0 .6rem 1rem; }
|
||||
.facet-head { color: var(--ink); font-size: .9rem; }
|
||||
.badge { display: inline-block; font-size: .72rem; padding: .05rem .4rem; border-radius: 6px;
|
||||
background: #2a2d4a; color: var(--accent); margin-left: .3rem; }
|
||||
.samples td.sig { color: var(--accent); padding-right: 1rem; cursor: help; }
|
||||
|
||||
/* Wyszukiwarka lokalizacji + mapa (OSM/Leaflet) */
|
||||
.geo { margin-top: .9rem; }
|
||||
.geo-search { display: flex; gap: .5rem; flex-wrap: wrap; }
|
||||
.geo-search input[type=search] { flex: 1; min-width: 12rem; }
|
||||
.geo-results { list-style: none; margin: .4rem 0 0; padding: 0; border: 1px solid var(--line);
|
||||
border-radius: 8px; overflow: hidden; background: #12132a; max-height: 14rem; overflow-y: auto; }
|
||||
.geo-results li { padding: .5rem .75rem; cursor: pointer; border-bottom: 1px solid var(--line); font-size: .9rem; }
|
||||
.geo-results li:last-child { border-bottom: none; }
|
||||
.geo-results li:hover { background: var(--panel); color: #fff; }
|
||||
.geo-map { height: 320px; margin-top: .6rem; border: 1px solid var(--line); border-radius: 10px; }
|
||||
.geo-map[hidden] { display: none; }
|
||||
.geo-attrib { margin: .4rem 0 0; }
|
||||
.geo-attrib a { color: var(--accent); }
|
||||
.geo-pin { font-size: 20px; line-height: 24px; text-align: center; }
|
||||
/* kafelki OSM są jasne — trzymamy kontrolki czytelne na ciemnym tle */
|
||||
.leaflet-control-attribution { font-size: .68rem; }
|
||||
|
||||
/* Generator promptu do LLM (LOG-29/30) */
|
||||
textarea.prompt { width: 100%; margin-top: .5rem; padding: .7rem .8rem; box-sizing: border-box;
|
||||
background: #12132a; color: var(--ink); border: 1px solid var(--line);
|
||||
border-radius: 10px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
|
||||
font-size: .82rem; line-height: 1.45; resize: vertical; white-space: pre; }
|
||||
textarea.prompt:focus { outline: 2px solid var(--accent); outline-offset: 1px; }
|
||||
|
||||
/* Okno postępu przy generowaniu horoskopu */
|
||||
/* z-index ponad Leaflet: jego kontrolki (.leaflet-top/.leaflet-bottom — zoom,
|
||||
atrybucja) siedzą na z-index:1000 i — bo .leaflet-container nie tworzy własnego
|
||||
kontekstu stackowania — trafiają wprost do korzenia. Przy z-index:50 mapa
|
||||
wychodziła NA WIERZCH modala. 1200 daje zapas nad 1000. */
|
||||
.progress-overlay { position: fixed; inset: 0; background: rgba(8,9,20,.72);
|
||||
display: flex; align-items: center; justify-content: center;
|
||||
z-index: 1200; padding: 1rem; }
|
||||
.progress-overlay[hidden] { display: none; }
|
||||
.progress-box { background: var(--panel); border: 1px solid var(--line); border-radius: 14px;
|
||||
padding: 1rem 1.1rem; width: min(38rem, 100%); box-shadow: 0 18px 48px rgba(0,0,0,.45); }
|
||||
.progress-head { display: flex; align-items: center; gap: .6rem; margin-bottom: .6rem; }
|
||||
.progress-clock { margin-left: auto; font-family: ui-monospace, Menlo, monospace;
|
||||
color: var(--muted); font-size: .9rem; }
|
||||
.progress-spinner { width: 14px; height: 14px; border-radius: 50%; flex: none;
|
||||
border: 2px solid var(--line); border-top-color: var(--accent);
|
||||
animation: spin .8s linear infinite; }
|
||||
@keyframes spin { to { transform: rotate(360deg); } }
|
||||
@media (prefers-reduced-motion: reduce) { .progress-spinner { animation: none; } }
|
||||
.progress-log { list-style: none; margin: 0 0 .6rem; padding: .6rem .7rem;
|
||||
background: #12132a; border: 1px solid var(--line); border-radius: 10px;
|
||||
max-height: 15rem; overflow-y: auto;
|
||||
font-family: ui-monospace, Menlo, monospace; font-size: .78rem; line-height: 1.6; }
|
||||
.progress-log li { color: var(--ink); white-space: pre-wrap; }
|
||||
.progress-log li.log-ok { color: #7fd18b; }
|
||||
.progress-log li.log-warn { color: #e0c060; }
|
||||
.progress-log li.log-err { color: #ef6b6b; }
|
||||
|
||||
/* Zakładka „Skompiluj" (PRE-23) — składanie raportu z trzech źródeł. */
|
||||
.readiness { list-style: none; margin: .3rem 0 1rem; padding: 0; }
|
||||
.readiness li { padding: .2rem 0; }
|
||||
.readiness .rdy-ok { color: #7fd18b; }
|
||||
.readiness .rdy-missing { color: #e0c060; }
|
||||
.report-head { margin: 1.5rem 0 .5rem; }
|
||||
.report-head h2 { margin: 0; font-size: 1.4rem; }
|
||||
/* Treść od AI bywa długa — white-space:pre-wrap zachowuje akapity modelu,
|
||||
bez przepisywania ich na HTML. */
|
||||
.report-text { white-space: pre-wrap; background: var(--panel); border: 1px solid var(--line);
|
||||
border-radius: 10px; padding: .8rem 1rem; margin-top: .4rem; line-height: 1.6; }
|
||||
|
||||
|
||||
/* ── ekran kont (PRE-26) ────────────────────────────────────────────── */
|
||||
.account-card {
|
||||
margin-top: 1rem; padding: 1rem 1.25rem;
|
||||
background: var(--panel); border: 1px solid var(--line); border-radius: 12px;
|
||||
}
|
||||
.account-head { display: flex; align-items: baseline; gap: .75rem; margin-bottom: .5rem; }
|
||||
.account-note input { width: 100%; }
|
||||
.account-card .actions { margin-top: .9rem; }
|
||||
button.danger { background: #8b2f2f; }
|
||||
|
||||
/* Potwierdzenie operacji. Odróżnia się od .house-warning, bo tamto ostrzega,
|
||||
a to tylko potwierdza — pomylenie ich uczy ignorować oba. */
|
||||
.done-note {
|
||||
margin: 1rem 0; padding: .6rem .9rem; font-size: .9rem;
|
||||
border: 1px solid var(--line); border-left: 4px solid var(--accent);
|
||||
border-radius: 4px; background: rgba(255, 255, 255, .03);
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user