58b9a630-8512-44e6-b730-daac96d1c4d7

Committed 29 Aug 2025 07:21AM UTC coverage: 47.493% (+2.5%) from 45.008%

Build # 58b9a630-8512-44e6-b730-daac96d1c4d7

Build Type

push

circleci

Committed by

mpasternak

Commit Message

Fix tests

Run Details

6 of 27 new or added lines in 2 files covered. (22.22%)

1342 existing lines in 64 files now uncovered.

19323 of 40686 relevant lines covered (47.49%)

1.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.79

src/bpp/models/cache/rekord.py

import denorm
from django.db import connections, models, router
from django.db.models.deletion import DO_NOTHING
from django.urls import reverse
from taggit.managers import TaggableManager, _TaggableManager

from .punktacja import Cache_Punktacja_Autora, Cache_Punktacja_Dyscypliny
from .views import SlowaKluczoweView

from django.contrib.contenttypes.models import ContentType
from django.contrib.postgres.fields.array import ArrayField
from django.contrib.postgres.search import SearchVectorField as VectorField

from django.utils.functional import cached_property

from bpp.models.abstract import (
    ModelPunktowanyBaza,
    ModelRecenzowany,
    ModelTypowany,
    ModelZCharakterem,
    ModelZDOI,
    ModelZeSlowamiKluczowymi,
    ModelZeStatusem,
    ModelZeSzczegolami,
    ModelZeZnakamiWydawniczymi,
    ModelZISBN,
    ModelZKonferencja,
    ModelZKwartylami,
    ModelZOpenAccess,
    ModelZPBN_UID,
    ModelZRokiem,
    ModelZWWW,
)
from bpp.models.fields import TupleField
from bpp.models.util import ModelZOpisemBibliograficznym
from bpp.util import FulltextSearchMixin


class RekordManager(FulltextSearchMixin, models.Manager):
    fts_field = "search_index"

    def get_for_model(self, model):
        pk = (ContentType.objects.get_for_model(model).pk, model.pk)
        return self.get(pk=pk)

    def prace_autora(self, autor):
        return self.filter(autorzy__autor=autor).distinct()

    def prace_autora_z_afiliowanych_jednostek(self, autor):
        """
        Funkcja zwraca prace danego autora, należące tylko i wyłącznie
        do jednostek skupiających pracowników, gdzie autor jest zaznaczony jako
        afiliowany.
        """
        return (
            self.prace_autora(autor)
            .filter(
                autorzy__autor=autor,
                autorzy__jednostka__skupia_pracownikow=True,
                autorzy__afiliuje=True,
            )
            .distinct()
        )

    def prace_autor_i_typ(self, autor, skrot):
        from bpp.models import Typ_Odpowiedzialnosci

        return (
            self.prace_autora(autor)
            .filter(
                autorzy__typ_odpowiedzialnosci_id=Typ_Odpowiedzialnosci.objects.get(
                    skrot=skrot
                ).pk
            )
            .distinct()
        )

    def prace_jednostki(self, jednostka, afiliowane=None):
        if afiliowane is None:
            return self.filter(
                autorzy__jednostka__pk__in=list(
                    jednostka.get_descendants(include_self=True).values_list(
                        "pk", flat=True
                    )
                )
            ).distinct()

        return self.filter(
            autorzy__jednostka__pk__in=list(
                jednostka.get_descendants(include_self=True).values_list(
                    "pk", flat=True
                )
            ),
            autorzy__afiliuje=afiliowane,
        ).distinct()

    def prace_wydzialu(self, wydzial, afiliowane=None):
        if afiliowane is None:
            return self.filter(autorzy__jednostka__wydzial=wydzial).distinct()

        return self.filter(
            autorzy__jednostka__wydzial=wydzial, autorzy__afiliuje=afiliowane
        ).distinct()

    def redaktorzy_z_jednostki(self, jednostka):
        from bpp.models import Typ_Odpowiedzialnosci

        return self.filter(
            autorzy__jednostka=jednostka,
            autorzy__typ_odpowiedzialnosci_id=Typ_Odpowiedzialnosci.objects.get(
                skrot="red."
            ).pk,
        ).distinct()

    def get_original(self, model):
        return self.get(pk=[ContentType.objects.get_for_model(model).pk, model.pk])

    def full_refresh(self):
        """Procedura odswieza opisy bibliograficzne dla wszystkich rekordów."""
        denorm.rebuildall("bpp.Wydawnictwo_Zwarte")
        denorm.rebuildall("bpp.Wydawnictwo_Ciagle")
        denorm.rebuildall("bpp.Patent")
        denorm.rebuildall("bpp.Praca_Doktorska")
        denorm.rebuildall("bpp.Praca_Habilitacyjna")


class _MyTaggableManager(_TaggableManager):
    def get_prefetch_queryset(self, instances, queryset=None):
        if queryset is not None:
            raise ValueError("Custom queryset can't be used for this lookup.")

        instance = instances[0]
        db = self._db or router.db_for_read(type(instance), instance=instance)

        fieldname = "rekord_id"
        fk = self.through._meta.get_field(fieldname)
        query = {
            "%s__%s__in"
            % (self.through.tag_relname(), fk.name): {
                obj._get_pk_val() for obj in instances
            }
        }
        join_table = self.through._meta.db_table
        source_col = fk.column
        connection = connections[db]
        qn = connection.ops.quote_name
        qs = (
            self.get_queryset(query)
            .using(db)
            .extra(
                select={
                    "_prefetch_related_val": "{}.{}".format(
                        qn(join_table), qn(source_col)
                    )
                }
            )
        )
        from operator import attrgetter

        rel_obj_attr = attrgetter("_prefetch_related_val")

        return (
            qs,
            rel_obj_attr,
            lambda obj: obj._get_pk_val(),
            False,
            self.prefetch_cache_name,
            False,
        )


class RekordBase(
    ModelPunktowanyBaza,
    ModelZOpisemBibliograficznym,
    ModelZRokiem,
    ModelZWWW,
    ModelZDOI,
    ModelZPBN_UID,
    ModelZeSzczegolami,
    ModelZeSlowamiKluczowymi,
    ModelRecenzowany,
    ModelZeZnakamiWydawniczymi,
    ModelZOpenAccess,
    ModelTypowany,
    ModelZCharakterem,
    ModelZKonferencja,
    ModelZISBN,
    ModelZeStatusem,
    ModelZKwartylami,
    models.Model,
):
    id = TupleField(models.IntegerField(), size=2, primary_key=True)

    tekst_przed_pierwszym_autorem = None
    tekst_po_ostatnim_autorze = None

    tytul_oryginalny = models.TextField()
    tytul = models.TextField()
    search_index = VectorField()

    zrodlo = models.ForeignKey("bpp.Zrodlo", null=True, on_delete=DO_NOTHING)
    wydawnictwo_nadrzedne = models.ForeignKey(
        "bpp.Wydawnictwo_Zwarte", null=True, on_delete=DO_NOTHING
    )
    slowa_kluczowe = TaggableManager(
        "Słowa kluczowe",
        through=SlowaKluczoweView,
        blank=True,
        manager=_MyTaggableManager,
    )

    wydawnictwo = models.TextField()

    adnotacje = models.TextField()
    ostatnio_zmieniony = models.DateTimeField()

    tytul_oryginalny_sort = models.TextField()

    liczba_autorow = models.SmallIntegerField()

    liczba_cytowan = models.SmallIntegerField()

    objects = RekordManager()

    opis_bibliograficzny_cache = models.TextField()
    opis_bibliograficzny_autorzy_cache = ArrayField(models.TextField())
    opis_bibliograficzny_zapisani_autorzy_cache = models.TextField()
    slug = models.TextField()

    wydawca = models.ForeignKey(
        "bpp.Wydawca", on_delete=DO_NOTHING, null=True, blank=True
    )

    strony = None
    nr_zeszytu = None
    tom = None

    jezyk_alt = None
    jezyk_orig = None

    # Skróty dla django-dsl

    django_dsl_shortcuts = {
        "charakter": "charakter_formalny__skrot",
        "typ_kbn": "typ_kbn__skrot",
        "typ_odpowiedzialnosci": "autorzy__typ_odpowiedzialnosci__skrot",
        "autor": "autorzy__autor_id",
        "jednostka": "autorzy__jednostka__pk",
        "wydzial": "autorzy__jednostka__wydzial__pk",
    }

    class Meta:
        abstract = True

    def __str__(self):
        return self.tytul_oryginalny

    @cached_property
    def content_type(self):
        return ContentType.objects.get(pk=self.id[0])

    @cached_property
    def describe_content_type(self):
        return ContentType.objects.get(pk=self.id[0]).model_class()._meta.verbose_name

    @cached_property
    def object_id(self):
        return self.id[1]

    @cached_property
    def original(self):
        return self.content_type.get_object_for_this_type(pk=self.object_id)

    @cached_property
    def js_safe_pk(self):
        return "%i_%i" % (self.pk[0], self.pk[1])

    @cached_property
    def form_post_pk(self):
        return "{%i,%i}" % (self.pk[0], self.pk[1])

    @cached_property
    def ma_punktacje_sloty(self):
        return (
            Cache_Punktacja_Autora.objects.filter(
                rekord_id=[self.id[0], self.id[1]]
            ).exists()
            or Cache_Punktacja_Dyscypliny.objects.filter(
                rekord_id=[self.id[0], self.id[1]]
            ).exists()
        )

    @cached_property
    def ma_odpiete_dyscypliny(self):
        return (
            self.original.autorzy_set.exclude(dyscyplina_naukowa=None)
            .exclude(przypieta=True)
            .exists()
        )

    @cached_property
    def punktacja_dyscypliny(self):
        return Cache_Punktacja_Dyscypliny.objects.filter(
            rekord_id=[self.id[0], self.id[1]]
        )

    @cached_property
    def punktacja_autora(self):
        return Cache_Punktacja_Autora.objects.filter(rekord_id=[self.id[0], self.id[1]])

    @cached_property
    def pierwszy_autor_afiliowany(self):
        """Zwraca pierwszego autora, afiliującego na jednostkę uczelni z tej pracy"""
        return self.autorzy.filter(afiliuje=True).order_by("kolejnosc").first()

    @cached_property
    def pierwsza_jednostka_afiliowana(self):
        """Zwraca pierwszego autora, afiliującego na jednostkę uczelni z tej pracy"""
        res = self.pierwszy_autor_afiliowany()
        if res is not None:
            return self.pierwszy_autor_afiliowany().jednostka

    def get_absolute_url(self):
        return reverse("bpp:browse_rekord", args=(self.pk[0], self.pk[1]))


class Rekord(RekordBase):
    class Meta:
        managed = False
        ordering = ["tytul_oryginalny_sort"]
        db_table = "bpp_rekord_mat"

    @cached_property
    def autorzy_set(self):
        return self.autorzy


class RekordView(RekordBase):
    class Meta:
        managed = False
        db_table = "bpp_rekord"

1	import denorm	4✔
2	from django.db import connections, models, router	4✔
3	from django.db.models.deletion import DO_NOTHING	4✔
4	from django.urls import reverse	4✔
5	from taggit.managers import TaggableManager, _TaggableManager	4✔
6
7	from .punktacja import Cache_Punktacja_Autora, Cache_Punktacja_Dyscypliny	4✔
8	from .views import SlowaKluczoweView	4✔
9
10	from django.contrib.contenttypes.models import ContentType	4✔
11	from django.contrib.postgres.fields.array import ArrayField	4✔
12	from django.contrib.postgres.search import SearchVectorField as VectorField	4✔
13
14	from django.utils.functional import cached_property	4✔
15
16	from bpp.models.abstract import (	4✔
17	ModelPunktowanyBaza,
18	ModelRecenzowany,
19	ModelTypowany,
20	ModelZCharakterem,
21	ModelZDOI,
22	ModelZeSlowamiKluczowymi,
23	ModelZeStatusem,
24	ModelZeSzczegolami,
25	ModelZeZnakamiWydawniczymi,
26	ModelZISBN,
27	ModelZKonferencja,
28	ModelZKwartylami,
29	ModelZOpenAccess,
30	ModelZPBN_UID,
31	ModelZRokiem,
32	ModelZWWW,
33	)
34	from bpp.models.fields import TupleField	4✔
35	from bpp.models.util import ModelZOpisemBibliograficznym	4✔
36	from bpp.util import FulltextSearchMixin	4✔
37
38
39	class RekordManager(FulltextSearchMixin, models.Manager):	4✔
40	fts_field = "search_index"	4✔
41
42	def get_for_model(self, model):	4✔
43	pk = (ContentType.objects.get_for_model(model).pk, model.pk)	×
44	return self.get(pk=pk)	×
45
46	def prace_autora(self, autor):	4✔
47	return self.filter(autorzy__autor=autor).distinct()	×
48
49	def prace_autora_z_afiliowanych_jednostek(self, autor):	4✔
50	"""
51	Funkcja zwraca prace danego autora, należące tylko i wyłącznie
52	do jednostek skupiających pracowników, gdzie autor jest zaznaczony jako
53	afiliowany.
54	"""
55	return (	×
56	self.prace_autora(autor)
57	.filter(
58	autorzy__autor=autor,
59	autorzy__jednostka__skupia_pracownikow=True,
60	autorzy__afiliuje=True,
61	)
62	.distinct()
63	)
64
65	def prace_autor_i_typ(self, autor, skrot):	4✔
66	from bpp.models import Typ_Odpowiedzialnosci	×
67
68	return (	×
69	self.prace_autora(autor)
70	.filter(
71	autorzy__typ_odpowiedzialnosci_id=Typ_Odpowiedzialnosci.objects.get(
72	skrot=skrot
73	).pk
74	)
75	.distinct()
76	)
77
78	def prace_jednostki(self, jednostka, afiliowane=None):	4✔
79	if afiliowane is None:	×
80	return self.filter(	×
81	autorzy__jednostka__pk__in=list(
82	jednostka.get_descendants(include_self=True).values_list(
83	"pk", flat=True
84	)
85	)
86	).distinct()
87
88	return self.filter(	×
89	autorzy__jednostka__pk__in=list(
90	jednostka.get_descendants(include_self=True).values_list(
91	"pk", flat=True
92	)
93	),
94	autorzy__afiliuje=afiliowane,
95	).distinct()
96
97	def prace_wydzialu(self, wydzial, afiliowane=None):	4✔
98	if afiliowane is None:	×
99	return self.filter(autorzy__jednostka__wydzial=wydzial).distinct()	×
100
101	return self.filter(	×
102	autorzy__jednostka__wydzial=wydzial, autorzy__afiliuje=afiliowane
103	).distinct()
104
105	def redaktorzy_z_jednostki(self, jednostka):	4✔
106	from bpp.models import Typ_Odpowiedzialnosci	×
107
108	return self.filter(	×
109	autorzy__jednostka=jednostka,
110	autorzy__typ_odpowiedzialnosci_id=Typ_Odpowiedzialnosci.objects.get(
111	skrot="red."
112	).pk,
113	).distinct()
114
115	def get_original(self, model):	4✔
116	return self.get(pk=[ContentType.objects.get_for_model(model).pk, model.pk])	×
117
118	def full_refresh(self):	4✔
119	"""Procedura odswieza opisy bibliograficzne dla wszystkich rekordów."""
120	denorm.rebuildall("bpp.Wydawnictwo_Zwarte")	1✔
121	denorm.rebuildall("bpp.Wydawnictwo_Ciagle")	1✔
122	denorm.rebuildall("bpp.Patent")	1✔
123	denorm.rebuildall("bpp.Praca_Doktorska")	1✔
124	denorm.rebuildall("bpp.Praca_Habilitacyjna")	1✔
125
126
127	class _MyTaggableManager(_TaggableManager):	4✔
128	def get_prefetch_queryset(self, instances, queryset=None):	4✔
129	if queryset is not None:	×
130	raise ValueError("Custom queryset can't be used for this lookup.")	×
131
132	instance = instances[0]	×
133	db = self._db or router.db_for_read(type(instance), instance=instance)	×
134
135	fieldname = "rekord_id"	×
136	fk = self.through._meta.get_field(fieldname)	×
137	query = {	×
138	"%s__%s__in"
139	% (self.through.tag_relname(), fk.name): {
140	obj._get_pk_val() for obj in instances
141	}
142	}
143	join_table = self.through._meta.db_table	×
144	source_col = fk.column	×
145	connection = connections[db]	×
146	qn = connection.ops.quote_name	×
147	qs = (	×
148	self.get_queryset(query)
149	.using(db)
150	.extra(
151	select={
152	"_prefetch_related_val": "{}.{}".format(
153	qn(join_table), qn(source_col)
154	)
155	}
156	)
157	)
158	from operator import attrgetter	×
159
160	rel_obj_attr = attrgetter("_prefetch_related_val")	×
161
162	return (	×
163	qs,
164	rel_obj_attr,
165	lambda obj: obj._get_pk_val(),
166	False,
167	self.prefetch_cache_name,
168	False,
169	)
170
171
172	class RekordBase(	4✔
173	ModelPunktowanyBaza,
174	ModelZOpisemBibliograficznym,
175	ModelZRokiem,
176	ModelZWWW,
177	ModelZDOI,
178	ModelZPBN_UID,
179	ModelZeSzczegolami,
180	ModelZeSlowamiKluczowymi,
181	ModelRecenzowany,
182	ModelZeZnakamiWydawniczymi,
183	ModelZOpenAccess,
184	ModelTypowany,
185	ModelZCharakterem,
186	ModelZKonferencja,
187	ModelZISBN,
188	ModelZeStatusem,
189	ModelZKwartylami,
190	models.Model,
191	):
192	id = TupleField(models.IntegerField(), size=2, primary_key=True)	4✔
193
194	tekst_przed_pierwszym_autorem = None	4✔
195	tekst_po_ostatnim_autorze = None	4✔
196
197	tytul_oryginalny = models.TextField()	4✔
198	tytul = models.TextField()	4✔
199	search_index = VectorField()	4✔
200
201	zrodlo = models.ForeignKey("bpp.Zrodlo", null=True, on_delete=DO_NOTHING)	4✔
202	wydawnictwo_nadrzedne = models.ForeignKey(	4✔
203	"bpp.Wydawnictwo_Zwarte", null=True, on_delete=DO_NOTHING
204	)
205	slowa_kluczowe = TaggableManager(	4✔
206	"Słowa kluczowe",
207	through=SlowaKluczoweView,
208	blank=True,
209	manager=_MyTaggableManager,
210	)
211
212	wydawnictwo = models.TextField()	4✔
213
214	adnotacje = models.TextField()	4✔
215	ostatnio_zmieniony = models.DateTimeField()	4✔
216
217	tytul_oryginalny_sort = models.TextField()	4✔
218
219	liczba_autorow = models.SmallIntegerField()	4✔
220
221	liczba_cytowan = models.SmallIntegerField()	4✔
222
223	objects = RekordManager()	4✔
224
225	opis_bibliograficzny_cache = models.TextField()	4✔
226	opis_bibliograficzny_autorzy_cache = ArrayField(models.TextField())	4✔
227	opis_bibliograficzny_zapisani_autorzy_cache = models.TextField()	4✔
228	slug = models.TextField()	4✔
229
230	wydawca = models.ForeignKey(	4✔
231	"bpp.Wydawca", on_delete=DO_NOTHING, null=True, blank=True
232	)
233
234	strony = None	4✔
235	nr_zeszytu = None	4✔
236	tom = None	4✔
237
238	jezyk_alt = None	4✔
239	jezyk_orig = None	4✔
240
241	# Skróty dla django-dsl
242
243	django_dsl_shortcuts = {	4✔
244	"charakter": "charakter_formalny__skrot",
245	"typ_kbn": "typ_kbn__skrot",
246	"typ_odpowiedzialnosci": "autorzy__typ_odpowiedzialnosci__skrot",
247	"autor": "autorzy__autor_id",
248	"jednostka": "autorzy__jednostka__pk",
249	"wydzial": "autorzy__jednostka__wydzial__pk",
250	}
251
252	class Meta:	4✔
253	abstract = True	4✔
254
255	def __str__(self):	4✔
UNCOV 256	return self.tytul_oryginalny	1✔
257
258	@cached_property	4✔
259	def content_type(self):	4✔
UNCOV 260	return ContentType.objects.get(pk=self.id[0])	1✔
261
262	@cached_property	4✔
263	def describe_content_type(self):	4✔
264	return ContentType.objects.get(pk=self.id[0]).model_class()._meta.verbose_name	×
265
266	@cached_property	4✔
267	def object_id(self):	4✔
UNCOV 268	return self.id[1]	1✔
269
270	@cached_property	4✔
271	def original(self):	4✔
UNCOV 272	return self.content_type.get_object_for_this_type(pk=self.object_id)	1✔
273
274	@cached_property	4✔
275	def js_safe_pk(self):	4✔
276	return "%i_%i" % (self.pk[0], self.pk[1])	2✔
277
278	@cached_property	4✔
279	def form_post_pk(self):	4✔
UNCOV 280	return "{%i,%i}" % (self.pk[0], self.pk[1])	1✔
281
282	@cached_property	4✔
283	def ma_punktacje_sloty(self):	4✔
284	return (	×
285	Cache_Punktacja_Autora.objects.filter(
286	rekord_id=[self.id[0], self.id[1]]
287	).exists()
288	or Cache_Punktacja_Dyscypliny.objects.filter(
289	rekord_id=[self.id[0], self.id[1]]
290	).exists()
291	)
292
293	@cached_property	4✔
294	def ma_odpiete_dyscypliny(self):	4✔
295	return (	×
296	self.original.autorzy_set.exclude(dyscyplina_naukowa=None)
297	.exclude(przypieta=True)
298	.exists()
299	)
300
301	@cached_property	4✔
302	def punktacja_dyscypliny(self):	4✔
303	return Cache_Punktacja_Dyscypliny.objects.filter(	×
304	rekord_id=[self.id[0], self.id[1]]
305	)
306
307	@cached_property	4✔
308	def punktacja_autora(self):	4✔
309	return Cache_Punktacja_Autora.objects.filter(rekord_id=[self.id[0], self.id[1]])	×
310
311	@cached_property	4✔
312	def pierwszy_autor_afiliowany(self):	4✔
313	"""Zwraca pierwszego autora, afiliującego na jednostkę uczelni z tej pracy"""
314	return self.autorzy.filter(afiliuje=True).order_by("kolejnosc").first()	×
315
316	@cached_property	4✔
317	def pierwsza_jednostka_afiliowana(self):	4✔
318	"""Zwraca pierwszego autora, afiliującego na jednostkę uczelni z tej pracy"""
319	res = self.pierwszy_autor_afiliowany()	×
320	if res is not None:	×
321	return self.pierwszy_autor_afiliowany().jednostka	×
322
323	def get_absolute_url(self):	4✔
UNCOV 324	return reverse("bpp:browse_rekord", args=(self.pk[0], self.pk[1]))	1✔
325
326
327	class Rekord(RekordBase):	4✔
328	class Meta:	4✔
329	managed = False	4✔
330	ordering = ["tytul_oryginalny_sort"]	4✔
331	db_table = "bpp_rekord_mat"	4✔
332
333	@cached_property	4✔
334	def autorzy_set(self):	4✔
335	return self.autorzy	×
336
337
338	class RekordView(RekordBase):	4✔
339	class Meta:	4✔
340	managed = False	4✔
341	db_table = "bpp_rekord"	4✔

iplweb / bpp / 58b9a630-8512-44e6-b730-daac96d1c4d7

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous