1ea03b9b-7097-444d-8202-6cdc97ff0c74

Committed 03 Mar 2025 07:38PM UTC coverage: 46.107% (+0.1%) from 45.98%

Build # 1ea03b9b-7097-444d-8202-6cdc97ff0c74

Build Type

push

circleci

Committed by

mpasternak

Commit Message

Merge branch 'release/v202503.1161'

Run Details

2 of 5 new or added lines in 4 files covered. (40.0%)

1318 existing lines in 80 files now uncovered.

16570 of 35938 relevant lines covered (46.11%)

0.84 hits per line

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

79.35

src/bpp/models/cache.py

# Cache'ujemy:
# - Wydawnictwo_Zwarte
# - Wydawnictwo_Ciagle
# - Patent
# - Praca_Doktorska
# - Praca_Habilitacyjna

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

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 import (
    Autor,
    Autor_Dyscyplina,
    Dyscyplina_Naukowa,
    Jednostka,
    ModelZDOI,
    ModelZeStatusem,
    ModelZISBN,
    ModelZKwartylami,
    ModelZPBN_UID,
    Typ_Odpowiedzialnosci,
    Wydawnictwo_Zwarte,
    Zrodlo,
)
from bpp.models.abstract import (
    ModelPunktowanyBaza,
    ModelRecenzowany,
    ModelTypowany,
    ModelZCharakterem,
    ModelZeSlowamiKluczowymi,
    ModelZeSzczegolami,
    ModelZeZnakamiWydawniczymi,
    ModelZKonferencja,
    ModelZOpenAccess,
    ModelZRokiem,
    ModelZWWW,
)
from bpp.models.util import ModelZOpisemBibliograficznym
from bpp.util import FulltextSearchMixin


class TupleField(ArrayField):
    def from_db_value(self, value, expression, connection):
        return tuple(value)


class AutorzyManager(models.Manager):
    def filter_rekord(self, rekord):
        return self.filter(rekord_id=rekord.pk)


class AutorzyBase(models.Model):
    id = TupleField(models.IntegerField(), size=2, primary_key=True)

    autor = models.ForeignKey("Autor", DO_NOTHING)
    jednostka = models.ForeignKey("Jednostka", DO_NOTHING)
    kolejnosc = models.IntegerField()
    typ_odpowiedzialnosci = models.ForeignKey("Typ_Odpowiedzialnosci", DO_NOTHING)
    zapisany_jako = models.TextField()
    dyscyplina_naukowa = models.ForeignKey("Dyscyplina_Naukowa", DO_NOTHING)
    kierunek_studiow = models.ForeignKey("Kierunek_Studiow", DO_NOTHING)

    afiliuje = models.BooleanField()
    zatrudniony = models.BooleanField()
    upowaznienie_pbn = models.BooleanField()
    oswiadczenie_ken = models.BooleanField()
    profil_orcid = models.BooleanField()

    objects = AutorzyManager()

    class Meta:
        abstract = True


class Autorzy(AutorzyBase):
    rekord = models.ForeignKey(
        "bpp.Rekord",
        related_name="autorzy",
        # tak na prawdę w bazie danych jest constraint dla ON_DELETE, ale
        # dajemy to tutaj, żeby django się nie awanturowało i nie próbowało
        # tego ręcznie kasować
        on_delete=DO_NOTHING,
    )

    # To poniżej musi być, bo się django-admin.py sqlflush nie uda
    typ_odpowiedzialnosci = models.ForeignKey("Typ_Odpowiedzialnosci", DO_NOTHING)
    autor = models.ForeignKey("Autor", DO_NOTHING)
    dyscyplina_naukowa = models.ForeignKey("Dyscyplina_Naukowa", DO_NOTHING)
    kierunek_studiow = models.ForeignKey("Kierunek_Studiow", DO_NOTHING)

    @cached_property
    def wydawnictwo_autor_class(self):
        return (
            ContentType.objects.get(pk=self.id[0])
            .model_class()
            .autorzy_set.rel.related_model
        )

    @cached_property
    def original(self):
        return self.wydawnictwo_autor_class.objects.get(pk=self.id[1])

    class Meta:
        managed = False
        db_table = "bpp_autorzy_mat"


class AutorzyView(AutorzyBase):
    rekord = models.ForeignKey(
        "bpp.RekordView",
        related_name="autorzy",
        # tak na prawdę w bazie danych jest constraint dla ON_DELETE, ale
        # dajemy to tutaj, żeby django się nie awanturowało i nie próbowało
        # tego ręcznie kasować
        on_delete=DO_NOTHING,
    )

    class Meta:
        managed = False
        db_table = "bpp_autorzy"


class SlowaKluczoweView(models.Model):
    id = ArrayField(base_field=models.IntegerField(), size=3, primary_key=True)

    rekord = models.ForeignKey(
        "bpp.Rekord", related_name="slowa_kluczowe_set", on_delete=DO_NOTHING
    )
    tag = models.ForeignKey(Tag, on_delete=DO_NOTHING)

    @classmethod
    def tag_relname(cls):
        field = cls._meta.get_field("tag")
        return field.remote_field.related_name

    @classmethod
    def tags_for(cls, model, instance=None, **kwargs):
        if model != Rekord:
            raise NotImplementedError
        if instance is not None:
            return cls.objects.filter(rekord_id=(instance.pk,))
        return cls.objects.all()

    class Meta:
        managed = False
        db_table = "bpp_slowa_kluczowe_view"


class ZewnetrzneBazyDanychView(models.Model):
    rekord = models.ForeignKey(
        "bpp.Rekord", related_name="zewnetrzne_bazy", on_delete=DO_NOTHING
    )

    baza = models.ForeignKey("bpp.Zewnetrzna_Baza_Danych", on_delete=DO_NOTHING)

    info = models.TextField()

    class Meta:
        managed = False
        db_table = "bpp_zewnetrzne_bazy_view"


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):
        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):
        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(Zrodlo, null=True, on_delete=DO_NOTHING)
    wydawnictwo_nadrzedne = models.ForeignKey(
        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()

    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"


class Cache_Punktacja_Dyscypliny(models.Model):
    rekord_id = TupleField(models.IntegerField(), size=2, db_index=True)
    # rekord = ForeignKey('bpp.Rekord', CASCADE)
    dyscyplina = ForeignKey(Dyscyplina_Naukowa, CASCADE)
    pkd = models.DecimalField(max_digits=20, decimal_places=4)
    slot = models.DecimalField(max_digits=20, decimal_places=4)

    autorzy_z_dyscypliny = ArrayField(
        models.PositiveIntegerField(), blank=True, null=True
    )
    zapisani_autorzy_z_dyscypliny = ArrayField(
        models.TextField(), blank=True, null=True
    )

    class Meta:
        ordering = ("dyscyplina__nazwa",)

    def serialize(self):
        return [self.rekord_id, self.dyscyplina_id, str(self.pkd), str(self.slot)]


class Cache_Punktacja_Autora_Base(models.Model):
    autor = ForeignKey(Autor, CASCADE)
    jednostka = ForeignKey(Jednostka, CASCADE)
    dyscyplina = ForeignKey(Dyscyplina_Naukowa, CASCADE)
    pkdaut = models.DecimalField(max_digits=20, decimal_places=4)
    slot = models.DecimalField(max_digits=20, decimal_places=4)

    class Meta:
        ordering = ("autor__nazwisko", "dyscyplina__nazwa")
        abstract = True


class Cache_Punktacja_Autora(Cache_Punktacja_Autora_Base):
    rekord_id = TupleField(models.IntegerField(), size=2, db_index=True)

    class Meta:
        ordering = ("autor__nazwisko", "dyscyplina__nazwa")

    def serialize(self):
        return [
            self.rekord_id,
            self.autor_id,
            self.jednostka_id,
            self.dyscyplina_id,
            str(self.pkdaut),
            str(self.slot),
        ]

    def dyscyplina_pracy(self):
        return self.dyscyplina

    def dyscypliny_autora(self):
        return Autor_Dyscyplina.objects.get(
            rok=Rekord.objects.get(pk=self.rekord_id).rok,
            autor_id=self.autor_id,
        )

    def czy_autor_ma_alternatywna_dyscypline(self):
        # Zwraca True jeżeli autor ma drugą dyscyplinę za ten rok, inną niż obecnie wybrana;
        # używane do wydruków oświadczeń
        try:
            ad = self.dyscypliny_autora()
        except Autor_Dyscyplina.DoesNotExist:
            return False

        if ad.dwie_dyscypliny():
            return True


class Cache_Punktacja_Autora_Query(Cache_Punktacja_Autora_Base):
    rekord = ForeignKey("bpp.Rekord", DO_NOTHING)

    class Meta:
        db_table = "bpp_cache_punktacja_autora"
        managed = False


class Cache_Punktacja_Autora_Query_View(models.Model):
    """W porównaniu do Cache_Punktacja_Autora, mam jeszcze listę zapisanych
    autorów z dyscypliny. A skąd? A z widoku bazodanowego, który bierze
    też pod uwagę Cache_Punktacja_Dyscypliny.
    """

    rekord = ForeignKey("bpp.Rekord", DO_NOTHING)
    autor = ForeignKey(Autor, DO_NOTHING)
    jednostka = ForeignKey(Jednostka, DO_NOTHING)
    dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)
    pkdaut = models.DecimalField(max_digits=20, decimal_places=4)
    slot = models.DecimalField(max_digits=20, decimal_places=4)
    zapisani_autorzy_z_dyscypliny = ArrayField(models.TextField())

    class Meta:
        ordering = ("rekord__tytul_oryginalny", "dyscyplina__nazwa")
        db_table = "bpp_cache_punktacja_autora_view"
        managed = False


class Cache_Punktacja_Autora_Sum(Cache_Punktacja_Autora_Base):
    rekord = ForeignKey("bpp.Rekord", DO_NOTHING)
    autor = ForeignKey(Autor, DO_NOTHING)
    jednostka = ForeignKey(Jednostka, DO_NOTHING)
    dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)
    pkdautslot = models.FloatField()
    pkdautsum = models.FloatField()
    pkdautslotsum = models.FloatField()

    class Meta:
        db_table = "bpp_temporary_cpaq"
        managed = False
        ordering = (
            "autor",
            "dyscyplina",
            "-pkdautslot",
        )


class Cache_Punktacja_Autora_Sum_Ponizej(Cache_Punktacja_Autora_Base):
    rekord = ForeignKey("bpp.Rekord", DO_NOTHING)
    autor = ForeignKey(Autor, DO_NOTHING)
    jednostka = ForeignKey(Jednostka, DO_NOTHING)
    dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)
    pkdautslot = models.FloatField()
    pkdautsum = models.FloatField()
    pkdautslotsum = models.FloatField()

    class Meta:
        db_table = "bpp_temporary_cpaq_2"
        managed = False
        ordering = (
            "autor",
            "dyscyplina",
            "pkdautslot",
        )


class Cache_Punktacja_Autora_Sum_Group_Ponizej(models.Model):
    autor = models.OneToOneField(Autor, DO_NOTHING, primary_key=True)
    jednostka = ForeignKey(Jednostka, DO_NOTHING)
    dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)
    pkdautsum = models.FloatField()
    pkdautslotsum = models.FloatField()

    class Meta:
        db_table = "bpp_temporary_cpasg_2"
        managed = False
        ordering = (
            "autor",
            "dyscyplina",
        )


class Cache_Punktacja_Autora_Sum_Gruop(models.Model):
    autor = models.OneToOneField(Autor, DO_NOTHING, primary_key=True)
    jednostka = ForeignKey(Jednostka, DO_NOTHING)
    dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)
    pkdautsum = models.FloatField()
    pkdautslotsum = models.FloatField()

    class Meta:
        db_table = "bpp_temporary_cpasg"
        managed = False
        ordering = (
            "autor",
            "dyscyplina",
        )

1	# Cache'ujemy:
2	# - Wydawnictwo_Zwarte
3	# - Wydawnictwo_Ciagle
4	# - Patent
5	# - Praca_Doktorska
6	# - Praca_Habilitacyjna
7
8	import denorm	2✔
9	from django.db import connections, models, router	2✔
10	from django.db.models import CASCADE, ForeignKey	2✔
11	from django.db.models.deletion import DO_NOTHING	2✔
12	from django.urls import reverse	2✔
13	from taggit.managers import TaggableManager, _TaggableManager	2✔
14	from taggit.models import Tag	2✔
15
16	from django.contrib.contenttypes.models import ContentType	2✔
17	from django.contrib.postgres.fields.array import ArrayField	2✔
18	from django.contrib.postgres.search import SearchVectorField as VectorField	2✔
19
20	from django.utils.functional import cached_property	2✔
21
22	from bpp.models import (	2✔
23	Autor,
24	Autor_Dyscyplina,
25	Dyscyplina_Naukowa,
26	Jednostka,
27	ModelZDOI,
28	ModelZeStatusem,
29	ModelZISBN,
30	ModelZKwartylami,
31	ModelZPBN_UID,
32	Typ_Odpowiedzialnosci,
33	Wydawnictwo_Zwarte,
34	Zrodlo,
35	)
36	from bpp.models.abstract import (	2✔
37	ModelPunktowanyBaza,
38	ModelRecenzowany,
39	ModelTypowany,
40	ModelZCharakterem,
41	ModelZeSlowamiKluczowymi,
42	ModelZeSzczegolami,
43	ModelZeZnakamiWydawniczymi,
44	ModelZKonferencja,
45	ModelZOpenAccess,
46	ModelZRokiem,
47	ModelZWWW,
48	)
49	from bpp.models.util import ModelZOpisemBibliograficznym	2✔
50	from bpp.util import FulltextSearchMixin	2✔
51
52
53	class TupleField(ArrayField):	2✔
54	def from_db_value(self, value, expression, connection):	2✔
55	return tuple(value)	2✔
56
57
58	class AutorzyManager(models.Manager):	2✔
59	def filter_rekord(self, rekord):	2✔
60	return self.filter(rekord_id=rekord.pk)	×
61
62
63	class AutorzyBase(models.Model):	2✔
64	id = TupleField(models.IntegerField(), size=2, primary_key=True)	2✔
65
66	autor = models.ForeignKey("Autor", DO_NOTHING)	2✔
67	jednostka = models.ForeignKey("Jednostka", DO_NOTHING)	2✔
68	kolejnosc = models.IntegerField()	2✔
69	typ_odpowiedzialnosci = models.ForeignKey("Typ_Odpowiedzialnosci", DO_NOTHING)	2✔
70	zapisany_jako = models.TextField()	2✔
71	dyscyplina_naukowa = models.ForeignKey("Dyscyplina_Naukowa", DO_NOTHING)	2✔
72	kierunek_studiow = models.ForeignKey("Kierunek_Studiow", DO_NOTHING)	2✔
73
74	afiliuje = models.BooleanField()	2✔
75	zatrudniony = models.BooleanField()	2✔
76	upowaznienie_pbn = models.BooleanField()	2✔
77	oswiadczenie_ken = models.BooleanField()	2✔
78	profil_orcid = models.BooleanField()	2✔
79
80	objects = AutorzyManager()	2✔
81
82	class Meta:	2✔
83	abstract = True	2✔
84
85
86	class Autorzy(AutorzyBase):	2✔
87	rekord = models.ForeignKey(	2✔
88	"bpp.Rekord",
89	related_name="autorzy",
90	# tak na prawdę w bazie danych jest constraint dla ON_DELETE, ale
91	# dajemy to tutaj, żeby django się nie awanturowało i nie próbowało
92	# tego ręcznie kasować
93	on_delete=DO_NOTHING,
94	)
95
96	# To poniżej musi być, bo się django-admin.py sqlflush nie uda
97	typ_odpowiedzialnosci = models.ForeignKey("Typ_Odpowiedzialnosci", DO_NOTHING)	2✔
98	autor = models.ForeignKey("Autor", DO_NOTHING)	2✔
99	dyscyplina_naukowa = models.ForeignKey("Dyscyplina_Naukowa", DO_NOTHING)	2✔
100	kierunek_studiow = models.ForeignKey("Kierunek_Studiow", DO_NOTHING)	2✔
101
102	@cached_property	2✔
103	def wydawnictwo_autor_class(self):	2✔
104	return (	×
105	ContentType.objects.get(pk=self.id[0])
106	.model_class()
107	.autorzy_set.rel.related_model
108	)
109
110	@cached_property	2✔
111	def original(self):	2✔
112	return self.wydawnictwo_autor_class.objects.get(pk=self.id[1])	×
113
114	class Meta:	2✔
115	managed = False	2✔
116	db_table = "bpp_autorzy_mat"	2✔
117
118
119	class AutorzyView(AutorzyBase):	2✔
120	rekord = models.ForeignKey(	2✔
121	"bpp.RekordView",
122	related_name="autorzy",
123	# tak na prawdę w bazie danych jest constraint dla ON_DELETE, ale
124	# dajemy to tutaj, żeby django się nie awanturowało i nie próbowało
125	# tego ręcznie kasować
126	on_delete=DO_NOTHING,
127	)
128
129	class Meta:	2✔
130	managed = False	2✔
131	db_table = "bpp_autorzy"	2✔
132
133
134	class SlowaKluczoweView(models.Model):	2✔
135	id = ArrayField(base_field=models.IntegerField(), size=3, primary_key=True)	2✔
136
137	rekord = models.ForeignKey(	2✔
138	"bpp.Rekord", related_name="slowa_kluczowe_set", on_delete=DO_NOTHING
139	)
140	tag = models.ForeignKey(Tag, on_delete=DO_NOTHING)	2✔
141
142	@classmethod	2✔
143	def tag_relname(cls):	2✔
144	field = cls._meta.get_field("tag")	×
145	return field.remote_field.related_name	×
146
147	@classmethod	2✔
148	def tags_for(cls, model, instance=None, **kwargs):	2✔
UNCOV 149	if model != Rekord:	×
150	raise NotImplementedError	×
UNCOV 151	if instance is not None:	×
UNCOV 152	return cls.objects.filter(rekord_id=(instance.pk,))	×
153	return cls.objects.all()	×
154
155	class Meta:	2✔
156	managed = False	2✔
157	db_table = "bpp_slowa_kluczowe_view"	2✔
158
159
160	class ZewnetrzneBazyDanychView(models.Model):	2✔
161	rekord = models.ForeignKey(	2✔
162	"bpp.Rekord", related_name="zewnetrzne_bazy", on_delete=DO_NOTHING
163	)
164
165	baza = models.ForeignKey("bpp.Zewnetrzna_Baza_Danych", on_delete=DO_NOTHING)	2✔
166
167	info = models.TextField()	2✔
168
169	class Meta:	2✔
170	managed = False	2✔
171	db_table = "bpp_zewnetrzne_bazy_view"	2✔
172
173
174	class RekordManager(FulltextSearchMixin, models.Manager):	2✔
175	fts_field = "search_index"	2✔
176
177	def get_for_model(self, model):	2✔
178	pk = (ContentType.objects.get_for_model(model).pk, model.pk)	×
179	return self.get(pk=pk)	×
180
181	def prace_autora(self, autor):	2✔
182	return self.filter(autorzy__autor=autor).distinct()	×
183
184	def prace_autora_z_afiliowanych_jednostek(self, autor):	2✔
185	"""
186	Funkcja zwraca prace danego autora, należące tylko i wyłącznie
187	do jednostek skupiających pracowników, gdzie autor jest zaznaczony jako
188	afiliowany.
189	"""
190	return (	×
191	self.prace_autora(autor)
192	.filter(
193	autorzy__autor=autor,
194	autorzy__jednostka__skupia_pracownikow=True,
195	autorzy__afiliuje=True,
196	)
197	.distinct()
198	)
199
200	def prace_autor_i_typ(self, autor, skrot):	2✔
201	return (	×
202	self.prace_autora(autor)
203	.filter(
204	autorzy__typ_odpowiedzialnosci_id=Typ_Odpowiedzialnosci.objects.get(
205	skrot=skrot
206	).pk
207	)
208	.distinct()
209	)
210
211	def prace_jednostki(self, jednostka, afiliowane=None):	2✔
212	if afiliowane is None:	×
213	return self.filter(	×
214	autorzy__jednostka__pk__in=list(
215	jednostka.get_descendants(include_self=True).values_list(
216	"pk", flat=True
217	)
218	)
219	).distinct()
220
221	return self.filter(	×
222	autorzy__jednostka__pk__in=list(
223	jednostka.get_descendants(include_self=True).values_list(
224	"pk", flat=True
225	)
226	),
227	autorzy__afiliuje=afiliowane,
228	).distinct()
229
230	def prace_wydzialu(self, wydzial, afiliowane=None):	2✔
231	if afiliowane is None:	×
232	return self.filter(autorzy__jednostka__wydzial=wydzial).distinct()	×
233
234	return self.filter(	×
235	autorzy__jednostka__wydzial=wydzial, autorzy__afiliuje=afiliowane
236	).distinct()
237
238	def redaktorzy_z_jednostki(self, jednostka):	2✔
239	return self.filter(	×
240	autorzy__jednostka=jednostka,
241	autorzy__typ_odpowiedzialnosci_id=Typ_Odpowiedzialnosci.objects.get(
242	skrot="red."
243	).pk,
244	).distinct()
245
246	def get_original(self, model):	2✔
247	return self.get(pk=[ContentType.objects.get_for_model(model).pk, model.pk])	×
248
249	def full_refresh(self):	2✔
250	"""Procedura odswieza opisy bibliograficzne dla wszystkich rekordów."""
251	denorm.rebuildall("bpp.Wydawnictwo_Zwarte")	1✔
252	denorm.rebuildall("bpp.Wydawnictwo_Ciagle")	1✔
253	denorm.rebuildall("bpp.Patent")	1✔
254	denorm.rebuildall("bpp.Praca_Doktorska")	1✔
255	denorm.rebuildall("bpp.Praca_Habilitacyjna")	1✔
256
257
258	class _MyTaggableManager(_TaggableManager):	2✔
259	def get_prefetch_queryset(self, instances, queryset=None):	2✔
260	if queryset is not None:	×
261	raise ValueError("Custom queryset can't be used for this lookup.")	×
262
263	instance = instances[0]	×
264	db = self._db or router.db_for_read(type(instance), instance=instance)	×
265
266	fieldname = "rekord_id"	×
267	fk = self.through._meta.get_field(fieldname)	×
268	query = {	×
269	"%s__%s__in"
270	% (self.through.tag_relname(), fk.name): {
271	obj._get_pk_val() for obj in instances
272	}
273	}
274	join_table = self.through._meta.db_table	×
275	source_col = fk.column	×
276	connection = connections[db]	×
277	qn = connection.ops.quote_name	×
278	qs = (	×
279	self.get_queryset(query)
280	.using(db)
281	.extra(
282	select={
283	"_prefetch_related_val": "{}.{}".format(
284	qn(join_table), qn(source_col)
285	)
286	}
287	)
288	)
289	from operator import attrgetter	×
290
291	rel_obj_attr = attrgetter("_prefetch_related_val")	×
292
293	return (	×
294	qs,
295	rel_obj_attr,
296	lambda obj: obj._get_pk_val(),
297	False,
298	self.prefetch_cache_name,
299	False,
300	)
301
302
303	class RekordBase(	2✔
304	ModelPunktowanyBaza,
305	ModelZOpisemBibliograficznym,
306	ModelZRokiem,
307	ModelZWWW,
308	ModelZDOI,
309	ModelZPBN_UID,
310	ModelZeSzczegolami,
311	ModelZeSlowamiKluczowymi,
312	ModelRecenzowany,
313	ModelZeZnakamiWydawniczymi,
314	ModelZOpenAccess,
315	ModelTypowany,
316	ModelZCharakterem,
317	ModelZKonferencja,
318	ModelZISBN,
319	ModelZeStatusem,
320	ModelZKwartylami,
321	models.Model,
322	):
323	id = TupleField(models.IntegerField(), size=2, primary_key=True)	2✔
324
325	tekst_przed_pierwszym_autorem = None	2✔
326	tekst_po_ostatnim_autorze = None	2✔
327
328	tytul_oryginalny = models.TextField()	2✔
329	tytul = models.TextField()	2✔
330	search_index = VectorField()	2✔
331
332	zrodlo = models.ForeignKey(Zrodlo, null=True, on_delete=DO_NOTHING)	2✔
333	wydawnictwo_nadrzedne = models.ForeignKey(	2✔
334	Wydawnictwo_Zwarte, null=True, on_delete=DO_NOTHING
335	)
336	slowa_kluczowe = TaggableManager(	2✔
337	"Słowa kluczowe",
338	through=SlowaKluczoweView,
339	blank=True,
340	manager=_MyTaggableManager,
341	)
342
343	wydawnictwo = models.TextField()	2✔
344
345	adnotacje = models.TextField()	2✔
346	ostatnio_zmieniony = models.DateTimeField()	2✔
347
348	tytul_oryginalny_sort = models.TextField()	2✔
349
350	liczba_autorow = models.SmallIntegerField()	2✔
351
352	liczba_cytowan = models.SmallIntegerField()	2✔
353
354	objects = RekordManager()	2✔
355
356	opis_bibliograficzny_cache = models.TextField()	2✔
357	opis_bibliograficzny_autorzy_cache = ArrayField(models.TextField())	2✔
358	opis_bibliograficzny_zapisani_autorzy_cache = models.TextField()	2✔
359	slug = models.TextField()	2✔
360
361	strony = None	2✔
362	nr_zeszytu = None	2✔
363	tom = None	2✔
364
365	jezyk_alt = None	2✔
366	jezyk_orig = None	2✔
367
368	# Skróty dla django-dsl
369
370	django_dsl_shortcuts = {	2✔
371	"charakter": "charakter_formalny__skrot",
372	"typ_kbn": "typ_kbn__skrot",
373	"typ_odpowiedzialnosci": "autorzy__typ_odpowiedzialnosci__skrot",
374	"autor": "autorzy__autor_id",
375	"jednostka": "autorzy__jednostka__pk",
376	"wydzial": "autorzy__jednostka__wydzial__pk",
377	}
378
379	class Meta:	2✔
380	abstract = True	2✔
381
382	def __str__(self):	2✔
UNCOV 383	return self.tytul_oryginalny	×
384
385	@cached_property	2✔
386	def content_type(self):	2✔
UNCOV 387	return ContentType.objects.get(pk=self.id[0])	×
388
389	@cached_property	2✔
390	def describe_content_type(self):	2✔
391	return ContentType.objects.get(pk=self.id[0]).model_class()._meta.verbose_name	×
392
393	@cached_property	2✔
394	def object_id(self):	2✔
UNCOV 395	return self.id[1]	×
396
397	@cached_property	2✔
398	def original(self):	2✔
UNCOV 399	return self.content_type.get_object_for_this_type(pk=self.object_id)	×
400
401	@cached_property	2✔
402	def js_safe_pk(self):	2✔
403	return "%i_%i" % (self.pk[0], self.pk[1])	2✔
404
405	@cached_property	2✔
406	def form_post_pk(self):	2✔
UNCOV 407	return "{%i,%i}" % (self.pk[0], self.pk[1])	×
408
409	@cached_property	2✔
410	def ma_punktacje_sloty(self):	2✔
411	return (	×
412	Cache_Punktacja_Autora.objects.filter(
413	rekord_id=[self.id[0], self.id[1]]
414	).exists()
415	or Cache_Punktacja_Dyscypliny.objects.filter(
416	rekord_id=[self.id[0], self.id[1]]
417	).exists()
418	)
419
420	@cached_property	2✔
421	def ma_odpiete_dyscypliny(self):	2✔
422	return (	×
423	self.original.autorzy_set.exclude(dyscyplina_naukowa=None)
424	.exclude(przypieta=True)
425	.exists()
426	)
427
428	@cached_property	2✔
429	def punktacja_dyscypliny(self):	2✔
430	return Cache_Punktacja_Dyscypliny.objects.filter(	×
431	rekord_id=[self.id[0], self.id[1]]
432	)
433
434	@cached_property	2✔
435	def punktacja_autora(self):	2✔
436	return Cache_Punktacja_Autora.objects.filter(rekord_id=[self.id[0], self.id[1]])	×
437
438	@cached_property	2✔
439	def pierwszy_autor_afiliowany(self):	2✔
440	"""Zwraca pierwszego autora, afiliującego na jednostkę uczelni z tej pracy"""
441	return self.autorzy.filter(afiliuje=True).order_by("kolejnosc").first()	×
442
443	@cached_property	2✔
444	def pierwsza_jednostka_afiliowana(self):	2✔
445	"""Zwraca pierwszego autora, afiliującego na jednostkę uczelni z tej pracy"""
446	res = self.pierwszy_autor_afiliowany()	×
447	if res is not None:	×
448	return self.pierwszy_autor_afiliowany().jednostka	×
449
450	def get_absolute_url(self):	2✔
UNCOV 451	return reverse("bpp:browse_rekord", args=(self.pk[0], self.pk[1]))	×
452
453
454	class Rekord(RekordBase):	2✔
455	class Meta:	2✔
456	managed = False	2✔
457	ordering = ["tytul_oryginalny_sort"]	2✔
458	db_table = "bpp_rekord_mat"	2✔
459
460	@cached_property	2✔
461	def autorzy_set(self):	2✔
462	return self.autorzy	×
463
464
465	class RekordView(RekordBase):	2✔
466	class Meta:	2✔
467	managed = False	2✔
468	db_table = "bpp_rekord"	2✔
469
470
471	class Cache_Punktacja_Dyscypliny(models.Model):	2✔
472	rekord_id = TupleField(models.IntegerField(), size=2, db_index=True)	2✔
473	# rekord = ForeignKey('bpp.Rekord', CASCADE)
474	dyscyplina = ForeignKey(Dyscyplina_Naukowa, CASCADE)	2✔
475	pkd = models.DecimalField(max_digits=20, decimal_places=4)	2✔
476	slot = models.DecimalField(max_digits=20, decimal_places=4)	2✔
477
478	autorzy_z_dyscypliny = ArrayField(	2✔
479	models.PositiveIntegerField(), blank=True, null=True
480	)
481	zapisani_autorzy_z_dyscypliny = ArrayField(	2✔
482	models.TextField(), blank=True, null=True
483	)
484
485	class Meta:	2✔
486	ordering = ("dyscyplina__nazwa",)	2✔
487
488	def serialize(self):	2✔
489	return [self.rekord_id, self.dyscyplina_id, str(self.pkd), str(self.slot)]	×
490
491
492	class Cache_Punktacja_Autora_Base(models.Model):	2✔
493	autor = ForeignKey(Autor, CASCADE)	2✔
494	jednostka = ForeignKey(Jednostka, CASCADE)	2✔
495	dyscyplina = ForeignKey(Dyscyplina_Naukowa, CASCADE)	2✔
496	pkdaut = models.DecimalField(max_digits=20, decimal_places=4)	2✔
497	slot = models.DecimalField(max_digits=20, decimal_places=4)	2✔
498
499	class Meta:	2✔
500	ordering = ("autor__nazwisko", "dyscyplina__nazwa")	2✔
501	abstract = True	2✔
502
503
504	class Cache_Punktacja_Autora(Cache_Punktacja_Autora_Base):	2✔
505	rekord_id = TupleField(models.IntegerField(), size=2, db_index=True)	2✔
506
507	class Meta:	2✔
508	ordering = ("autor__nazwisko", "dyscyplina__nazwa")	2✔
509
510	def serialize(self):	2✔
511	return [	×
512	self.rekord_id,
513	self.autor_id,
514	self.jednostka_id,
515	self.dyscyplina_id,
516	str(self.pkdaut),
517	str(self.slot),
518	]
519
520	def dyscyplina_pracy(self):	2✔
521	return self.dyscyplina	×
522
523	def dyscypliny_autora(self):	2✔
524	return Autor_Dyscyplina.objects.get(	×
525	rok=Rekord.objects.get(pk=self.rekord_id).rok,
526	autor_id=self.autor_id,
527	)
528
529	def czy_autor_ma_alternatywna_dyscypline(self):	2✔
530	# Zwraca True jeżeli autor ma drugą dyscyplinę za ten rok, inną niż obecnie wybrana;
531	# używane do wydruków oświadczeń
532	try:	×
533	ad = self.dyscypliny_autora()	×
534	except Autor_Dyscyplina.DoesNotExist:	×
535	return False	×
536
537	if ad.dwie_dyscypliny():	×
538	return True	×
539
540
541	class Cache_Punktacja_Autora_Query(Cache_Punktacja_Autora_Base):	2✔
542	rekord = ForeignKey("bpp.Rekord", DO_NOTHING)	2✔
543
544	class Meta:	2✔
545	db_table = "bpp_cache_punktacja_autora"	2✔
546	managed = False	2✔
547
548
549	class Cache_Punktacja_Autora_Query_View(models.Model):	2✔
550	"""W porównaniu do Cache_Punktacja_Autora, mam jeszcze listę zapisanych
551	autorów z dyscypliny. A skąd? A z widoku bazodanowego, który bierze
552	też pod uwagę Cache_Punktacja_Dyscypliny.
553	"""
554
555	rekord = ForeignKey("bpp.Rekord", DO_NOTHING)	2✔
556	autor = ForeignKey(Autor, DO_NOTHING)	2✔
557	jednostka = ForeignKey(Jednostka, DO_NOTHING)	2✔
558	dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)	2✔
559	pkdaut = models.DecimalField(max_digits=20, decimal_places=4)	2✔
560	slot = models.DecimalField(max_digits=20, decimal_places=4)	2✔
561	zapisani_autorzy_z_dyscypliny = ArrayField(models.TextField())	2✔
562
563	class Meta:	2✔
564	ordering = ("rekord__tytul_oryginalny", "dyscyplina__nazwa")	2✔
565	db_table = "bpp_cache_punktacja_autora_view"	2✔
566	managed = False	2✔
567
568
569	class Cache_Punktacja_Autora_Sum(Cache_Punktacja_Autora_Base):	2✔
570	rekord = ForeignKey("bpp.Rekord", DO_NOTHING)	2✔
571	autor = ForeignKey(Autor, DO_NOTHING)	2✔
572	jednostka = ForeignKey(Jednostka, DO_NOTHING)	2✔
573	dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)	2✔
574	pkdautslot = models.FloatField()	2✔
575	pkdautsum = models.FloatField()	2✔
576	pkdautslotsum = models.FloatField()	2✔
577
578	class Meta:	2✔
579	db_table = "bpp_temporary_cpaq"	2✔
580	managed = False	2✔
581	ordering = (	2✔
582	"autor",
583	"dyscyplina",
584	"-pkdautslot",
585	)
586
587
588	class Cache_Punktacja_Autora_Sum_Ponizej(Cache_Punktacja_Autora_Base):	2✔
589	rekord = ForeignKey("bpp.Rekord", DO_NOTHING)	2✔
590	autor = ForeignKey(Autor, DO_NOTHING)	2✔
591	jednostka = ForeignKey(Jednostka, DO_NOTHING)	2✔
592	dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)	2✔
593	pkdautslot = models.FloatField()	2✔
594	pkdautsum = models.FloatField()	2✔
595	pkdautslotsum = models.FloatField()	2✔
596
597	class Meta:	2✔
598	db_table = "bpp_temporary_cpaq_2"	2✔
599	managed = False	2✔
600	ordering = (	2✔
601	"autor",
602	"dyscyplina",
603	"pkdautslot",
604	)
605
606
607	class Cache_Punktacja_Autora_Sum_Group_Ponizej(models.Model):	2✔
608	autor = models.OneToOneField(Autor, DO_NOTHING, primary_key=True)	2✔
609	jednostka = ForeignKey(Jednostka, DO_NOTHING)	2✔
610	dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)	2✔
611	pkdautsum = models.FloatField()	2✔
612	pkdautslotsum = models.FloatField()	2✔
613
614	class Meta:	2✔
615	db_table = "bpp_temporary_cpasg_2"	2✔
616	managed = False	2✔
617	ordering = (	2✔
618	"autor",
619	"dyscyplina",
620	)
621
622
623	class Cache_Punktacja_Autora_Sum_Gruop(models.Model):	2✔
624	autor = models.OneToOneField(Autor, DO_NOTHING, primary_key=True)	2✔
625	jednostka = ForeignKey(Jednostka, DO_NOTHING)	2✔
626	dyscyplina = ForeignKey(Dyscyplina_Naukowa, DO_NOTHING)	2✔
627	pkdautsum = models.FloatField()	2✔
628	pkdautslotsum = models.FloatField()	2✔
629
630	class Meta:	2✔
631	db_table = "bpp_temporary_cpasg"	2✔
632	managed = False	2✔
633	ordering = (	2✔
634	"autor",
635	"dyscyplina",
636	)

iplweb / bpp / 1ea03b9b-7097-444d-8202-6cdc97ff0c74

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