fix(eksport-autora): eksport bez ukrytych statusów także dla redakcji i bez uczelni (#921)

Uzupełnienie #901. Zakres ukrytych statusów w eksporcie BibTeX/RIS
liczyła ukryte_statusy_podgladu(request), czyli reguła strony rekordu:

- redakcja dostawała pustą listę — także w zadaniu w tle, którego plik
  jest publiczny po UUID, więc zlecenie redaktora publikowało prace
  o ukrytych statusach,
- przy nieustalonej uczelni lista była pusta (fail-open).

Nowy helper ukryte_statusy_eksportu(request): reguła publiczna dla
każdego (plik wychodzi poza stronę), a bez uczelni — statusy ukryte
w kanale "podglad" w dowolnej uczelni. Używany w eksporcie
synchronicznym i przy starcie zadania (zakres i deduplikacja).


Claude-Session: https://claude.ai/code/session_01A6vyhS6eoLYPN5ceSPJ1sh

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: mpasternak

src/bpp/newsfragments/eksport-autora-widocznosc.bugfix.rst

@@ -0,0 +1 @@
+Eksport prac autora do BibTeX/RIS (synchroniczny i w tle) nie zawiera prac o statusach korekty ukrytych na stronach publicznych także wtedy, gdy zleca go redaktor (plik wychodzi poza stronę) oraz gdy nie da się ustalić uczelni.

src/bpp/tests/test_profil/test_widocznosc_profilu.py

@@ -215,10 +215,28 @@ def test_eksport_sync_bez_ukrytych_dla_zwyklego_usera(
     assert "Praca ukryta" not in body
 
 
-def test_eksport_sync_redakcja_widzi_ukryte(admin_client, dorobek_z_ukryta):
-    url = reverse("bpp:autor_eksport_bibtex", args=(dorobek_z_ukryta.pk,))
+@pytest.mark.parametrize("nazwa", ["autor_eksport_bibtex", "autor_eksport_ris"])
+def test_eksport_sync_redakcja_tez_bez_ukrytych(admin_client, dorobek_z_ukryta, nazwa):
+    """Plik wychodzi poza stronę — redakcja też nie dostaje ukrytych prac."""
+    url = reverse(f"bpp:{nazwa}", args=(dorobek_z_ukryta.pk,))
     body = admin_client.get(url).content.decode("utf-8")
-    assert "Praca ukryta" in body
+    assert "Praca widoczna" in body
+    assert "Praca ukryta" not in body
+
+
+def test_eksport_sync_bez_uczelni_bez_ukrytych(
+    client, django_user_model, dorobek_z_ukryta
+):
+    """Bez ustalonej uczelni eksport nie jest fail-open: wyklucza statusy
+    ukryte w dowolnej uczelni."""
+    client.force_login(_zwykly_user(django_user_model))
+    url = reverse("bpp:autor_eksport_bibtex", args=(dorobek_z_ukryta.pk,))
+    with mock.patch(
+        "bpp.models.Uczelnia.objects.get_for_request", return_value=None
+    ):
+        body = client.get(url).content.decode("utf-8")
+    assert "Praca widoczna" in body
+    assert "Praca ukryta" not in body
 
 
 def test_eksport_sync_ukryty_autor_404(client, admin_client, django_user_model):
@@ -250,10 +268,13 @@ def test_eksport_sync_limit_zadan(client, django_user_model):
 # --- eksport asynchroniczny --------------------------------------------------
 
 
-def test_eksport_async_zapisuje_zakres_i_rozdziela_deduplikacje(
+def test_eksport_async_zakres_publiczny_takze_dla_redakcji(
     client, admin_client, uczelnia, dorobek_z_ukryta
 ):
-    ukryte = list(uczelnia.ukryte_statusy("podglad"))
+    """Plik zadania jest publiczny po UUID — zlecenie redakcji dostaje ten
+    sam (publiczny) zakres, więc anonim reużywa tego samego zadania."""
+    ukryte = sorted(uczelnia.ukryte_statusy("podglad"))
+    assert ukryte
     url = reverse(
         "bpp:autor_eksport_start", kwargs={"pk": dorobek_z_ukryta.pk, "format": "bib"}
     )
@@ -265,7 +286,22 @@ def test_eksport_async_zapisuje_zakres_i_rozdziela_deduplikacje(
             client.post(url, {"captcha": "eyJjaGFsbGVuZ2UiOiAieCJ9"})
 
     zadania = AutorEksportTask.objects.filter(autor=dorobek_z_ukryta)
-    assert sorted(list(t.ukryte_statusy) for t in zadania) == sorted([[], ukryte])
+    assert [list(t.ukryte_statusy) for t in zadania] == [ukryte]
+
+
+def test_eksport_async_bez_uczelni_bez_ukrytych(admin_client, dorobek_z_ukryta):
+    """Bez ustalonej uczelni zadanie dostaje statusy ukryte w dowolnej
+    uczelni (nie pustą listę)."""
+    url = reverse(
+        "bpp:autor_eksport_start", kwargs={"pk": dorobek_z_ukryta.pk, "format": "ris"}
+    )
+    with mock.patch("bpp.tasks.generuj_eksport_autora.delay"), mock.patch(
+        "bpp.models.Uczelnia.objects.get_for_request", return_value=None
+    ):
+        admin_client.post(url)
+    task = AutorEksportTask.objects.get(autor=dorobek_z_ukryta)
+    ukryty = Status_Korekty.objects.get(nazwa="ukryty-test")
+    assert list(task.ukryte_statusy) == [ukryty.pk]
 
 
 def test_eksport_async_wyklucza_ukryte(dorobek_z_ukryta, uczelnia):

src/bpp/util/ukryte_statusy.py

@@ -42,3 +42,26 @@ def wyklucz_ukryte_statusy(
     if not statusy:
         return qs
     return qs.exclude(**{f"{lookup}__in": statusy})
+
+
+def ukryte_statusy_eksportu(request, kanal="podglad"):
+    """Lista PK statusów korekty wykluczanych z eksportu plików (BibTeX/RIS).
+
+    W odróżnieniu od :func:`ukryte_statusy_dla` reguła jest publiczna dla
+    KAŻDEGO, także redaktora: plik wychodzi poza stronę (można go przekazać
+    dalej, a plik z zadania w tle jest dostępny po UUID). Gdy nie da się
+    ustalić uczelni, nie jest fail-open — zwraca statusy ukryte w danym
+    kanale w KTÓREJKOLWIEK uczelni.
+    """
+    from bpp.models import Uczelnia, Ukryj_Status_Korekty
+
+    uczelnia = Uczelnia.objects.get_for_request(request)
+    if uczelnia is not None:
+        return sorted(set(uczelnia.ukryte_statusy(kanal)))
+    return sorted(
+        set(
+            Ukryj_Status_Korekty.objects.filter(**{kanal: True}).values_list(
+                "status_korekty_id", flat=True
+            )
+        )
+    )

src/bpp/views/eksport_autora.py

@@ -30,7 +30,7 @@
 from bpp.export.ris import export_to_ris
 from bpp.models import Autor, AutorEksportTask, Rekord
 from bpp.permissions import moze_wprowadzac_dane
-from bpp.profil_autora_dane import ukryte_statusy_podgladu
+from bpp.util.ukryte_statusy import ukryte_statusy_eksportu
 
 #: Maksymalna liczba eksportowanych rekordów. Zabezpiecza przed OOM przy
 #: autorach z gigantyczną liczbą prac (eksport materializuje instancje
@@ -99,7 +99,8 @@ def get(self, request, pk):
             )
 
         qs = Rekord.objects.prace_autora(autor)
-        ukryte = ukryte_statusy_podgladu(request)
+        # Plik wychodzi poza stronę — reguła publiczna także dla redakcji.
+        ukryte = ukryte_statusy_eksportu(request)
         if ukryte:
             qs = qs.exclude(status_korekty_id__in=ukryte)
         wszystkich = qs.count()
@@ -204,9 +205,10 @@ def post(self, request, pk, format):
             return self._render(request, autor, format, form)
 
         # Zakres widoczności (ukryte statusy) zapisujemy w zadaniu — worker
-        # Celery nie ma requestu. Wchodzi też do deduplikacji, żeby zadania
-        # o różnym zakresie (redakcja vs. pozostali) nie były współdzielone.
-        ukryte = sorted(ukryte_statusy_podgladu(request))
+        # Celery nie ma requestu. Plik jest publiczny po UUID, więc zakres
+        # jest publiczny także dla redakcji; wchodzi do deduplikacji, żeby
+        # zadania różnych uczelni (inne ukryte statusy) nie były współdzielone.
+        ukryte = ukryte_statusy_eksportu(request)
 
         od = timezone.now() - timedelta(minutes=DEDUPE_MINUTES)
         istniejacy = (