diff --git a/.env.docker b/.env.docker index e2e265d57..357a24b77 100644 --- a/.env.docker +++ b/.env.docker @@ -5,7 +5,17 @@ STATIC_ROOT=/staticroot DEBUG=true # DJANGO_BPP_DB_PASSWORD="" + +# Hostname (single-host deployment, backward compat). +# Dla multi-hosted użyj DJANGO_BPP_HOSTNAMES (poniżej) i pomiń tę zmienną. DJANGO_BPP_HOSTNAME="bpp.localnet" + +# Multi-hosted: comma-separated lista nazw hostów (jedna instalacja BPP +# obsługuje wiele uczelni/domen). Pierwsza pozycja jest używana jako +# canonical hostname (m.in. identyfikacja deployment'u w Rollbarze). +# Jeśli ustawisz DJANGO_BPP_HOSTNAMES, DJANGO_BPP_HOSTNAME jest ignorowany. +# Przykład: +# DJANGO_BPP_HOSTNAMES="bpp.uczelnia1.pl,bpp.uczelnia2.pl" DJANGO_BPP_SECRET_KEY="ZMIEN_KONIECZNIE_PRZED_URUCHOMIENIEM_PRODUKCJI" DJANGO_BPP_DB_NAME="bpp" diff --git a/.env.example b/.env.example index cfc40c35b..6b51df314 100644 --- a/.env.example +++ b/.env.example @@ -1,6 +1,19 @@ # Moduł ustawień Django (w docker-compose devowym używamy settings.local). # DJANGO_SETTINGS_MODULE="django_bpp.settings.local" +# +# Konfiguracja hostów +# + +# Single-host (backward compat). Pojedyncza nazwa hosta serwowanego przez BPP. +# DJANGO_BPP_HOSTNAME="bpp.example.org" + +# Multi-hosted: comma-separated lista nazw hostów (jedna instalacja BPP +# obsługuje wiele uczelni/domen). Pierwsza pozycja jest używana jako +# canonical hostname (m.in. identyfikacja deployment'u w Rollbarze). +# Jeśli ustawisz DJANGO_BPP_HOSTNAMES, DJANGO_BPP_HOSTNAME jest ignorowany. +# DJANGO_BPP_HOSTNAMES="bpp.uczelnia1.pl,bpp.uczelnia2.pl" + # Jeżeli w pliku konfiguracyjnym podany zostanie URI do serwera LDAP, # włączona zostanie autoryzacja LDAP. Będzie ona miała pierwszeństwo # wobec autoryzacji z serwera bazowego tzn z bazy danych. diff --git a/.github/workflows/build-docker-images.yml b/.github/workflows/build-docker-images.yml index 50ca5a8cc..e3a64effd 100644 --- a/.github/workflows/build-docker-images.yml +++ b/.github/workflows/build-docker-images.yml @@ -108,6 +108,11 @@ jobs: env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} REF_NAME: ${{ github.ref_name }} + # head_ref jest ustawione tylko dla pull_request eventów — to nazwa + # branchu zrodlowego PR-a (ref_name na PR to "/merge" ktorego + # workflow_dispatch nie akceptuje). Uzywane do hintu w komunikacie + # "jak wymusic build". + HEAD_REF: ${{ github.head_ref }} EVENT_NAME: ${{ github.event_name }} REPO: ${{ github.repository }} ACTOR: ${{ github.actor }} diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index fd88603d9..43017cb3f 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -43,6 +43,8 @@ jobs: steps: - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3 + with: + persist-credentials: false - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0 with: diff --git a/.gitignore b/.gitignore index 4d505d70a..500a86cf5 100644 --- a/.gitignore +++ b/.gitignore @@ -45,6 +45,7 @@ htmlcov/ nosetests.xml coverage.xml coverage.json +coverage-*.json cov_html/ *,cover diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a4e2617d7..a987721e2 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -28,7 +28,23 @@ repos: # diff-y indentacji na pre-commit, blokujac niezmienione pliki). args: ["--lint"] files: \.html$ - exclude: ^(node_modules/|.*/migrations/|.*/staticroot/|src/django_bpp/static/500\.html$|src/bpp/static/500\.html$) + # Tech-debt z dev (dochodzi w merge'u origin/dev): templaty + # z wzorcem `{% if %}{% else %}{% endif %}content` + # ktorego djlint nie potrafi sparsowac (H025 orphan tags) + + # pojedyncze H020 empty-tag. Pre-existing na dev, follow-up + # PR rozwiaze refactorem href-y do jednego wezla + # ``. + exclude: | + (?x)^( + node_modules/ + | .*/migrations/ + | .*/staticroot/ + | src/django_bpp/static/500\.html$ + | src/bpp/static/500\.html$ + | src/rozbieznosci_if/templates/rozbieznosci_if/index\.html$ + | src/rozbieznosci_pk/templates/rozbieznosci_pk/index\.html$ + | src/snapshot_odpiec/templates/snapshot_odpiec/snapshotodpiec_list\.html$ + ) - repo: https://github.com/pre-commit/pre-commit-hooks rev: 'v6.0.0' @@ -39,6 +55,7 @@ repos: # base file. PyYAML's safe loader doesn't know # Compose-specific tags, so check-yaml chokes on a file # that `docker compose config` parses fine. + # # mkdocs.yml uses `!!python/object/apply:pymdownx.slugs.slugify` # (Python-object tag) — SafeLoader odmawia jego budowy, choć # `mkdocs build --strict` parsuje plik bez problemu. diff --git a/CLAUDE.md b/CLAUDE.md index 68b977143..5a6fa6d4c 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -398,6 +398,27 @@ usuwajacy tagi starsze niz N dni. - Fixtures in `src/conftest.py` and subdirectories - Full suite timeout: at least 600000ms (10 minutes) +### Uruchamiaj testy LOKALNIE — nie spychaj wszystkiego na CI + +**Domyślnie odpalaj testy na swojej maszynie.** „Środowiskowo-ciężkie", +„zostawmy to CI", „Playwright wymaga setupu" to NIE są powody, żeby pominąć +lokalny przebieg — to najwyżej powód, żeby najpierw zrobić warunki wstępne +(`make assets`, `make playwright-install`). Brak warunku wstępnego = wykonaj go, +nie pomijaj testu. + +- **Praca nad zdalnym branchem / w PR:** odpalenie lokalnego `make tests` + **równolegle** z czekaniem na CI jest OK i **zalecane** — szybszy feedback, + łapiesz regresje zanim CI je zwróci, nie marnujesz rundy CI. Te dwa kanały się + nie wykluczają; rób oba. +- Pełne `make tests` przerywa się na pierwszym błędnym kroku (`make` zwraca na + Error 1), więc gdy `tests-without-playwright` padnie, kroki + `tests-only-playwright` i `js-tests` się NIE wykonają. Po naprawie Pythona + **dokończ** pozostałe kroki (albo ponów całe `make tests`), zamiast uznać je + za „pominięte". +- Jedyny akceptowalny powód, by czegoś nie odpalić lokalnie: fizyczny brak + możliwości (np. brak działającego Dockera dla testcontainers) — wtedy powiedz + to wprost, a nie „jest ciężkie". + ### Testy Playwright (`src/integration_tests/`) lokalnie Testy przeglądarkowe (np. `test_global_search.py`) **da się** odpalić diff --git a/Makefile b/Makefile index 8fc212ae3..09a13ded6 100644 --- a/Makefile +++ b/Makefile @@ -29,7 +29,7 @@ BRANCH=`git branch | sed -n '/\* /s///p'` -.PHONY: help clean distclean tests test-durations release tests-without-playwright tests-only-playwright docker destroy-test-databases cache-delete buildx-cache-stats buildx-cache-prune buildx-cache-prune-aggressive buildx-cache-prune-registry buildx-cache-export buildx-cache-import buildx-cache-list bump-dev bump-release bump-and-start-dev migrate new-worktree clean-worktree generate-500-page build build-force build-base build-app-services build-appserver-base build-appserver build-workerserver build-beatserver build-authserver build-denorm-queue build-servers check-clean-tree prepare-claude prepare-developer-machine prepare-developer-machine-linux prepare-developer-machine-macos playwright-install +.PHONY: help clean distclean tests test-durations release tests-without-playwright tests-only-playwright docker destroy-test-databases cache-delete buildx-cache-stats buildx-cache-prune buildx-cache-prune-aggressive buildx-cache-prune-registry buildx-cache-export buildx-cache-import buildx-cache-list bump-dev bump-release bump-and-start-dev migrate new-worktree clean-worktree generate-500-page build build-force build-base build-app-services build-appserver-base build-appserver build-workerserver build-beatserver build-authserver build-denorm-queue build-servers docker-images-on-ci check-clean-tree prepare-claude prepare-developer-machine prepare-developer-machine-linux prepare-developer-machine-macos playwright-install .DEFAULT_GOAL := help @@ -530,6 +530,34 @@ gh-run-watch-docker-images: ## Obserwuj najnowszy run workflow "Docker - oficjal gh-run-watch-docker-images-alt: ## Alternatywna wersja gh-run-watch-docker-images (pipe) gh run list --workflow="Docker - oficjalne obrazy" --limit=1 --json databaseId --jq '.[0].databaseId' | xargs gh run watch +docker-images-on-ci: ## Wyślij build "Docker - oficjalne obrazy" na CI i obserwuj go + @BRANCH=$$(git rev-parse --abbrev-ref HEAD); \ + UPSTREAM=$$(git rev-parse --abbrev-ref --symbolic-full-name "@{u}" 2>/dev/null || true); \ + if [ -z "$$UPSTREAM" ]; then \ + echo "BŁĄD: Gałąź $$BRANCH nie ma upstreamu. Wypchnij ją najpierw na remote."; \ + exit 1; \ + fi; \ + if [ -n "$$(git status --porcelain)" ]; then \ + echo "BŁĄD: Working tree zawiera niezcommitowane zmiany. Zcommituj lub stashuj je przed wysłaniem buildu na CI."; \ + exit 1; \ + fi; \ + if [ "$$(git rev-parse HEAD)" != "$$(git rev-parse "$$UPSTREAM")" ]; then \ + echo "BŁĄD: Lokalna gałąź $$BRANCH nie jest zsynchronizowana z $$UPSTREAM."; \ + echo " Wypchnij zmiany przed wysłaniem buildu na CI."; \ + exit 1; \ + fi; \ + echo "Wysyłam build Docker - oficjalne obrazy na CI dla gałęzi: $$BRANCH"; \ + gh workflow run build-docker-images.yml --ref "$$BRANCH"; \ + echo "Czekam na pojawienie się runu..."; \ + sleep 3; \ + RUN_ID=$$(gh run list --workflow="Docker - oficjalne obrazy" --branch="$$BRANCH" --limit=1 --json databaseId --jq '.[0].databaseId'); \ + if [ -z "$$RUN_ID" ]; then \ + echo "BŁĄD: Nie udało się znaleźć nowego runu workflow."; \ + exit 1; \ + fi; \ + echo "Obserwuję run ID: $$RUN_ID"; \ + gh run watch "$$RUN_ID" + ##@ Wersjonowanie i release sleep-3: ## `sleep 3` (helper używany w pipeline release) diff --git a/conftest.py b/conftest.py index deb444790..aceca2a68 100644 --- a/conftest.py +++ b/conftest.py @@ -61,6 +61,7 @@ def pytest_configure(config): # Load fixtures from submodules - must be at top-level conftest per pytest requirements pytest_plugins = [ "fixtures.conftest_models", + "fixtures.conftest_multisite", "fixtures.conftest_publications", "fixtures.conftest_system", "fixtures.conftest_browser", diff --git a/docker/bpp_base/Dockerfile b/docker/bpp_base/Dockerfile index 7dec4e534..38ca99386 100644 --- a/docker/bpp_base/Dockerfile +++ b/docker/bpp_base/Dockerfile @@ -94,6 +94,11 @@ COPY src/bpp/static/scss/ src/bpp/static/scss/ COPY src/bpp/static/bpp/scss/ src/bpp/static/bpp/scss/ # JS for esbuild bundle COPY src/bpp/static/bpp/js/ src/bpp/static/bpp/js/ +# Notifications JS jest teraz dostarczane przez pakiet django-channels-broadcast +# (zainstalowany przez uv) — collectstatic w runtime stage zaciągnie pliki +# z venv-a. Stara apka src/notifications/ usunięta na dev w commicie +# 048c2cfa2 (refactor: usun src/notifications/ — dostarczane przez +# django-channels-broadcast). # JS for esbuild bundle eksploratora powiązań (cytoscape-entry + moduły ES) COPY src/powiazania_autorow/static/powiazania_autorow/js/ \ src/powiazania_autorow/static/powiazania_autorow/js/ diff --git a/docs/administrator/konfiguracja-pbn.md b/docs/administrator/konfiguracja-pbn.md index 28cc8f5c9..0b8a00bb6 100644 --- a/docs/administrator/konfiguracja-pbn.md +++ b/docs/administrator/konfiguracja-pbn.md @@ -30,26 +30,26 @@ W formularzu edycji uczelni/instytucji znajdziesz następujące pola związane z ### Podstawowe ustawienia API -**Adres API w PBN** +**Adres API w PBN** - **Pole:** `pbn_api_root` - **Domyślna wartość:** `https://pbn-micro-alpha.opi.org.pl` - **Opis:** Adres serwera testowego API PBN. W wersji produkcyjnej należy ustawić `https://pbn.nauka.gov.pl/` - **Format:** Pełny adres URL (np. `https://pbn-micro-alpha.opi.org.pl`) -**Nazwa aplikacji w PBN** +**Nazwa aplikacji w PBN** - **Pole:** `pbn_app_name` - **Wymagane:** Tak - **Opis:** Identyfikator aplikacji otrzymany przy rejestracji w PBN - **Maksymalna długość:** 128 znaków -**Token aplikacji w PBN** +**Token aplikacji w PBN** - **Pole:** `pbn_app_token` - **Wymagane:** Tak - **Opis:** Token bezpieczeństwa aplikacji otrzymany z PBN - **Maksymalna długość:** 128 znaków - **Uwaga:** Pole to zawiera dane poufne -**Odpowiednik w PBN** +**Odpowiednik w PBN** - **Pole:** `pbn_uid` - **Opis:** Instytucja w bazie PBN odpowiadająca Twojej uczelni - **Uwaga:** Pole to zostanie automatycznie wypełnione po zaimportowaniu danych instytucji z PBN @@ -57,29 +57,29 @@ W formularzu edycji uczelni/instytucji znajdziesz następujące pola związane z Opcje eksportu danych -------------------- -**Kasuj oświadczenia rekordu przed wysłaniem do PBN** +**Kasuj oświadczenia rekordu przed wysłaniem do PBN** - **Pole:** `pbn_api_kasuj_przed_wysylka` - **Domyślnie:** Nie zaznaczone - **Opis:** Gdy zaznaczone, system usunie wszystkie istniejące oświadczenia publikacji w PBN przed przesłaniem nowych danych -**Nie wysyłaj do PBN prac z punktami MNISW = 0** +**Nie wysyłaj do PBN prac z punktami MNISW = 0** - **Pole:** `pbn_api_nie_wysylaj_prac_bez_pk` - **Domyślnie:** Nie zaznaczone - **Opis:** Blokuje wysyłanie do PBN publikacji bez punktów MNiSW -**Wysyłaj prace bez oświadczeń** +**Wysyłaj prace bez oświadczeń** - **Pole:** `pbn_wysylaj_bez_oswiadczen` - **Domyślnie:** Nie zaznaczone - **Opis:** Umożliwia wysyłanie do PBN publikacji bez oświadczeń dyscyplinowych. Takie publikacje trafiają do repozytorium PBN zamiast do systemu ewaluacyjnego i nie zawierają informacji o dyscyplinach naukowych autorów -**Wysyłaj zawsze PBN UID uczelni jako afiliację** +**Wysyłaj zawsze PBN UID uczelni jako afiliację** - **Pole:** `pbn_api_afiliacja_zawsze_na_uczelnie` - **Domyślnie:** Zaznaczone - **Opis:** Gdy zaznaczone, wszystkie publikacje będą afiliowane do uczelni, a nie do konkretnych jednostek organizacyjnych; zachowanie to jest obecnie domyślne - pole używane było w czasach, gdy publikacja mogła być afiliowana na konkretną jednostkę uczelni/instytucji w PBN (na Klinikę, Dział, Katedrę itp...). -**Użytkownik BPP dla PBN API** +**Użytkownik BPP dla PBN API** - **Pole:** `pbn_api_user` - **Opis:** Użytkownik systemu BPP odpowiedzialny za automatyczne operacje z PBN wykonywane przez procesy systemowe - **Uwaga:** Ten użytkownik musi wykonać autoryzację w PBN, aby umożliwić automatyczne operacje (w tle) @@ -123,35 +123,35 @@ Po skonfigurowaniu integracji zaleca się import podstawowych danych słownikowy ## Typowe problemy i rozwiązania -**Problem:** Komunikat "Brak nazwy aplikacji dla API PBN" +**Problem:** Komunikat "Brak nazwy aplikacji dla API PBN" - **Rozwiązanie:** Wypełnij pole "Nazwa aplikacji w PBN" w ustawieniach uczelni -**Problem:** Komunikat "Brak tokena aplikacji dla API PBN" +**Problem:** Komunikat "Brak tokena aplikacji dla API PBN" - **Rozwiązanie:** Wypełnij pole "Token aplikacji w PBN" w ustawieniach uczelni -**Problem:** Komunikat "Token aplikacji PBN nieprawidłowy" +**Problem:** Komunikat "Token aplikacji PBN nieprawidłowy" - **Rozwiązanie:** Sprawdź poprawność skopiowanego tokena w PBN, upewnij się że nie ma dodatkowych spacji -**Problem:** Komunikat "Najpierw wykonaj autoryzację w PBN API" +**Problem:** Komunikat "Najpierw wykonaj autoryzację w PBN API" - **Rozwiązanie:** Wykonaj proces autoryzacji opisany w sekcji "Autoryzacja w systemie PBN" -**Problem:** Brak możliwości wysyłania publikacji do PBN +**Problem:** Brak możliwości wysyłania publikacji do PBN - **Rozwiązanie:** Upewnij się, że pole "Odpowiednik w PBN" jest wypełnione i że wykonano autoryzację użytkownika ## Operacje na publikacjach Po skonfigurowaniu integracji możesz: -**Wysyłać pojedyncze publikacje do PBN:** +**Wysyłać pojedyncze publikacje do PBN:** 1. Otwórz publikację w panelu administracyjnym 2. Użyj przycisku **Wyślij do PBN** (jeśli dostępny) 3. System automatycznie wyśle publikację i pobierze z powrotem dane wraz z PBN UID -**Importować dane publikacji z PBN:** +**Importować dane publikacji z PBN:** - System może automatycznie pobierać informacje o publikacjach już istniejących w PBN - Możliwe jest też pobieranie abstraktów i innych metadanych -**Zarządzać oświadczeniami dyscyplin:** +**Zarządzać oświadczeniami dyscyplin:** - System automatycznie wysyła oświadczenia dotyczące dyscyplin naukowych autorów - Możliwa jest również wysyłka samych oświadczeń bez całej publikacji diff --git a/docs/administrator/ogolna.md b/docs/administrator/ogolna.md index 0d54adf2b..58644fae9 100644 --- a/docs/administrator/ogolna.md +++ b/docs/administrator/ogolna.md @@ -110,7 +110,7 @@ formularza, następnie zaznacz lub odznacz opcję "Publiczny" i zapisz rekord powiązań autor + rekord dla danego roku, dla danego autora - we wszystkich rekordach, które mają „starą” subdyscyplinę - na pustą. -4. **usunięcie przypisania** autora do dyscypliny (rekord `Autor_Dyscyplina`) powoduje ustawienie +4. **usunięcie przypisania** autora do dyscypliny (rekord `Autor_Dyscyplina`) powoduje ustawienie wartości pustej (`NULL`) dla danego roku, dla danego autora - we wszystkich rekordach, do których przypisany jest dany autor. diff --git a/docs/deweloper/audyt-multihosted-pbn.md b/docs/deweloper/audyt-multihosted-pbn.md new file mode 100644 index 000000000..654c00ccd --- /dev/null +++ b/docs/deweloper/audyt-multihosted-pbn.md @@ -0,0 +1,201 @@ +# Audyt multi-hosted: PBN i `Uczelnia.get_default` + +Data: 2026-06-02. Gałąź: `feature/multi-hosted-config`. + +Cel: w instalacji **wielouczelnianej** (jedna instancja BPP obsługuje wiele +obiektów `Uczelnia`, każda z własną konfiguracją PBN: `pbn_app_name`, +`pbn_app_token`, `pbn_api_root`, token użytkownika) żadna ścieżka runtime nie +może „zgadywać" uczelni. Audyt wynajduje miejsca, które: + +- **(A)** wołają `Uczelnia.pbn_client(...)` / `get_pbn_client(...)`, +- **(B)** budują połączenie do PBN „poza" obiektem `Uczelnia` (ręczna + instancja `PBNClient(RequestsTransport(...))`), +- **(C)** „zgadują" uczelnię przez `get_default()` / `objects.default` / + `.first()`. + +## Kontekst API + +- `Uczelnia.pbn_client(pbn_user_token=None)` — metoda **instancji**: buduje + klienta PBN z konfiguracji **tej** uczelni. Wywołanie na złej uczelni = + połączenie ze złym kontem PBN. +- `UczelniaManager.get_default()` → `self.all().first()` — **pierwsza + z brzegu**. W multi-hosted to losowy/błędny strzał. +- Poprawne resolvery (już istnieją): `get_for_request(request)`, + `get_for_pbn_background(uczelnia_id)` (rzuca `ValueError` przy `None`), + `get_for_site(site)`. + +## Ustalenie kluczowe + +`PBNClient` **nie zna swojej `Uczelnia`** (`client/__init__.py` trzyma tylko +`self.transport`). Dlatego nawet gdy klient zbudowano z właściwej uczelni, kod +*wewnątrz* klienta (`publication_sync.py`, adapter) **ponownie zgaduje** +uczelnię przez `get_default()`. To źródło kilku WYSOKICH ryzyk i główny motyw +rozbicia `PBNClient` na dwie warstwy (osobny spec: +`docs/superpowers/specs/2026-06-02-pbn-client-split-design.md`). + +--- + +## Tier 🔴 WYSOKIE — runtime buduje ZŁEGO klienta PBN/OAuth lub wpis kolejki bez uczelni + +| Miejsce | Wzorzec | Problem | +|---|---|---| +| `pbn_api/adapters/wydawnictwo.py:94` ← `pbn_api/client/publication_sync.py:191, 622` | C | Adapter wysyłki instancjonowany w środku klienta **bez** uczelni → `get_default()` czyta flagi payloadu (`pbn_api_nie_wysylaj_prac_bez_pk`, `pbn_wysylaj_bez_oswiadczen`) z losowej uczelni | +| `pbn_import/utils/import_manager.py:108→125` + `initial_setup.py:23→31` | A+C | `tasks.py` poprawnie wybiera uczelnię, ale `ImportManager` **nie propaguje** jej do kroków → `get_default()` **nadpisuje** `self.client` klientem złej uczelni (regresja na już-poprawionej ścieżce) | +| `importer_publikacji/providers/pbn.py:42, 214` + `views/pbn_check.py:131` | A+B+C | `_get_pbn_client()` buduje klienta **ręcznie** (`PBNClient(RequestsTransport(...))`) z `get_default()`, mimo że oba wywołania siedzą w widokach z `request`. Jedyny produkcyjny wzorzec (B) | +| `importer_publikacji/tasks.py` → `bpp/admin/helpers/pbn_api/gui.py:87` → `cli.py:43` | C | `create_publication_task` tworzy `_PbnRequestStub` bez `_uczelnia`; wpis `PBN_Export_Queue` powstaje z `uczelnia=None`; wysyłka z kolejki znów spada do `get_default()`. Docstring wprost zakłada „fallback OK" — błędne w multi-hosted | +| `orcid_integration/views.py:29` (`_get_orcid_client`) | B+C | Buduje `OrcidClient` z credentiali uczelni przez `get_default()`, mimo dostępnego `request` → logowanie do złego konta ORCID | +| `pbn_integrator/utils/scientists.py:61/156` | A+C | Buduje klienta z `get_default()` gdy `uczelnia=None` (w praktyce łagodzone — zwykle przekazuje się gotowy klient) | + +## Tier 🟠 ŚREDNIE — runtime zgaduje uczelnię dla DANYCH, nie dla klienta + +Skutkuje złym `pbn_uid`, błędnymi filtrami/flagami, ale **nie** łączy się ze +złym kontem PBN. + +| Miejsce | Co zgaduje | +|---|---| +| `pbn_api/client/publication_sync.py:287, 1046` | flaga `pbn_kasuj_dyscypliny_selektywnie` (strategia DELETE oświadczeń) | +| `importer_autorow_pbn/views.py:69` | `objects.default` do filtra listy naukowców po `pbn_uid_id` | +| `pbn_import/utils/{author_import.py:18, publication_import.py:79, institution_import.py:101}` | `pbn_uid_id`, `obca_jednostka` w ścieżce Celery | +| `pbn_integrator/utils/scientists.py:435`, `institutions.py:64/86`, `importer/authors.py:89+` | `pbn_uid_id`, `obca_jednostka` przy imporcie | +| `pbn_integrator/management/commands/pbn_integrator.py:217` | `pbn_uid_id` mimo dostępnej `uczelnia` w `handle()` | +| `zglos_publikacje/forms.py:316`, `models.py:254` | flagi formularza zgłoszeń (wizard nie przekazuje uczelni) | +| `importer_publikacji/views/{steps.py:336, publikacja.py:125}` | flagi `pbn_integracja`/`pbn_aktualizuj_na_biezaco`, `obca_jednostka` | +| `bpp/models/sloty/core.py:34`, `abstract/disciplines.py:18`, `jednostka.py:46`, `multiseek_registry/fields/numeric_fields.py:71`, `abstract/pbn.py:23/89` | per-uczelnia ustawienia: ukryte statusy, sortowanie, index copernicus, liczenie slotów, linki PBN | + +## Tier 🟢 OK / NISKIE — jawny resolver albo świadomy fallback + +- Jawny `get_for_request`/`pbn_client` tej uczelni: `crossref_bpp/views.py:124`, + `bpp/views/api/pbn_get_by_parameter.py:56/62`, + `bpp/views/autocomplete/{pbn_api.py:82, wydawnictwo_nadrzedne_w_pbn.py:172}`, + `bpp/admin/helpers/pbn_api/gui.py:137`, `bpp/admin/uczelnia.py:307`. +- Już naprawione ścieżki Celery (ostatnie commity) przez + `get_for_pbn_background(uczelnia_id)`: `pbn_downloader_app/tasks.py`, + `pbn_wysylka_oswiadczen/tasks.py`, `pbn_export_queue` (FK na wpisie), + `pbn_import/tasks.py:78/82`. +- Wzorcowa warstwa management commands: + `pbn_api/management/commands/util.py:_resolve_uczelnia` — `get_default()` + TYLKO gdy `count==1`, inaczej `CommandError`. +- Świadome, udokumentowane fallbacki: `bpp/middleware.py:295` (Site bez + Uczelni), `bpp/util/bpp_specific.py:104` (CLI/Celery bez requestu), + `do_roku_default`. Migracje backfill i testy. + +--- + +## Audyt wewnętrzny `PBNClient` — gdzie potrzebna jest `Uczelnia` + +Pełny audyt linia-po-linii w `src/pbn_api/client/` + `src/pbn_api/adapters/`. + +### Kontrakt: pola `Uczelnia` faktycznie używane przez warstwę klienta + +Tylko **trzy** flagi `bool` przepływają do logiki klienta: + +| Flaga | Gdzie | Cel | Typ do W1 | +|---|---|---|---| +| `pbn_kasuj_dyscypliny_selektywnie` | `publication_sync.py:289, 1048` | strategia DELETE oświadczeń: per-osoba vs batch | `bool` | +| `pbn_wysylaj_bez_oswiadczen` | `adapters/wydawnictwo.py:100` | praca bez statements → inny endpoint + pre-clear | `bool` (przez obecność `statements` w JSON) | +| `pbn_api_nie_wysylaj_prac_bez_pk` | `adapters/wydawnictwo.py:97` | blokuje eksport prac z `punkty_kbn==0` | `bool` (już jako `export_pk_zero`) | + +Cała reszta sprzężenia to rekord BPP (do adaptera) i modele persystencji +(`SentData`, `Rekord`, `Publication`, `OswiadczenieInstytucji`, +`PBNOdpowiedziNiepozadane`, `PublikacjaInstytucji_V2`, `Dyscyplina_Naukowa`, +`TlumaczDyscyplin`). + +**Kontrakt W2→W1 dla sync publikacji:** +`(pbn_publication_json, statements_intended, pbn_uid, kasuj_selektywnie: bool, +bez_oswiadczen: bool)`. + +### Czyste (Warstwa 1) vs BPP-aware (Warstwa 2) + +- **Czyste PBN (zostają w `pbn_client`):** `transport`, `auth` (OAuth), + `pagination`, `utils`, wszystkie 8 mixinów słownikowo-CRUD (`conferences`, + `dictionaries`, `institutions`, `journals`, `person`, `publications`, + `publishers`, `search`) — **zero importów `bpp`**. Plus z `publication_sync`: + silnik oświadczeń (`_diff_statements`, `_delete_statements_*`, + `_get_pbn_statements_with_retry`, `post_publication*`, `get_publication_fee*`, + `convert_json_with_statements_to_no_statements`, `_convert_stmt_for_api`). +- **BPP-orchestracja (→ `pbn_client_bpp`):** `sync_publication`, + `upload_publication`, `_prepare_publication_json`, `_check_upload_needed`, + `_pre_upload_clear_pbn_statements_if_any`, `download_publication`, + `download_statements_of_publication`, `pobierz_publikacje_instytucji_v2`, + `_build_post_statements_payload`, `_handle_uid_change/_handle_uid_conflict`, + `eventually_coerce_to_publication`, `upload_publication_fee`, oraz **cały** + `DisciplinesMixin` (`sync_disciplines`). Plus wszystkie `adapters/*`. +- **Mieszane (rozcięcie):** `_post_statements_with_retry`, + `_sync_statements_with_pbn` — W2 dostarcza gotowy payload / „intencję" + (listy dict z adaptera) + flagi, W1 robi czyste HTTP/diff. + +### Skala migracji call-site'ów + +- Metody orchestracji woła się **tylko w 6 miejscach** (poza klientem/testami): + `bpp/admin/helpers/pbn_api/common.py:155`, + `pbn_import/utils/initial_setup.py:73`, + `pbn_integrator/management/commands/pbn_integrator.py:182`, + `pbn_integrator/utils/synchronization.py:91, 277, 321`. +- `from pbn_api.client import PBNClient`: 35 importów (utrzymać re-eksportem). +- Budowa klienta przez `Uczelnia.pbn_client(...)`: ~20 call-site'ów — jedna + fabryka. + +--- + +## Decyzja w sprawie `get_default` + +(Patrz dyskusja z 2026-06-02.) + +- **Produkcja (runtime: widoki, zadania, sygnały)** — nigdy nie zgaduje; + uczelnia przychodzi jawnie (`get_for_request`, argument, `self.uczelnia` w W2). +- **Legalny przypadek „jest jedna uczelnia" (testy + single-install CLI)** — + `Uczelnia.objects.get()` (Django rzuca `MultipleObjectsReturned` przy >1, + `DoesNotExist` przy 0). Bez nowej metody typu `get_single_fail_if_more`. +- **`get_default`** — nie wołać w nowym kodzie; legalnych callerów migrować na + `.get()`; docelowo zostawić tylko świadomy „dowolna" (ewentualny + `get_arbitrary()` dla `middleware` Site-bez-uczelni) albo wycofać. + +### Status: ZREALIZOWANE (2026-06-02, Fazy 1–9) + +Cleanup wykonany. Pozostały po nim **tylko świadome użycia** `get_default`/ +`objects.default` (15 plików), pilnowane przez sentinel-test +`src/bpp/tests/test_multihosted_get_default_guard.py` (nowy `get_default` +w runtime → fail CI). Kategorie pozostałych: + +- **Świadome fallbacki bez requestu:** `middleware.py` (Site bez Uczelni), + `util/bpp_specific.py` (CLI/Celery bez requestu), `pbn_import_tags.py` + (template tag, request-first), `command_helpers.py` (CLI + `CommandError`). +- **None-tolerant warstwa modelu/wyświetlanie:** `jednostka.py` (sortowanie), + `multiseek .../numeric_fields.py` (index copernicus), `abstract/pbn.py` + (root linków). +- **GUARDED:** `pbn_api/.../util.py` (`count==1` else `CommandError`). +- **Test-only:** `adapters/wydawnictwo.py` (runtime przekazuje jawną uczelnię). +- **PARKED z TODO (deeper redesign per-uczelnia):** `sloty/core.py`, + `abstract/disciplines.py` (sloty/punktacja per-uczelnia — cache per + rekord×uczelnia), oraz integrator (`scientists.py`, `importer/authors.py`, + `pbn_integrator.py` — threading uczelni docelowej przez pipeline). + +Reszta runtime została przepięta na jawną uczelnię: `get_for_request` (widoki, +ORCID, importer steps/detail), `session.uczelnia` (importer_publikacji), +`self.uczelnia` w `BppPBNClient`/`ImportManager` (PBN sync, import), oraz +`Uczelnia.objects.get()` w fallbackach single-install (komendy CLI, taski +z `uczelnia_id`). + +**Następny, osobny wątek (brainstorm):** per-uczelnia liczenie slotów/punktacji +(parked TODO) — `Cache_Punktacja_*` z `uczelnia_id`, liczenie+zapis per +uczelnia autora, odczyty filtrowane po uczelni oglądającego. + +## Backfill per-uczelnia cache (write-side) + +Migracje dodają nullable `uczelnia` na `Cache_Punktacja_Dyscypliny` +(`0424_cache_punktacja_dyscypliny_uczelnia_and_more`) i naprawiają widok +`bpp_cache_punktacja_autora_view` tak, by joinował po uczelni +(`0425_per_uczelnia_cache_view`). + +Po deployu należy **przeliczyć cache** pełnym przeliczeniem punktów dyscyplin — +nowy kod (`IPunktacjaCacher.rebuildEntries`) zapisze wiersze osobno per uczelnia. +W instalacji jednouczelnianej liczby pozostają identyczne (fast-track: jedna +uczelnia w systemie ⇒ liczenie jak dotychczas, tylko z otagowaniem uczelnią). + +Wyzwolenie pełnego przeliczenia: rebuild pól `@denormalized cached_punkty_dyscyplin` +(np. denorm rebuild używany w projekcie lub `denorms.flush()` w shellu), który +woła `przelicz_punkty_dyscyplin()` per rekord. Konkretną komendę denorm rebuild +potwierdzić w środowisku docelowym. + +Opcjonalnie, po przeliczeniu, można dodać migrację zacieśniającą +`Cache_Punktacja_Dyscypliny.uczelnia` do `null=False`. diff --git a/docs/deweloper/przeglad-pbn-import-2026-06-12.md b/docs/deweloper/przeglad-pbn-import-2026-06-12.md new file mode 100644 index 000000000..4e51dbb40 --- /dev/null +++ b/docs/deweloper/przeglad-pbn-import-2026-06-12.md @@ -0,0 +1,155 @@ +# Przegląd kodu importu PBN — 2026-06-12 + +> Read-only review przeprowadzony na branchu `feature/multi-hosted-config`. +> Implementacja poprawek: branch `feature/pbn-import-cleanup` → PR do +> `feature/multi-hosted-config`. Plan wdrożenia: +> [`docs/superpowers/plans/2026-06-12-pbn-import-cleanup.md`](../superpowers/plans/2026-06-12-pbn-import-cleanup.md). + +## Zakres + +Przegląd `src/pbn_import/` oraz powiązanego kodu importu PBN +(`pbn_integrator`, `pbn_api`, `import_common`). ~22k linii kodu produkcyjnego +(bez testów/migracji) w czterech głównych aplikacjach. + +## Architektura — obraz ogólny + +System jest poprawnie zbudowany **warstwowo**, nie jako konkurujące +reimplementacje: + +``` +pbn_import (UI WebSocket/HTMX + ImportManager + pipeline kroków) ← nowsza prezentacja + └─deleguje→ pbn_integrator (właściwy silnik importu encji) ← kanoniczny + └─używa→ pbn_api (klient + adaptery + modele) +``` + +Zależność jest jednokierunkowa: `pbn_integrator` ma **zero** realnych +zależności kodowych od `pbn_import` (dwa „odwrotne" trafienia to nazwa +loggera `"pbn_import"` w `pbn_integrator/importer/publishers.py:14` oraz +`call_command` do komendy z `pbn_api`). 8 z 10 klas-kroków w +`pbn_import/utils/*_import.py` to cienkie wrappery (30–90 linii) +delegujące do `pbn_integrator`. **Nie ma duplikacji importerów encji do +usunięcia** — konsolidacja przeniosłaby kod, nie usunęła. + +## Ustalenia i rekomendacje (rankingowane) + +### 1. Martwa warstwa WebSocket — usunąć w całości ✅ DO ZROBIENIA + +`pbn_import` dostarcza dwa mechanizmy postępu: Django Channels (WebSocket) +**oraz** polling HTMX. Działa tylko HTMX. Ścieżka WS jest martwa na trzy +niezależnie zabójcze sposoby (zweryfikowane bezpośrednio): + +- **Niezgodność koperty.** Każde `send_websocket_update` pakuje payload jako + `{"type": "import_update", ...}` (`tasks.py:27`, `views.py:307`), więc + dispatchowany jest tylko handler `import_update` konsumenta. Bogatsze + handlery `progress_update`/`log_entry`/`status_change`/`completion_notification` + (`consumers.py:74–134`) są **nieosiągalne**. +- **Klient porzuca wszystko.** `dashboard.html:459` robi `switch(data.type)` + na zewnętrznej kopercie (zawsze `"import_update"`), a `case` to + `'progress_update'`/`'log_entry'`/`'completion'` — żaden nie pasuje, każda + wiadomość jest odrzucana. +- **Nawet pasujący handler nic nie robi.** `updateProgressDisplay` ustawia + tylko `document.title`; `addLogEntry` (`dashboard.html:464`) jest + **wywoływany, ale nigdy nie zdefiniowany** (ReferenceError). + +Polling HTMX (`every 5s` na postępie/logach) jest w pełni podłączony i to +on realizuje cały realtime. + +**Akcja:** usunąć `consumers.py`, `routing.py`, helpery i wywołania +`send_websocket_update` (`tasks.py`, `views.py`), blok ` +""" class Command(BaseCommand): - help = "Generuje statyczny plik 500.html dla nginx" + help = "Generuje statyczne pliki 500.html dla nginx (generyczny + per-domena)" def handle(self, *args, **options): - # Create fake request with anonymous user - factory = RequestFactory() - request = factory.get("/") - request.user = AnonymousUser() - request.session = {} + static_root = Path(settings.STATIC_ROOT) + + # 1. Generyczny fallback — pojedyncza uczelnia (single-site) albo + # neutralna „niezdefiniowana uczelnia" (multi-site bez dopasowania + # domeny). nginx serwuje go przez `try_files ... /static/500.html`, + # gdy brak strony per-domena. Host z ALLOWED_HOSTS, by jakikolwiek + # procesor/template wołający get_host() nie wywalił DisallowedHost. + generic_html = self._render_500( + Uczelnia.objects.get_single_uczelnia_or_none(), self._valid_host() + ) + # Source-dir (gitignored) — zbierany przez collectstatic na buildzie, + # zachowuje wsteczny kontrakt z obrazami pre-multi-hosted. + bpp_app_dir = Path(__file__).parent.parent.parent + self._write(bpp_app_dir / "static" / "500.html", generic_html) + # $STATIC_ROOT — autorytatywne miejsce serwowane przez nginx w runtime. + self._write(static_root / "500.html", generic_html) + + # 2. Per-domena — każdy Site dostaje stronę z brandingiem swojej + # uczelni w `$STATIC_ROOT/500/.html`. + count = 0 + for site in Site.objects.all(): + try: + uczelnia = Uczelnia.objects.get_for_site(site) + html = self._render_500(uczelnia, site.domain) + self._write(static_root / "500" / f"{site.domain}.html", html) + count += 1 + except Exception: + # Best-effort artefakt: jedna wadliwa domena nie może wywalić + # generacji pozostałych. Loguj pełny traceback i kontynuuj. + self.stderr.write( + self.style.ERROR( + f"Nie udało się wygenerować strony 500 dla domeny " + f"{site.domain!r}:" + ) + ) + traceback.print_exc() + continue - # Create fake Uczelnia object for 500 error page - class FakeUczelnia: - skrot = "Strona główna" - nazwa = "Błąd 500" + self.stdout.write( + self.style.SUCCESS( + f"Wygenerowano stronę 500: generyczną + {count} per-domena " + f"w {static_root}" + ) + ) - def sprawdz_uprawnienie(self, attr, request, ignoruj_grupe=None): - # For 500 error page, don't show any permission-restricted content - return False + def _render_500(self, uczelnia, host): + """Wyrenderuj finalny HTML strony 500 dla danej uczelni i hosta. - uczelnia_context = {"uczelnia": FakeUczelnia()} + ``uczelnia`` może być ``None`` (→ neutralna „niezdefiniowana uczelnia"). + ``host`` trafia do ``SERVER_NAME`` fałszywego requestu — musi być w + ALLOWED_HOSTS, bo procesory/template mogą wołać ``get_host()``. + """ + factory = RequestFactory() + request = factory.get("/", SERVER_NAME=host) + request.user = AnonymousUser() + request.session = {} + # KLUCZ: ustaw uczelnię z góry. ``Uczelnia.objects.get_for_request`` + # zwraca ``request._uczelnia`` ZANIM sięgnie po ``get_host()`` w + # ``_site_dla_requestu`` — to jednocześnie wymusza właściwy branding + # per-domena i uodparnia command na DisallowedHost (testserver). + request._uczelnia = uczelnia - # Build context from all context processors context = {} - context.update(uczelnia_context) context.update(bpp_configuration(request)) context.update(global_nav_user(request)) context.update(google_analytics(request)) context.update(microsoft_auth_status(request)) context.update(testing(request)) - - # Add any additional required context context["messages"] = [] context["password_change_required"] = False - - # Set cookielaw to accepted to avoid showing cookie banner on 500 page + # Ustaw cookielaw na zaakceptowane, by nie pokazywać bannera cookies. context["cookielaw"] = {"notset": False, "accepted": True, "rejected": False} - # Render the template + # Context processor ``uczelnia`` trzyma globalny cache ``b"bpp_uczelnia"`` + # NIE rozróżniający domen — przy seryjnym renderowaniu per-domena + # pierwsza uczelnia „zatrułaby" kolejne strony. Czyść przed każdym + # renderem, by processor policzył uczelnię z ``request._uczelnia``. + cache.delete(b"bpp_uczelnia") + template = loader.get_template("50x.html") rendered_html = template.render(context, request) + rendered_html = rendered_html.replace("", CLEANUP_SCRIPT + "") - # Add JavaScript to remove login menu from the rendered page - cleanup_script = """ - -""" - # Insert the script before tag - rendered_html = rendered_html.replace("", cleanup_script + "") - - # Add warning comment at the top warning = f""" - {% with box=praca.autorzy_dla_opisu_skrocony %} + {% autorzy_skrocony praca uczelnia as box %}
{% if box.skrocony %} @@ -57,7 +57,6 @@

{% endif %}

- {% endwith %} @@ -292,21 +291,21 @@

{% endif %} - {% if not request.user.is_anonymous and praca.link_do_pi %} + {% if not request.user.is_anonymous and praca|link_do_pi:uczelnia %}
Profil instytucji
-
{{ praca.link_do_pi|truncatechars:40 }}
+
{{ praca|link_do_pi:uczelnia|truncatechars:40 }}
diff --git a/src/bpp/templates/browse/praca_tabela_new.html b/src/bpp/templates/browse/praca_tabela_new.html index a982280e3..b97a1b1b8 100644 --- a/src/bpp/templates/browse/praca_tabela_new.html +++ b/src/bpp/templates/browse/praca_tabela_new.html @@ -193,9 +193,9 @@

data-open-url="{{ praca.link_do_pbn }}" data-target="_blank"> Otworz w PBN: {{ praca.pbn_uid_id }} - {% if not request.user.is_anonymous and praca.link_do_pi %} + {% if not request.user.is_anonymous and praca|link_do_pi:uczelnia %} {% endif %} diff --git a/src/bpp/templatetags/prace.py b/src/bpp/templatetags/prace.py index 6e164a2c8..f15dae225 100644 --- a/src/bpp/templatetags/prace.py +++ b/src/bpp/templatetags/prace.py @@ -128,6 +128,23 @@ def jsonify(value): return json.dumps(value, ensure_ascii=False) +@register.filter(name="link_do_pi") +def link_do_pi(praca, uczelnia=None): + """Zwróć link do Profilu Instytucji rekordu dla danej uczelni. + + Multi-hosted (audyt uczelnia, track 7b): templejt nie umie podać argumentu + metodzie, więc filtr przekazuje uczelnię oglądającego (z kontekstu) do + ``praca.link_do_pi(uczelnia)`` — link wskazuje na PBN-root TEJ uczelni i + rozwiązuje wiersz ``PublikacjaInstytucji_V2`` otagowany TĄ uczelnią. + ``uczelnia=None`` (brak uczelni w kontekście) → brak linku (NIE ma + „uczelni domyślnej"). + """ + method = getattr(praca, "link_do_pi", None) + if method is None: + return None + return method(uczelnia=uczelnia) + + @register.simple_tag def opis_bibliograficzny_cache(pk): from bpp.models.cache import Rekord @@ -225,6 +242,19 @@ def generate_coins(praca, autorzy): # noqa return mark_safe(f'') +@register.simple_tag +def autorzy_skrocony(praca, uczelnia=None): + """Skrócony widok listy autorów (``autorzy_dla_opisu_skrocony``) z przekazaną + oglądającą uczelnią, tak by wyróżnienie "naszego" autora było host-aware. + + Metoda modelu nie może dostać argumentu przez ``{% with %}``/``{{ }}``, + więc owijamy ją w simple_tag wywoływany jako + ``{% autorzy_skrocony praca uczelnia as box %}``. ``uczelnia`` pochodzi + z context processora (``Uczelnia.objects.get_for_request``). + """ + return praca.autorzy_dla_opisu_skrocony(uczelnia=uczelnia) + + @register.simple_tag def autor_nazwa(autor, links="", pokaz_pozycje=False): """Renderuje pojedynczego autora na liście na stronie rekordu: nazwisko diff --git a/src/bpp/tests/test_admin/test_autor_form_afiliuje_per_uczelnia.py b/src/bpp/tests/test_admin/test_autor_form_afiliuje_per_uczelnia.py new file mode 100644 index 000000000..59810269f --- /dev/null +++ b/src/bpp/tests/test_admin/test_autor_form_afiliuje_per_uczelnia.py @@ -0,0 +1,41 @@ +"""Multi-hosted: domyślna wartość pola ``afiliuje`` w admin-owym formularzu +inline autora (``generuj_formularz_dla_autorow``). + +Formularz inline NIE dostaje requestu (świadoma, minimalna decyzja — to tylko +UI-default nowego wiersza). Zamiast zgadywać pierwszą-z-brzegu uczelnię +(``Uczelnia.objects.first()``) używa ``get_single_uczelnia_or_none``: +- single-install → czyta ``domyslnie_afiliuje`` z tej jednej uczelni, +- >1 uczelnia → None → neutralny hardcoded default (True), bez zgadywania. +""" + +import pytest + +from bpp.admin.core import generuj_formularz_dla_autorow +from bpp.models import Wydawnictwo_Ciagle_Autor + + +def _form_class(): + return generuj_formularz_dla_autorow( + Wydawnictwo_Ciagle_Autor, include_rekord=True + ) + + +@pytest.mark.django_db +def test_afiliuje_default_wiele_uczelni_neutralny(uczelnia1, uczelnia2): + """>1 uczelnia: bez requestu nie da się ustalić uczelni → neutralny + default True, NIE ``domyslnie_afiliuje`` pierwszej-z-brzegu (uczelnia1).""" + uczelnia1.domyslnie_afiliuje = False # to jest first() (niższy pk) + uczelnia1.save() + + form = _form_class()() + assert form.fields["afiliuje"].initial is True + + +@pytest.mark.django_db +def test_afiliuje_default_single_install_czyta_uczelnie(uczelnia): + """Single-install: czyta ``domyslnie_afiliuje`` z jedynej uczelni.""" + uczelnia.domyslnie_afiliuje = False + uczelnia.save() + + form = _form_class()() + assert form.fields["afiliuje"].initial is False diff --git a/src/bpp/tests/test_admin/test_site_filtered.py b/src/bpp/tests/test_admin/test_site_filtered.py new file mode 100644 index 000000000..f4f6b94d7 --- /dev/null +++ b/src/bpp/tests/test_admin/test_site_filtered.py @@ -0,0 +1,103 @@ +import pytest +from django.contrib.admin.sites import AdminSite + +from bpp.admin.jednostka import JednostkaAdmin +from bpp.admin.uczelnia import UczelniaAdmin +from bpp.admin.wydzial import WydzialAdmin +from bpp.models import Jednostka, Uczelnia, Wydzial +from fixtures.conftest_multisite import make_request_for_site + +MULTISITE_DOMAINS = [ + "uczelnia1.localhost", + "uczelnia2.localhost", +] + + +@pytest.fixture(autouse=True) +def _allow_multisite_hosts(settings): + """Add test site domains to ALLOWED_HOSTS.""" + settings.ALLOWED_HOSTS = [ + *settings.ALLOWED_HOSTS, + *MULTISITE_DOMAINS, + ] + + +@pytest.mark.django_db +def test_jednostka_admin_filters_by_uczelnia( + site1, + uczelnia1, + uczelnia2, + jednostka_uczelnia1, + jednostka_uczelnia2, + staff_user_uczelnia1, +): + """Staff user on site1 sees only jednostki from uczelnia1.""" + request = make_request_for_site(site1, path="/admin/", user=staff_user_uczelnia1) + admin = JednostkaAdmin(Jednostka, AdminSite()) + qs = admin.get_queryset(request) + assert jednostka_uczelnia1 in qs + assert jednostka_uczelnia2 not in qs + + +@pytest.mark.django_db +def test_wydzial_admin_filters_by_uczelnia( + site1, + uczelnia1, + uczelnia2, + wydzial_uczelnia1, + wydzial_uczelnia2, + staff_user_uczelnia1, +): + """Staff user on site1 sees only wydzialy from uczelnia1.""" + request = make_request_for_site(site1, path="/admin/", user=staff_user_uczelnia1) + admin = WydzialAdmin(Wydzial, AdminSite()) + qs = admin.get_queryset(request) + assert wydzial_uczelnia1 in qs + assert wydzial_uczelnia2 not in qs + + +@pytest.mark.django_db +def test_superuser_sees_all_jednostki( + site1, + uczelnia1, + uczelnia2, + jednostka_uczelnia1, + jednostka_uczelnia2, + superuser_multisite, +): + """Superuser sees jednostki from all uczelnie.""" + request = make_request_for_site(site1, path="/admin/", user=superuser_multisite) + admin = JednostkaAdmin(Jednostka, AdminSite()) + qs = admin.get_queryset(request) + assert jednostka_uczelnia1 in qs + assert jednostka_uczelnia2 in qs + + +@pytest.mark.django_db +def test_uczelnia_admin_filters_for_non_superuser( + site1, + uczelnia1, + uczelnia2, + staff_user_uczelnia1, +): + """Non-superuser sees only their own uczelnia.""" + request = make_request_for_site(site1, path="/admin/", user=staff_user_uczelnia1) + admin = UczelniaAdmin(Uczelnia, AdminSite()) + qs = admin.get_queryset(request) + assert uczelnia1 in qs + assert uczelnia2 not in qs + + +@pytest.mark.django_db +def test_superuser_sees_all_uczelnie( + site1, + uczelnia1, + uczelnia2, + superuser_multisite, +): + """Superuser sees all uczelnie.""" + request = make_request_for_site(site1, path="/admin/", user=superuser_multisite) + admin = UczelniaAdmin(Uczelnia, AdminSite()) + qs = admin.get_queryset(request) + assert uczelnia1 in qs + assert uczelnia2 in qs diff --git a/src/bpp/tests/test_admin/test_uczelnia_site_required.py b/src/bpp/tests/test_admin/test_uczelnia_site_required.py new file mode 100644 index 000000000..d45b5ffbe --- /dev/null +++ b/src/bpp/tests/test_admin/test_uczelnia_site_required.py @@ -0,0 +1,32 @@ +"""Multi-hosted: admin-owy formularz Uczelni wymaga jawnie pola ``site`` +(domena), z przyjaznym komunikatem. + +Na poziomie DB ``site`` jest już NOT NULL (migracja 0417), ale domyślny +komunikat Django ("To pole jest wymagane.") nie tłumaczy, DLACZEGO — w trybie +multi-hosted to Site wiąże uczelnię z domeną. Forma dostarcza komunikat +dziedzinowy. +""" + +import pytest +from django.forms import modelform_factory + +from bpp.admin.uczelnia import UczelniaAdminForm +from bpp.models import Uczelnia + + +def _form_with_site(): + return modelform_factory( + Uczelnia, + form=UczelniaAdminForm, + fields=["nazwa", "skrot", "site", "theme_name"], + ) + + +@pytest.mark.django_db +def test_uczelnia_form_site_wymagany_przyjazny_komunikat(): + """Brak ``site`` → forma niewalidna, a komunikat wspomina o domenie/Site.""" + form = _form_with_site()(data={"nazwa": "Testowa", "skrot": "T"}) + + assert not form.is_valid() + assert "site" in form.errors + assert "domen" in " ".join(form.errors["site"]).lower() diff --git a/src/bpp/tests/test_admin/test_uczelnia_theme.py b/src/bpp/tests/test_admin/test_uczelnia_theme.py new file mode 100644 index 000000000..88e9033b0 --- /dev/null +++ b/src/bpp/tests/test_admin/test_uczelnia_theme.py @@ -0,0 +1,47 @@ +"""Motywy front-endu pochodzą z jednej listy w settings (BPP_THEMES). + +Patrz docs/superpowers/specs/2026-06-02-motywy-z-settings-design.md +""" + +import pytest +from django.conf import settings + +from bpp.models import Uczelnia + + +def test_theme_name_field_ma_choices_z_settings(): + """Model nie zamraża listy motywów (zero migracji przy zmianie listy). + + Pole `theme_name` to zwykły CharField — dozwolone wartości żyją w + settings.BPP_THEMES, a nie w `choices` pola modelu. + """ + field = Uczelnia._meta.get_field("theme_name") + assert not field.choices, ( + "theme_name nie powinno mieć statycznych choices na poziomie modelu " + "— inaczej każda zmiana listy motywów wymusza migrację." + ) + + +def test_bpp_themes_jest_lista_wartosc_etykieta(): + """settings.BPP_THEMES to lista krotek (wartość, etykieta).""" + assert settings.BPP_THEMES + for entry in settings.BPP_THEMES: + value, label = entry # rozpakowanie wymusza kształt 2-krotki + assert value and label + + +def test_compress_offline_context_wyliczany_z_bpp_themes(): + """COMPRESS_OFFLINE_CONTEXT pochodzi z BPP_THEMES (bez drugiej listy).""" + ctx = settings.COMPRESS_OFFLINE_CONTEXT + assert len(ctx) == len(settings.BPP_THEMES) + expected = {f"scss/{value}.css" for value, _ in settings.BPP_THEMES} + assert {c["THEME_NAME"] for c in ctx} == expected + + +@pytest.mark.django_db +def test_admin_form_oferuje_motywy_z_settings(): + """Dropdown w adminie uczelni odbija aktualną listę z settings.""" + from bpp.admin.uczelnia import UczelniaAdminForm + + form = UczelniaAdminForm() + assert list(form.fields["theme_name"].choices) == list(settings.BPP_THEMES) diff --git a/src/bpp/tests/test_admin/test_wydawnictwo_ciagle.py b/src/bpp/tests/test_admin/test_wydawnictwo_ciagle.py index c1390c209..26586878a 100644 --- a/src/bpp/tests/test_admin/test_wydawnictwo_ciagle.py +++ b/src/bpp/tests/test_admin/test_wydawnictwo_ciagle.py @@ -102,7 +102,11 @@ def test_wydawnictwo_ciagle_admin_zapisz_i_wyslij_do_pbn_change_tak( cf.save() pub = baker.make(Publication) - SentData.objects.create(object=wydawnictwo_ciagle, data_sent={}, pbn_uid=pub) + # Multi-hosted (Track 4): SentData taguje uczelnię — akcja PBN szuka + # wpisu przez get_for_rec(obj, uczelnia), więc musi być otagowany. + SentData.objects.create( + object=wydawnictwo_ciagle, data_sent={}, pbn_uid=pub, uczelnia=uczelnia + ) url = "admin:bpp_wydawnictwo_ciagle_change" page = admin_app.get(reverse(url, args=(wydawnictwo_ciagle.pk,))) diff --git a/src/bpp/tests/test_autocomplete/test_ma_osobe_z_instytucji_per_uczelnia.py b/src/bpp/tests/test_autocomplete/test_ma_osobe_z_instytucji_per_uczelnia.py new file mode 100644 index 000000000..fa6f0460e --- /dev/null +++ b/src/bpp/tests/test_autocomplete/test_ma_osobe_z_instytucji_per_uczelnia.py @@ -0,0 +1,76 @@ +"""Track 7a: wskaźnik ``ma_osobe_z_instytucji`` zawężony do uczelni z requestu. + +Adnotacja ``Exists(OsobaZInstytucji.objects.filter(personId=...))`` w +autocomplete autorów powinna odzwierciedlać instytucję PBN OGLĄDAJĄCEJ +uczelni (``request._uczelnia.pbn_uid``), nie dowolnej instytucji. +""" + +import pytest +from model_bakery import baker + +from fixtures.conftest_multisite import make_request_for_site + + +@pytest.mark.django_db +def test_ma_osobe_z_instytucji_scoped_to_viewing_uczelnia( + uczelnia1, uczelnia2, settings +): + settings.ALLOWED_HOSTS = ["*"] + from bpp.views.autocomplete.authors import AutorAutocompleteBase + from pbn_api.models import Institution, OsobaZInstytucji, Scientist + + inst1 = baker.make(Institution, name="Inst U1") + inst2 = baker.make(Institution, name="Inst U2") + uczelnia1.pbn_uid = inst1 + uczelnia1.save() + uczelnia2.pbn_uid = inst2 + uczelnia2.save() + + sci_in_u2 = baker.make(Scientist) + sci_in_u1_only = baker.make(Scientist) + + autor_u2 = baker.make("bpp.Autor", pbn_uid_id=sci_in_u2.pk) + autor_u1_only = baker.make("bpp.Autor", pbn_uid_id=sci_in_u1_only.pk) + + # OsobaZInstytucji autora U2 jest w instytucji U2, autora "U1-only" w U1. + baker.make(OsobaZInstytucji, personId=sci_in_u2, institutionId=inst2) + baker.make(OsobaZInstytucji, personId=sci_in_u1_only, institutionId=inst1) + + # Request oglądany jako uczelnia2 (jej site). + view = AutorAutocompleteBase() + view.request = make_request_for_site(uczelnia2.site) + view.q = "" + + qs = view.get_queryset() + by_pk = {a.pk: a for a in qs} + + # Autor w instytucji U2 → oznaczony; autor tylko w U1 → NIE oznaczony. + assert by_pk[autor_u2.pk].ma_osobe_z_instytucji is True + assert by_pk[autor_u1_only.pk].ma_osobe_z_instytucji is False + + +@pytest.mark.django_db +def test_ma_osobe_z_instytucji_global_without_pbn_uid(uczelnia, settings): + """Bez ``pbn_uid`` uczelni → subquery globalne (dawne zachowanie).""" + settings.ALLOWED_HOSTS = ["*"] + from django.test import RequestFactory + + from bpp.views.autocomplete.authors import AutorAutocompleteBase + from pbn_api.models import Institution, OsobaZInstytucji, Scientist + + inst = baker.make(Institution) + sci = baker.make(Scientist) + autor = baker.make("bpp.Autor", pbn_uid_id=sci.pk) + baker.make(OsobaZInstytucji, personId=sci, institutionId=inst) + + request = RequestFactory().get("/") + request._uczelnia = uczelnia # uczelnia bez pbn_uid + + view = AutorAutocompleteBase() + view.request = request + view.q = "" + + qs = view.get_queryset() + by_pk = {a.pk: a for a in qs} + # Brak pbn_uid → subquery globalne → autor oznaczony. + assert by_pk[autor.pk].ma_osobe_z_instytucji is True diff --git a/src/bpp/tests/test_cache/test_cache_pk_filter.py b/src/bpp/tests/test_cache/test_cache_pk_filter.py index a886098e4..84600f8be 100644 --- a/src/bpp/tests/test_cache/test_cache_pk_filter.py +++ b/src/bpp/tests/test_cache/test_cache_pk_filter.py @@ -36,25 +36,82 @@ def test_object_id_raw_obecne_na_wszystkich_widokach(): assert c.fetchone() is not None, f"{v} nie ma kolumny object_id_raw" +def _zasiej_klonujac(cursor, table, n): + """Szybko rozdmuchuje `table` do `n`+ wierszy, klonując istniejący wiersz + jednym ``INSERT ... SELECT × generate_series`` (bez kosztu baker + per-wiersz — ~0.3 s zamiast ~17 s dla 600 wierszy). + + Kolumny UNIQUE (poza PK) nullujemy, żeby nie złamać ograniczeń przy + duplikowaniu wiersza. PK (``id``) pomijamy — generuje się z sekwencji. + """ + cursor.execute( + "SELECT column_name FROM information_schema.columns " + "WHERE table_name = %s ORDER BY ordinal_position", + [table], + ) + cols = [r[0] for r in cursor.fetchall()] + cursor.execute( + "SELECT a.attname FROM pg_index i " + "JOIN pg_attribute a ON a.attrelid = i.indrelid " + " AND a.attnum = ANY(i.indkey) " + "WHERE i.indrelid = %s::regclass " + " AND i.indisunique AND NOT i.indisprimary", + [table], + ) + unique_cols = {r[0] for r in cursor.fetchall()} + + insert_cols = [col for col in cols if col != "id"] + select_exprs = ["NULL" if col in unique_cols else col for col in insert_cols] + collist = ", ".join(insert_cols) + selectlist = ", ".join(select_exprs) + cursor.execute( + f"INSERT INTO {table} ({collist}) " # noqa: S608 — nazwy z katalogu, nie userinput + f"SELECT {selectlist} FROM {table}, generate_series(1, %s)", + [n], + ) + + @pytest.mark.django_db def test_object_id_raw_daje_index_seek_na_pk(): """Filtr po object_id_raw musi schodzić do Index Cond na PK tabeli bazowej, - nie do Seq Scan (sedno optymalizacji).""" + nie do Seq Scan — sedno optymalizacji (#311). + + Sprawdzamy, że na realnym (dużym) zbiorze planner SAM wybiera index scan + po PK. Testowa tabela jest pusta, więc najpierw zasiewamy ją do rozmiaru, + przy którym Seq Scan jest droższy od Index Scan (~600 wierszy → ~120 + stron), i robimy ANALYZE, żeby planner widział realne statystyki. + + Bez tego zasiewu test jest *order-dependent* i flakuje w pełnej suite: + + - W IZOLACJI tabela jest świeża i nigdy nie ANALYZE-owana + (``pg_class.relpages = 0``, ``reltuples = -1``). Planner heurystyką + ``estimate_rel_size`` zakłada wtedy ~10 stron, więc Index Scan i tak + wygrywa kosztowo → test „przechodzi" przypadkiem. + - W PEŁNEJ SUITE insert/rollback churn z setek testów przekracza próg + autoanalyze (``50 + 0.1·reltuples``); autovacuum w tle ustawia realne + ``relpages = 1`` → planner poprawnie wybiera Seq Scan na 1-stronicowej + tabeli → test pada. + + Czyli pierwotnie test sprawdzał *rozmiar* tabeli (zależny od statystyk), + a nie samą optymalizację. Po zasianiu sprawdza to, o co chodzi: że + predykat po ``object_id_raw`` schodzi do indeksowanego PK tabeli bazowej + i że na realnym wolumenie planner go używa zamiast Seq Scanu. Regres, w + którym ``object_id_raw`` przestałby schodzić do PK (np. stałby się + wyliczaną kolumną na unii), wywali ten test, bo planner nie miałby jak + użyć indeksu PK. + """ wc = baker.make(Wydawnictwo_Ciagle) with connection.cursor() as c: - # enable_seqscan=off: na malej tabeli planner potrafi wybrac - # Seq Scan mimo indeksu (zalezne od statystyk => flaky w CI); - # wylaczenie wymusza indeks JESLI ISTNIEJE - a o jego uzycie - # przez widok tu chodzi. - c.execute("SET enable_seqscan = off") + _zasiej_klonujac(c, "bpp_wydawnictwo_ciagle", 600) + c.execute("ANALYZE bpp_wydawnictwo_ciagle") c.execute( "EXPLAIN SELECT * FROM bpp_wydawnictwo_ciagle_view " "WHERE object_id_raw = %s", [wc.pk], ) plan = "\n".join(row[0] for row in c.fetchall()) - c.execute("RESET enable_seqscan") - assert "Index Cond" in plan, plan + assert "bpp_wydawnictwo_ciagle_pkey" in plan, plan + assert f"Index Cond: (id = {wc.pk})" in plan, plan assert "Seq Scan on bpp_wydawnictwo_ciagle " not in plan, plan diff --git a/src/bpp/tests/test_conftest_preload_safety.py b/src/bpp/tests/test_conftest_preload_safety.py index 79509b647..2536b25bb 100644 --- a/src/bpp/tests/test_conftest_preload_safety.py +++ b/src/bpp/tests/test_conftest_preload_safety.py @@ -18,6 +18,7 @@ and asserts the rootdir conftest imports without touching the app registry. """ +import ast import os import subprocess import sys @@ -68,3 +69,106 @@ def test_rootdir_conftest_imports_before_django_setup(): "preload chain. Move it into a pytest_plugins module instead.\n\n" f"--- stdout ---\n{result.stdout}\n--- stderr ---\n{result.stderr}" ) + + +def _pytest_plugins_of(conftest_path: Path) -> list[str]: + """Statically extract the ``pytest_plugins`` list literal from a conftest. + + Uses ``ast`` instead of importing the module: the rootdir conftest runs a + ``make assets`` check and ``from fixtures import *`` at import time, and + ``src/conftest.py`` installs monkey-patches — none of which we want to + trigger just to read a list of strings. + """ + tree = ast.parse(conftest_path.read_text(encoding="utf-8")) + for node in ast.walk(tree): + if isinstance(node, ast.Assign) and any( + isinstance(t, ast.Name) and t.id == "pytest_plugins" for t in node.targets + ): + return [el.value for el in node.value.elts if isinstance(el, ast.Constant)] + return [] + + +# Probe run in a clean subprocess that mirrors the plugin preload bootstrap +# (settings configured, ``django.setup()`` NOT called). For each plugin module +# named on argv it prints ``\tOK`` if it imports cleanly or +# ``\tUNSAFE: `` if importing it touches the unpopulated app +# registry. A module that is UNSAFE here cannot be reliably registered from the +# rootdir conftest's ``pytest_plugins`` (whose loading races ``django.setup()``) +# and therefore MUST also be registered in ``src/conftest.py`` (loaded AFTER +# ``django.setup()``), or its fixtures silently vanish — exactly the +# ``fixture 'site1' not found`` class of failure. +_PLUGIN_IMPORT_PROBE = """ +import importlib +import os +import sys + +os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_bpp.settings.local") + +from django.conf import settings + +settings.INSTALLED_APPS # force lazy settings load; does NOT populate apps + +import django.apps + +assert django.apps.apps.ready is False, ( + "precondition failed: app registry is already populated" +) + +for module in sys.argv[1:]: + try: + importlib.import_module(module) + except Exception as exc: # noqa: BLE001 -- any failure means preload-unsafe + print(f"{module}\\tUNSAFE: {type(exc).__name__}: {exc}") + else: + print(f"{module}\\tOK") +""" + + +def test_model_bearing_plugins_are_registered_post_django_setup(): + """Every preload-unsafe fixture plugin in the rootdir conftest must also be + registered in ``src/conftest.py`` (the post-``django.setup()`` list). + + The rootdir conftest's ``pytest_plugins`` is loaded during the + ``pytest-testcontainers-django`` preload, which races ``django.setup()``. + A model-bearing module registered ONLY there fails to import (its fixtures + never register) and every test requesting them errors at setup with + ``fixture '...' not found``. ``src/conftest.py`` is the safety net that + registers such modules once the app registry is ready. + """ + root_plugins = _pytest_plugins_of(REPO_ROOT / "conftest.py") + src_plugins = set(_pytest_plugins_of(REPO_ROOT / "src" / "conftest.py")) + assert root_plugins, "could not parse pytest_plugins from rootdir conftest.py" + + env = { + **os.environ, + "PYTHONPATH": os.pathsep.join([str(REPO_ROOT), str(REPO_ROOT / "src")]), + "DJANGO_BPP_TESTING": "1", + } + result = subprocess.run( + [sys.executable, "-c", _PLUGIN_IMPORT_PROBE, *root_plugins], + cwd=REPO_ROOT, + env=env, + capture_output=True, + text=True, + ) + assert result.returncode == 0, ( + "plugin import probe crashed:\n" + f"--- stdout ---\n{result.stdout}\n--- stderr ---\n{result.stderr}" + ) + + unsafe = { + line.split("\t", 1)[0] + for line in result.stdout.splitlines() + if "\tUNSAFE:" in line + } + offenders = sorted(unsafe - src_plugins) + assert not offenders, ( + "These fixture plugin modules import Django models at top level and are " + "registered ONLY in the rootdir conftest.py's pytest_plugins, so their " + "fixtures silently fail to register under the testcontainers preload " + "(tests requesting them error with `fixture '...' not found`). Add them " + "to src/conftest.py's pytest_plugins (loaded after django.setup()), " + "alongside fixtures.pbn_api / fixtures.wydawnictwa:\n " + + "\n ".join(offenders) + + f"\n\n--- probe output ---\n{result.stdout}" + ) diff --git a/src/bpp/tests/test_management_command_wyczysc_publikacje_importu.py b/src/bpp/tests/test_management_command_wyczysc_publikacje_importu.py new file mode 100644 index 000000000..034108f9e --- /dev/null +++ b/src/bpp/tests/test_management_command_wyczysc_publikacje_importu.py @@ -0,0 +1,118 @@ +from io import StringIO + +import pytest +from django.contrib.contenttypes.models import ContentType +from django.core.management import call_command +from django.db import connection +from model_bakery import baker + +from bpp.models import ( + Grant, + Grant_Rekordu, + OplatyPublikacjiLog, + Wydawnictwo_Ciagle, + Wydawnictwo_Ciagle_Autor, + Wydawnictwo_Ciagle_Streszczenie, + Wydawnictwo_Ciagle_Tytul, + Wydawnictwo_Zwarte, + Wydawnictwo_Zwarte_Autor, + Wydawnictwo_Zwarte_Streszczenie, + Wydawnictwo_Zwarte_Tytul, +) + + +def _confirm_db(): + return f"--confirm-db={connection.settings_dict['NAME']}" + + +@pytest.mark.django_db(transaction=True) +def test_wyczysc_publikacje_importu_deletes_publications_and_children(): + ciagle = baker.make(Wydawnictwo_Ciagle) + zwarte = baker.make(Wydawnictwo_Zwarte) + child = baker.make(Wydawnictwo_Zwarte, wydawnictwo_nadrzedne=zwarte) + + baker.make(Wydawnictwo_Ciagle_Autor, rekord=ciagle) + baker.make(Wydawnictwo_Zwarte_Autor, rekord=zwarte) + baker.make(Wydawnictwo_Zwarte_Autor, rekord=child) + baker.make(Wydawnictwo_Ciagle_Streszczenie, rekord=ciagle) + baker.make(Wydawnictwo_Zwarte_Streszczenie, rekord=zwarte) + baker.make(Wydawnictwo_Ciagle_Tytul, rekord=ciagle, kod_jezyka_pbn="en") + baker.make(Wydawnictwo_Zwarte_Tytul, rekord=zwarte, kod_jezyka_pbn="en") + + content_type = ContentType.objects.get_for_model(ciagle) + grant = baker.make(Grant, numer_projektu="TEST-RESET-1") + Grant_Rekordu.objects.create( + content_type=content_type, + object_id=ciagle.pk, + grant=grant, + ) + OplatyPublikacjiLog.objects.create( + content_type=content_type, + object_id=ciagle.pk, + changed_by="test", + ) + + call_command( + "wyczysc_publikacje_importu", + "--yes-i-am-sure", + _confirm_db(), + ) + + assert Wydawnictwo_Ciagle.objects.count() == 0 + assert Wydawnictwo_Zwarte.objects.count() == 0 + assert Wydawnictwo_Ciagle_Autor.objects.count() == 0 + assert Wydawnictwo_Zwarte_Autor.objects.count() == 0 + assert Wydawnictwo_Ciagle_Streszczenie.objects.count() == 0 + assert Wydawnictwo_Zwarte_Streszczenie.objects.count() == 0 + assert Wydawnictwo_Ciagle_Tytul.objects.count() == 0 + assert Wydawnictwo_Zwarte_Tytul.objects.count() == 0 + assert Grant.objects.filter(pk=grant.pk).exists() + assert Grant_Rekordu.objects.count() == 0 + assert OplatyPublikacjiLog.objects.count() == 0 + + +@pytest.mark.django_db(transaction=True) +def test_wyczysc_publikacje_importu_dry_run_does_not_delete(): + baker.make(Wydawnictwo_Ciagle) + + call_command("wyczysc_publikacje_importu", "--dry-run") + + assert Wydawnictwo_Ciagle.objects.count() == 1 + + +@pytest.mark.django_db(transaction=True) +def test_wyczysc_publikacje_importu_can_clean_only_ciagle(): + baker.make(Wydawnictwo_Ciagle) + zwarte = baker.make(Wydawnictwo_Zwarte) + + call_command( + "wyczysc_publikacje_importu", + "--ciagle", + "--yes-i-am-sure", + _confirm_db(), + ) + + assert Wydawnictwo_Ciagle.objects.count() == 0 + assert list(Wydawnictwo_Zwarte.objects.values_list("pk", flat=True)) == [zwarte.pk] + + +@pytest.mark.django_db(transaction=True) +def test_wyczysc_publikacje_importu_reports_progress(): + baker.make(Wydawnictwo_Ciagle, _quantity=2) + stdout = StringIO() + + call_command( + "wyczysc_publikacje_importu", + "--ciagle", + "--yes-i-am-sure", + _confirm_db(), + "--batch-size=1", + stdout=stdout, + ) + + output = stdout.getvalue() + assert "Postep czyszczenia:" in output + assert " - czyszcze referencje publikacji:" in output + assert " - bpp.Wydawnictwo_Ciagle: usuwam 2 rekordow" in output + assert " bpp.Wydawnictwo_Ciagle: 1/2 identyfikatorow" in output + assert " bpp.Wydawnictwo_Ciagle: 2/2 identyfikatorow" in output diff --git a/src/bpp/tests/test_management_commands_generate_500_page.py b/src/bpp/tests/test_management_commands_generate_500_page.py new file mode 100644 index 000000000..2813ab927 --- /dev/null +++ b/src/bpp/tests/test_management_commands_generate_500_page.py @@ -0,0 +1,80 @@ +"""Testy dla `generate_500_page` w trybie multi-hosted (per-domena). + +Command renderuje statyczną stronę 500 dla nginx. W instalacji multi-hosted +(jedna baza, wiele `Site`/`Uczelnia` mapowanych po domenie) potrzebujemy +osobnej strony 500 per domena — `$STATIC_ROOT/500/.html` — plus +generyczny fallback `$STATIC_ROOT/500.html`. +""" + +import pytest +from django.contrib.sites.models import Site +from django.core.management import call_command + +from bpp.models import Uczelnia + + +def _make_uczelnia(domain, skrot, nazwa): + site = Site.objects.create(domain=domain, name=nazwa) + return Uczelnia.objects.create(skrot=skrot, nazwa=nazwa, site=site) + + +@pytest.mark.django_db +def test_generate_500_page_writes_per_domain_files(settings, tmp_path): + """Każda domena dostaje własną stronę 500 z brandingiem swojej uczelni.""" + settings.STATIC_ROOT = str(tmp_path) + _make_uczelnia("alfa.example.test", "ALFAUNIQ", "Alfa Uczelnia") + _make_uczelnia("beta.example.test", "BETAUNIQ", "Beta Uczelnia") + + call_command("generate_500_page") + + html_alfa = (tmp_path / "500" / "alfa.example.test.html").read_text("utf-8") + html_beta = (tmp_path / "500" / "beta.example.test.html").read_text("utf-8") + + # Górny pasek base.html renderuje {{ uczelnia.skrot }} — każda strona + # musi nieść skrót SWOJEJ uczelni i nie zawierać skrótu drugiej. + assert "ALFAUNIQ" in html_alfa and "BETAUNIQ" not in html_alfa + assert "BETAUNIQ" in html_beta and "ALFAUNIQ" not in html_beta + + +@pytest.mark.django_db +def test_generate_500_page_writes_generic_fallback(settings, tmp_path): + """Generyczny `$STATIC_ROOT/500.html` powstaje (fallback dla nginx).""" + settings.STATIC_ROOT = str(tmp_path) + _make_uczelnia("alfa.example.test", "ALFAUNIQ", "Alfa Uczelnia") + _make_uczelnia("beta.example.test", "BETAUNIQ", "Beta Uczelnia") + + call_command("generate_500_page") + + generic = tmp_path / "500.html" + assert generic.exists() + assert "Wystąpił błąd serwera" in generic.read_text("utf-8") + + +@pytest.mark.django_db +def test_generate_500_page_robust_against_disallowed_host(settings, tmp_path): + """Command nie wywala się DisallowedHost gdy `testserver` nie jest w + ALLOWED_HOSTS — fałszywy request nigdy nie używa hosta `testserver`.""" + settings.STATIC_ROOT = str(tmp_path) + settings.ALLOWED_HOSTS = ["alfa.example.test"] # bez "testserver" + _make_uczelnia("alfa.example.test", "ALFAUNIQ", "Alfa Uczelnia") + + # Nie może rzucić django.core.exceptions.DisallowedHost. + call_command("generate_500_page") + + assert (tmp_path / "500" / "alfa.example.test.html").exists() + + +@pytest.mark.django_db +def test_generate_500_page_succeeds_with_no_uczelnia(settings, tmp_path): + """Świeża instalacja: ZERO obiektów Uczelnia — generacja musi się udać + (neutralna strona), bez wyjątku. Entrypoint woła to po `migrate` na pustej + bazie, zanim setup wizard utworzy uczelnię.""" + settings.STATIC_ROOT = str(tmp_path) + assert not Uczelnia.objects.exists() + + call_command("generate_500_page") + + generic = tmp_path / "500.html" + assert generic.exists() + # Neutralna „niezdefiniowana uczelnia" — strona renderuje się poprawnie. + assert "Wystąpił błąd serwera" in generic.read_text("utf-8") diff --git a/src/bpp/tests/test_management_commands_zbieraj_sloty_uczelnia.py b/src/bpp/tests/test_management_commands_zbieraj_sloty_uczelnia.py new file mode 100644 index 000000000..ad05ba959 --- /dev/null +++ b/src/bpp/tests/test_management_commands_zbieraj_sloty_uczelnia.py @@ -0,0 +1,49 @@ +"""Testy multi-hosted dla komendy ``zbieraj_sloty`` (audyt follow-up B2). + +Kontrakt do zablokowania: +(a) ``Autor.zbieraj_sloty`` przekazuje ``uczelnia_id`` do funkcji + ``bpp.core.zbieraj_sloty`` (scope per-uczelnia). +(b) Komenda CLI: gdy >1 uczelnia i brak ``--uczelnia`` -> ``CommandError`` + (bez cichego wyboru pierwszej-z-brzegu). +""" + +from unittest.mock import patch + +import pytest +from django.core.management import call_command +from django.core.management.base import CommandError +from model_bakery import baker + + +@pytest.mark.django_db +def test_autor_zbieraj_sloty_przekazuje_uczelnia_id(): + autor = baker.make("bpp.Autor") + with patch("bpp.models.autor.zbieraj_sloty") as m: + m.return_value = (0, []) + autor.zbieraj_sloty(4, 2017, 2020, uczelnia_id=123) + assert m.call_args.kwargs["uczelnia_id"] == 123 + + +@pytest.mark.django_db +def test_command_wiele_uczelni_bez_flagi_to_commanderror(): + autor = baker.make("bpp.Autor") + baker.make("bpp.Uczelnia") + baker.make("bpp.Uczelnia") + + with pytest.raises(CommandError): + call_command("zbieraj_sloty", autor.pk) + + +@pytest.mark.django_db +def test_command_jedna_uczelnia_nie_wymaga_flagi(): + autor = baker.make("bpp.Autor") + baker.make("bpp.Uczelnia") + + with patch("bpp.models.autor.zbieraj_sloty") as m: + m.return_value = (0, []) + # Komenda kończy się sys.exit(0) przy braku --xls; łapiemy SystemExit, + # liczy się tylko że NIE poleciał CommandError "podaj --uczelnia". + with pytest.raises(SystemExit): + call_command("zbieraj_sloty", autor.pk) + + assert m.call_args.kwargs["uczelnia_id"] is not None diff --git a/src/bpp/tests/test_middleware/test_site_resolution.py b/src/bpp/tests/test_middleware/test_site_resolution.py new file mode 100644 index 000000000..d7fa271b5 --- /dev/null +++ b/src/bpp/tests/test_middleware/test_site_resolution.py @@ -0,0 +1,113 @@ +import pytest +from django.contrib.auth.models import AnonymousUser +from django.test import RequestFactory + +from bpp.middleware import SiteResolutionMiddleware +from fixtures.conftest_multisite import make_request_for_site + +MULTISITE_HOSTS = [ + "uczelnia1.localhost", + "uczelnia2.localhost", + "unknown.localhost", +] + + +@pytest.fixture(autouse=True) +def _allow_test_hosts(settings): + """Add test domains to ALLOWED_HOSTS for the duration of each test.""" + settings.ALLOWED_HOSTS = list(settings.ALLOWED_HOSTS) + MULTISITE_HOSTS + + +@pytest.mark.django_db +def test_middleware_resolves_site_from_hostname(site1, uczelnia1): + """Request to uczelnia1.localhost resolves to site1.""" + request = make_request_for_site(site1) + assert request.site == site1 + + +@pytest.mark.django_db +def test_middleware_resolves_uczelnia_from_site(site1, uczelnia1): + """request._uczelnia is the uczelnia linked to the resolved site.""" + request = make_request_for_site(site1) + assert request._uczelnia == uczelnia1 + + +@pytest.mark.django_db +def test_middleware_resolves_different_uczelnia_for_different_site( + site1, site2, uczelnia1, uczelnia2 +): + """Different hostnames resolve to different uczelnie.""" + req1 = make_request_for_site(site1) + req2 = make_request_for_site(site2) + assert req1._uczelnia == uczelnia1 + assert req2._uczelnia == uczelnia2 + assert req1._uczelnia != req2._uczelnia + + +@pytest.mark.django_db +def test_middleware_fallback_to_site_id(uczelnia1, site1, settings): + """Unknown hostname falls back to settings.SITE_ID.""" + settings.SITE_ID = site1.pk + factory = RequestFactory() + request = factory.get("/", HTTP_HOST="unknown.localhost") + request.user = AnonymousUser() + mw = SiteResolutionMiddleware(lambda r: None) + mw.process_request(request) + assert request.site == site1 + + +@pytest.mark.django_db +def test_middleware_blocks_staff_without_access(site2, uczelnia2, staff_user_uczelnia1): + """Staff user with access to site1 gets 403 on site2's admin.""" + request = make_request_for_site(site2, path="/admin/", user=staff_user_uczelnia1) + mw = SiteResolutionMiddleware(lambda r: None) + response = mw.process_view(request, None, [], {}) + assert response is not None + assert response.status_code == 403 + + +@pytest.mark.django_db +def test_middleware_allows_staff_with_correct_access( + site1, uczelnia1, staff_user_uczelnia1 +): + """Staff user with access to site1 can access site1's admin.""" + request = make_request_for_site(site1, path="/admin/", user=staff_user_uczelnia1) + mw = SiteResolutionMiddleware(lambda r: None) + response = mw.process_view(request, None, [], {}) + assert response is None # None means "continue processing" + + +@pytest.mark.django_db +def test_middleware_allows_superuser_everywhere( + site1, site2, uczelnia1, uczelnia2, superuser_multisite +): + """Superuser can access admin on any site.""" + for site in [site1, site2]: + request = make_request_for_site(site, path="/admin/", user=superuser_multisite) + mw = SiteResolutionMiddleware(lambda r: None) + response = mw.process_view(request, None, [], {}) + assert response is None + + +@pytest.mark.django_db +def test_middleware_allows_anonymous_public_pages(site1, uczelnia1): + """Anonymous user can access public pages.""" + request = make_request_for_site(site1, path="/bpp/") + mw = SiteResolutionMiddleware(lambda r: None) + response = mw.process_view(request, None, [], {}) + assert response is None + + +@pytest.mark.django_db +def test_middleware_allows_staff_with_no_sites_configured(site1, uczelnia1, db): + """Staff with empty accessible_uczelnie is allowed (backward compat).""" + from bpp.models import BppUser + + user = BppUser.objects.create_user( + username="staff_no_sites", password="test", is_staff=True + ) + # user.accessible_uczelnie is empty + request = make_request_for_site(site1, path="/admin/", user=user) + mw = SiteResolutionMiddleware(lambda r: None) + response = mw.process_view(request, None, [], {}) + assert response is None # allowed (backward compat) diff --git a/src/bpp/tests/test_models/test_autorzy_dla_opisu_skrocony.py b/src/bpp/tests/test_models/test_autorzy_dla_opisu_skrocony.py index 0c2ae7cd4..7a0e6bb8c 100644 --- a/src/bpp/tests/test_models/test_autorzy_dla_opisu_skrocony.py +++ b/src/bpp/tests/test_models/test_autorzy_dla_opisu_skrocony.py @@ -226,3 +226,108 @@ def test_skrocony_na_niezapisanym_rekordzie_nie_wybucha(): assert box["skrocony"] is False assert box["wszyscy"] == [] assert box["liczba"] == 0 + + +@pytest.mark.django_db +def test_czy_nasz_filtruje_po_uczelni_ogladajacej( + wydawnictwo_ciagle, jednostka_uczelnia1, uczelnia1, uczelnia2 +): + """Autor z jednostki uczelni1 jest "nasz" TYLKO gdy oglądamy z uczelni1. + + Regresja multi-hosted: ta sama praca na dwóch różnych hostach/uczelniach + pokazywała tego samego autora jako "naszego" na obu — bo ``czy_nasz`` + nie uwzględniało oglądającej uczelni, tylko ``skupia_pracownikow``. + """ + _dodaj_autorow(wydawnictwo_ciagle, [jednostka_uczelnia1]) + + box_u1 = wydawnictwo_ciagle.autorzy_dla_opisu_skrocony(uczelnia=uczelnia1) + assert box_u1["wszyscy"][0].czy_nasz is True + + box_u2 = wydawnictwo_ciagle.autorzy_dla_opisu_skrocony(uczelnia=uczelnia2) + assert box_u2["wszyscy"][0].czy_nasz is False + + +@pytest.mark.django_db +def test_czy_nasz_obca_jednostka_nigdy_nasza_mimo_uczelni( + wydawnictwo_ciagle, obca_jednostka, uczelnia +): + """Obca jednostka (skupia_pracownikow=False) nie jest "nasza", nawet jeśli + należy do oglądającej uczelni — ``skupia_pracownikow`` ma pierwszeństwo.""" + # obca_jednostka należy (przez wydzial) do fixture'owej `uczelnia`. + assert obca_jednostka.uczelnia_id == uczelnia.pk + _dodaj_autorow(wydawnictwo_ciagle, [obca_jednostka]) + + box = wydawnictwo_ciagle.autorzy_dla_opisu_skrocony(uczelnia=uczelnia) + assert box["wszyscy"][0].czy_nasz is False + + +@pytest.mark.django_db +def test_czy_nasz_bez_uczelni_zachowuje_stare_zachowanie( + wydawnictwo_ciagle, jednostka +): + """Bez podanej uczelni (uczelnia=None) flaga zależy wyłącznie od + ``skupia_pracownikow`` — wstecz-kompatybilność z istniejącymi callerami.""" + _dodaj_autorow(wydawnictwo_ciagle, [jednostka]) + + box = wydawnictwo_ciagle.autorzy_dla_opisu_skrocony() + assert box["wszyscy"][0].czy_nasz is True + + +@pytest.mark.django_db +def test_simple_tag_autorzy_skrocony_przekazuje_uczelnie( + wydawnictwo_ciagle, jednostka_uczelnia1, uczelnia1, uczelnia2 +): + """Tag ``autorzy_skrocony`` przekazuje oglądającą uczelnię do metody, więc + "nasz" autor jest host-aware już na poziomie szablonu.""" + from bpp.templatetags.prace import autorzy_skrocony + + _dodaj_autorow(wydawnictwo_ciagle, [jednostka_uczelnia1]) + + box_u1 = autorzy_skrocony(wydawnictwo_ciagle, uczelnia1) + assert box_u1["wszyscy"][0].czy_nasz is True + + box_u2 = autorzy_skrocony(wydawnictwo_ciagle, uczelnia2) + assert box_u2["wszyscy"][0].czy_nasz is False + + +@pytest.mark.django_db +def test_render_nasz_autor_jest_host_aware( + client, + settings, + wydawnictwo_ciagle, + jednostka_uczelnia1, + site1, + site2, + uczelnia1, + uczelnia2, + denorms, +): + """Regresja multi-hosted (objaw zgłoszony przez użytkownika): ta sama praca + z autorem z uczelni1 jest podświetlona jako "nasz" na hoście uczelni1, ale + NIE na hoście uczelni2 — bo oglądająca uczelnia rozwiązywana jest per-host. + """ + settings.ALLOWED_HOSTS = list(settings.ALLOWED_HOSTS) + [ + site1.domain, + site2.domain, + ] + _dodaj_autorow(wydawnictwo_ciagle, [jednostka_uczelnia1]) + denorms.flush() + + url = reverse( + "bpp:browse_praca", + args=( + ContentType.objects.get( + app_label="bpp", model="wydawnictwo_ciagle" + ).pk, + wydawnictwo_ciagle.pk, + ), + ) + nasz = "praca-mono__author-name--nasz" + + res_u1 = client.get(url, HTTP_HOST=site1.domain, follow=True) + assert res_u1.status_code == 200 + assert nasz in res_u1.content.decode("utf-8") # nasz host -> podświetlony + + res_u2 = client.get(url, HTTP_HOST=site2.domain, follow=True) + assert res_u2.status_code == 200 + assert nasz not in res_u2.content.decode("utf-8") # obcy host -> nie diff --git a/src/bpp/tests/test_models/test_dopasowanie_autora.py b/src/bpp/tests/test_models/test_dopasowanie_autora.py new file mode 100644 index 000000000..83bfd5e57 --- /dev/null +++ b/src/bpp/tests/test_models/test_dopasowanie_autora.py @@ -0,0 +1,143 @@ +"""Testy ``BppUser.sprobuj_dopasowac_autora`` — guard kolizji + scope uczelni. + +Dwa wymagania (multi-hosted, jedna baza / wiele Uczelni): + +1. **Nie nadpisuj zajętego profilu** — autor już powiązany z innym kontem + (``OneToOne`` ``BppUser.autor``) NIE może zostać dopasowany do kolejnego + konta. Wcześniej brak guardu powodował ``IntegrityError`` (traceback) na + unikalnym ``autor_id``. +2. **Scope po uczelni** — dopasowujemy tylko autorów z uczelni, do której + konto ma uprawnienia (``accessible_uczelnie`` → ``aktualna_jednostka. + uczelnia``). Puste ``accessible_uczelnie`` = brak ograniczenia + (kompatybilność wsteczna single-install). +""" + +import pytest +from model_bakery import baker + + +def _autor_w_uczelni(uczelnia, **kwargs): + jednostka = baker.make("bpp.Jednostka", uczelnia=uczelnia) + return baker.make("bpp.Autor", aktualna_jednostka=jednostka, **kwargs) + + +@pytest.mark.django_db +def test_pomija_autora_z_przypisanym_userem(): + # Autor już zajęty przez inne konto — kolejne konto o tym samym e-mailu + # NIE może go przejąć (i nie wolno rzucić IntegrityError). + uczelnia = baker.make("bpp.Uczelnia") + autor = _autor_w_uczelni(uczelnia, email="jan@uafm.edu.pl") + baker.make("bpp.BppUser", autor=autor, username="pierwszy") + + drugi = baker.make("bpp.BppUser", username="drugi", email="jan@uafm.edu.pl") + drugi.accessible_uczelnie.add(uczelnia) + + drugi.sprobuj_dopasowac_autora() # nie może rzucić wyjątku + + drugi.refresh_from_db() + assert drugi.autor_id is None + + +@pytest.mark.django_db +def test_dopasowuje_autora_w_uczelni_z_uprawnieniem(): + uczelnia = baker.make("bpp.Uczelnia") + autor = _autor_w_uczelni(uczelnia, email="jan@uafm.edu.pl") + + user = baker.make("bpp.BppUser", email="jan@uafm.edu.pl") + user.accessible_uczelnie.add(uczelnia) + + user.sprobuj_dopasowac_autora() + + user.refresh_from_db() + assert user.autor_id == autor.pk + + +@pytest.mark.django_db +def test_nie_dopasowuje_autora_z_obcej_uczelni(): + # Autor istnieje tylko w uczelni B, a konto ma uprawnienia do A → brak + # dopasowania (scope po uczelni). + uczelnia_a = baker.make("bpp.Uczelnia") + uczelnia_b = baker.make("bpp.Uczelnia") + _autor_w_uczelni(uczelnia_b, email="jan@uafm.edu.pl") + + user = baker.make("bpp.BppUser", email="jan@uafm.edu.pl") + user.accessible_uczelnie.add(uczelnia_a) + + user.sprobuj_dopasowac_autora() + + user.refresh_from_db() + assert user.autor_id is None + + +@pytest.mark.django_db +def test_scope_rozroznia_autorow_o_tym_samym_emailu(): + # Ten sam e-mail w dwóch uczelniach — scope wybiera tego z uczelni konta + # (bez scope byłby count()==2 i żadnego dopasowania). + uczelnia_a = baker.make("bpp.Uczelnia") + uczelnia_b = baker.make("bpp.Uczelnia") + autor_a = _autor_w_uczelni(uczelnia_a, email="jan@uafm.edu.pl") + _autor_w_uczelni(uczelnia_b, email="jan@uafm.edu.pl") + + user = baker.make("bpp.BppUser", email="jan@uafm.edu.pl") + user.accessible_uczelnie.add(uczelnia_a) + + user.sprobuj_dopasowac_autora() + + user.refresh_from_db() + assert user.autor_id == autor_a.pk + + +@pytest.mark.django_db +def test_bez_accessible_uczelnie_dopasowuje_globalnie(): + # Kompatybilność wsteczna: puste accessible_uczelnie = bez ograniczenia. + uczelnia = baker.make("bpp.Uczelnia") + autor = _autor_w_uczelni(uczelnia, email="jan@uafm.edu.pl") + + user = baker.make("bpp.BppUser", email="jan@uafm.edu.pl") + + user.sprobuj_dopasowac_autora() + + user.refresh_from_db() + assert user.autor_id == autor.pk + + +@pytest.mark.django_db +def test_dopasowanie_po_imieniu_nazwisku_scope(): + # Brak dopasowania po e-mailu → fallback po imieniu+nazwisku, też scope. + uczelnia = baker.make("bpp.Uczelnia") + autor = _autor_w_uczelni(uczelnia, imiona="Przemysław", nazwisko="Kowalczewski") + + user = baker.make( + "bpp.BppUser", + email="", + first_name="Przemysław", + last_name="Kowalczewski", + ) + user.accessible_uczelnie.add(uczelnia) + + user.sprobuj_dopasowac_autora() + + user.refresh_from_db() + assert user.autor_id == autor.pk + + +@pytest.mark.django_db +def test_po_imieniu_nazwisku_pomija_zajetego(): + # Fallback po nazwisku też respektuje guard user__isnull=True. + uczelnia = baker.make("bpp.Uczelnia") + autor = _autor_w_uczelni(uczelnia, imiona="Przemysław", nazwisko="Kowalczewski") + baker.make("bpp.BppUser", autor=autor, username="pierwszy") + + user = baker.make( + "bpp.BppUser", + username="drugi", + email="", + first_name="Przemysław", + last_name="Kowalczewski", + ) + user.accessible_uczelnie.add(uczelnia) + + user.sprobuj_dopasowac_autora() # bez wyjątku + + user.refresh_from_db() + assert user.autor_id is None diff --git a/src/bpp/tests/test_models/test_rekord_punktacja_per_uczelnia.py b/src/bpp/tests/test_models/test_rekord_punktacja_per_uczelnia.py new file mode 100644 index 000000000..e646a932e --- /dev/null +++ b/src/bpp/tests/test_models/test_rekord_punktacja_per_uczelnia.py @@ -0,0 +1,100 @@ +"""Track 1 (audyt uczelnia 2026-06-04): tabela punktacji na stronie rekordu +pokazuje sloty/punkty TYLKO uczelni oglądającego. + +``Rekord.punktacja_autora`` / ``punktacja_dyscypliny`` / ``ma_punktacje_sloty`` +filtrowały tylko po ``rekord_id`` → publiczna strona rekordu (renderowana na +domenie jednej uczelni) pokazywała CPD/CPA wszystkich uczelni współautorskiego +rekordu. Widok ustawia ``rekord._uczelnia_ogladajacego``; metody zawężają +(CPD po ``uczelnia``, CPA po ``jednostka__uczelnia``). +""" + +import pytest +from django.contrib.sites.models import Site +from model_bakery import baker + +from bpp.models import ( + Cache_Punktacja_Autora, + Cache_Punktacja_Dyscypliny, + Jednostka, + Uczelnia, + Wydzial, +) +from bpp.models.cache import Rekord + + +@pytest.fixture +def jednostka_drugiej_uczelni(db): + site = baker.make(Site, domain="druga-rek.testserver", name="druga-rek") + uczelnia2 = Uczelnia.objects.create(skrot="DRR", nazwa="Druga", site=site) + wydzial = Wydzial.objects.create(uczelnia=uczelnia2, skrot="W2", nazwa="Wydz II") + return Jednostka.objects.create( + nazwa="Jedn II", skrot="JDR", wydzial=wydzial, uczelnia=uczelnia2 + ) + + +@pytest.mark.django_db +def test_punktacja_rekordu_zaweza_do_uczelni_ogladajacego( + autor_jan_kowalski, jednostka, jednostka_drugiej_uczelni, dyscyplina1 +): + uczelnia1 = jednostka.uczelnia + uczelnia2 = jednostka_drugiej_uczelni.uczelnia + rid = [1, 999] + + for ucz in (uczelnia1, uczelnia2): + Cache_Punktacja_Dyscypliny.objects.create( + rekord_id=rid, + dyscyplina=dyscyplina1, + uczelnia=ucz, + pkd=50, + slot=20, + autorzy_z_dyscypliny=[autor_jan_kowalski.pk], + zapisani_autorzy_z_dyscypliny=["x"], + ) + for jedn in (jednostka, jednostka_drugiej_uczelni): + Cache_Punktacja_Autora.objects.create( + rekord_id=rid, + autor=autor_jan_kowalski, + jednostka=jedn, + dyscyplina=dyscyplina1, + pkdaut=50, + slot=20, + ) + + rekord = Rekord() + rekord.id = (1, 999) + rekord._uczelnia_ogladajacego = uczelnia1 + + cpd_uczelnie = set( + rekord.punktacja_dyscypliny.values_list("uczelnia_id", flat=True) + ) + cpa_uczelnie = set( + rekord.punktacja_autora.values_list("jednostka__uczelnia_id", flat=True) + ) + + assert cpd_uczelnie == {uczelnia1.pk} + assert cpa_uczelnie == {uczelnia1.pk} + assert rekord.ma_punktacje_sloty is True + + +@pytest.mark.django_db +def test_punktacja_rekordu_bez_uczelni_globalnie( + autor_jan_kowalski, jednostka, dyscyplina1 +): + """Bez ``_uczelnia_ogladajacego`` (np. admin) zachowanie globalne — brak + regresji w kontekstach, które nie ustawiają uczelni oglądającego.""" + uczelnia1 = jednostka.uczelnia + rid = [1, 998] + Cache_Punktacja_Dyscypliny.objects.create( + rekord_id=rid, + dyscyplina=dyscyplina1, + uczelnia=uczelnia1, + pkd=50, + slot=20, + autorzy_z_dyscypliny=[autor_jan_kowalski.pk], + zapisani_autorzy_z_dyscypliny=["x"], + ) + + rekord = Rekord() + rekord.id = (1, 998) + + assert rekord.punktacja_dyscypliny.count() == 1 diff --git a/src/bpp/tests/test_models/test_sloty/conftest.py b/src/bpp/tests/test_models/test_sloty/conftest.py index 5666f6085..9c25fe187 100644 --- a/src/bpp/tests/test_models/test_sloty/conftest.py +++ b/src/bpp/tests/test_models/test_sloty/conftest.py @@ -1,14 +1,17 @@ import pytest - -from ewaluacja_common.models import Rodzaj_Autora +from django.contrib.sites.models import Site from bpp import const from bpp.models import ( Autor_Dyscyplina, Charakter_Formalny, + Jednostka, + Uczelnia, Wydawnictwo_Ciagle, Wydawnictwo_Zwarte, + Wydzial, ) +from ewaluacja_common.models import Rodzaj_Autora @pytest.fixture @@ -192,3 +195,70 @@ def referat_z_dyscyplinami(zwarte_z_dyscyplinami, charakter_referat): zwarte_z_dyscyplinami.save() return zwarte_z_dyscyplinami + + +@pytest.fixture +def druga_uczelnia(db): + site, _ = Site.objects.get_or_create( + domain="druga.testserver", defaults={"name": "druga"} + ) + return Uczelnia.objects.create( + skrot="DR", nazwa="Druga uczelnia", site=site + ) + + +@pytest.fixture +def jednostka_drugiej_uczelni(druga_uczelnia, db): + wydzial = Wydzial.objects.create( + uczelnia=druga_uczelnia, skrot="W2", nazwa="Wydział II" + ) + return Jednostka.objects.create( + nazwa="Jedn. Drugiej Ucz.", + skrot="JDU", + wydzial=wydzial, + uczelnia=druga_uczelnia, + ) + + +@pytest.fixture +def zwarte_dwie_uczelnie( + wydawnictwo_zwarte, + autor_jan_nowak, + autor_jan_kowalski, + jednostka, + jednostka_drugiej_uczelni, + dyscyplina1, + rodzaj_autora_n, + charaktery_formalne, + wydawca, + typy_odpowiedzialnosci, + rok, +): + # Obaj autorzy w TEJ SAMEJ dyscyplinie, ale w różnych uczelniach. + Autor_Dyscyplina.objects.create( + autor=autor_jan_nowak, + dyscyplina_naukowa=dyscyplina1, + rok=rok, + rodzaj_autora=rodzaj_autora_n, + ) + Autor_Dyscyplina.objects.create( + autor=autor_jan_kowalski, + dyscyplina_naukowa=dyscyplina1, + rok=rok, + rodzaj_autora=rodzaj_autora_n, + ) + wydawnictwo_zwarte.dodaj_autora( + autor_jan_nowak, jednostka, dyscyplina_naukowa=dyscyplina1 + ) + wydawnictwo_zwarte.dodaj_autora( + autor_jan_kowalski, + jednostka_drugiej_uczelni, + dyscyplina_naukowa=dyscyplina1, + ) + wydawnictwo_zwarte.punkty_kbn = 20 + wydawnictwo_zwarte.wydawca = wydawca + wydawnictwo_zwarte.charakter_formalny = Charakter_Formalny.objects.get( + skrot="KSP" + ) + wydawnictwo_zwarte.save() + return wydawnictwo_zwarte diff --git a/src/bpp/tests/test_models/test_sloty/test_per_uczelnia.py b/src/bpp/tests/test_models/test_sloty/test_per_uczelnia.py new file mode 100644 index 000000000..66a22057d --- /dev/null +++ b/src/bpp/tests/test_models/test_sloty/test_per_uczelnia.py @@ -0,0 +1,379 @@ +import pytest + +from bpp.models import ( + Autor_Dyscyplina, + Charakter_Formalny, +) +from bpp.models.cache import Cache_Punktacja_Dyscypliny + + +@pytest.mark.django_db +def test_cache_punktacja_dyscypliny_ma_uczelnia(uczelnia, dyscyplina1): + obj = Cache_Punktacja_Dyscypliny( + rekord_id=[1, 1], + dyscyplina=dyscyplina1, + pkd=10, + slot=1, + uczelnia=uczelnia, + ) + assert obj.uczelnia_id == uczelnia.pk + assert obj.serialize()[-1] == uczelnia.pk + + +@pytest.mark.django_db +def test_slotmixin_wszyscy_scoped_po_uczelni(zwarte_dwie_uczelnie, jednostka): + from bpp.models.sloty.wydawnictwo_zwarte import ( + SlotKalkulator_Wydawnictwo_Zwarte_Prog3, + ) + + kalk_all = SlotKalkulator_Wydawnictwo_Zwarte_Prog3( + zwarte_dwie_uczelnie, tryb_kalkulacji=None + ) + kalk_u1 = SlotKalkulator_Wydawnictwo_Zwarte_Prog3( + zwarte_dwie_uczelnie, tryb_kalkulacji=None, uczelnia=jednostka.uczelnia + ) + assert kalk_all.wszyscy() == 2 + assert kalk_u1.wszyscy() == 1 + + +@pytest.mark.django_db +def test_uczelnie_rekordu_zwraca_obie( + zwarte_dwie_uczelnie, jednostka, druga_uczelnia +): + assert set(zwarte_dwie_uczelnie.uczelnie_rekordu()) == { + jednostka.uczelnia, + druga_uczelnia, + } + + +@pytest.mark.django_db +def test_islot_jawna_uczelnia_scoped(zwarte_dwie_uczelnie, jednostka): + from bpp.models.sloty.core import ISlot + + kalk = ISlot(zwarte_dwie_uczelnie, uczelnia=jednostka.uczelnia) + assert kalk.uczelnia == jednostka.uczelnia + assert kalk.wszyscy() == 1 + + +@pytest.mark.django_db +def test_islot_none_cross_uczelnia_failuje(zwarte_dwie_uczelnie, druga_uczelnia): + from bpp.models.sloty.core import CannotAdapt, ISlot + + # 2 uczelnie w systemie + praca cross-uczelnia => niejednoznaczne => CannotAdapt + with pytest.raises(CannotAdapt): + ISlot(zwarte_dwie_uczelnie) + + +@pytest.mark.django_db +def test_islot_none_jedna_uczelnia_systemu_rozstrzyga(zwarte_z_dyscyplinami, uczelnia): + from bpp.models.sloty.core import ISlot + + # tylko jedna uczelnia w systemie => ISlot(obj) rozstrzyga ją + kalk = ISlot(zwarte_z_dyscyplinami) + assert kalk.uczelnia == uczelnia + + +@pytest.mark.django_db +def test_rebuild_tworzy_wiersze_per_uczelnia( + zwarte_dwie_uczelnie, jednostka, druga_uczelnia +): + from bpp.models.cache import ( + Cache_Punktacja_Autora, + Cache_Punktacja_Dyscypliny, + ) + from bpp.models.sloty.core import IPunktacjaCacher + + cacher = IPunktacjaCacher(zwarte_dwie_uczelnie) + cacher.removeEntries() + cacher.rebuildEntries() + + cpd = Cache_Punktacja_Dyscypliny.objects.filter( + rekord_id=[cacher.ctype, zwarte_dwie_uczelnie.pk] + ) + assert cpd.count() == 2 + assert set(cpd.values_list("uczelnia_id", flat=True)) == { + jednostka.uczelnia_id, + druga_uczelnia.pk, + } + for row in cpd: + assert len(row.autorzy_z_dyscypliny) == 1 + + cpa = Cache_Punktacja_Autora.objects.filter( + rekord_id=[cacher.ctype, zwarte_dwie_uczelnie.pk] + ) + assert cpa.count() == 2 + assert {c.jednostka.uczelnia_id for c in cpa} == { + jednostka.uczelnia_id, + druga_uczelnia.pk, + } + + +@pytest.mark.django_db +def test_przelicz_per_uczelnia_dzielnik_k1(zwarte_dwie_uczelnie): + from bpp.models.cache import Cache_Punktacja_Autora + + zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + + cpa_nowak = Cache_Punktacja_Autora.objects.get(autor__nazwisko="Nowak") + cpa_kowalski = Cache_Punktacja_Autora.objects.get(autor__nazwisko="Kowalski") + # k=1 w obrębie każdej uczelni => każdy ma pełny slot, suma = 2.0 + assert cpa_nowak.slot == cpa_kowalski.slot + assert cpa_nowak.slot + cpa_kowalski.slot == 2 + + +@pytest.mark.django_db +def test_przelicz_zwrotka_deterministyczna(zwarte_dwie_uczelnie): + a = zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + b = zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + assert str(a) == str(b) + + +@pytest.mark.django_db +def test_widok_nie_duplikuje_miedzy_uczelniami(zwarte_dwie_uczelnie): + from django.contrib.contenttypes.models import ContentType + + from bpp.models.cache import Cache_Punktacja_Autora_Query_View + + zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + ctype = ContentType.objects.get_for_model(zwarte_dwie_uczelnie).pk + + rows = Cache_Punktacja_Autora_Query_View.objects.filter( + rekord_id=[ctype, zwarte_dwie_uczelnie.pk] + ) + # 2 autorow x 2 dyscyplina-agregaty bez joina po uczelni = 4 (kartezjan). + # Z naprawą: 2. + assert rows.count() == 2 + + +@pytest.mark.django_db +def test_ukryte_statusy_gatuje_jedna_uczelnie( + zwarte_dwie_uczelnie, jednostka, druga_uczelnia +): + from bpp.models import Ukryj_Status_Korekty + from bpp.models.sloty.core import IPunktacjaCacher + + # Druga uczelnia ukrywa status korekty tej pracy dla slotów; pierwsza nie. + Ukryj_Status_Korekty.objects.create( + uczelnia=druga_uczelnia, + status_korekty=zwarte_dwie_uczelnie.status_korekty, + sloty=True, + ) + + ctype = IPunktacjaCacher(zwarte_dwie_uczelnie).ctype + zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + + uczelnie = set( + Cache_Punktacja_Dyscypliny.objects.filter( + rekord_id=[ctype, zwarte_dwie_uczelnie.pk] + ).values_list("uczelnia_id", flat=True) + ) + assert jednostka.uczelnia_id in uczelnie + assert druga_uczelnia.pk not in uczelnie + + +@pytest.mark.django_db +def test_wypadniecie_uczelni_kasuje_sieroty( + zwarte_dwie_uczelnie, jednostka, druga_uczelnia +): + from bpp.models.sloty.core import IPunktacjaCacher + + ctype = IPunktacjaCacher(zwarte_dwie_uczelnie).ctype + zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + assert ( + Cache_Punktacja_Dyscypliny.objects.filter( + rekord_id=[ctype, zwarte_dwie_uczelnie.pk] + ).count() + == 2 + ) + + # Przenieś autora drugiej uczelni do pierwszej jednostki i przelicz ponownie. + wa = zwarte_dwie_uczelnie.autorzy_set.get(autor__nazwisko="Kowalski") + wa.jednostka = jednostka + wa.save() + + zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + uczelnie = set( + Cache_Punktacja_Dyscypliny.objects.filter( + rekord_id=[ctype, zwarte_dwie_uczelnie.pk] + ).values_list("uczelnia_id", flat=True) + ) + assert uczelnie == {jednostka.uczelnia_id} # brak sieroty druga_uczelnia + + +@pytest.mark.django_db +def test_view_eksponuje_uczelnia(zwarte_dwie_uczelnie, jednostka, druga_uczelnia): + from django.contrib.contenttypes.models import ContentType + + from bpp.models.cache import Cache_Punktacja_Autora_Query_View + + zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + ctype = ContentType.objects.get_for_model(zwarte_dwie_uczelnie).pk + + rows = Cache_Punktacja_Autora_Query_View.objects.filter( + rekord_id=[ctype, zwarte_dwie_uczelnie.pk] + ) + for row in rows: + assert row.uczelnia_id == row.jednostka.uczelnia_id + assert set(rows.values_list("uczelnia_id", flat=True)) == { + jednostka.uczelnia_id, + druga_uczelnia.pk, + } + + +@pytest.mark.django_db +def test_cpd_uczelnia_not_null(dyscyplina1): + from django.db import IntegrityError, transaction + + from bpp.models.cache import Cache_Punktacja_Dyscypliny + + with pytest.raises(IntegrityError): + with transaction.atomic(): + Cache_Punktacja_Dyscypliny.objects.create( + rekord_id=[1, 1], + dyscyplina=dyscyplina1, + pkd=10, + slot=1, + ) + + +@pytest.mark.django_db +def test_invariant_jedna_uczelnia_k2( + wydawnictwo_zwarte, + autor_jan_nowak, + autor_jan_kowalski, + jednostka, + dyscyplina1, + rodzaj_autora_n, + charaktery_formalne, + wydawca, + typy_odpowiedzialnosci, + rok, +): + from bpp.models.cache import Cache_Punktacja_Autora + + # Obaj autorzy w TEJ SAMEJ uczelni i dyscyplinie => k=2, slot dzielony. + Autor_Dyscyplina.objects.create( + autor=autor_jan_nowak, + dyscyplina_naukowa=dyscyplina1, + rok=rok, + rodzaj_autora=rodzaj_autora_n, + ) + Autor_Dyscyplina.objects.create( + autor=autor_jan_kowalski, + dyscyplina_naukowa=dyscyplina1, + rok=rok, + rodzaj_autora=rodzaj_autora_n, + ) + wydawnictwo_zwarte.dodaj_autora( + autor_jan_nowak, jednostka, dyscyplina_naukowa=dyscyplina1 + ) + wydawnictwo_zwarte.dodaj_autora( + autor_jan_kowalski, jednostka, dyscyplina_naukowa=dyscyplina1 + ) + wydawnictwo_zwarte.punkty_kbn = 20 + wydawnictwo_zwarte.wydawca = wydawca + wydawnictwo_zwarte.charakter_formalny = Charakter_Formalny.objects.get(skrot="KSP") + wydawnictwo_zwarte.save() + + wydawnictwo_zwarte.przelicz_punkty_dyscyplin() + slots = list( + Cache_Punktacja_Autora.objects.filter( + autor__in=[autor_jan_nowak, autor_jan_kowalski] + ).values_list("slot", flat=True) + ) + assert len(slots) == 2 + assert sum(slots) == 1 # k=2 w jednej uczelni: po pół slotu, suma 1.0 + + +# --------------------------------------------------------------------------- +# Hardening #1 — wiele_hst liczone per-uczelnia +# --------------------------------------------------------------------------- + + +@pytest.fixture +def zwarte_cross_hst( + wydawnictwo_zwarte, + autor_jan_nowak, + autor_jan_kowalski, + jednostka, + jednostka_drugiej_uczelni, + dyscyplina1_hst, + dyscyplina2, + rodzaj_autora_n, + charaktery_formalne, + wydawca, + typy_odpowiedzialnosci, + rok, +): + """Praca z autorem HST w uczelni A i autorem nie-HST w uczelni B. + + Globalnie: dyscypliny_rekordu() → {HST, nie-HST} → wiele_hst=True. + Per-uczelnia: każda uczelnia ma jednorodny zestaw → wiele_hst=False. + """ + Autor_Dyscyplina.objects.create( + autor=autor_jan_nowak, + dyscyplina_naukowa=dyscyplina1_hst, + rok=rok, + rodzaj_autora=rodzaj_autora_n, + ) + Autor_Dyscyplina.objects.create( + autor=autor_jan_kowalski, + dyscyplina_naukowa=dyscyplina2, + rok=rok, + rodzaj_autora=rodzaj_autora_n, + ) + wydawnictwo_zwarte.dodaj_autora( + autor_jan_nowak, jednostka, dyscyplina_naukowa=dyscyplina1_hst + ) + wydawnictwo_zwarte.dodaj_autora( + autor_jan_kowalski, + jednostka_drugiej_uczelni, + dyscyplina_naukowa=dyscyplina2, + ) + wydawnictwo_zwarte.punkty_kbn = 20 + wydawnictwo_zwarte.wydawca = wydawca + wydawnictwo_zwarte.charakter_formalny = Charakter_Formalny.objects.get( + skrot="KSP" + ) + wydawnictwo_zwarte.save() + return wydawnictwo_zwarte + + +@pytest.mark.django_db +def test_wszystkie_dyscypliny_rekordu_bez_uczelni_zwraca_obie( + zwarte_cross_hst, dyscyplina1_hst, dyscyplina2 +): + """Bez filtrowania uczelni: globalnie obie dyscypliny są widoczne.""" + pks = {row[0] for row in zwarte_cross_hst.wszystkie_dyscypliny_rekordu()} + assert dyscyplina1_hst.pk in pks + assert dyscyplina2.pk in pks + + +@pytest.mark.django_db +def test_wszystkie_dyscypliny_rekordu_uczelnia_a_zwraca_tylko_hst( + zwarte_cross_hst, jednostka, dyscyplina1_hst, dyscyplina2 +): + """Per uczelnia A (HST): widoczna tylko dyscyplina HST.""" + pks = { + row[0] + for row in zwarte_cross_hst.wszystkie_dyscypliny_rekordu( + uczelnia=jednostka.uczelnia + ) + } + assert dyscyplina1_hst.pk in pks + assert dyscyplina2.pk not in pks + + +@pytest.mark.django_db +def test_wszystkie_dyscypliny_rekordu_uczelnia_b_zwraca_tylko_nie_hst( + zwarte_cross_hst, jednostka_drugiej_uczelni, dyscyplina1_hst, dyscyplina2 +): + """Per uczelnia B (nie-HST): widoczna tylko dyscyplina nie-HST.""" + pks = { + row[0] + for row in zwarte_cross_hst.wszystkie_dyscypliny_rekordu( + uczelnia=jednostka_drugiej_uczelni.uczelnia + ) + } + assert dyscyplina2.pk in pks + assert dyscyplina1_hst.pk not in pks diff --git a/src/bpp/tests/test_models/test_sloty/test_sloty_misc.py b/src/bpp/tests/test_models/test_sloty/test_sloty_misc.py index 17a095520..842a5edbb 100644 --- a/src/bpp/tests/test_models/test_sloty/test_sloty_misc.py +++ b/src/bpp/tests/test_models/test_sloty/test_sloty_misc.py @@ -8,7 +8,7 @@ import pytest -from bpp.models import Rekord, Typ_KBN, Uczelnia +from bpp.models import Rekord, Typ_KBN from bpp.models.sloty.core import ISlot from bpp.models.sloty.exceptions import CannotAdapt @@ -90,9 +90,7 @@ def test_ISlot_ukryty_status_nie_licz_punktow( zwarte_z_dyscyplinami.status_korekty = przed_korekta zwarte_z_dyscyplinami.save() - Uczelnia.objects.get_default().ukryj_status_korekty_set.create( - status_korekty=przed_korekta - ) + uczelnia.ukryj_status_korekty_set.create(status_korekty=przed_korekta) with pytest.raises(CannotAdapt): ISlot(zwarte_z_dyscyplinami) diff --git a/src/bpp/tests/test_models/test_sloty/test_zbieraj_sloty_uczelnia.py b/src/bpp/tests/test_models/test_sloty/test_zbieraj_sloty_uczelnia.py new file mode 100644 index 000000000..eaea4c911 --- /dev/null +++ b/src/bpp/tests/test_models/test_sloty/test_zbieraj_sloty_uczelnia.py @@ -0,0 +1,28 @@ +import pytest + +from bpp.core import zbieraj_sloty + + +@pytest.mark.django_db +def test_zbieraj_sloty_zaweza_po_uczelni( + zwarte_dwie_uczelnie, jednostka, druga_uczelnia +): + zwarte_dwie_uczelnie.przelicz_punkty_dyscyplin() + autor = zwarte_dwie_uczelnie.autorzy_set.first().autor + + _pkt_all, lista_all, _slot_all = zbieraj_sloty( + autor.pk, + 1, + zwarte_dwie_uczelnie.rok, + zwarte_dwie_uczelnie.rok, + akcja="wszystko", + ) + _pkt_u, lista_u, _slot_u = zbieraj_sloty( + autor.pk, + 1, + zwarte_dwie_uczelnie.rok, + zwarte_dwie_uczelnie.rok, + akcja="wszystko", + uczelnia_id=jednostka.uczelnia_id, + ) + assert len(lista_u) <= len(lista_all) diff --git a/src/bpp/tests/test_models/test_struktura/test_uczelnia.py b/src/bpp/tests/test_models/test_struktura/test_uczelnia.py index 45b30e194..f307749c9 100644 --- a/src/bpp/tests/test_models/test_struktura/test_uczelnia.py +++ b/src/bpp/tests/test_models/test_struktura/test_uczelnia.py @@ -445,4 +445,8 @@ def test_zapis_uczelni_inwaliduje_cache_strony_glownej(uczelnia, mocker): uczelnia.save() invalidate.assert_called_once_with() - delete.assert_called_once_with(b"bpp_uczelnia") + # Po wprowadzeniu kluczowania cache context-processora per-site, sygnał kasuje + # ZARÓWNO klucz per-site (bpp_uczelnia_) JAK I legacy b"bpp_uczelnia". + assert delete.call_count == 2 + delete.assert_any_call(f"bpp_uczelnia_{uczelnia.site_id}") + delete.assert_any_call(b"bpp_uczelnia") diff --git a/src/bpp/tests/test_models/test_uczelnia_pbn_resolver.py b/src/bpp/tests/test_models/test_uczelnia_pbn_resolver.py new file mode 100644 index 000000000..b642e9f26 --- /dev/null +++ b/src/bpp/tests/test_models/test_uczelnia_pbn_resolver.py @@ -0,0 +1,47 @@ +"""Testy dla ścisłego resolwera uczelni dla zadań PBN w tle. + +W trybie multi-hosted KAŻDY entrypoint (widok) zna konkretną uczelnię +z requestu i MUSI przekazać jej ``pk`` do zadania Celery. Resolwer +``get_for_pbn_background`` świadomie NIE robi fallbacku do +``get_default()`` — wybór "pierwszej z brzegu" uczelni to właśnie ten +bug, przez który zadania pobierały konfigurację PBN złej uczelni. +""" + +import pytest + +from bpp.models import Uczelnia + + +@pytest.mark.django_db +def test_get_for_pbn_background_raises_without_id(): + """Brak uczelnia_id => ValueError, ZERO fallbacku do get_default().""" + with pytest.raises(ValueError): + Uczelnia.objects.get_for_pbn_background(None) + + +@pytest.mark.django_db +def test_get_for_pbn_background_returns_requested_uczelnia(uczelnia): + """Z poprawnym id zwraca dokładnie tę uczelnię.""" + assert Uczelnia.objects.get_for_pbn_background(uczelnia.pk) == uczelnia + + +@pytest.mark.django_db +def test_get_for_pbn_background_does_not_fall_back_to_first(uczelnia): + """Gdy istnieją dwie uczelnie, a id jest None — resolwer MUSI rzucić, + a nie po cichu zwrócić pierwszą (to było źródłem błędu 403).""" + from django.contrib.sites.models import Site + + site2, _ = Site.objects.get_or_create( + domain="druga.example.com", defaults={"name": "druga"} + ) + Uczelnia.objects.create(skrot="DR", nazwa="Druga uczelnia", site=site2) + + with pytest.raises(ValueError): + Uczelnia.objects.get_for_pbn_background(None) + + +@pytest.mark.django_db +def test_get_for_pbn_background_raises_for_unknown_id(uczelnia): + """Nieistniejące id => Uczelnia.DoesNotExist (nie cichy fallback).""" + with pytest.raises(Uczelnia.DoesNotExist): + Uczelnia.objects.get_for_pbn_background(uczelnia.pk + 9999) diff --git a/src/bpp/tests/test_models/test_uczelnia_resolution.py b/src/bpp/tests/test_models/test_uczelnia_resolution.py new file mode 100644 index 000000000..4fa587d53 --- /dev/null +++ b/src/bpp/tests/test_models/test_uczelnia_resolution.py @@ -0,0 +1,135 @@ +"""Multi-hosted: rozstrzyganie uczelni bez „uczelni domyślnej". + +Pokrywa ``UczelniaManager``: ``get_single_uczelnia_or_none`` / +``get_single_uczelnia_or_fail`` / ``get_for_site`` / ``get_for_request``. +Zasada: brak → None, jedna → ta, wiele bez wskazania z site → None +(NIGDY pierwsza-z-brzegu). ``get_for_request`` NIGDY nie rzuca. +""" + +import pytest +from django.test import RequestFactory +from model_bakery import baker + +from bpp.models import Uczelnia + + +@pytest.mark.django_db +def test_get_single_uczelnia_or_none_pusta_baza(): + assert Uczelnia.objects.get_single_uczelnia_or_none() is None + + +@pytest.mark.django_db +def test_get_single_uczelnia_or_none_jedna(): + u = baker.make(Uczelnia) + assert Uczelnia.objects.get_single_uczelnia_or_none() == u + + +@pytest.mark.django_db +def test_get_single_uczelnia_or_none_wiele_to_none(): + baker.make(Uczelnia) + baker.make(Uczelnia) + assert Uczelnia.objects.get_single_uczelnia_or_none() is None + + +@pytest.mark.django_db +def test_get_single_uczelnia_or_fail_jedna(): + u = baker.make(Uczelnia) + assert Uczelnia.objects.get_single_uczelnia_or_fail() == u + + +@pytest.mark.django_db +def test_get_single_uczelnia_or_fail_wiele_rzuca(): + baker.make(Uczelnia) + baker.make(Uczelnia) + with pytest.raises(Uczelnia.MultipleObjectsReturned): + Uczelnia.objects.get_single_uczelnia_or_fail() + + +@pytest.mark.django_db +def test_get_single_uczelnia_or_fail_pusta_rzuca(): + with pytest.raises(Uczelnia.DoesNotExist): + Uczelnia.objects.get_single_uczelnia_or_fail() + + +@pytest.mark.django_db +def test_get_for_site_none_to_none(): + assert Uczelnia.objects.get_for_site(None) is None + + +@pytest.mark.django_db +def test_get_for_site_zwraca_uczelnie_site(): + u = baker.make(Uczelnia) + assert Uczelnia.objects.get_for_site(u.site) == u + + +@pytest.mark.django_db +def test_get_for_request_cache_zwraca_scacheowana(): + # request._uczelnia ustawione (przez middleware) → bierzemy je, bez DB. + rf = RequestFactory() + req = rf.get("/") + sentinel = object() + req._uczelnia = sentinel + assert Uczelnia.objects.get_for_request(req) is sentinel + + +@pytest.mark.django_db +def test_get_for_request_po_domenie_site(settings): + settings.ALLOWED_HOSTS = ["*"] + u = baker.make(Uczelnia) + u.site.domain = "uczelnia-a.example.com" + u.site.save() + rf = RequestFactory() + req = rf.get("/", HTTP_HOST="uczelnia-a.example.com") + assert Uczelnia.objects.get_for_request(req) == u + # i scacheowane + assert req._uczelnia == u + + +@pytest.mark.django_db +def test_get_for_request_jedyna_uczelnia_bez_dopasowania_domeny(settings): + settings.ALLOWED_HOSTS = ["*"] + u = baker.make(Uczelnia) + rf = RequestFactory() + req = rf.get("/", HTTP_HOST="niezmapowana-domena.example") + # Brak Site dla domeny, ale JEDNA uczelnia → ona. + assert Uczelnia.objects.get_for_request(req) == u + + +@pytest.mark.django_db +def test_get_for_request_wiele_uczelni_bez_domeny_to_none_nie_rzuca(settings): + settings.ALLOWED_HOSTS = ["*"] + baker.make(Uczelnia) + baker.make(Uczelnia) + rf = RequestFactory() + req = rf.get("/", HTTP_HOST="niezmapowana-domena.example") + # Wiele uczelni, brak wskazania z domeny → None (ŻADNA), bez wyjątku. + assert Uczelnia.objects.get_for_request(req) is None + + +@pytest.mark.django_db +def test_get_for_request_pusta_baza_to_none_nie_rzuca(settings): + # Setup wizard / pusta baza: strona MUSI działać bez uczelni. + settings.ALLOWED_HOSTS = ["*"] + rf = RequestFactory() + req = rf.get("/", HTTP_HOST="cokolwiek.example") + assert Uczelnia.objects.get_for_request(req) is None + + +@pytest.mark.django_db +def test_get_for_request_none_jedna_uczelnia(): + # Wołający z warstwy modelu/CBV bez requestu przekazuje None — nie crash. + u = baker.make(Uczelnia) + assert Uczelnia.objects.get_for_request(None) == u + + +@pytest.mark.django_db +def test_get_for_request_none_wiele_uczelni_to_none_nie_rzuca(): + baker.make(Uczelnia) + baker.make(Uczelnia) + assert Uczelnia.objects.get_for_request(None) is None + + +def test_get_default_nie_istnieje(): + # „Uczelnia domyślna" została usunięta na trwałe. + assert not hasattr(Uczelnia.objects, "get_default") + assert "default" not in type(Uczelnia.objects).__dict__ diff --git a/src/bpp/tests/test_multihosted_get_default_guard.py b/src/bpp/tests/test_multihosted_get_default_guard.py new file mode 100644 index 000000000..3d4d69df0 --- /dev/null +++ b/src/bpp/tests/test_multihosted_get_default_guard.py @@ -0,0 +1,100 @@ +"""Guard multi-hosted: pilnuje, że footguny „pierwszej-z-brzegu uczelni" +nie wracają do kodu runtime. + +NIE MA „uczelni domyślnej". ``Uczelnia.objects.get_default()`` / +``Uczelnia.objects.default`` zostały TRWALE USUNIĘTE — każde ich wystąpienie +w ``src/`` (poza testami/migracjami) to regresja. Uczelnię ustala się z +requestu (``get_for_request`` → domena → Site → Uczelnia); gdy się NIE DA, +jedyny dozwolony fallback to ``get_single_uczelnia_or_none`` (jedna albo None, +bez zgadywania) lub ``get_single_uczelnia_or_fail`` (jedna albo głośny błąd). + +Drugi, semantycznie równoważny footgun to ``Uczelnia.objects.first()`` / +``Uczelnia.objects.all()[0]`` — pilnowany osobno (whitelista demo/debug/ +warstwa-modelu/UI default). + +Gdy ten test PADA: +- dla get_default → USUNĄŁEŚ regres: ``Uczelnia.objects.get_default()``/ + ``.default`` NIE WOLNO użyć (metoda nie istnieje). Użyj jawnej uczelni + (``get_for_request`` / argument / FK obiektu) albo ``get_single_uczelnia_*``. +- dla first() → użyj jawnej uczelni / single-or-fail, albo dopisz do + ``APPROVED_FIRST`` z uzasadnieniem (gdy to świadomy fallback bez requestu). + +Patrz: docs/deweloper/audyt-multihosted-pbn.md +""" + +import re +from pathlib import Path + +# TWARDY ZAKAZ: ``Uczelnia.objects.get_default()`` / ``Uczelnia.objects.default`` +# nie istnieją już jako API — 0 dozwolonych wystąpień (też w komentarzach, żeby +# nie sugerować nieistniejącej metody). +PATTERN = re.compile(r"Uczelnia\.objects\.(?:get_default\(\)|default\b)") + +# Drugi footgun, semantycznie równoważny: ``Uczelnia.objects.first()`` / +# ``Uczelnia.objects.all()[0]`` zgaduje „pierwszą-z-brzegu" uczelnię niezależnie +# od hosta z requestu. ``all()[0]`` dorzucony prewencyjnie (0 wystąpień dziś). +PATTERN_FIRST = re.compile(r"Uczelnia\.objects\.(?:first\(\)|all\(\)\s*\[\s*0\s*\])") + +SRC = Path(__file__).resolve().parents[2] # .../src + +# Whitelist dla ``Uczelnia.objects.first()``. Każdy wpis to ŚWIADOMY fallback +# bez requestu (warstwa modelu / UI default / demo / debug / komentarz). +APPROVED_FIRST: dict[str, int] = { + "bpp/demo_data/generators/uczelnia.py": 1, # demo/seed, CLI bez requestu + "bpp/management/commands/debug_setup_initial_data.py": 1, # debug command, None-tolerant + "bpp/models/jednostka.py": 1, # KOMENTARZ (nie kod) — zakomentowany default=lambda +} + + +def _scan(pattern: re.Pattern) -> dict[str, int]: + found: dict[str, int] = {} + for path in SRC.rglob("*.py"): + rel = path.relative_to(SRC).as_posix() + if "/tests/" in f"/{rel}" or "/migrations/" in f"/{rel}": + continue + if path.name.startswith("test_") or path.name == "tests.py": + continue + n = len(pattern.findall(path.read_text(encoding="utf-8"))) + if n: + found[rel] = n + return found + + +def test_get_default_usuniete_na_trwale(): + """``Uczelnia.objects.get_default()`` / ``.default`` NIE MOŻE istnieć w + runtime — metoda i cached_property zostały usunięte (nie ma „uczelni + domyślnej"). Każde wystąpienie = regresja do footguna pierwszej-z-brzegu. + """ + found = _scan(PATTERN) + + assert not found, ( + "Znaleziono Uczelnia.objects.get_default()/.default — ten byt został " + f"USUNIĘTY na trwałe (nie ma uczelni domyślnej): {found}. Użyj jawnej " + "uczelni (get_for_request / argument / FK obiektu) albo " + "get_single_uczelnia_or_none / get_single_uczelnia_or_fail." + ) + + +def test_first_poza_whitelista_to_regresja_multihosted(): + """``Uczelnia.objects.first()`` w runtime to ten sam bug co get_default: + wybiera pierwszą-z-brzegu uczelnię zamiast tej z requestu/argumentu. + + Gdy ten test PADA: + - DODAŁEŚ ``Uczelnia.objects.first()`` → użyj JAWNEJ uczelni: + ``uczelnia_dla_odczytu(request)`` / ``get_for_request(request)`` w + widokach, argument przekazany od wołającego, albo single-or-fail + (``get()`` z CommandError) w komendach CLI. Jeśli miejsce jest NAPRAWDĘ + akceptowalne (warstwa modelu / UI default / demo / debug) — dopisz je do + ``APPROVED_FIRST`` z uzasadnieniem. + - USUNĄŁEŚ ``first()`` (naprawiłeś multi-hosted) → zmniejsz licznik / usuń + wpis z ``APPROVED_FIRST``. + """ + found = _scan(PATTERN_FIRST) + + nowe = {f: n for f, n in found.items() if n > APPROVED_FIRST.get(f, 0)} + assert not nowe, ( + "Nowe/dodatkowe Uczelnia.objects.first()/all()[0] poza whitelistą " + f"(potencjalny bug multi-hosted): {nowe}. Użyj jawnej uczelni " + "(uczelnia_dla_odczytu / get_for_request / argument / single-or-fail) " + "albo dopisz do APPROVED_FIRST w tym pliku z uzasadnieniem." + ) diff --git a/src/bpp/tests/test_multiseek/test_index_copernicus_per_uczelnia.py b/src/bpp/tests/test_multiseek/test_index_copernicus_per_uczelnia.py new file mode 100644 index 000000000..d7848bf6c --- /dev/null +++ b/src/bpp/tests/test_multiseek/test_index_copernicus_per_uczelnia.py @@ -0,0 +1,54 @@ +"""Multi-hosted: pole multiseek „Index Copernicus" respektuje ustawienie +``pokazuj_index_copernicus`` uczelni Z REQUESTU (host), a nie zgaduje +jedynej/pierwszej-z-brzegu. + +Bug: bazowy ``BppMultiseekVisibilityMixin.enabled(request)`` wołał +``option_enabled()`` bez argumentów, więc ``IndexCopernicusQueryObject`` +nigdy nie dostawał requestu → przy >1 uczelni zawsze ``True`` (widoczne), +niezależnie od ustawienia oglądanej uczelni. +""" + +import pytest + +from bpp.models import BppUser +from bpp.multiseek_registry.fields.numeric_fields import IndexCopernicusQueryObject +from fixtures.conftest_multisite import make_request_for_site + + +def _staff_request(site): + user = BppUser.objects.create_user( + username=f"ic_staff_{site.pk}", is_staff=True + ) + return make_request_for_site(site, user=user) + + +@pytest.mark.django_db +def test_index_copernicus_ukryty_dla_uczelni_z_requestu( + uczelnia1, uczelnia2, site1, settings +): + """U1.pokazuj_index_copernicus=False + request na host U1 → pole ukryte, + mimo że w systemie jest druga uczelnia (get_single_uczelnia_or_none → None + nie może o tym decydować).""" + settings.ALLOWED_HOSTS = ["*"] + uczelnia1.pokazuj_index_copernicus = False + uczelnia1.save() + uczelnia2.pokazuj_index_copernicus = True + uczelnia2.save() + + field = IndexCopernicusQueryObject() + assert field.enabled(_staff_request(site1)) is False + + +@pytest.mark.django_db +def test_index_copernicus_widoczny_dla_uczelni_z_requestu( + uczelnia1, uczelnia2, site2, settings +): + """U2.pokazuj_index_copernicus=True + request na host U2 → pole widoczne.""" + settings.ALLOWED_HOSTS = ["*"] + uczelnia1.pokazuj_index_copernicus = False + uczelnia1.save() + uczelnia2.pokazuj_index_copernicus = True + uczelnia2.save() + + field = IndexCopernicusQueryObject() + assert field.enabled(_staff_request(site2)) is True diff --git a/src/bpp/tests/test_multiseek/test_mixins.py b/src/bpp/tests/test_multiseek/test_mixins.py index 70ac5af8f..c0b53e55c 100644 --- a/src/bpp/tests/test_multiseek/test_mixins.py +++ b/src/bpp/tests/test_multiseek/test_mixins.py @@ -20,7 +20,7 @@ class TestQueryObjectDisabled(BppMultiseekVisibilityMixin, StringQueryObject): field_name = "bar" public = True - def option_enabled(self): + def option_enabled(self, request=None): return False diff --git a/src/pbn_api/conf/__init__.py b/src/bpp/tests/test_multisite/__init__.py similarity index 100% rename from src/pbn_api/conf/__init__.py rename to src/bpp/tests/test_multisite/__init__.py diff --git a/src/bpp/tests/test_multisite/test_isolation.py b/src/bpp/tests/test_multisite/test_isolation.py new file mode 100644 index 000000000..02d7c355c --- /dev/null +++ b/src/bpp/tests/test_multisite/test_isolation.py @@ -0,0 +1,172 @@ +"""Integration tests for multi-site data isolation.""" + +import pytest +from model_bakery import baker + +from fixtures.conftest_multisite import make_request_for_site + + +@pytest.mark.django_db +def test_article_visible_only_on_assigned_site( + uczelnia1, uczelnia2, site1, site2, settings +): + """Article z siteblog przypisany do site1 nie jest widoczny na uczelni2.""" + from siteblog.models import Article + + settings.ALLOWED_HOSTS = ["*"] + + article = baker.make( + Article, + title="Test Article U1", + article_body="Body text", + status=Article.STATUS.published, + ) + article.sites.set([site1]) + + from bpp.views.browse import get_uczelnia_context_data + + get_uczelnia_context_data.invalidate() + + ctx1 = get_uczelnia_context_data(uczelnia1) + ctx2 = get_uczelnia_context_data(uczelnia2) + + assert article in ctx1["news"] + assert article not in ctx2["news"] + + +@pytest.mark.django_db +def test_article_on_all_sites_when_both_assigned(uczelnia1, uczelnia2, site1, site2): + """Article przypisany do obu site'ów jest widoczny na obu uczelniach.""" + from siteblog.models import Article + + from bpp.views.browse import get_uczelnia_context_data + + article = baker.make( + Article, + title="Global Article", + article_body="Body text", + status=Article.STATUS.published, + ) + article.sites.set([site1, site2]) + + get_uczelnia_context_data.invalidate() + + ctx1 = get_uczelnia_context_data(uczelnia1) + ctx2 = get_uczelnia_context_data(uczelnia2) + + assert article in ctx1["news"] + assert article in ctx2["news"] + + +@pytest.mark.django_db +def test_article_with_empty_m2m_visible_on_all_sites(uczelnia1, uczelnia2): + """Pusty M2M ``sites`` = artykuł widoczny wszędzie (siteblog convention).""" + from siteblog.models import Article + + from bpp.views.browse import get_uczelnia_context_data + + article = baker.make( + Article, + title="Universal Article", + article_body="Body text", + status=Article.STATUS.published, + ) + # Celowo brak article.sites.set(...) — pusty M2M, zgodnie z help_textem + # siteblog: "Leave empty to make it visible on all sites." + + get_uczelnia_context_data.invalidate() + + ctx1 = get_uczelnia_context_data(uczelnia1) + ctx2 = get_uczelnia_context_data(uczelnia2) + + assert article in ctx1["news"] + assert article in ctx2["news"] + + +@pytest.mark.django_db +def test_staff_cannot_see_other_uczelnia_jednostki_in_admin( + site1, + site2, + uczelnia1, + uczelnia2, + jednostka_uczelnia1, + jednostka_uczelnia2, + staff_user_uczelnia1, + settings, +): + """Staff user on site1 cannot see jednostki from uczelnia2.""" + settings.ALLOWED_HOSTS = ["*"] + from django.contrib.admin.sites import AdminSite + + from bpp.admin.jednostka import JednostkaAdmin + from bpp.models import Jednostka + + request = make_request_for_site(site1, path="/admin/", user=staff_user_uczelnia1) + admin = JednostkaAdmin(Jednostka, AdminSite()) + qs = admin.get_queryset(request) + + assert jednostka_uczelnia1 in qs + assert jednostka_uczelnia2 not in qs + + +@pytest.mark.django_db +def test_staff_cannot_access_other_uczelnia_admin( + site1, + site2, + uczelnia1, + uczelnia2, + staff_user_uczelnia1, + settings, +): + """Staff user with access to site1 gets 403 on site2's admin.""" + settings.ALLOWED_HOSTS = ["*"] + from bpp.middleware import SiteResolutionMiddleware + + request = make_request_for_site(site2, path="/admin/", user=staff_user_uczelnia1) + mw = SiteResolutionMiddleware(lambda r: None) + response = mw.process_view(request, None, [], {}) + assert response is not None + assert response.status_code == 403 + + +@pytest.mark.django_db +def test_browse_uczelnia_count_excludes_other_uczelnia( + uczelnia1, + uczelnia2, + jednostka_uczelnia1, + jednostka_uczelnia2, + autor_uczelnia1, + autor_uczelnia2, + typy_odpowiedzialnosci, + jezyki, + charaktery_formalne, +): + """Record count on uczelnia1 excludes uczelnia2's records.""" + from bpp.views.browse import get_uczelnia_context_data + + # Create a publication with autor from uczelnia1 + wc1 = baker.make("bpp.Wydawnictwo_Ciagle") + baker.make( + "bpp.Wydawnictwo_Ciagle_Autor", + rekord=wc1, + autor=autor_uczelnia1, + jednostka=jednostka_uczelnia1, + ) + + # Create a publication with autor from uczelnia2 + wc2 = baker.make("bpp.Wydawnictwo_Ciagle") + baker.make( + "bpp.Wydawnictwo_Ciagle_Autor", + rekord=wc2, + autor=autor_uczelnia2, + jednostka=jednostka_uczelnia2, + ) + + get_uczelnia_context_data.invalidate() + + ctx1 = get_uczelnia_context_data(uczelnia1) + ctx2 = get_uczelnia_context_data(uczelnia2) + + # Each uczelnia should see only its own record count + assert ctx1["total_rekord_count"] >= 1 + assert ctx2["total_rekord_count"] >= 1 diff --git a/src/bpp/tests/test_playwright/test_admin/test_admin_actions.py b/src/bpp/tests/test_playwright/test_admin/test_admin_actions.py index 6a1f8b715..01f704604 100644 --- a/src/bpp/tests/test_playwright/test_admin/test_admin_actions.py +++ b/src/bpp/tests/test_playwright/test_admin/test_admin_actions.py @@ -75,9 +75,13 @@ def test_admin_domyslnie_afiliuje_istniejacy_rekord( from bpp.models.wydawnictwo_zwarte import Wydawnictwo_Zwarte # twórz nowy obiekt, nie używaj z fixtury, bo db i transactional_db - baker.make(Uczelnia, domyslnie_afiliuje=expected) + uczelnia = baker.make(Uczelnia, domyslnie_afiliuje=expected) autor = baker.make(Autor, nazwisko="Kowal", imiona="Ski") - jednostka = baker.make(Jednostka, nazwa="Lol", skrot="WT") + # Przypnij jednostkę do TEJ uczelni — bez tego baker przez FK + # Jednostka.uczelnia tworzy DRUGĄ uczelnię, get_single_uczelnia_or_none() + # zwraca wtedy None (>1) i default afiliacji degraduje do True, psując + # asercję dla expected=False. + jednostka = baker.make(Jednostka, nazwa="Lol", skrot="WT", uczelnia=uczelnia) klasa_model = { "Wydawnictwo_Ciagle": Wydawnictwo_Ciagle, diff --git a/src/bpp/tests/test_util/test_uczelnia_scope.py b/src/bpp/tests/test_util/test_uczelnia_scope.py new file mode 100644 index 000000000..3df614ae1 --- /dev/null +++ b/src/bpp/tests/test_util/test_uczelnia_scope.py @@ -0,0 +1,50 @@ +import pytest +from model_bakery import baker + +from bpp.models import Rekord +from bpp.util.uczelnia_scope import scope_rekord_do_uczelni, tylko_jedna_uczelnia + + +@pytest.mark.django_db +def test_tylko_jedna_uczelnia_true_dla_jednej(uczelnia1): + assert tylko_jedna_uczelnia() is True + + +@pytest.mark.django_db +def test_tylko_jedna_uczelnia_false_dla_dwoch(uczelnia1, uczelnia2): + assert tylko_jedna_uczelnia() is False + + +@pytest.mark.django_db +def test_scope_none_uczelnia_zwraca_qs_bez_zmian(uczelnia1): + qs = Rekord.objects.all() + assert scope_rekord_do_uczelni(qs, None) is qs + + +@pytest.mark.django_db +def test_scope_single_install_short_circuit(uczelnia1): + qs = Rekord.objects.all() + assert scope_rekord_do_uczelni(qs, uczelnia1) is qs + + +@pytest.mark.django_db +def test_scope_dwie_uczelnie_filtruje( + uczelnia1, + uczelnia2, + jednostka_uczelnia1, + jednostka_uczelnia2, + autor_uczelnia1, + autor_uczelnia2, +): + w1 = baker.make("bpp.Wydawnictwo_Ciagle", tytul_oryginalny="MOJA") + w1.dodaj_autora(autor_uczelnia1, jednostka_uczelnia1) + w2 = baker.make("bpp.Wydawnictwo_Ciagle", tytul_oryginalny="OBCA") + w2.dodaj_autora(autor_uczelnia2, jednostka_uczelnia2) + + tytuly = set( + scope_rekord_do_uczelni(Rekord.objects.all(), uczelnia1).values_list( + "tytul_oryginalny", flat=True + ) + ) + assert "MOJA" in tytuly + assert "OBCA" not in tytuly diff --git a/src/bpp/tests/test_views/test_api.py b/src/bpp/tests/test_views/test_api.py index 4457fcc32..0770807bd 100644 --- a/src/bpp/tests/test_views/test_api.py +++ b/src/bpp/tests/test_views/test_api.py @@ -4,7 +4,7 @@ import pytest from django.urls import reverse -from bpp.models import Autor_Dyscyplina, Typ_Odpowiedzialnosci, Uczelnia +from bpp.models import Autor_Dyscyplina, Typ_Odpowiedzialnosci from bpp.models.zrodlo import Punktacja_Zrodla from bpp.tests.util import CURRENT_YEAR, any_autor, any_habilitacja, any_zrodlo from bpp.views.api import ( @@ -87,8 +87,6 @@ def test_GetPBNPublicationsByISBN_jedna_praca( UID_REKORDU = "foobar" TYTUL_REKORDU = "Jakis tytul" - orig = Uczelnia.objects.get_default - pub1 = pbn_publication_json( mongoId=UID_REKORDU, year=ROK, isbn=ISBN, title=TYTUL_REKORDU ) @@ -100,17 +98,15 @@ def test_GetPBNPublicationsByISBN_jedna_praca( req = rf.post("/", data=dict(t=ISBN, rok="2021")) req.user = admin_user + # Multi-hosted: jawnie ustawiamy uczelnię requestu (NIE ma get_default). + req._uczelnia = pbn_uczelnia - pbn_client.transport.return_values[ - "/api/v1/search/publications?size=10" - ] = pbn_pageable_json([pub1]) + pbn_client.transport.return_values["/api/v1/search/publications?size=10"] = ( + pbn_pageable_json([pub1]) + ) pbn_client.transport.return_values[f"/api/v1/publications/id/{UID_REKORDU}"] = pub1 - try: - Uczelnia.objects.get_default = lambda *args, **kw: pbn_uczelnia - res = GetPBNPublicationsByISBN(request=req).post(req) - finally: - Uczelnia.objects.get_default = orig + res = GetPBNPublicationsByISBN(request=req).post(req) assert json.loads(res.content)["id"] == UID_REKORDU @@ -124,8 +120,6 @@ def test_GetPBNPublicationsByISBN_wiele_isbn( UID_REKORDU = "foobar" TYTUL_REKORDU = "Jakis tytul" - orig = Uczelnia.objects.get_default - pub1 = pbn_publication_json( mongoId=UID_REKORDU, year=ROK, isbn=ISBN, title=TYTUL_REKORDU ) @@ -140,19 +134,16 @@ def test_GetPBNPublicationsByISBN_wiele_isbn( req = rf.post("/", data=dict(t=ISBN, rok="2021")) req.user = admin_user + # Multi-hosted: jawnie ustawiamy uczelnię requestu (NIE ma get_default). + req._uczelnia = pbn_uczelnia - pbn_client.transport.return_values[ - "/api/v1/search/publications?size=10" - ] = pbn_pageable_json([pub1, pub2]) + pbn_client.transport.return_values["/api/v1/search/publications?size=10"] = ( + pbn_pageable_json([pub1, pub2]) + ) pbn_client.transport.return_values[f"/api/v1/publications/id/{UID_REKORDU}"] = pub1 pbn_client.transport.return_values[f"/api/v1/publications/id/{UID_REKORDU}2"] = pub2 - try: - Uczelnia.objects.get_default = lambda *args, **kw: pbn_uczelnia - - res = GetPBNPublicationsByISBN(request=req).post(req) - finally: - Uczelnia.objects.get_default = orig + res = GetPBNPublicationsByISBN(request=req).post(req) assert json.loads(res.content)["id"] == UID_REKORDU diff --git a/src/bpp/tests/test_views/test_autocomplete_per_uczelnia.py b/src/bpp/tests/test_views/test_autocomplete_per_uczelnia.py new file mode 100644 index 000000000..3d8f10b00 --- /dev/null +++ b/src/bpp/tests/test_views/test_autocomplete_per_uczelnia.py @@ -0,0 +1,310 @@ +import pytest + +from bpp.models import Jednostka, Wydzial +from fixtures.conftest_multisite import make_request_for_site + + +@pytest.mark.django_db +def test_jednostka_autocomplete_zawezony_do_uczelni( + uczelnia1, uczelnia2, site1, jednostka_uczelnia1, jednostka_uczelnia2, settings +): + settings.ALLOWED_HOSTS = ["*"] + from bpp.views.autocomplete.units import WidocznaJednostkaAutocomplete + + # WidocznaJednostkaAutocomplete.qset = Jednostka.objects.widoczne(), tj. + # filter(widoczna=True). Pole `widoczna` ma default=True, ale ustawiamy je + # jawnie na obu jednostkach, by test mierzył filtr per-uczelnia, a nie + # widoczność. + Jednostka.objects.filter( + pk__in=[jednostka_uczelnia1.pk, jednostka_uczelnia2.pk] + ).update(widoczna=True) + + view = WidocznaJednostkaAutocomplete() + view.request = make_request_for_site(site1) + view.q = "" + pks = set(view.get_queryset().values_list("pk", flat=True)) + assert jednostka_uczelnia1.pk in pks + assert jednostka_uczelnia2.pk not in pks + + +@pytest.mark.django_db +def test_wydzial_autocomplete_zawezony_do_uczelni( + uczelnia1, uczelnia2, site1, wydzial_uczelnia1, wydzial_uczelnia2, settings +): + settings.ALLOWED_HOSTS = ["*"] + from bpp.views.autocomplete.simple import PublicWydzialAutocomplete + + # PublicWydzialAutocomplete.qset = Wydzial.objects.filter(widoczny=True). + # Pole `widoczny` ma default=True, ale ustawiamy je jawnie na obu + # wydziałach, by test mierzył filtr per-uczelnia, a nie widoczność. + Wydzial.objects.filter(pk__in=[wydzial_uczelnia1.pk, wydzial_uczelnia2.pk]).update( + widoczny=True + ) + + view = PublicWydzialAutocomplete() + view.request = make_request_for_site(site1) + view.q = "" + pks = set(view.get_queryset().values_list("pk", flat=True)) + assert wydzial_uczelnia1.pk in pks + assert wydzial_uczelnia2.pk not in pks + + +@pytest.mark.django_db +def test_autor_autocomplete_kiedykolwiek_zwiazany( + uczelnia1, + uczelnia2, + site1, + jednostka_uczelnia1, + jednostka_uczelnia2, + autor_uczelnia1, + autor_uczelnia2, + settings, +): + settings.ALLOWED_HOSTS = ["*"] + from model_bakery import baker + + from bpp.views.autocomplete.authors import PublicAutorAutocomplete + + # autor historyczny: aktualna jednostka w U2, ale wpis Autor_Jednostka w U1 + autor_hist = baker.make("bpp.Autor", aktualna_jednostka=jednostka_uczelnia2) + baker.make("bpp.Autor_Jednostka", autor=autor_hist, jednostka=jednostka_uczelnia1) + + view = PublicAutorAutocomplete() + view.request = make_request_for_site(site1) + view.q = "" + pks = set(view.get_queryset().values_list("pk", flat=True)) + assert autor_uczelnia1.pk in pks # obecny pracownik U1 + assert autor_hist.pk in pks # historycznie związany z U1 + assert autor_uczelnia2.pk not in pks # tylko U2 → zewnętrzny dla U1 + + +@pytest.mark.django_db +def test_autor_autocomplete_dedup_wielokrotna_historia( + uczelnia1, uczelnia2, site1, jednostka_uczelnia1, settings +): + """Autor z wieloma wpisami Autor_Jednostka w U1 pojawia się DOKŁADNIE raz + (kontrakt .distinct() — join po historii mnoży wiersze).""" + settings.ALLOWED_HOSTS = ["*"] + from model_bakery import baker + + from bpp.views.autocomplete.authors import PublicAutorAutocomplete + + # druga jednostka tej samej uczelni U1, by autor miał 2 wpisy historii w U1 + jedn_u1_b = baker.make("bpp.Jednostka", uczelnia=uczelnia1) + autor = baker.make("bpp.Autor", aktualna_jednostka=jednostka_uczelnia1) + baker.make("bpp.Autor_Jednostka", autor=autor, jednostka=jednostka_uczelnia1) + baker.make("bpp.Autor_Jednostka", autor=autor, jednostka=jedn_u1_b) + + view = PublicAutorAutocomplete() + view.request = make_request_for_site(site1) + view.q = "" + pk_list = list(view.get_queryset().values_list("pk", flat=True)) + assert pk_list.count(autor.pk) == 1 # nie zduplikowany mimo 2 wpisów historii + + +def test_admin_autocomplety_nie_sa_zawezone(): + """Admin/edytor autocomplety NIE dziedziczą scopingu — pełny dostęp do + wszystkich uczelni (multi-hosted: tylko publiczne pickery są zawężone).""" + from bpp.views.autocomplete.authors import AutorAutocomplete + from bpp.views.autocomplete.mixins import UczelniaScopedAutocompleteMixin + from bpp.views.autocomplete.simple import WydzialAutocomplete + from bpp.views.autocomplete.units import JednostkaAutocomplete + + assert not issubclass(JednostkaAutocomplete, UczelniaScopedAutocompleteMixin) + assert not issubclass(WydzialAutocomplete, UczelniaScopedAutocompleteMixin) + assert not issubclass(AutorAutocomplete, UczelniaScopedAutocompleteMixin) + + +@pytest.mark.django_db +def test_public_jednostka_autocomplete_zawezony_do_uczelni( + uczelnia1, uczelnia2, site1, jednostka_uczelnia1, jednostka_uczelnia2, settings +): + settings.ALLOWED_HOSTS = ["*"] + from bpp.views.autocomplete.units import PublicJednostkaAutocomplete + + # PublicJednostkaAutocomplete używa Jednostka.objects.publiczne(), tj. + # widoczne().filter(aktualna=True) → filter(widoczna=True, aktualna=True). + # `aktualna` ma default=False, więc fixtury (Jednostka.objects.create bez + # tego pola) NIE są publiczne. Ustawiamy widoczna=True ORAZ aktualna=True na + # obu jednostkach, by test mierzył filtr per-uczelnia, a nie publiczność. + Jednostka.objects.filter( + pk__in=[jednostka_uczelnia1.pk, jednostka_uczelnia2.pk] + ).update(widoczna=True, aktualna=True) + + view = PublicJednostkaAutocomplete() + view.request = make_request_for_site(site1) + view.q = "" + pks = set(view.get_queryset().values_list("pk", flat=True)) + assert jednostka_uczelnia1.pk in pks + assert jednostka_uczelnia2.pk not in pks + + +@pytest.mark.django_db +def test_public_autor_autocomplete_plaska_lista_bez_optgroup( + uczelnia1, uczelnia2, site1, jednostka_uczelnia1, autor_uczelnia1, settings +): + """Publiczny picker autorów zwraca PŁASKĄ listę (bez optgroup). + + Grupowanie z ``AutorAutocompleteBase`` emitowało nagłówek optgroup w każdej + stronie odpowiedzi Select2 → przy przewijaniu „✅ Autorzy z naszej uczelni" + powielał się. Publiczny picker ma listę płaską (klucz ``children`` nie + występuje). + """ + settings.ALLOWED_HOSTS = ["*"] + from model_bakery import baker + + from bpp.views.autocomplete.authors import PublicAutorAutocomplete + + baker.make("bpp.Autor", aktualna_jednostka=jednostka_uczelnia1) + + view = PublicAutorAutocomplete() + view.request = make_request_for_site(site1) + view.q = "" + context = {"object_list": list(view.get_queryset())} + results = view.get_results(context) + + assert results, "brak wyników w teście" + assert all("children" not in r for r in results), "wciąż są optgroupy" + assert all(r["id"] for r in results), "element bez id (nagłówek grupy)" + + +@pytest.mark.django_db +def test_public_autor_autocomplete_single_install_tylko_uczelnia( + uczelnia1, site1, jednostka_uczelnia1, autor_uczelnia1, settings +): + """Single-install: publiczny picker pokazuje TYLKO autorów z uczelni. + + Mixin scope'ujący jest no-op przy jednej uczelni (``tylko_jedna_uczelnia``), + więc bez własnego filtra autor zewnętrzny (bez afiliacji) by przeciekł. + """ + settings.ALLOWED_HOSTS = ["*"] + from model_bakery import baker + + from bpp.models import Uczelnia + from bpp.views.autocomplete.authors import PublicAutorAutocomplete + + assert Uczelnia.objects.count() == 1, "to ma być scenariusz single-install" + + zewnetrzny = baker.make("bpp.Autor", aktualna_jednostka=None) + + view = PublicAutorAutocomplete() + view.request = make_request_for_site(site1) + view.q = "" + pks = set(view.get_queryset().values_list("pk", flat=True)) + assert autor_uczelnia1.pk in pks + assert zewnetrzny.pk not in pks + + +@pytest.mark.django_db +def test_autor_aktualnie_zatrudniony_tylko_aktualna_jednostka( + uczelnia1, + uczelnia2, + site1, + jednostka_uczelnia1, + jednostka_uczelnia2, + autor_uczelnia1, + autor_uczelnia2, + settings, +): + """``AutorAktualnieZatrudnionyNaUczelni`` zawęża WYŁĄCZNIE po + ``aktualna_jednostka__uczelnia`` — bez żadnych innych warunków. + + Aktualnie zatrudniony w U1 → jest. Aktualny w U2 → odpada. Bez aktualnej + jednostki (niezatrudniony / tylko historia) → odpada. Lista płaska. + """ + settings.ALLOWED_HOSTS = ["*"] + from model_bakery import baker + + from bpp.views.autocomplete.authors import AutorAktualnieZatrudnionyNaUczelni + + # niezatrudniony aktualnie nigdzie (np. tylko historia) → poza zakresem + autor_bez_aktualnej = baker.make("bpp.Autor", aktualna_jednostka=None) + + view = AutorAktualnieZatrudnionyNaUczelni() + view.request = make_request_for_site(site1) + view.q = "" + pks = set(view.get_queryset().values_list("pk", flat=True)) + + assert autor_uczelnia1.pk in pks # aktualnie zatrudniony w U1 + assert autor_uczelnia2.pk not in pks # aktualny w U2 → odpada + assert autor_bez_aktualnej.pk not in pks # brak aktualnej jednostki → odpada + + context = {"object_list": list(view.get_queryset())} + results = view.get_results(context) + assert all("children" not in r for r in results), "lista ma być płaska" + + +@pytest.mark.django_db +def test_create_from_string_honoruje_podana_uczelnie(uczelnia1, uczelnia2): + """``AutorManager.create_from_string`` czyta ``nowy_autor_z_formularza_pokazuj`` + z PODANEJ uczelni, nie z pierwszej-z-brzegu (``Uczelnia.objects.first()``). + """ + from bpp.models import Autor + + uczelnia1.nowy_autor_z_formularza_pokazuj = False + uczelnia1.save() + uczelnia2.nowy_autor_z_formularza_pokazuj = True + uczelnia2.save() + + # uczelnia2 (wyższy pk) NIE jest first() — first() to uczelnia1 (False). + autor = Autor.objects.create_from_string("Kowalski Jan", uczelnia=uczelnia2) + assert autor.pokazuj is True + + autor2 = Autor.objects.create_from_string("Nowak Anna", uczelnia=uczelnia1) + assert autor2.pokazuj is False + + +@pytest.mark.django_db +def test_create_from_string_bez_uczelni_wiele_uczelni_nie_zgaduje(uczelnia1, uczelnia2): + """Bez podanej uczelni i przy >1 uczelni: get_single_uczelnia_or_none → None + → ``pokazuj=False`` (bezpieczny default), bez zgadywania pierwszej-z-brzegu. + """ + from bpp.models import Autor + + uczelnia1.nowy_autor_z_formularza_pokazuj = True # first(), gdyby zgadywał + uczelnia1.save() + + autor = Autor.objects.create_from_string("Bezuczelni Ktos") + assert autor.pokazuj is False + + +@pytest.mark.django_db +def test_autor_autocomplete_create_object_uzywa_uczelni_z_requestu( + uczelnia1, uczelnia2, site2, settings +): + """``AutorAutocomplete.create_object`` ustala ``pokazuj`` nowego autora z + uczelni Z REQUESTU (host), nie z pierwszej-z-brzegu. + """ + settings.ALLOWED_HOSTS = ["*"] + from bpp.models import Autor, BppUser + from bpp.views.autocomplete.authors import AutorAutocomplete + + uczelnia1.nowy_autor_z_formularza_pokazuj = False # first() + uczelnia1.save() + uczelnia2.nowy_autor_z_formularza_pokazuj = True + uczelnia2.save() + + user = BppUser.objects.create_user(username="ac_creator", is_staff=True) + + view = AutorAutocomplete() + view.request = make_request_for_site(site2, user=user) # → uczelnia2 + + obj = view.create_object("Iksinski Piotr") + + assert isinstance(obj, Autor) + assert obj.pokazuj is True # z uczelni2 (request), nie z first()=uczelnia1 + + +@pytest.mark.django_db +def test_autocomplete_get_queryset_bez_requestu_nie_wywala(uczelnia1, uczelnia2): + """Mixin toleruje brak self.request (no-op) — kontrakt defensywny bazy. + + Niektóre testy/ścieżki instancjonują widok bez requestu i wołają + get_queryset() bezpośrednio; mixin nie może na tym wywalić AttributeError. + """ + from bpp.views.autocomplete.units import WidocznaJednostkaAutocomplete + + view = WidocznaJednostkaAutocomplete() # brak view.request + view.q = "" + # nie powinno rzucić AttributeError — po prostu nie zawęża + list(view.get_queryset()) diff --git a/src/bpp/tests/test_views/test_browse/test_browse.py b/src/bpp/tests/test_views/test_browse/test_browse.py index 38e9dc074..145ee8aa8 100644 --- a/src/bpp/tests/test_views/test_browse/test_browse.py +++ b/src/bpp/tests/test_views/test_browse/test_browse.py @@ -13,10 +13,10 @@ from model_bakery import baker from multiseek.logic import EQUAL, EQUAL_FEMALE, EQUAL_NONE from multiseek.views import MULTISEEK_SESSION_KEY +from siteblog.models import Article from bpp.models import Rekord, Wydawnictwo_Zwarte from bpp.views.browse import BuildSearch, PracaViewBySlug -from siteblog.models import Article def test_buildSearch(settings): @@ -168,6 +168,7 @@ def test_artykuly(uczelnia, client): a = Article.objects.create( title=TYTUL, article_body="456", status=Article.STATUS.draft, slug="1" ) + a.sites.set([uczelnia.site]) res = client.get(reverse("bpp:browse_uczelnia", args=(uczelnia.slug,))) assert TYTUL.encode("utf-8") not in res.content @@ -189,6 +190,7 @@ def test_artykul_ze_skrotem(uczelnia, client): status=Article.STATUS.published, slug="1", ) + a.sites.set([uczelnia.site]) # Invalidate cacheops cache for get_uczelnia_context_data invalidate_all() diff --git a/src/bpp/tests/test_views/test_browse/test_lata_rok_per_uczelnia.py b/src/bpp/tests/test_views/test_browse/test_lata_rok_per_uczelnia.py new file mode 100644 index 000000000..2fe3a5af0 --- /dev/null +++ b/src/bpp/tests/test_views/test_browse/test_lata_rok_per_uczelnia.py @@ -0,0 +1,62 @@ +import pytest +from model_bakery import baker + +from bpp.views.browse import LataView, RokView +from fixtures.conftest_multisite import make_request_for_site + + +def _dwie_prace( + jednostka_uczelnia1, jednostka_uczelnia2, autor_uczelnia1, autor_uczelnia2 +): + w1 = baker.make("bpp.Wydawnictwo_Ciagle", rok=2020) + w1.dodaj_autora(autor_uczelnia1, jednostka_uczelnia1) + w2 = baker.make("bpp.Wydawnictwo_Ciagle", rok=2021) + w2.dodaj_autora(autor_uczelnia2, jednostka_uczelnia2) + + +@pytest.mark.django_db +def test_lata_view_liczy_tylko_swoja_uczelnie( + uczelnia1, + uczelnia2, + site1, + jednostka_uczelnia1, + jednostka_uczelnia2, + autor_uczelnia1, + autor_uczelnia2, + typy_odpowiedzialnosci, + settings, +): + settings.ALLOWED_HOSTS = ["*"] + _dwie_prace( + jednostka_uczelnia1, jednostka_uczelnia2, autor_uczelnia1, autor_uczelnia2 + ) + view = LataView() + view.request = make_request_for_site(site1) + view.kwargs = {} + lata = {y["year"] for y in view.get_queryset()} + assert 2020 in lata + assert 2021 not in lata + + +@pytest.mark.django_db +def test_rok_view_listuje_tylko_swoja_uczelnie( + uczelnia1, + uczelnia2, + site1, + jednostka_uczelnia1, + jednostka_uczelnia2, + autor_uczelnia1, + autor_uczelnia2, + typy_odpowiedzialnosci, + settings, +): + settings.ALLOWED_HOSTS = ["*"] + _dwie_prace( + jednostka_uczelnia1, jednostka_uczelnia2, autor_uczelnia1, autor_uczelnia2 + ) + view = RokView() + view.request = make_request_for_site(site1) + view.kwargs = {"rok": 2021} + view.object_list = view.get_queryset() + ctx = view.get_context_data() + assert ctx["total_count"] == 0 # praca 2021 należy do uczelni2 diff --git a/src/bpp/tests/test_views/test_global_nav_per_uczelnia.py b/src/bpp/tests/test_views/test_global_nav_per_uczelnia.py new file mode 100644 index 000000000..5ff0d359b --- /dev/null +++ b/src/bpp/tests/test_views/test_global_nav_per_uczelnia.py @@ -0,0 +1,49 @@ +"""Track 1 (audyt uczelnia 2026-06-04): publiczny ``GlobalNavigationAutocomplete`` +zawęża wyniki (jednostki/autorzy/rekordy) do uczelni oglądającego. + +Globalna wyszukiwarka nawigacyjna szukała jednostek/autorów/rekordów globalnie +(tylko ``ukryte_statusy``) — R3b objął dedykowane pickery, ten search-box +pominął. +""" + +import pytest +from django.contrib.auth.models import AnonymousUser +from django.contrib.sites.models import Site +from model_bakery import baker + +from bpp.models import Jednostka, Uczelnia, Wydzial +from bpp.views.autocomplete.navigation import GlobalNavigationAutocomplete + + +@pytest.fixture +def jednostka_drugiej_uczelni(db): + site = baker.make(Site, domain="druga-nav.testserver", name="druga-nav") + uczelnia2 = Uczelnia.objects.create(skrot="DRN", nazwa="Druga", site=site) + wydzial = Wydzial.objects.create(uczelnia=uczelnia2, skrot="W2", nazwa="Wydz II") + return Jednostka.objects.create( + nazwa="Instytut Testowy Beta", skrot="JDN", wydzial=wydzial, uczelnia=uczelnia2 + ) + + +@pytest.mark.django_db +def test_global_nav_zaweza_jednostki_do_uczelni( + jednostka, jednostka_drugiej_uczelni, denorms, rf +): + j1 = jednostka + j1.nazwa = "Instytut Testowy Alfa" + j1.save() + denorms.flush() + + request = rf.get("/?q=Instytut") + request._uczelnia = j1.uczelnia + request.user = AnonymousUser() + + view = GlobalNavigationAutocomplete() + view.request = request + view.q = "Instytut" + + jednostki = [o for o in view.get_queryset() if isinstance(o, Jednostka)] + uczelnie = {j.uczelnia_id for j in jednostki} + + assert j1.pk in {j.pk for j in jednostki} # U1 widoczny + assert jednostka_drugiej_uczelni.uczelnia_id not in uczelnie # U2 nie przecieka diff --git a/src/bpp/tests/test_views/test_handlers.py b/src/bpp/tests/test_views/test_handlers.py index 3196e61b3..87ab6abd0 100644 --- a/src/bpp/tests/test_views/test_handlers.py +++ b/src/bpp/tests/test_views/test_handlers.py @@ -3,6 +3,7 @@ import pytest +@pytest.mark.django_db def test_handler403_permission_denied(client): try: client.get("/admin/bpp/") diff --git a/src/bpp/tests/test_views/test_lata_autocomplete_per_uczelnia.py b/src/bpp/tests/test_views/test_lata_autocomplete_per_uczelnia.py new file mode 100644 index 000000000..7441bf7c5 --- /dev/null +++ b/src/bpp/tests/test_views/test_lata_autocomplete_per_uczelnia.py @@ -0,0 +1,98 @@ +"""Track 1 (audyt uczelnia 2026-06-04): publiczny ``LataAutocomplete`` zawęża +lata do uczelni oglądającego (jak ``LataView`` w R3a). + +Było ``Rekord.objects.all()`` globalnie — picker lat na domenie U1 podpowiadał +lata z rekordów wszystkich uczelni. +""" + +import pytest +from django.contrib.sites.models import Site +from model_bakery import baker + +from bpp.models import ( + Autor_Dyscyplina, + Jednostka, + Uczelnia, + Wydawnictwo_Ciagle, + Wydzial, +) +from bpp.views.autocomplete.simple import LataAutocomplete + + +@pytest.fixture +def jednostka_drugiej_uczelni(db): + site = baker.make(Site, domain="druga-lata.testserver", name="druga-lata") + uczelnia2 = Uczelnia.objects.create(skrot="DRL", nazwa="Druga", site=site) + wydzial = Wydzial.objects.create(uczelnia=uczelnia2, skrot="W2", nazwa="Wydz II") + return Jednostka.objects.create( + nazwa="Jedn II", skrot="JDL", wydzial=wydzial, uczelnia=uczelnia2 + ) + + +@pytest.mark.django_db +def test_lata_autocomplete_zaweza_do_uczelni( + autor_jan_kowalski, + autor_jan_nowak, + jednostka, + jednostka_drugiej_uczelni, + dyscyplina1, + denorms, + typy_odpowiedzialnosci, + charaktery_formalne, + rf, +): + uczelnia1 = jednostka.uczelnia + + Autor_Dyscyplina.objects.create( + autor=autor_jan_kowalski, rok=2020, dyscyplina_naukowa=dyscyplina1 + ) + Autor_Dyscyplina.objects.create( + autor=autor_jan_nowak, rok=2021, dyscyplina_naukowa=dyscyplina1 + ) + wc1 = baker.make(Wydawnictwo_Ciagle, rok=2020, punkty_kbn=5) + wc1.dodaj_autora(autor_jan_kowalski, jednostka, dyscyplina_naukowa=dyscyplina1) + wc2 = baker.make(Wydawnictwo_Ciagle, rok=2021, punkty_kbn=5) + wc2.dodaj_autora( + autor_jan_nowak, jednostka_drugiej_uczelni, dyscyplina_naukowa=dyscyplina1 + ) + denorms.flush() + + request = rf.get("/") + request._uczelnia = uczelnia1 + + view = LataAutocomplete() + view.q = "" + view.request = request + + lata = set(view.get_queryset()) + + assert 2020 in lata # U1 + assert 2021 not in lata # U2 — nie przecieka + + +@pytest.mark.django_db +def test_lata_autocomplete_single_install_bez_zmian( + autor_jan_kowalski, + jednostka, + dyscyplina1, + denorms, + typy_odpowiedzialnosci, + charaktery_formalne, + rf, +): + """Invariant: przy jednej uczelni picker działa jak dawniej.""" + Autor_Dyscyplina.objects.create( + autor=autor_jan_kowalski, rok=2020, dyscyplina_naukowa=dyscyplina1 + ) + wc = baker.make(Wydawnictwo_Ciagle, rok=2020, punkty_kbn=5) + wc.dodaj_autora(autor_jan_kowalski, jednostka, dyscyplina_naukowa=dyscyplina1) + denorms.flush() + + request = rf.get("/") + request._uczelnia = jednostka.uczelnia + + view = LataAutocomplete() + view.q = "" + view.request = request + + assert 2020 in set(view.get_queryset()) diff --git a/src/bpp/tests/test_views/test_oai.py b/src/bpp/tests/test_views/test_oai.py index 3a2cf8d98..a1e22b3cd 100644 --- a/src/bpp/tests/test_views/test_oai.py +++ b/src/bpp/tests/test_views/test_oai.py @@ -58,7 +58,7 @@ def test_listRecords_status_korekty( @pytest.mark.django_db def test_listRecords_no_queries_zwarte(ksiazka, client, django_assert_max_num_queries): listRecords = reverse("bpp:oai") + "?verb=ListRecords&metadataPrefix=oai_dc" - with django_assert_max_num_queries(6): + with django_assert_max_num_queries(9): res = client.get(listRecords) assert "Tytul Wydawnictwo" in toXML(res)[2][0][1][0][1].text @@ -66,6 +66,6 @@ def test_listRecords_no_queries_zwarte(ksiazka, client, django_assert_max_num_qu @pytest.mark.django_db def test_listRecords_no_queries_ciagle(artykul, client, django_assert_max_num_queries): listRecords = reverse("bpp:oai") + "?verb=ListRecords&metadataPrefix=oai_dc" - with django_assert_max_num_queries(7): + with django_assert_max_num_queries(10): res = client.get(listRecords) assert "Tytul Wydawnictwo" in toXML(res)[2][0][1][0][1].text diff --git a/src/bpp/tests/test_views/test_oai_per_uczelnia.py b/src/bpp/tests/test_views/test_oai_per_uczelnia.py new file mode 100644 index 000000000..848c01333 --- /dev/null +++ b/src/bpp/tests/test_views/test_oai_per_uczelnia.py @@ -0,0 +1,38 @@ +import pytest +from django.urls import reverse +from model_bakery import baker + + +@pytest.mark.django_db +def test_oai_listrecords_wyklucza_obca_uczelnie( + uczelnia1, + uczelnia2, + site1, + jednostka_uczelnia1, + jednostka_uczelnia2, + autor_uczelnia1, + autor_uczelnia2, + client, + settings, +): + settings.ALLOWED_HOSTS = ["*"] # pozwól na HTTP_HOST domeny uczelni + chf = baker.make("bpp.Charakter_Formalny", skrot="OAI-TST", nazwa_w_primo="Artykuł") + w1 = baker.make( + "bpp.Wydawnictwo_Ciagle", + tytul_oryginalny="PRACA-MOJA", + rok=2020, + charakter_formalny=chf, + ) + w1.dodaj_autora(autor_uczelnia1, jednostka_uczelnia1) + w2 = baker.make( + "bpp.Wydawnictwo_Ciagle", + tytul_oryginalny="PRACA-OBCA", + rok=2020, + charakter_formalny=chf, + ) + w2.dodaj_autora(autor_uczelnia2, jednostka_uczelnia2) + + url = reverse("bpp:oai") + "?verb=ListRecords&metadataPrefix=oai_dc" + body = client.get(url, HTTP_HOST=site1.domain).content.decode("utf-8") + assert "PRACA-MOJA" in body + assert "PRACA-OBCA" not in body diff --git a/src/bpp/tests/test_views/test_profile_per_uczelnia.py b/src/bpp/tests/test_views/test_profile_per_uczelnia.py new file mode 100644 index 000000000..3b509ecf2 --- /dev/null +++ b/src/bpp/tests/test_views/test_profile_per_uczelnia.py @@ -0,0 +1,74 @@ +"""Track 1 (audyt uczelnia 2026-06-04): profil użytkownika pokazuje metryki +TYLKO z uczelni oglądającego (tej z requestu). + +``ProfilUzytkownikaView`` robił ``MetrykaAutora.objects.filter(autor=autor)`` +bez zawężenia — autor afiliowany do >1 uczelni widział na profilu metryki ze +WSZYSTKICH uczelni (przeoczenie wątku D, który objął tylko ``ewaluacja_metryki/ +views/``, nie profil w ``bpp/views/``). +""" + +from decimal import Decimal + +import pytest +from django.contrib.sites.models import Site +from model_bakery import baker + +from bpp.models import Uczelnia +from bpp.views.profile import ProfilUzytkownikaView + + +@pytest.fixture +def druga_uczelnia_profile(db): + site = baker.make(Site, domain="druga-prof.testserver", name="druga-prof") + return Uczelnia.objects.create(skrot="DRP", nazwa="Druga", site=site) + + +@pytest.mark.django_db +def test_profil_metryki_zaweza_do_uczelni_ogladajacego( + autor_jan_kowalski, uczelnia, druga_uczelnia_profile, dyscyplina1, rf +): + from ewaluacja_metryki.models import MetrykaAutora + + # MetrykaAutora.save() PRZELICZA pola pochodne z pól slotów/punktów: + # srednia_za_slot_* = punkty_* / slot_* + # procent_wykorzystania_slotow = (slot_nazbierany / slot_maksymalny) * 100 + # Losowe wartości baker-a (DecimalField(10,4), niezależne) potrafią dać iloraz + # przepełniający procent (DecimalField(5,2), < 10^3) albo średnią — stąd flaky + # NumericValueOutOfRange zależny od seeda/sharda. Pinujemy pola WEJŚCIOWE do + # zdrowych wartości; test i tak nie patrzy na liczby, tylko na zawężenie po + # uczelni. + metryka_pola = dict( + slot_maksymalny=Decimal("10.0000"), + slot_nazbierany=Decimal("5.0000"), + punkty_nazbierane=Decimal("50.0000"), + slot_wszystkie=Decimal("10.0000"), + punkty_wszystkie=Decimal("50.0000"), + ) + baker.make( + MetrykaAutora, + autor=autor_jan_kowalski, + dyscyplina_naukowa=dyscyplina1, + uczelnia=uczelnia, + **metryka_pola, + ) + baker.make( + MetrykaAutora, + autor=autor_jan_kowalski, + dyscyplina_naukowa=dyscyplina1, + uczelnia=druga_uczelnia_profile, + **metryka_pola, + ) + + user = baker.make("bpp.BppUser", autor=autor_jan_kowalski) + request = rf.get("/") + request._uczelnia = uczelnia + request.user = user + + view = ProfilUzytkownikaView() + view.request = request + view.kwargs = {} + + ctx = view.get_context_data() + uczelnia_ids = set(ctx["metryki"].values_list("uczelnia_id", flat=True)) + + assert uczelnia_ids == {uczelnia.pk} diff --git a/src/bpp/tests/test_views/test_views_browse.py b/src/bpp/tests/test_views/test_views_browse.py index eb423fb1c..cc5a4beb8 100644 --- a/src/bpp/tests/test_views/test_views_browse.py +++ b/src/bpp/tests/test_views/test_views_browse.py @@ -17,6 +17,7 @@ any_doktorat, any_habilitacja, any_jednostka, + any_uczelnia, ) from bpp.util import rebuild_contenttypes from bpp.views.browse import AutorView, AutorzyView, get_available_letters @@ -42,14 +43,14 @@ def test_root_empty(setup_group, logged_in_client): @pytest.mark.django_db def test_root_with_uczelnia(setup_group, logged_in_client): - Uczelnia.objects.create(nazwa="uczelnia 123", skrot="uu123") + any_uczelnia(nazwa="uczelnia 123", skrot="uu123") res = logged_in_client.get("/", follow=False) assert b"uczelnia 123" in res.content @pytest.mark.django_db def test_browse_wydzial(setup_group, logged_in_client): - u = Uczelnia.objects.create(nazwa="uczelnia", skrot="uu") + u = any_uczelnia(nazwa="uczelnia", skrot="uu") Wydzial.objects.create(nazwa="wydzial", uczelnia=u) res = logged_in_client.get(reverse("bpp:browse_uczelnia", args=("uu",))) assert res.status_code == 200 @@ -59,7 +60,7 @@ def test_browse_wydzial(setup_group, logged_in_client): @pytest.mark.django_db def test_wydzial_with_single_jednostka_redirects(setup_group, logged_in_client): """Wydzial z jedną jednostką przekierowuje na stronę jednostki.""" - u = Uczelnia.objects.create(nazwa="uczelnia", skrot="uu") + u = any_uczelnia(nazwa="uczelnia", skrot="uu") w = Wydzial.objects.create(nazwa="wydzial", uczelnia=u) j = Jednostka.objects.create( nazwa="jedyna jednostka", @@ -80,7 +81,7 @@ def test_wydzial_with_single_jednostka_redirects(setup_group, logged_in_client): @pytest.mark.django_db def test_wydzial_with_multiple_jednostki_shows_page(setup_group, logged_in_client): """Wydzial z wieloma jednostkami wyświetla stronę wydziału.""" - u = Uczelnia.objects.create(nazwa="uczelnia", skrot="uu") + u = any_uczelnia(nazwa="uczelnia", skrot="uu") w = Wydzial.objects.create(nazwa="wydzial", uczelnia=u) Jednostka.objects.create( nazwa="jednostka 1", @@ -108,7 +109,7 @@ def test_wydzial_with_multiple_jednostki_shows_page(setup_group, logged_in_clien @pytest.mark.django_db def test_wydzial_with_single_kolo_naukowe_redirects(setup_group, logged_in_client): """Wydzial z jednym kołem naukowym przekierowuje na stronę koła.""" - u = Uczelnia.objects.create(nazwa="uczelnia", skrot="uu") + u = any_uczelnia(nazwa="uczelnia", skrot="uu") w = Wydzial.objects.create(nazwa="wydzial", uczelnia=u) j = Jednostka.objects.create( nazwa="koło naukowe", @@ -129,7 +130,7 @@ def test_wydzial_with_single_kolo_naukowe_redirects(setup_group, logged_in_clien @pytest.mark.django_db def test_browse_jednostka(setup_group, logged_in_client): - u = Uczelnia.objects.create(nazwa="uczelnia", skrot="uu") + u = any_uczelnia(nazwa="uczelnia", skrot="uu") w = Wydzial.objects.create(nazwa="wydzial", uczelnia=u) j = Jednostka.objects.create(nazwa="jednostka", wydzial=w, uczelnia=u) @@ -285,7 +286,7 @@ def test_oai_list_records(oai_data): def test_autorzy_view_empty_page_redirects(client, setup_group): """Test: AutorzyView redirects to page 1 when EmptyPage occurs.""" # Create test data - need 100+ authors for 2+ pages (paginate_by=50) - Uczelnia.objects.create(nazwa="Test University", skrot="TU") + any_uczelnia(nazwa="Test University", skrot="TU") baker.make(Autor, nazwisko="Test", imiona="Autor", pokazuj=True, _quantity=100) # Try to access non-existent page (we have 2 pages, try page 10) @@ -306,7 +307,7 @@ def test_autorzy_view_empty_page_redirects(client, setup_group): @pytest.mark.django_db def test_autorzy_view_empty_page_preserves_search(client, setup_group): """Test: Redirect preserves search parameter.""" - Uczelnia.objects.create(nazwa="Test University", skrot="TU") + any_uczelnia(nazwa="Test University", skrot="TU") baker.make(Autor, nazwisko="Test", imiona="Autor", pokazuj=True, _quantity=100) url = reverse("bpp:browse_autorzy") + "?page=10&search=Test" @@ -321,7 +322,7 @@ def test_autorzy_view_empty_page_preserves_search(client, setup_group): @pytest.mark.django_db def test_autorzy_view_empty_page_preserves_literka_in_path(client, setup_group): """Test: Redirect preserves literka in URL path.""" - Uczelnia.objects.create(nazwa="Test University", skrot="TU") + any_uczelnia(nazwa="Test University", skrot="TU") # Create 100 authors starting with 'A' baker.make(Autor, nazwisko="Atest", imiona="Autor", pokazuj=True, _quantity=100) @@ -337,7 +338,7 @@ def test_autorzy_view_empty_page_preserves_literka_in_path(client, setup_group): @pytest.mark.django_db def test_autorzy_view_page_not_integer_redirects(client, setup_group): """Test: Non-integer page values redirect to page 1.""" - Uczelnia.objects.create(nazwa="Test University", skrot="TU") + any_uczelnia(nazwa="Test University", skrot="TU") baker.make(Autor, nazwisko="Test", imiona="Autor", pokazuj=True, _quantity=100) url = reverse("bpp:browse_autorzy") + "?page=abc" @@ -360,7 +361,7 @@ def test_autorzy_view_page_not_integer_redirects(client, setup_group): @pytest.mark.django_db def test_get_available_letters_polish_diacritics_canonical(): """Polskie znaki diakrytyczne mapują się na kanoniczną literkę.""" - Uczelnia.objects.create(nazwa="X", skrot="X") + any_uczelnia(nazwa="X", skrot="X") baker.make(Autor, nazwisko="Ąbrowski", pokazuj=True) baker.make(Autor, nazwisko="ćwiek", pokazuj=True) baker.make(Autor, nazwisko="Łyk", pokazuj=True) @@ -378,7 +379,7 @@ def test_get_available_letters_polish_diacritics_canonical(): @pytest.mark.django_db def test_get_available_letters_runs_single_query(django_assert_num_queries): """Regresja: jedno zapytanie, niezależnie od liczby liter.""" - Uczelnia.objects.create(nazwa="X", skrot="X") + any_uczelnia(nazwa="X", skrot="X") baker.make(Autor, nazwisko="Adam", pokazuj=True) baker.make(Autor, nazwisko="Bartek", pokazuj=True) baker.make(Autor, nazwisko="Cezary", pokazuj=True) @@ -392,7 +393,7 @@ def test_get_available_letters_runs_single_query(django_assert_num_queries): @pytest.mark.django_db def test_get_available_letters_respects_queryset_filter(): """Pre-filtry queryseta są zachowane (nie pokazujemy ukrytych autorów).""" - Uczelnia.objects.create(nazwa="X", skrot="X") + any_uczelnia(nazwa="X", skrot="X") baker.make(Autor, nazwisko="Adam", pokazuj=True) baker.make(Autor, nazwisko="Bartek", pokazuj=False) diff --git a/src/bpp/tests/util.py b/src/bpp/tests/util.py index d2f5a1228..1dce403f4 100644 --- a/src/bpp/tests/util.py +++ b/src/bpp/tests/util.py @@ -50,8 +50,14 @@ def any_autor(nazwisko="Kowalski", imiona="Jan Maria", tytul="dr", **kw): return Autor.objects.create(nazwisko=nazwisko, tytul=tytul, imiona=imiona, **kw) -def any_uczelnia(nazwa="Uczelnia", skrot="UCL"): - return Uczelnia.objects.create(nazwa=nazwa, skrot=skrot) +def any_uczelnia(nazwa="Uczelnia", skrot="UCL", site=None): + if site is None: + from django.contrib.sites.models import Site + + site, _ = Site.objects.get_or_create( + domain="testserver", defaults={"name": "testserver"} + ) + return Uczelnia.objects.create(nazwa=nazwa, skrot=skrot, site=site) wydzial_cnt = 0 diff --git a/src/bpp/urls.py b/src/bpp/urls.py index 37e9ca582..52ed57f05 100644 --- a/src/bpp/urls.py +++ b/src/bpp/urls.py @@ -28,8 +28,8 @@ ) from bpp.views.autocomplete import ( AdminNavigationAutocomplete, + AutorAktualnieZatrudnionyNaUczelni, AutorAutocomplete, - AutorZUczelniAutocopmlete, Dyscyplina_Naukowa_PrzypisanieAutocomplete, Dyscyplina_NaukowaAutocomplete, GlobalNavigationAutocomplete, @@ -437,7 +437,7 @@ ), url( r"^autor-z-uczelni-autocomplete/$", - AutorZUczelniAutocopmlete.as_view(), + AutorAktualnieZatrudnionyNaUczelni.as_view(), name="autor-z-uczelni-autocomplete", ), url( diff --git a/src/bpp/util/__init__.py b/src/bpp/util/__init__.py index f95492335..f883ed512 100644 --- a/src/bpp/util/__init__.py +++ b/src/bpp/util/__init__.py @@ -19,6 +19,7 @@ formdefaults_html_before, get_fixture, pbar, + site_url_for_request, year_last_month, ) from bpp.util.concurrency import ( @@ -111,6 +112,7 @@ def __getattr__(name): "formdefaults_html_before", "get_fixture", "pbar", + "site_url_for_request", "year_last_month", # concurrency "disable_multithreading_by_monkeypatching_pool", diff --git a/src/bpp/util/bpp_specific.py b/src/bpp/util/bpp_specific.py index bb311bb91..c861f155e 100644 --- a/src/bpp/util/bpp_specific.py +++ b/src/bpp/util/bpp_specific.py @@ -85,3 +85,23 @@ def dont_log_anonymous_crud_events( """ if kwargs.get("request", None) and getattr(kwargs["request"], "user", None): return True + + +def site_url_for_request(request=None): + """Zwraca bazowy URL serwisu (``scheme://host``) z bieżącego requestu. + + W multi-hosted ten URL musi pochodzić z requestu. Bez requestu (CLI, + Celery task, test) NIE ma „uczelni domyślnej", więc bazowy URL bierzemy + z pierwszego ``Site`` (lub localhost) — to request-less fallback dla + maili/linków, nie ścieżka uczelniozależna. + """ + if request is not None: + return f"{request.scheme}://{request.get_host()}" + + from django.contrib.sites.models import Site + + site = Site.objects.first() + if site is not None: + return "https://" + site.domain + + return "https://localhost" diff --git a/src/bpp/util/uczelnia_scope.py b/src/bpp/util/uczelnia_scope.py new file mode 100644 index 000000000..7daf3c2cc --- /dev/null +++ b/src/bpp/util/uczelnia_scope.py @@ -0,0 +1,31 @@ +"""Zawężanie querysetów Rekordów do uczelni oglądającego (multi-hosted, read-side). + +Jedno źródło reguły rekordowej + guard single-install. Reguła atrybucji = +strona główna (``get_uczelnia_context_data``): rekord należy do uczelni, gdy +którakolwiek z jednostek zapisanych na autorstwie należy do tej uczelni. +BEZ ``skupia_pracownikow`` (włącznie z obcą jednostką) — świadoma decyzja +(spec R3a). +""" + + +def tylko_jedna_uczelnia() -> bool: + """True, gdy w systemie jest dokładnie jedna uczelnia. + + Fast-track jak ``IPunktacjaCacher._uczelnie_do_przeliczenia``: przy jednej + uczelni filtr per-uczelnia jest no-op, więc pomijamy go (i kosztowny JOIN). + """ + from bpp.models import Uczelnia + + return Uczelnia.objects.count() == 1 + + +def scope_rekord_do_uczelni(qs, uczelnia): + """Zawęź queryset ``Rekord`` do uczelni oglądającego. + + No-op (zwraca ten sam qs) gdy brak uczelni (brak mapowania Site→Uczelnia) + albo gdy w systemie jest dokładnie jedna uczelnia — wynik identyczny, + a unikamy JOIN-a przez M2M ``autorzy`` + ``DISTINCT``. + """ + if uczelnia is None or tylko_jedna_uczelnia(): + return qs + return qs.filter(autorzy__jednostka__uczelnia=uczelnia).distinct() diff --git a/src/bpp/views/__init__.py b/src/bpp/views/__init__.py index 35e426aed..2abb64502 100644 --- a/src/bpp/views/__init__.py +++ b/src/bpp/views/__init__.py @@ -23,8 +23,7 @@ def root(request): """Wyświetl stronę główną z pierwszą dostępną w bazie danych uczelnią, lub wyświetl komunikat jeżeli nie ma żadnych uczelni wpisanych do bazy danych.""" - # TODO: jeżeli będzie więcej, niż jeden obiekt Uczelnia...? - uczelnia = Uczelnia.objects.first() + uczelnia = Uczelnia.objects.get_for_request(request) if uczelnia is None: return shortcuts.render(request, "browse/brak_uczelni.html") diff --git a/src/bpp/views/api/pbn_get_by_parameter.py b/src/bpp/views/api/pbn_get_by_parameter.py index 3ccb71e84..753d48251 100644 --- a/src/bpp/views/api/pbn_get_by_parameter.py +++ b/src/bpp/views/api/pbn_get_by_parameter.py @@ -53,7 +53,7 @@ def post(self, request, *args, **kw): if not ni: return JsonResponse({"error": API_BRAK_PARAMETRU}) - uczelnia = Uczelnia.objects.get_default() + uczelnia = Uczelnia.objects.get_for_request(request) if not uczelnia: return JsonResponse({"error": "W systemie brak obiektu Uczelnia"}) diff --git a/src/bpp/views/autocomplete/__init__.py b/src/bpp/views/autocomplete/__init__.py index 690b6efaf..b675f864a 100644 --- a/src/bpp/views/autocomplete/__init__.py +++ b/src/bpp/views/autocomplete/__init__.py @@ -17,9 +17,9 @@ # Base classes and utilities # Author autocompletes from .authors import ( # noqa: F401 + AutorAktualnieZatrudnionyNaUczelni, AutorAutocomplete, AutorAutocompleteBase, - AutorZUczelniAutocopmlete, Dyscyplina_Naukowa_PrzypisanieAutocomplete, PodrzednaPublikacjaHabilitacyjnaAutocomplete, PublicAutorAutocomplete, diff --git a/src/bpp/views/autocomplete/authors.py b/src/bpp/views/autocomplete/authors.py index 0373b49a6..020ad378b 100644 --- a/src/bpp/views/autocomplete/authors.py +++ b/src/bpp/views/autocomplete/authors.py @@ -1,6 +1,7 @@ """Author-related autocomplete views.""" import json +from collections import OrderedDict from braces.views import GroupRequiredMixin from dal import autocomplete @@ -13,14 +14,14 @@ from bpp.const import GR_WPROWADZANIE_DANYCH from bpp.jezyk_polski import warianty_zapisanego_nazwiska from bpp.models import Autor_Dyscyplina -from bpp.models.autor import Autor +from bpp.models.autor import Autor, Autor_Jednostka from bpp.models.patent import Patent, Patent_Autor from bpp.models.wydawnictwo_ciagle import Wydawnictwo_Ciagle, Wydawnictwo_Ciagle_Autor from bpp.models.wydawnictwo_zwarte import Wydawnictwo_Zwarte, Wydawnictwo_Zwarte_Autor from pbn_api.models import OsobaZInstytucji from .base import autocomplete_create_error -from .mixins import SanitizedAutocompleteMixin +from .mixins import SanitizedAutocompleteMixin, UczelniaScopedAutocompleteMixin class AutorAutocompleteBase( @@ -28,32 +29,107 @@ class AutorAutocompleteBase( ): """Base autocomplete for authors with PBN indicators.""" - def get_queryset(self): - from django.db.models import Exists, OuterRef + GROUP_NASZA_UCZELNIA = 1 + GROUP_HISTORYCZNIE = 2 + GROUP_ZEWNETRZNI = 3 - qs = Autor.objects.select_related("tytul", "pbn_uid") + GROUP_LABELS = { + GROUP_NASZA_UCZELNIA: "✅ Autorzy z naszej uczelni", + GROUP_HISTORYCZNIE: "🏛️ Autorzy powiązani historycznie z naszą uczelnią", + GROUP_ZEWNETRZNI: "🌐 Autorzy zewnętrzni", + } - # Annotate with information if person is from institution (OsobaZInstytucji) - qs = qs.annotate( - ma_osobe_z_instytucji=Exists( - OsobaZInstytucji.objects.filter(personId_id=OuterRef("pbn_uid_id")) - ) + def get_queryset(self): + from django.db.models import ( + Case, + Exists, + IntegerField, + OuterRef, + Value, + When, ) if self.q: - return ( - Autor.objects.fulltext_filter(self.q) - .select_related("tytul", "pbn_uid") - .annotate( - ma_osobe_z_instytucji=Exists( - OsobaZInstytucji.objects.filter( - personId_id=OuterRef("pbn_uid_id") - ) - ) + qs = Autor.objects.fulltext_filter(self.q) + else: + qs = Autor.objects.all() + + uczelnia = getattr(getattr(self, "request", None), "_uczelnia", None) + + # Multi-hosted (Track 7a): wskaźnik "✅ jest w PBN naszej instytucji" + # ma odzwierciedlać instytucję PBN OGLĄDAJĄCEJ uczelni + # (``uczelnia.pbn_uid``), nie dowolnej. ``OsobaZInstytucji`` to lustro + # per-instytucja (institutionId == uczelnia.pbn_uid), więc zawężamy + # subquery. Brak uczelni / brak pbn_uid → subquery globalne (dawne + # zachowanie, single-install / uczelnia bez konfiguracji PBN). + osoba_z_instytucji_qs = OsobaZInstytucji.objects.filter( + personId_id=OuterRef("pbn_uid_id") + ) + if uczelnia is not None and uczelnia.pbn_uid_id is not None: + osoba_z_instytucji_qs = osoba_z_instytucji_qs.filter( + institutionId_id=uczelnia.pbn_uid_id + ) + + qs = qs.select_related("tytul", "pbn_uid").annotate( + ma_osobe_z_instytucji=Exists(osoba_z_instytucji_qs) + ) + + if uczelnia: + ma_jednostke_w_naszej = Exists( + Autor_Jednostka.objects.filter( + autor=OuterRef("pk"), + jednostka__uczelnia=uczelnia, ) ) + qs = qs.annotate( + ma_jednostke_w_naszej=ma_jednostke_w_naszej, + grupa_uczelnia=Case( + When( + aktualna_jednostka__uczelnia=uczelnia, + then=Value(self.GROUP_NASZA_UCZELNIA), + ), + When( + ma_jednostke_w_naszej=True, + then=Value(self.GROUP_HISTORYCZNIE), + ), + default=Value(self.GROUP_ZEWNETRZNI), + output_field=IntegerField(), + ), + ).order_by("grupa_uczelnia", "nazwisko", "imiona") + return qs + def get_results(self, context): + """Group authors into optgroups by their relation to the current uczelnia.""" + uczelnia = getattr(getattr(self, "request", None), "_uczelnia", None) + if uczelnia is None: + return super().get_results(context) + + groups = OrderedDict((grp_no, []) for grp_no in self.GROUP_LABELS) + for result in context["object_list"]: + grp_no = getattr(result, "grupa_uczelnia", self.GROUP_ZEWNETRZNI) + groups.setdefault(grp_no, []).append(result) + + output = [] + for grp_no, items in groups.items(): + if not items: + continue + output.append( + { + "id": None, + "text": self.GROUP_LABELS.get(grp_no, ""), + "children": [ + { + "id": self.get_result_value(r), + "text": self.get_result_label(r), + "selected_text": self.get_selected_result_label(r), + } + for r in items + ], + } + ) + return output + def get_result_label(self, result): # Handle error objects or non-Autor instances if not isinstance(result, Autor): @@ -93,8 +169,13 @@ class AutorAutocomplete(GroupRequiredMixin, AutorAutocompleteBase): ) def create_object(self, text): + # Multi-hosted: nowy autor dziedziczy widoczność (``pokazuj``) z uczelni + # Z REQUESTU (host), nie z pierwszej-z-brzegu. + from bpp.models.uczelnia import Uczelnia + + uczelnia = Uczelnia.objects.get_for_request(getattr(self, "request", None)) try: - obj = Autor.objects.create_from_string(text) + obj = Autor.objects.create_from_string(text, uczelnia=uczelnia) except ValueError: return self.err @@ -116,18 +197,86 @@ def create_object(self, text): return obj -class PublicAutorAutocomplete(AutorAutocompleteBase): - """Public autocomplete for authors (no create, no PBN/MNISW markers).""" +class PublicAutorAutocomplete(UczelniaScopedAutocompleteMixin, AutorAutocompleteBase): + """Public autocomplete for authors (no create, no PBN/MNISW markers). + + Pokazuje WYŁĄCZNIE autorów z aktualnej uczelni — związanych z nią obecnie + (``aktualna_jednostka``) lub historycznie (``Autor_Jednostka``). Autorzy + zewnętrzni (nigdy nie afiliowani) odpadają. W odróżnieniu od staffowego + ``AutorAutocomplete`` lista jest PŁASKA (bez optgroup): grupowanie z + ``AutorAutocompleteBase`` powielało nagłówek „✅ Autorzy z naszej uczelni" + w każdej stronie odpowiedzi Select2 → przy przewijaniu nagłówek dublował + się. Skoro picker pokazuje już tylko autorów z uczelni, grupy są zbędne. + """ + + uczelnia_lookups = ( + "aktualna_jednostka__uczelnia", + "autor_jednostka__jednostka__uczelnia", + ) + + def get_queryset(self): + qs = super().get_queryset() + + # ``UczelniaScopedAutocompleteMixin`` jest no-op przy jednej uczelni + # (``tylko_jedna_uczelnia``), a picker ma pokazywać tylko autorów z + # uczelni także w single-install — więc zawężamy jawnie, gdy uczelnię da + # się ustalić z requestu. Brak uczelni (brak mapowania Site→Uczelnia) → + # bez zawężenia (zachowanie defensywne, jak w bazie/mixinie). + from django.db.models import Q + + from bpp.models import Uczelnia + + request = getattr(self, "request", None) + uczelnia = Uczelnia.objects.get_for_request(request) if request else None + if uczelnia is not None: + qs = qs.filter( + Q(aktualna_jednostka__uczelnia=uczelnia) + | Q(autor_jednostka__jednostka__uczelnia=uczelnia) + ).distinct() + return qs + + def get_results(self, context): + """Płaska lista wyników — bez optgroupów (kontrakt: brak duplikacji).""" + return autocomplete.Select2QuerySetView.get_results(self, context) def get_result_label(self, result): """Return clean author name without PBN/MNISW markers.""" return str(result) -class AutorZUczelniAutocopmlete(AutorAutocomplete): - """Autocomplete for authors from the institution.""" +class AutorAktualnieZatrudnionyNaUczelni(AutorAutocomplete): + """Autocomplete autorów AKTUALNIE zatrudnionych w oglądającej uczelni. + + Zawęża WYŁĄCZNIE po ``aktualna_jednostka__uczelnia`` == uczelnia z requestu — + i tylko tyle. Bez grup „naszej/historycznie/zewnętrzni", bez autorów spoza + uczelni, bez historycznie związanych. Lista jest płaska (override + ``get_results``), więc nagłówki optgroup nie powielają się przy przewijaniu + Select2. Używany w adminie prac doktorskich/habilitacyjnych, gdzie kandydat + z definicji jest pracownikiem uczelni. + + Dziedziczy po ``AutorAutocomplete`` dla kontroli dostępu (``group_required``) + i możliwości tworzenia nowego autora — ale całkowicie nadpisuje wybór i + prezentację wyników. + """ + + def get_queryset(self): + if self.q: + qs = Autor.objects.fulltext_filter(self.q) + else: + qs = Autor.objects.all() + + from bpp.models import Uczelnia + + request = getattr(self, "request", None) + uczelnia = Uczelnia.objects.get_for_request(request) if request else None + if uczelnia is not None: + qs = qs.filter(aktualna_jednostka__uczelnia=uczelnia) + + return qs.select_related("tytul", "pbn_uid").order_by("nazwisko", "imiona") - pass + def get_results(self, context): + """Płaska lista wyników — bez optgroupów.""" + return autocomplete.Select2QuerySetView.get_results(self, context) class ZapisanyJakoAutocomplete( diff --git a/src/bpp/views/autocomplete/mixins.py b/src/bpp/views/autocomplete/mixins.py index a9ee57d40..54d37f7d8 100644 --- a/src/bpp/views/autocomplete/mixins.py +++ b/src/bpp/views/autocomplete/mixins.py @@ -25,3 +25,41 @@ def dispatch(self, request, *args, **kwargs): request.GET["q"] = q[: self.MAX_QUERY_LENGTH] return super().dispatch(request, *args, **kwargs) + + +class UczelniaScopedAutocompleteMixin: + """Publiczny autocomplete zawężony do uczelni oglądającego (multi-hosted). + + No-op gdy brak uczelni w requeście (brak mapowania Site→Uczelnia) albo gdy + w systemie jest jedna uczelnia (guard ``tylko_jedna_uczelnia`` z R3a) — + podpowiedzi i wydajność wtedy identyczne jak dawniej. + + Podklasy ustawiają ``uczelnia_lookups`` — krotkę ścieżek ORM od modelu do + ``Uczelnia``; są łączone przez OR. ``.distinct()`` zawsze (joiny po historii + mnożą wiersze; dla FK jest nieszkodliwe). + + UWAGA: umieszczaj ten mixin PRZED konkretnym widokiem w MRO — inaczej + ``get_queryset`` bazy przesłoni ten i zawężenie po cichu się nie wykona. + """ + + uczelnia_lookups = ("uczelnia",) + + def get_queryset(self): + qs = super().get_queryset() + + from django.db.models import Q + + from bpp.models import Uczelnia + from bpp.util.uczelnia_scope import tylko_jedna_uczelnia + + request = getattr(self, "request", None) + if request is None: + return qs + + uczelnia = Uczelnia.objects.get_for_request(request) + if uczelnia is not None and not tylko_jedna_uczelnia(): + warunek = Q() + for lookup in self.uczelnia_lookups: + warunek |= Q(**{lookup: uczelnia}) + qs = qs.filter(warunek).distinct() + return qs diff --git a/src/bpp/views/autocomplete/navigation.py b/src/bpp/views/autocomplete/navigation.py index 8abc50519..e33f0fd61 100644 --- a/src/bpp/views/autocomplete/navigation.py +++ b/src/bpp/views/autocomplete/navigation.py @@ -128,64 +128,72 @@ def get_results(self, context): for model, results in groups.items() ] - def get_queryset(self): - if not hasattr(self, "q"): - return [] - - if not self.q: - return [] - - querysets = [] - globalne_wyszukiwanie_jednostki(querysets, self.q) + def _uczelnia_scope(self): + """Uczelnia oglądającego do zawężenia global-searcha. - globalne_wyszukiwanie_autora(querysets, self.q) + ``None`` (brak zawężenia) gdy brak requestu albo single-install + (guard ``tylko_jedna_uczelnia`` — wyniki/wydajność jak dawniej). + """ + from bpp.util.uczelnia_scope import tylko_jedna_uczelnia - globalne_wyszukiwanie_zrodla(querysets, self.q) + if not hasattr(self, "request") or tylko_jedna_uczelnia(): + return None + return Uczelnia.objects.get_for_request(self.request) - # Rekord + def _rekord_querysets(self, uczelnia): + """Querysety Rekordów do global-searcha, zawężone do uczelni.""" + from bpp.util.uczelnia_scope import scope_rekord_do_uczelni - rekord_qset_ftx = Rekord.objects.fulltext_filter(self.q) + ftx = scope_rekord_do_uczelni(Rekord.objects.fulltext_filter(self.q), uczelnia) - rekord_qset_doi = Rekord.objects.filter(doi__iexact=self.q) - rekord_qset_isbn = Rekord.objects.filter(isbn__iexact=self.q) - rekord_qset_pbn = None + qry = Q(pk__in=Rekord.objects.filter(doi__iexact=self.q).values_list("pk")) + qry |= Q(pk__in=Rekord.objects.filter(isbn__iexact=self.q)) if jest_pbn_uid(self.q): - rekord_qset_pbn = Rekord.objects.filter(pbn_uid_id=self.q) - - qry = Q(pk__in=rekord_qset_doi.values_list("pk")) - qry |= Q(pk__in=rekord_qset_isbn) - if rekord_qset_pbn: - qry |= Q(pk__in=rekord_qset_pbn.values_list("pk")) - - rekord_qset = Rekord.objects.filter(qry).only("tytul_oryginalny") + qry |= Q(pk__in=Rekord.objects.filter(pbn_uid_id=self.q).values_list("pk")) + glowny = scope_rekord_do_uczelni( + Rekord.objects.filter(qry).only("tytul_oryginalny"), uczelnia + ) if hasattr(self, "request") and self.request.user.is_anonymous: - uczelnia = Uczelnia.objects.get_for_request(self.request) - if uczelnia is not None: - rekord_qset_ftx = rekord_qset_ftx.exclude( - status_korekty_id__in=uczelnia.ukryte_statusy("podglad") - ) + uczelnia_status = Uczelnia.objects.get_for_request(self.request) + if uczelnia_status is not None: + ukryte = uczelnia_status.ukryte_statusy("podglad") + ftx = ftx.exclude(status_korekty_id__in=ukryte) + glowny = glowny.exclude(status_korekty_id__in=ukryte) - rekord_qset = rekord_qset.exclude( - status_korekty_id__in=uczelnia.ukryte_statusy("podglad") - ) - querysets.append(rekord_qset_ftx) - querysets.append(rekord_qset) + rekordy = [ftx, glowny] - this_is_an_id = False try: this_is_an_id = int(self.q) except (TypeError, ValueError): - pass - - if this_is_an_id: - querysets.append( - Rekord.objects.annotate( - _object_id=RawSQL("(id)[2]", [], output_field=IntegerField()) + this_is_an_id = None + if this_is_an_id is not None: + rekordy.append( + scope_rekord_do_uczelni( + Rekord.objects.annotate( + _object_id=RawSQL("(id)[2]", [], output_field=IntegerField()) + ) + .filter(_object_id=this_is_an_id) + .only("tytul_oryginalny"), + uczelnia, ) - .filter(_object_id=this_is_an_id) - .only("tytul_oryginalny") ) + return rekordy + + def get_queryset(self): + if not hasattr(self, "q") or not self.q: + return [] + + # Multi-hosted: publiczny global-search zawężamy do uczelni oglądającego + # (jednostki/autorzy/rekordy). Zrodlo nie ma FK uczelnia (słownik + # współdzielony). No-op przy single-install (uczelnia → None). + uczelnia = self._uczelnia_scope() + + querysets = [] + globalne_wyszukiwanie_jednostki(querysets, self.q, uczelnia=uczelnia) + globalne_wyszukiwanie_autora(querysets, self.q, uczelnia=uczelnia) + globalne_wyszukiwanie_zrodla(querysets, self.q) + querysets.extend(self._rekord_querysets(uczelnia)) ret = QuerySetSequence(*querysets) return self.mixup_querysets(ret) diff --git a/src/bpp/views/autocomplete/search_services.py b/src/bpp/views/autocomplete/search_services.py index d7b06a7b4..e6feeddf1 100644 --- a/src/bpp/views/autocomplete/search_services.py +++ b/src/bpp/views/autocomplete/search_services.py @@ -1,5 +1,6 @@ """Global search functions for autocomplete views.""" +from django.db.models import Q from django.db.models.aggregates import Count from bpp import const @@ -39,34 +40,63 @@ def jest_pbn_uid(s): return jest_czyms(s, const.PBN_UID_LEN) -def globalne_wyszukiwanie_autora(querysets, q): - """Add author search querysets.""" +def globalne_wyszukiwanie_autora(querysets, q, uczelnia=None): + """Add author search querysets. + + Gdy podano ``uczelnia`` (multi-hosted, publiczny global-search), zawęża do + autorów związanych z uczelnią obecnie LUB w przeszłości (reguła R3b z + ``PublicAutorAutocomplete``). ``uczelnia=None`` → globalnie (admin search). + """ + + def _scope(qs): + if uczelnia is None: + return qs + return qs.filter( + Q(aktualna_jednostka__uczelnia=uczelnia) + | Q(autor_jednostka__jednostka__uczelnia=uczelnia) + ).distinct() + if jest_orcid(q): querysets.append( - Autor.objects.filter(orcid__icontains=q) - .only(*AUTOR_ONLY) - .select_related(*AUTOR_SELECT_RELATED) + _scope( + Autor.objects.filter(orcid__icontains=q) + .only(*AUTOR_ONLY) + .select_related(*AUTOR_SELECT_RELATED) + ) ) if jest_pbn_uid(q): querysets.append( - Autor.objects.filter(pbn_uid_id=q).only(*AUTOR_ONLY).select_related("tytul") + _scope( + Autor.objects.filter(pbn_uid_id=q) + .only(*AUTOR_ONLY) + .select_related("tytul") + ) ) querysets.append( - Autor.objects.fulltext_filter(q) - .annotate(Count("wydawnictwo_ciagle")) - .only(*AUTOR_ONLY) - .select_related(*AUTOR_SELECT_RELATED) - .order_by("-search__rank", "-wydawnictwo_ciagle__count") + _scope( + Autor.objects.fulltext_filter(q) + .annotate(Count("wydawnictwo_ciagle")) + .only(*AUTOR_ONLY) + .select_related(*AUTOR_SELECT_RELATED) + .order_by("-search__rank", "-wydawnictwo_ciagle__count") + ) ) -def globalne_wyszukiwanie_jednostki(querysets, s): - """Add unit search querysets.""" +def globalne_wyszukiwanie_jednostki(querysets, s, uczelnia=None): + """Add unit search querysets. + + Gdy podano ``uczelnia`` (multi-hosted, publiczny global-search), zawęża + jednostki po FK ``uczelnia``. ``None`` → globalnie (admin search). + """ def _fun(qry): - return qry.only("pk", "nazwa", "wydzial__skrot").select_related("wydzial") + qry = qry.only("pk", "nazwa", "wydzial__skrot").select_related("wydzial") + if uczelnia is not None: + qry = qry.filter(uczelnia=uczelnia) + return qry querysets.append(_fun(Jednostka.objects.fulltext_filter(s))) diff --git a/src/bpp/views/autocomplete/simple.py b/src/bpp/views/autocomplete/simple.py index 897ed4b98..276c8be68 100644 --- a/src/bpp/views/autocomplete/simple.py +++ b/src/bpp/views/autocomplete/simple.py @@ -30,7 +30,7 @@ NazwaTrigramMixin, autocomplete_create_error, ) -from .mixins import SanitizedAutocompleteMixin +from .mixins import SanitizedAutocompleteMixin, UczelniaScopedAutocompleteMixin class _OrderedSlicedQuerySetSequence(QuerySetSequence): @@ -73,14 +73,24 @@ def get_queryset(self): class LataAutocomplete(SanitizedAutocompleteMixin, autocomplete.Select2QuerySetView): - """Autocomplete for years (lata) from Rekord cache.""" + """Autocomplete for years (lata) from Rekord cache. - qset = ( - Rekord.objects.all().values_list("rok", flat=True).distinct().order_by("-rok") - ) + Zawężony do uczelni oglądającego (jak ``LataView`` w R3a) — picker lat na + domenie jednej uczelni nie podpowiada lat z rekordów innych uczelni. + """ def get_queryset(self): - qs = self.qset + from bpp.util.uczelnia_scope import scope_rekord_do_uczelni + from raport_slotow.uczelnia_helper import uczelnia_dla_odczytu + + qs = ( + scope_rekord_do_uczelni( + Rekord.objects.all(), uczelnia_dla_odczytu(self.request) + ) + .values_list("rok", flat=True) + .distinct() + .order_by("-rok") + ) if self.q: qs = qs.filter(rok=self.q) return qs @@ -197,9 +207,12 @@ class WydzialAutocomplete( class PublicWydzialAutocomplete( - SanitizedAutocompleteMixin, NazwaLubSkrotMixin, autocomplete.Select2QuerySetView + UczelniaScopedAutocompleteMixin, + SanitizedAutocompleteMixin, + NazwaLubSkrotMixin, + autocomplete.Select2QuerySetView, ): - """Public autocomplete for visible departments.""" + """Public autocomplete for visible departments (per-uczelnia, multi-hosted).""" qset = Wydzial.objects.filter(widoczny=True) diff --git a/src/bpp/views/autocomplete/units.py b/src/bpp/views/autocomplete/units.py index c9395ca4b..d1797ddbd 100644 --- a/src/bpp/views/autocomplete/units.py +++ b/src/bpp/views/autocomplete/units.py @@ -6,7 +6,7 @@ from bpp.models import Jednostka from .base import JednostkaMixin -from .mixins import SanitizedAutocompleteMixin +from .mixins import SanitizedAutocompleteMixin, UczelniaScopedAutocompleteMixin class JednostkaAutocomplete( @@ -23,13 +23,17 @@ def get_queryset(self): return qs.order_by(*Jednostka.objects.get_default_ordering()) -class WidocznaJednostkaAutocomplete(JednostkaAutocomplete): - """Autocomplete for visible organizational units.""" +class WidocznaJednostkaAutocomplete( + UczelniaScopedAutocompleteMixin, JednostkaAutocomplete +): + """Autocomplete for visible organizational units (per-uczelnia, multi-hosted).""" qset = Jednostka.objects.widoczne().select_related("wydzial") -class PublicJednostkaAutocomplete(JednostkaAutocomplete): - """Public autocomplete for public organizational units.""" +class PublicJednostkaAutocomplete( + UczelniaScopedAutocompleteMixin, JednostkaAutocomplete +): + """Public autocomplete for public organizational units (per-uczelnia, multi-hosted).""" qset = Jednostka.objects.publiczne().select_related("wydzial") diff --git a/src/bpp/views/browse.py b/src/bpp/views/browse.py index a36bffbcb..2c6d9f0d9 100644 --- a/src/bpp/views/browse.py +++ b/src/bpp/views/browse.py @@ -10,6 +10,7 @@ from django.db.models.functions import Substr from django.http import JsonResponse from django.utils import timezone +from django.utils.http import url_has_allowed_host_and_scheme try: from django.core.urlresolvers import reverse @@ -43,6 +44,7 @@ ZakresLatQueryObject, ZrodloQueryObject, ) +from bpp.util.uczelnia_scope import scope_rekord_do_uczelni logger = logging.getLogger(__name__) @@ -68,21 +70,40 @@ def get_uczelnia_context_data(uczelnia, article_slug=None): """Shared function to get context data for uczelnia view.""" context = {"object": uczelnia, "uczelnia": uczelnia} + # Multi-host: filtruj artykuły po Site bieżącej uczelni. siteblog.Article + # ma M2M `sites`; pusty M2M = artykuł widoczny wszędzie (zgodnie z + # help_textem w siteblog). on_site (CurrentSiteManager) jest strict — + # wymusza Site_id i wyklucza puste M2M — więc używamy własnego Q. + site_id = uczelnia.site_id + visible_articles = Article.objects.filter( + Q(sites=site_id) | Q(sites__isnull=True) + ).distinct() + if article_slug: - context["article"] = get_object_or_404(Article, slug=article_slug) + context["article"] = get_object_or_404(visible_articles, slug=article_slug) else: - context["news"] = Article.objects.filter(status=Article.STATUS.published)[:5] - # Add 5 most recently updated records - context["recently_updated"] = Rekord.objects.order_by("-ostatnio_zmieniony")[ - :12 - ] - # Add 5 recent records with abstracts + context["news"] = visible_articles.filter(status=Article.STATUS.published)[:5] + + # Multi-host: rekordy z autorami z jednostek tej uczelni + jednostki_uczelni = uczelnia.jednostka_set.all() + context["recently_updated"] = ( + Rekord.objects.filter(autorzy__jednostka__in=jednostki_uczelni) + .order_by("-ostatnio_zmieniony") + .distinct()[:12] + ) + context["recent_abstracts"] = ( Wydawnictwo_Ciagle_Streszczenie.objects.exclude(streszczenie__isnull=True) .exclude(streszczenie__exact="") - .order_by("-rekord__ostatnio_zmieniony")[:5] + .filter(rekord__autorzy_set__jednostka__in=jednostki_uczelni) + .order_by("-rekord__ostatnio_zmieniony") + .distinct()[:5] + ) + context["total_rekord_count"] = ( + Rekord.objects.filter(autorzy__jednostka__in=jednostki_uczelni) + .distinct() + .count() ) - context["total_rekord_count"] = Rekord.objects.count() context["current_year"] = timezone.now().date().year return context @@ -281,6 +302,16 @@ def get(self, request, *args, **kwargs): if params: redirect_url += "?" + params.urlencode() + # Guard against open redirects: only ever redirect within this + # host. The constructed URL is always same-origin (request.path + # + urlencoded params), so this guard passes in practice; the + # fallback is a constant (not request-derived) so the redirect + # sink only ever sees validated-or-literal data. + if not url_has_allowed_host_and_scheme( + redirect_url, allowed_hosts={request.get_host()} + ): + redirect_url = "/" + # Add warning message messages.warning( request, @@ -447,17 +478,9 @@ class JednostkiView(Browser): paginate_by = 150 def get_paginate_by(self, queryset): - uczelnia = None - - if hasattr(self, "request") and self.request is not None: - uczelnia = Uczelnia.objects.get_for_request(self.request) - - if uczelnia is None: - uczelnia = Uczelnia.objects.get_default() - + uczelnia = Uczelnia.objects.get_for_request(getattr(self, "request", None)) if uczelnia is None: return self.paginate_by - return uczelnia.ilosc_jednostek_na_strone def get_queryset(self): @@ -518,9 +541,11 @@ class LataView(ListView): paginate_by = None def get_queryset(self): + uczelnia = Uczelnia.objects.get_for_request(self.request) + qs = scope_rekord_do_uczelni(Rekord.objects.all(), uczelnia) return [ {"year": row["rok"], "count": row["count"]} - for row in Rekord.objects.values("rok") + for row in qs.values("rok") .annotate(count=Count("*")) .filter(count__gt=0) .order_by("-rok") @@ -528,7 +553,8 @@ def get_queryset(self): def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) - # Suma z policzonych juz count-ow per rok — bez drugiego skanu tabeli. + # Suma z policzonych juz count-ow per rok (get_queryset liczy je juz + # w zakresie uczelni) — bez drugiego skanu tabeli. context["total_publications"] = sum( year_data["count"] for year_data in context["years"] ) @@ -567,7 +593,10 @@ def get_queryset(self): raise Http404("Nieprawidłowy rok") from e # Get publications for this year - return Rekord.objects.filter(rok=year).order_by("-ostatnio_zmieniony") + uczelnia = Uczelnia.objects.get_for_request(self.request) + return scope_rekord_do_uczelni( + Rekord.objects.filter(rok=year), uczelnia + ).order_by("-ostatnio_zmieniony") def get_context_data(self, **kwargs): context = super().get_context_data(**kwargs) @@ -578,8 +607,11 @@ def get_context_data(self, **kwargs): context["prev_year"] = None context["next_year"] = None + uczelnia = Uczelnia.objects.get_for_request(self.request) sasiednie_lata = set( - Rekord.objects.filter(rok__in=(year - 1, year + 1)) + scope_rekord_do_uczelni( + Rekord.objects.filter(rok__in=(year - 1, year + 1)), uczelnia + ) .values_list("rok", flat=True) .distinct() ) @@ -588,8 +620,8 @@ def get_context_data(self, **kwargs): if year + 1 in sasiednie_lata: context["next_year"] = year + 1 - # Paginator ListView policzyl juz COUNT dla tego roku — nie liczymy - # drugi raz. + # Paginator ListView policzyl juz COUNT dla tego roku (queryset jest + # juz zawezony do uczelni) — nie liczymy drugi raz. context["total_count"] = context["paginator"].count return context @@ -692,8 +724,15 @@ def post(self, *args, **kw): class PracaViewMixin: def get(self, request, *args, **kwargs): + from raport_slotow.uczelnia_helper import uczelnia_dla_odczytu + self.object = self.get_object() + # Multi-hosted: tabela punktacji na stronie rekordu pokazuje sloty/ + # punkty tylko uczelni oglądającego (CPD po uczelni, CPA po + # jednostka__uczelnia). No-op przy single-install. + self.object._uczelnia_ogladajacego = uczelnia_dla_odczytu(request) + if request.user.is_anonymous: # Jeżeli użytkownik jest anonimowy, to może obejmować go ukrywanie statusów uczelnia = Uczelnia.objects.get_for_request(request) diff --git a/src/bpp/views/oai.py b/src/bpp/views/oai.py index 1a5772af9..66e6f5935 100644 --- a/src/bpp/views/oai.py +++ b/src/bpp/views/oai.py @@ -16,6 +16,7 @@ from moai.server import FeedConfig from bpp.models import Rekord, Uczelnia +from bpp.util.uczelnia_scope import scope_rekord_do_uczelni class CacheMetadata: @@ -87,8 +88,9 @@ def get_dc_ident(model, obj_pk): class BPPOAIDatabase: - def __init__(self, original): + def __init__(self, original, request=None): self.original = original + self.request = request def get_set(self, oai_id): if oai_id == 1: @@ -183,7 +185,7 @@ def oai_query( if from_date is not None: query = query.filter(ostatnio_zmieniony__gte=from_date) - uczelnia = Uczelnia.objects.get_default() + uczelnia = Uczelnia.objects.get_for_request(self.request) if uczelnia: ukryte_statusy = uczelnia.ukryte_statusy("api") if ukryte_statusy: @@ -239,9 +241,12 @@ def get(self, request, *args, **kwargs): url = "/".join(urlparts) - db = BPPOAIDatabase( - Rekord.objects.all().exclude(charakter_formalny__nazwa_w_primo="") + uczelnia = Uczelnia.objects.get_for_request(request) + base_qs = scope_rekord_do_uczelni( + Rekord.objects.all().exclude(charakter_formalny__nazwa_w_primo=""), + uczelnia, ) + db = BPPOAIDatabase(base_qs, request=request) oai_server = OAIServerFactory(db, FeedConfig("bpp", base_url)) return HttpResponse( content=oai_server.handleRequest(request.GET), diff --git a/src/bpp/views/profile.py b/src/bpp/views/profile.py index 85041d113..8a16e5125 100644 --- a/src/bpp/views/profile.py +++ b/src/bpp/views/profile.py @@ -17,9 +17,15 @@ def get_context_data(self, **kwargs): if autor: from ewaluacja_metryki.models import MetrykaAutora + from ewaluacja_metryki.uczelnia_scope import scope_metryki + from raport_slotow.uczelnia_helper import uczelnia_dla_odczytu - context["metryki"] = MetrykaAutora.objects.filter( - autor=autor + # Metryki pokazujemy z JEDNEJ uczelni — tej z requestu. Autor + # afiliowany do wielu uczelni nie może widzieć tu metryk obcej + # uczelni (no-op przy single-install). + context["metryki"] = scope_metryki( + MetrykaAutora.objects.filter(autor=autor), + uczelnia_dla_odczytu(self.request), ).select_related("dyscyplina_naukowa") return context diff --git a/src/bpp_setup_wizard/forms.py b/src/bpp_setup_wizard/forms.py index f3c36e202..c9c1dba36 100644 --- a/src/bpp_setup_wizard/forms.py +++ b/src/bpp_setup_wizard/forms.py @@ -110,7 +110,7 @@ def clean(self): return cleaned_data - def save(self, commit=True): + def save(self, commit=True, request=None): uczelnia = super().save(commit=False) # Set the fields that should always be True @@ -129,6 +129,11 @@ def save(self, commit=True): True # Włącz opcjonalną aktualizację przy edycji ) + if uczelnia.site_id is None and request is not None: + from django.contrib.sites.shortcuts import get_current_site + + uczelnia.site = get_current_site(request) + if commit: uczelnia.save() diff --git a/src/bpp_setup_wizard/steps.py b/src/bpp_setup_wizard/steps.py index 4c03e43d1..e65c724df 100644 --- a/src/bpp_setup_wizard/steps.py +++ b/src/bpp_setup_wizard/steps.py @@ -27,3 +27,10 @@ def is_complete(self) -> bool: def get_context(self, request) -> dict: return {"subtitle": "Podstawowe dane instytucji"} + + def on_complete(self, form, request): + # Multi-hosted: form needs request to auto-link uczelnia.site to + # the current Site via get_current_site(request). Without it the + # uczelnia would land without a Site FK and fail the NOT NULL + # constraint added in migration 0417. + return form.save(request=request) diff --git a/src/conftest.py b/src/conftest.py index ee1f4dee8..c6648a3eb 100644 --- a/src/conftest.py +++ b/src/conftest.py @@ -50,6 +50,15 @@ "fixtures.conftest_system", "fixtures.conftest_browser", "fixtures.conftest_disciplines", + # ``conftest_multisite`` importuje modele Django na top-levelu (``Site``, + # ``Uczelnia``, ``BppUser``...), więc — jak moduły niżej — MUSI być tutaj. + # Rejestracja wyłącznie w rootdir-owym ``conftest.py`` nie wystarcza: jego + # ``pytest_plugins`` ładuje się w preloadzie ``pytest-testcontainers-django`` + # ZANIM ``django.setup()`` zapełni rejestr aplikacji, import wybucha + # ``AppRegistryNotReady`` i fikstury (``site1``, ``uczelnia1``...) cicho się + # nie rejestrują → ``fixture 'site1' not found``. Guard: + # bpp/tests/test_conftest_preload_safety.py. + "fixtures.conftest_multisite", # ``pbn_api`` i ``wydawnictwa`` importują modele Django na top-levelu, # więc MUSZĄ być rejestrowane tutaj (plugin ładowany po ``django.setup()``), # a NIE przez ``from fixtures import *`` w rootdir-owym ``conftest.py`` — @@ -594,8 +603,8 @@ def constance_cache_warmed_up(db): Fixture that pre-creates constance values in the database and warms the cache to prevent constance queries during test execution. - This ensures all constance values exist in the DB before the test runs, - avoiding INSERT/UPDATE queries during the test's query assertion block. + Note: Most constance settings have been migrated to Uczelnia model fields. + This fixture now only handles remaining constance entries (if any). """ import json @@ -609,17 +618,6 @@ def constance_cache_warmed_up(db): value_json = json.dumps({"__type__": "default", "__value__": default}) Constance.objects.get_or_create(key=key, defaults={"value": value_json}) - # Warm the cache by accessing all values - _ = ( - config.UZYWAJ_PUNKTACJI_WEWNETRZNEJ, - config.POKAZUJ_INDEX_COPERNICUS, - config.POKAZUJ_PUNKTACJA_SNIP, - config.POKAZUJ_OSWIADCZENIE_KEN, - config.SKROT_WYDZIALU_W_NAZWIE_JEDNOSTKI, - config.UCZELNIA_UZYWA_WYDZIALOW, - config.GOOGLE_ANALYTICS_PROPERTY_ID, - config.GOOGLE_VERIFICATION_CODE, - ) return config diff --git a/src/crossref_bpp/views.py b/src/crossref_bpp/views.py index ba03c9d15..b5e527eaf 100644 --- a/src/crossref_bpp/views.py +++ b/src/crossref_bpp/views.py @@ -111,7 +111,7 @@ def _pobierz_dane_z_pbn(request, doi): pbn_error = None try: - uczelnia = Uczelnia.objects.get_default() + uczelnia = Uczelnia.objects.get_for_request(request) if not uczelnia or not uczelnia.pbn_integracja: return None, "Integracja z PBN nieaktywna" diff --git a/src/deduplikator_autorow/admin.py b/src/deduplikator_autorow/admin.py index 407f2e8a2..b59b13949 100644 --- a/src/deduplikator_autorow/admin.py +++ b/src/deduplikator_autorow/admin.py @@ -18,6 +18,9 @@ @admin.register(NotADuplicate) class NotADuplicateAdmin(DynamicAdminFilterMixin, admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "autor", "created_by", @@ -79,6 +82,9 @@ def get_author_last_name(self, obj): @admin.register(IgnoredScientist) class IgnoredScientistAdmin(DynamicAdminFilterMixin, admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "get_scientist_display", "get_autor_display", @@ -136,6 +142,9 @@ def save_model(self, request, obj, form, change): @admin.register(IgnoredAuthor) class IgnoredAuthorAdmin(DynamicAdminFilterMixin, admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "get_autor_display", "reason", @@ -172,6 +181,9 @@ def save_model(self, request, obj, form, change): @admin.register(LogScalania) class LogScalaniaAdmin(DynamicAdminFilterMixin, admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "get_operation_icon", "get_merge_description", @@ -376,6 +388,9 @@ def has_change_permission(self, request, obj=None): @admin.register(DuplicateScanRun) class DuplicateScanRunAdmin(DynamicAdminFilterMixin, admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "id", "status", @@ -489,6 +504,9 @@ def has_change_permission(self, request, obj=None): @admin.register(DuplicateCandidate) class DuplicateCandidateAdmin(DynamicAdminFilterMixin, admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "id", "get_main_autor_link", diff --git a/src/deduplikator_autorow/tests/test_xlsx_orcid_and_pbn_url.py b/src/deduplikator_autorow/tests/test_xlsx_orcid_and_pbn_url.py index 33ee44e50..ed7619bb2 100644 --- a/src/deduplikator_autorow/tests/test_xlsx_orcid_and_pbn_url.py +++ b/src/deduplikator_autorow/tests/test_xlsx_orcid_and_pbn_url.py @@ -14,14 +14,20 @@ @pytest.fixture def candidate_with_orcid_and_pbn(db): """Para autorów z ORCID i PBN UID, oraz Uczelnia z pbn_api_root.""" + from django.contrib.sites.models import Site + from bpp.models import Uczelnia + site, _ = Site.objects.get_or_create( + domain="testserver", defaults={"name": "testserver"} + ) uczelnia, _ = Uczelnia.objects.get_or_create( nazwa="Test U", defaults={ "skrot": "TU", "slug": "test-u", "pbn_api_root": "https://pbn-micro-alpha.opi.org.pl", + "site": site, }, ) if not uczelnia.pbn_api_root: diff --git a/src/deduplikator_autorow/utils/export.py b/src/deduplikator_autorow/utils/export.py index 67a378117..9c2116ea7 100644 --- a/src/deduplikator_autorow/utils/export.py +++ b/src/deduplikator_autorow/utils/export.py @@ -5,21 +5,20 @@ from collections import Counter from io import BytesIO -from django.contrib.sites.models import Site from openpyxl.styles import Font from openpyxl.workbook import Workbook -from bpp.util import worksheet_columns_autosize, worksheet_create_table +from bpp.util import ( + site_url_for_request, + worksheet_columns_autosize, + worksheet_create_table, +) from deduplikator_autorow.models import DuplicateCandidate -def _get_site_domain(): - """Pobierz domenę serwisu do konstrukcji pełnych URLi.""" - try: - current_site = Site.objects.get_current() - return f"https://{current_site.domain}" - except BaseException: - return "https://bpp.iplweb.pl" +def _get_site_domain(request=None): + """Pobierz bazowy URL serwisu do konstrukcji pełnych URLi.""" + return site_url_for_request(request) def _create_pbn_url(autor): @@ -87,7 +86,7 @@ def _format_url_hyperlinks(ws, data_rows_count): cell.font = Font(color="0000FF", underline="single") -def export_duplicates_to_xlsx(): +def export_duplicates_to_xlsx(request=None): """ Eksportuje kandydatów na duplikaty do formatu XLSX. @@ -114,7 +113,7 @@ def export_duplicates_to_xlsx(): Returns: bytes: Zawartość pliku XLSX """ - site_domain = _get_site_domain() + site_domain = _get_site_domain(request) # JEDNO zapytanie zamiast tysięcy! Materializujemy raz, żeby Counter # i list-comprehension nie wykonywały dwóch iteracji po queryset diff --git a/src/deduplikator_autorow/views/export.py b/src/deduplikator_autorow/views/export.py index fcb78ec28..8f543e0c3 100644 --- a/src/deduplikator_autorow/views/export.py +++ b/src/deduplikator_autorow/views/export.py @@ -28,7 +28,7 @@ def download_duplicates_xlsx(request): """ try: # Generuj plik XLSX - xlsx_content = export_duplicates_to_xlsx() + xlsx_content = export_duplicates_to_xlsx(request) # Stwórz odpowiedź HTTP z plikiem response = HttpResponse( diff --git a/src/deduplikator_publikacji/admin.py b/src/deduplikator_publikacji/admin.py index 3f45296c8..17ecfd41f 100644 --- a/src/deduplikator_publikacji/admin.py +++ b/src/deduplikator_publikacji/admin.py @@ -5,6 +5,9 @@ @admin.register(PublicationDuplicateScanRun) class PublicationDuplicateScanRunAdmin(admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "pk", "status", @@ -31,6 +34,9 @@ class PublicationDuplicateScanRunAdmin(admin.ModelAdmin): @admin.register(PublicationDuplicateCandidate) class PublicationDuplicateCandidateAdmin(admin.ModelAdmin): + def has_module_permission(self, request): + return request.user.is_superuser + list_display = [ "pk", "original_title_short", diff --git a/src/deduplikator_zrodel/utils.py b/src/deduplikator_zrodel/utils.py index 0b99e6426..d796d5b1c 100644 --- a/src/deduplikator_zrodel/utils.py +++ b/src/deduplikator_zrodel/utils.py @@ -328,15 +328,11 @@ def policz_zrodla_z_duplikatami(): return count -def _get_site_domain(): - """Helper function to get site domain for XLSX export.""" - from django.contrib.sites.models import Site +def _get_site_domain(request=None): + """Helper function to get site URL for XLSX export.""" + from bpp.util import site_url_for_request - try: - current_site = Site.objects.get_current() - return f"https://{current_site.domain}" - except BaseException: - return "https://bpp.iplweb.pl" + return site_url_for_request(request) def _create_pbn_journal_url(pbn_uid): @@ -440,7 +436,7 @@ def _format_worksheet_urls(ws, data_rows): cell.font = Font(color="0000FF", underline="single") -def export_duplicates_to_xlsx(): +def export_duplicates_to_xlsx(request=None): """ Eksportuje wszystkie źródła z duplikatami do formatu XLSX. @@ -471,7 +467,7 @@ def export_duplicates_to_xlsx(): from bpp.util import worksheet_columns_autosize, worksheet_create_table - site_domain = _get_site_domain() + site_domain = _get_site_domain(request) # Pobierz źródła ignorowane ignored_ids = set(IgnoredSource.objects.values_list("zrodlo_id", flat=True)) diff --git a/src/deduplikator_zrodel/views.py b/src/deduplikator_zrodel/views.py index bc9412a3a..cd8a04252 100644 --- a/src/deduplikator_zrodel/views.py +++ b/src/deduplikator_zrodel/views.py @@ -302,7 +302,7 @@ def download_duplicates_xlsx(request): try: # Generuj plik XLSX - xlsx_content = export_duplicates_to_xlsx() + xlsx_content = export_duplicates_to_xlsx(request) # Stwórz odpowiedź HTTP z plikiem response = HttpResponse( diff --git a/src/django_bpp/asgi.py b/src/django_bpp/asgi.py index 5a28357af..f192cd4bc 100644 --- a/src/django_bpp/asgi.py +++ b/src/django_bpp/asgi.py @@ -8,17 +8,14 @@ # is populated before importing code that may import ORM models. django_asgi_app = get_asgi_application() -from channels.auth import AuthMiddlewareStack -from channels.routing import ProtocolTypeRouter, URLRouter -from channels.security.websocket import AllowedHostsOriginValidator +# Te importy muszą biec po get_asgi_application(), żeby AppRegistry +# było zainicjalizowane — channels_broadcast.routing importuje ORM modele. +import channels_broadcast.routing # noqa: E402 +from channels.auth import AuthMiddlewareStack # noqa: E402 +from channels.routing import ProtocolTypeRouter, URLRouter # noqa: E402 +from channels.security.websocket import AllowedHostsOriginValidator # noqa: E402 -import channels_broadcast.routing -import pbn_import.routing - -websocket_urlpatterns = ( - channels_broadcast.routing.websocket_urlpatterns - + pbn_import.routing.websocket_urlpatterns -) +websocket_urlpatterns = channels_broadcast.routing.websocket_urlpatterns application = ProtocolTypeRouter( { diff --git a/src/django_bpp/external_auth.py b/src/django_bpp/external_auth.py index d29b706a9..e2ae7e055 100644 --- a/src/django_bpp/external_auth.py +++ b/src/django_bpp/external_auth.py @@ -5,7 +5,12 @@ nie ma password_policies w INSTALLED_APPS). """ +MICROSOFT_BACKEND = "microsoft_auth.backends.MicrosoftAuthenticationBackend" +ORCID_BACKEND = "orcid_integration.backends.OrcidAuthenticationBackend" +OIDC_BACKEND = "oidc_integration.backends.BppOIDCBackend" + EXTERNAL_AUTH_BACKENDS = { - "microsoft_auth.backends.MicrosoftAuthenticationBackend", - "orcid_integration.backends.OrcidAuthenticationBackend", + MICROSOFT_BACKEND, + ORCID_BACKEND, + OIDC_BACKEND, } diff --git a/src/django_bpp/menu.py b/src/django_bpp/menu.py index bb4cd80cc..c7e6492b0 100644 --- a/src/django_bpp/menu.py +++ b/src/django_bpp/menu.py @@ -230,7 +230,7 @@ def flt(n1, n2, v, icon_class=None): from bpp.models import Uczelnia - uczelnia = Uczelnia.objects.get_default() + uczelnia = Uczelnia.objects.get_for_request(context["request"]) uzywaj_wydzialow = True if uczelnia is not None: uzywaj_wydzialow = uczelnia.uzywaj_wydzialow diff --git a/src/django_bpp/settings/base.py b/src/django_bpp/settings/base.py index 902bb88fa..e85c9b9bc 100644 --- a/src/django_bpp/settings/base.py +++ b/src/django_bpp/settings/base.py @@ -93,6 +93,9 @@ def int_or_none(v): # Konfiguracja Django # DJANGO_BPP_HOSTNAME=(str, "localhost"), + # Multi-hosted: comma-separated lista nazw hostów (np. "u1.example,u2.example"). + # Pusta wartość = używaj DJANGO_BPP_HOSTNAME (single-host, backward compat). + DJANGO_BPP_HOSTNAMES=(str, ""), DJANGO_BPP_DB_NAME=(str, "bpp"), DJANGO_BPP_DB_USER=(str, "bpp"), DJANGO_BPP_DB_PASSWORD=(str, "password"), @@ -205,7 +208,10 @@ def int_or_none(v): os.path.join(BASE_DIR, "locale"), ] -SITE_ID = 1 # dla static-sitemaps +# SITE_ID służy jako fallback dla SiteResolutionMiddleware gdy hostname +# nie pasuje do żadnego obiektu Site. W multi-hosted ustawia się na ID +# domyślnego Site. static-sitemaps również wymaga tej wartości. +SITE_ID = env("DJANGO_BPP_SITE_ID", default=1, cast=int) USE_I18N = True USE_TZ = True @@ -290,6 +296,8 @@ def int_or_none(v): "bpp.context_processors.pbn_token_aktualny.pbn_token_aktualny", "bpp.context_processors.microsoft_auth.microsoft_auth_status", "bpp.context_processors.orcid.orcid_auth_status", + "bpp.context_processors.oidc.oidc_auth_status", + "bpp.context_processors.external_auth.external_auth_status", "bpp.context_processors.testing.testing", "cookielaw.context_processors.cookielaw", "django_countdown.context_processors.countdown_context", @@ -307,6 +315,7 @@ def int_or_none(v): "django.middleware.common.CommonMiddleware", "django.middleware.csrf.CsrfViewMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", + "bpp.middleware.SiteResolutionMiddleware", # After auth - resolves Site/Uczelnia from hostname "django_countdown.middleware.CountdownBlockingMiddleware", # After auth - needs request.user "first_run_wizard.middleware.FirstRunWizardMiddleware", # After auth middleware to have request.user "django.contrib.messages.middleware.MessageMiddleware", @@ -591,50 +600,85 @@ def autoslug_gen(): COMPRESS_JS_FILTERS = [] COMPRESS_ROOT = STATIC_ROOT + +# Jedyne źródło prawdy dla listy motywów kolorystycznych front-endu: +# (wartość pliku SCSS bez rozszerzenia, etykieta widoczna w adminie uczelni). +# Admin (UczelniaAdminForm) czyta tę listę, a COMPRESS_OFFLINE_CONTEXT poniżej +# jest z niej wyliczany — dodanie motywu = jeden wpis tutaj (+ ręcznie target +# w Gruntfile.js). Walidacja wyboru żyje w formularzu, NIE w `choices` pola +# modelu, dzięki czemu zmiana listy nie wymaga migracji. +BPP_THEMES = [ + ("app-green", "Zielony"), + ("app-blue", "Niebieski"), + ("app-orange", "Pomarańczowy"), + ("app-vizja", "Bursztynowo-granatowy (VIZJA)"), + ("app-mwsl", "Pomarańczowo-granatowy (MWSL)"), + ("app-uafm", "Czerwono-błękitny (UAFM)"), +] + COMPRESS_OFFLINE_CONTEXT = [ { - "THEME_NAME": "scss/app-blue.css", - "STATIC_URL": STATIC_URL, - "LANGUAGE_CODE": "pl", - }, - { - "THEME_NAME": "scss/app-green.css", - "STATIC_URL": STATIC_URL, - "LANGUAGE_CODE": "pl", - }, - { - "THEME_NAME": "scss/app-orange.css", - "STATIC_URL": STATIC_URL, - "LANGUAGE_CODE": "pl", - }, - { - "THEME_NAME": "scss/app-vizja.css", - "STATIC_URL": STATIC_URL, - "LANGUAGE_CODE": "pl", - }, - { - "THEME_NAME": "scss/app-mwsl.css", - "STATIC_URL": STATIC_URL, - "LANGUAGE_CODE": "pl", - }, - { - "THEME_NAME": "scss/app-uafm.css", + "THEME_NAME": f"scss/{value}.css", "STATIC_URL": STATIC_URL, "LANGUAGE_CODE": "pl", - }, + } + for value, _label in BPP_THEMES ] -DJANGO_BPP_HOSTNAME = env("DJANGO_BPP_HOSTNAME") +# Lista hostów obsługiwanych przez deployment. +# Konfiguracja jawnie XOR: ustaw ALBO DJANGO_BPP_HOSTNAME (single, bez +# przecinka), ALBO DJANGO_BPP_HOSTNAMES (multi-host, CSV z minimum dwoma +# hostami). Ustawienie obu = ImproperlyConfigured (intencja niejasna). +_hostname = os.environ.get("DJANGO_BPP_HOSTNAME", "").strip() +_hostnames_csv = os.environ.get("DJANGO_BPP_HOSTNAMES", "").strip() + +if _hostname and _hostnames_csv: + raise ImproperlyConfigured( + "Ustaw albo DJANGO_BPP_HOSTNAME (single host, bez przecinka), albo " + "DJANGO_BPP_HOSTNAMES (multi-host, comma-separated, minimum dwa). " + "Oba naraz są niejednoznaczne — wybierz jedno." + ) + +if _hostnames_csv: + if "," not in _hostnames_csv: + raise ImproperlyConfigured( + f"DJANGO_BPP_HOSTNAMES musi zawierać minimum dwa hosty " + f"oddzielone przecinkiem (otrzymano: {_hostnames_csv!r}). " + f"Dla single-host użyj DJANGO_BPP_HOSTNAME." + ) + DJANGO_BPP_HOSTNAMES = [h.strip() for h in _hostnames_csv.split(",") if h.strip()] + if len(DJANGO_BPP_HOSTNAMES) < 2: + raise ImproperlyConfigured( + f"DJANGO_BPP_HOSTNAMES po sparsowaniu daje mniej niż dwa hosty " + f"(otrzymano: {DJANGO_BPP_HOSTNAMES!r}). " + f"Dla single-host użyj DJANGO_BPP_HOSTNAME." + ) +elif _hostname: + if "," in _hostname: + raise ImproperlyConfigured( + f"DJANGO_BPP_HOSTNAME nie może zawierać przecinka " + f"(otrzymano: {_hostname!r}). Dla multi-host użyj " + f"DJANGO_BPP_HOSTNAMES." + ) + DJANGO_BPP_HOSTNAMES = [_hostname] +else: + # Żadne nie ustawione — fallback do default ("localhost") z env declaration + DJANGO_BPP_HOSTNAMES = [env("DJANGO_BPP_HOSTNAME")] + +# Canonical/primary hostname — pierwszy z listy. Używany m.in. przez +# Rollbar jako identyfikacja deployment'u (oznaczenie instalacji); per-request +# vhost gdzie padło zgłoszenie ma osobny klucz w extra_data middleware'u. +DJANGO_BPP_HOSTNAME = DJANGO_BPP_HOSTNAMES[0] ALLOWED_HOSTS = [ "127.0.0.1", "appserver", "appserver:8000", "test.unexistenttld", - DJANGO_BPP_HOSTNAME, + *DJANGO_BPP_HOSTNAMES, ] -CSRF_TRUSTED_ORIGINS = ["https://" + DJANGO_BPP_HOSTNAME] +CSRF_TRUSTED_ORIGINS = ["https://" + h for h in DJANGO_BPP_HOSTNAMES] # Optional extra CSRF origins for dev with non-standard ports # (comma-separated, e.g. "https://bpp.localnet:10443,https://localhost:10443") @@ -1178,6 +1222,69 @@ def can_login_as(request, target_user): "orcid_integration.backends.OrcidAuthenticationBackend", ] +# +# Konfiguracja logowania OpenID Connect (Keycloak) — opcjonalna i ADDYTYWNA. +# +# Aktywuje się TYLKO gdy w środowisku jest komplet DJANGO_BPP_OIDC_*_{CLIENT_ID, +# CLIENT_SECRET,ISSUER} (z prefiksem skrótu uczelni lub bez). Nie przejmuje +# strony logowania — dokłada się jako kolejna metoda obok hasła/Microsoft/ORCID. +# Backend jest DOPISYWANY do listy (ModelBackend zostaje → logowanie hasłem +# działa równolegle). +# +from oidc_integration.conf import ( # noqa: E402 + discover_oidc_config, + fetch_well_known_endpoints, +) + +_OIDC_CONFIG = discover_oidc_config() +OIDC_LOGIN_ENABLED = _OIDC_CONFIG is not None +OIDC_LOGIN_SKROT = (_OIDC_CONFIG or {}).get("skrot") or "" + +if _OIDC_CONFIG: + if "oidc_integration" not in INSTALLED_APPS: + INSTALLED_APPS = list(INSTALLED_APPS) + ["oidc_integration"] + + OIDC_RP_CLIENT_ID = _OIDC_CONFIG["client_id"] + OIDC_RP_CLIENT_SECRET = _OIDC_CONFIG["client_secret"] + + # Źródła claimów (konfigurowalne env-em, default mail-first / username z + # preferred_username) — czytane przez BppOIDCBackend. + OIDC_EMAIL_CLAIMS = _OIDC_CONFIG["email_claims"] + OIDC_USERNAME_CLAIMS = _OIDC_CONFIG["username_claims"] + + # Endpointy: preferuj .well-known (źródło prawdy serwera), z fallbackiem na + # konwencję Keycloaka gdy IdP nieosiągalny przy starcie. + _oidc_endpoints = ( + fetch_well_known_endpoints(_OIDC_CONFIG["issuer"]) or _OIDC_CONFIG["endpoints"] + ) + OIDC_OP_AUTHORIZATION_ENDPOINT = _oidc_endpoints["authorization"] + OIDC_OP_TOKEN_ENDPOINT = _oidc_endpoints["token"] + OIDC_OP_USER_ENDPOINT = _oidc_endpoints.get("userinfo", "") + OIDC_OP_JWKS_ENDPOINT = _oidc_endpoints["jwks"] + # end_session: wylogowanie z Keycloaka (RP-Initiated Logout). + OIDC_OP_LOGOUT_ENDPOINT = _oidc_endpoints.get("end_session", "") + OIDC_OP_LOGOUT_URL_METHOD = "oidc_integration.logout.build_provider_logout_url" + + # Panel konta Keycloaka (Account Console) — konwencja {issuer}/account. + # Tam użytkownik OIDC zmienia hasło; w BPP nie ma takiej możliwości, więc + # SmartPasswordChangeView kieruje go pod ten URL zamiast formularza BPP. + OIDC_ACCOUNT_CONSOLE_URL = _OIDC_CONFIG["issuer"].rstrip("/") + "/account" + + # Keycloak podpisuje id_token RS256; scope email konieczny do auto-create. + OIDC_RP_SIGN_ALGO = "RS256" + OIDC_RP_SCOPES = "openid email profile" + OIDC_CREATE_USER = True + # Zapamiętaj id_token w sesji — potrzebny jako id_token_hint przy logout. + OIDC_STORE_ID_TOKEN = True + + AUTHENTICATION_BACKENDS = list(AUTHENTICATION_BACKENDS) + [ + "oidc_integration.backends.BppOIDCBackend", + ] + +# +# Koniec konfiguracji OpenID Connect +# + # # django-axes — ochrona przed zgadywaniem hasła (brute-force / credential stuffing) # @@ -1361,13 +1468,20 @@ def iter_namespace(ns_pkg): # # django-static-sitemaps +# W trybie multi-hosted można wyłączyć sitemaps ustawiając +# DJANGO_BPP_ENABLE_SITEMAPS=False, ponieważ static-sitemaps +# generuje sitemapę tylko dla jednej domeny (SITE_ID). # -STATICSITEMAPS_ROOT_SITEMAP = "django_bpp.sitemaps.django_bpp_sitemaps" +ENABLE_SITEMAPS = env("DJANGO_BPP_ENABLE_SITEMAPS", default=True, cast=bool) -STATICSITEMAPS_REFRESH_AFTER = 24 * 60 - -STATICSITEMAPS_ROOT_DIR = os.path.relpath(STATIC_ROOT, os.getcwd()) +if ENABLE_SITEMAPS: + STATICSITEMAPS_ROOT_SITEMAP = "django_bpp.sitemaps.django_bpp_sitemaps" + STATICSITEMAPS_REFRESH_AFTER = 24 * 60 + STATICSITEMAPS_ROOT_DIR = os.path.relpath(STATIC_ROOT, os.getcwd()) +else: + if "static_sitemaps" in INSTALLED_APPS: + INSTALLED_APPS.remove("static_sitemaps") # # "Audyt" bezpieczeństwa @@ -1531,6 +1645,24 @@ def iter_namespace(ns_pkg): "level": "WARNING", "propagate": False, }, + # OIDC (Keycloak). Domyślnie WARNING — zwykła praca milczy. Diagnostyka + # claimów realmu (`_log_claims_debug` w backends.py zrzuca KAŻDY klucz + # i wartość) wymaga opt-in: ustaw DJANGO_BPP_OIDC_DEBUG_CLAIMS=1 i zaloguj + # się przez Keycloaka, żeby zobaczyć faktyczne nazwy claimów na stderr. + # ⚠️ DEBUG loguje też wartości (adresy e-mail, login) — włączaj tylko + # do diagnostyki, nie zostawiaj na produkcji. + "oidc_integration": { + "handlers": ["console"], + "level": ( + "DEBUG" + if os.getenv("DJANGO_BPP_OIDC_DEBUG_CLAIMS") == "1" + else "WARNING" + ), + # propagate=True (inaczej niż sąsiednie loggery): root nie ma tu + # własnego handlera, więc propagacja nie dubluje wyjścia, a pozwala + # pytestowemu `caplog` (łapie na rootcie) widzieć zrzut claimów. + "propagate": True, + }, }, } @@ -1554,93 +1686,11 @@ def iter_namespace(ns_pkg): CONSTANCE_BACKEND = "constance.backends.database.DatabaseBackend" CONSTANCE_DATABASE_CACHE_BACKEND = "constance_cache" -CONSTANCE_CONFIG = { - # Punktacja - "UZYWAJ_PUNKTACJI_WEWNETRZNEJ": ( - env("DJANGO_BPP_UZYWAJ_PUNKTACJI_WEWNETRZNEJ"), - "Używaj punktacji wewnętrznej w systemie", - bool, - ), - "POKAZUJ_INDEX_COPERNICUS": ( - True, - "Pokazuj pole Index Copernicus w formularzach", - bool, - ), - "POKAZUJ_PUNKTACJA_SNIP": ( - True, - "Pokazuj pole punktacji SNIP w formularzach", - bool, - ), - # Funkcjonalność - "POKAZUJ_OSWIADCZENIE_KEN": ( - env("DJANGO_BPP_POKAZUJ_OSWIADCZENIE_KEN"), - "Pokazuj opcję oświadczenia KEN", - bool, - ), - # Struktura uczelni - "SKROT_WYDZIALU_W_NAZWIE_JEDNOSTKI": ( - env("DJANGO_BPP_SKROT_WYDZIALU_W_NAZWIE_JEDNOSTKI"), - "Wyświetlaj skrót wydziału w nazwie jednostki", - bool, - ), - "UCZELNIA_UZYWA_WYDZIALOW": ( - env("DJANGO_BPP_UCZELNIA_UZYWA_WYDZIALOW"), - "Uczelnia używa struktury wydziałowej", - bool, - ), - # Integracje Google - "GOOGLE_ANALYTICS_PROPERTY_ID": ( - env("DJANGO_BPP_GOOGLE_ANALYTICS_PROPERTY_ID"), - "Google Analytics Property ID (np. UA-XXXXXXXX-X lub G-XXXXXXXXXX)", - str, - ), - "GOOGLE_VERIFICATION_CODE": ( - env("DJANGO_BPP_GOOGLE_VERIFICATION_CODE"), - "Kod weryfikacyjny Google Search Console", - str, - ), - # Wydruk - marginesy - "WYDRUK_MARGINES_GORA": ( - "2cm", - "Margines górny wydruku (np. 2cm, 20mm, 0.8in)", - str, - ), - "WYDRUK_MARGINES_DOL": ( - "2cm", - "Margines dolny wydruku (np. 2cm, 20mm, 0.8in)", - str, - ), - "WYDRUK_MARGINES_LEWO": ( - "2cm", - "Margines lewy wydruku (np. 2cm, 20mm, 0.8in)", - str, - ), - "WYDRUK_MARGINES_PRAWO": ( - "2cm", - "Margines prawy wydruku (np. 2cm, 20mm, 0.8in)", - str, - ), -} - -CONSTANCE_CONFIG_FIELDSETS = { - "Punktacja": ( - "UZYWAJ_PUNKTACJI_WEWNETRZNEJ", - "POKAZUJ_INDEX_COPERNICUS", - "POKAZUJ_PUNKTACJA_SNIP", - ), - "Funkcjonalność": ("POKAZUJ_OSWIADCZENIE_KEN",), - "Struktura uczelni": ( - "SKROT_WYDZIALU_W_NAZWIE_JEDNOSTKI", - "UCZELNIA_UZYWA_WYDZIALOW", - ), - "Integracje Google": ( - "GOOGLE_ANALYTICS_PROPERTY_ID", - "GOOGLE_VERIFICATION_CODE", - ), - "Wydruk": ( - "WYDRUK_MARGINES_GORA", - "WYDRUK_MARGINES_DOL", - "WYDRUK_MARGINES_LEWO", - "WYDRUK_MARGINES_PRAWO", - ), -} +# Ustawienia per-uczelnia przeniesione do modelu Uczelnia: +# UZYWAJ_PUNKTACJI_WEWNETRZNEJ, POKAZUJ_INDEX_COPERNICUS, POKAZUJ_PUNKTACJA_SNIP, +# POKAZUJ_OSWIADCZENIE_KEN, SKROT_WYDZIALU_W_NAZWIE_JEDNOSTKI, +# UCZELNIA_UZYWA_WYDZIALOW, GOOGLE_ANALYTICS_PROPERTY_ID, +# GOOGLE_VERIFICATION_CODE, WYDRUK_MARGINES_* +# Puste CONSTANCE_CONFIG zachowane dla backward compat z django-constance. +CONSTANCE_CONFIG = {} +CONSTANCE_CONFIG_FIELDSETS = {} diff --git a/src/django_bpp/settings/local.py b/src/django_bpp/settings/local.py index f51481616..22198052f 100644 --- a/src/django_bpp/settings/local.py +++ b/src/django_bpp/settings/local.py @@ -26,6 +26,7 @@ def setenv_default(varname, default_value): from .base import * # noqa from .base import ( # noqa DATABASES, + DJANGO_BPP_HOSTNAMES, INSTALLED_APPS, MIDDLEWARE, REDIS_HOST, @@ -57,7 +58,7 @@ def setenv_default(varname, default_value): "mac-mini", "publikacje-test", "test.unexistenttld", - env("DJANGO_BPP_HOSTNAME"), # noqa + *DJANGO_BPP_HOSTNAMES, ] CELERY_ALWAYS_EAGER = False diff --git a/src/django_bpp/settings/production.py b/src/django_bpp/settings/production.py index 4647ad07e..b5fd22bcc 100644 --- a/src/django_bpp/settings/production.py +++ b/src/django_bpp/settings/production.py @@ -3,6 +3,7 @@ from .base import * # noqa from .base import ( # noqa DJANGO_BPP_ENABLE_TEST_CONFIGURATION, + DJANGO_BPP_HOSTNAMES, INSTALLED_APPS, MIDDLEWARE, REDIS_HOST, @@ -116,7 +117,7 @@ def should_minify(self, request, response): "127.0.0.1", "appserver", "appserver:8000", - env("DJANGO_BPP_HOSTNAME"), # noqa + *DJANGO_BPP_HOSTNAMES, ] SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https") diff --git a/src/django_bpp/templates/admin/base_site.html b/src/django_bpp/templates/admin/base_site.html index 657ed2150..7708ecad7 100644 --- a/src/django_bpp/templates/admin/base_site.html +++ b/src/django_bpp/templates/admin/base_site.html @@ -69,8 +69,10 @@

{% trans 'Django administration' %}

// Change cursor to waiting $('body').css('cursor', 'wait'); - // Perform redirect - location.href = "/global-nav-redir/" + $(this).val() + + // Perform redirect (encode value to avoid + // reinterpreting DOM text as part of the URL/markup) + location.href = "/global-nav-redir/" + + encodeURIComponent($(this).val()) + "?source=admin"; }); @@ -222,6 +224,12 @@

{% trans 'Django administration' %}

--admin-hover-bg: #f0f8f2; {% elif THEME_NAME_RAW == 'app-orange' %} --admin-hover-bg: #fef5f0; + {% elif THEME_NAME_RAW == 'app-vizja' %} + --admin-hover-bg: #fdf8ec; + {% elif THEME_NAME_RAW == 'app-mwsl' %} + --admin-hover-bg: #fdf3ec; + {% elif THEME_NAME_RAW == 'app-uafm' %} + --admin-hover-bg: #fbeeec; {% else %} --admin-hover-bg: #f5f5f5; {% endif %} diff --git a/src/django_bpp/templates/registration/login.html b/src/django_bpp/templates/registration/login.html index 902d2297a..d335c19ae 100644 --- a/src/django_bpp/templates/registration/login.html +++ b/src/django_bpp/templates/registration/login.html @@ -6,7 +6,7 @@ {% block breadcrumbs %} {{ block.super }} -
  • Logowanie +
  • Logowanie
    • {% endblock %} {% block content %} diff --git a/src/django_bpp/templates/registration/password_change_external.html b/src/django_bpp/templates/registration/password_change_external.html index 364d749a1..0de2f4830 100644 --- a/src/django_bpp/templates/registration/password_change_external.html +++ b/src/django_bpp/templates/registration/password_change_external.html @@ -19,14 +19,16 @@

    Zmiana hasła

    Hasło jest zarządzane przez tego dostawcę i nie może zostać zmienione w systemie BPP.

    -

    - Aby zmienić hasło, przejdź do panelu zarządzania - kontem {{ provider }}: -

    -

    - Zarządzaj kontem {{ provider }} -

    + {% if url %} +

    + Aby zmienić hasło, przejdź do panelu zarządzania + kontem {{ provider }}: +

    +

    + Zarządzaj kontem {{ provider }} +

    + {% endif %}
    {% endblock %} diff --git a/src/django_bpp/templates/top_bar.html b/src/django_bpp/templates/top_bar.html index ac0bf0bf0..b7d075dd8 100644 --- a/src/django_bpp/templates/top_bar.html +++ b/src/django_bpp/templates/top_bar.html @@ -287,7 +287,7 @@ mój profil - {% if not microsoft_login_enabled %} + {% if not logged_in_via_external_auth %}
  • zmiana hasła
    • {% endif %} {% if request.user.is_superuser %} @@ -461,13 +461,18 @@ {% endif %} {% if request.user.is_anonymous %} - {% if microsoft_login_enabled %} + {% if microsoft_login_enabled or oidc_login_enabled %}
  • zaloguj