endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/administration/case/case.py

@@ -0,0 +1,114 @@
+from django.db import models
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..person import Patient
+    from ...medical.patient.patient_examination import PatientExamination
+from django.utils import timezone
+
+
+class Case(models.Model):
+    """
+    Represents a clinical case, linking a patient to one or more examinations over a specific period.
+
+    Attributes:
+        patient (Patient): The patient associated with this case.
+        patient_examinations (QuerySet[PatientExamination]): Examinations included in this case.
+        hash (str): An optional hash value for the case.
+        start_date (datetime): The start date and time of the case.
+        end_date (datetime): The end date and time of the case (optional).
+        is_active (bool): Indicates if the case is currently active.
+        is_closed (bool): Indicates if the case has been closed.
+        is_deleted (bool): Indicates if the case is marked as deleted.
+        created_at (datetime): Timestamp of case creation.
+        updated_at (datetime): Timestamp of last case update.
+    """
+
+    patient = models.ForeignKey(
+        "Patient",
+        on_delete=models.CASCADE,
+        related_name="cases",
+        help_text="The patient associated with this case.",
+        db_index=True,
+    )
+    patient_examinations = models.ManyToManyField(
+        "PatientExamination",
+        related_name="cases",
+        help_text="The examinations included in this case.",
+    )
+    hash = models.CharField(
+        max_length=255,
+        blank=True,
+        null=True,
+        help_text="An optional hash value associated with the case.",
+    )
+
+    start_date = models.DateTimeField(
+        help_text="The start date and time of the case.", db_index=True
+    )
+    end_date = models.DateTimeField(
+        null=True, blank=True, help_text="The end date and time of the case (optional)."
+    )
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Flag indicating if the case is currently active.",
+        db_index=True,
+    )
+    is_closed = models.BooleanField(
+        default=False,
+        help_text="Flag indicating if the case has been closed.",
+        db_index=True,
+    )
+    is_deleted = models.BooleanField(
+        default=False,
+        help_text="Flag indicating if the case is marked as deleted.",
+        db_index=True,
+    )
+    created_at = models.DateTimeField(
+        auto_now_add=True, help_text="The date and time the case was created."
+    )
+    updated_at = models.DateTimeField(
+        auto_now=True, help_text="The date and time the case was last updated."
+    )
+
+    if TYPE_CHECKING:
+        patient: models.ForeignKey["Patient"]
+        patient_examinations: models.ManyToManyField[
+            "PatientExamination", "PatientExamination"
+        ]
+
+    class Meta:
+        ordering = ["-start_date", "patient"]
+        verbose_name = "Case"
+        verbose_name_plural = "Cases"
+
+    def __str__(self):
+        string_representation = f"Case {self.pk} ({self.patient})"
+        if self.start_date:
+            string_representation += f" - {self.start_date.strftime('%Y-%m-%d')}"
+        if self.end_date:
+            string_representation += f" - {self.end_date.strftime('%Y-%m-%d')}"
+        return string_representation
+
+    def close(self, end_date=None):
+        """Close this case with optional end date."""
+        self.is_closed = True
+        self.is_active = False
+        if end_date:
+            self.end_date = end_date
+        elif not self.end_date:
+            self.end_date = timezone.now()
+        self.save()
+
+    def reopen(self):
+        """Reopen this case if it was closed."""
+        self.is_closed = False
+        self.is_active = True
+        self.save()
+
+    def mark_as_deleted(self):
+        """Mark this case as deleted."""
+        self.is_deleted = True
+        self.is_active = False
+        self.save()

endoreg_db/models/administration/case/case_template/__init__.py

@@ -0,0 +1,3 @@
+"""Case template models have been deprecated and are no longer available."""
+
+__all__: list[str] = []

endoreg_db/models/administration/case/case_template/case_template.py

@@ -0,0 +1,3 @@
+"""Deprecated case template models have been removed."""
+
+__all__: list[str] = []

endoreg_db/models/administration/case/case_template/case_template_rule.py

@@ -0,0 +1,3 @@
+"""Deprecated case template rule models have been removed."""
+
+__all__: list[str] = []

endoreg_db/models/administration/case/case_template/case_template_rule_value.py

@@ -0,0 +1,3 @@
+"""Deprecated case template rule value models have been removed."""
+
+__all__: list[str] = []

endoreg_db/models/administration/case/case_template/case_template_type.py

@@ -0,0 +1,3 @@
+"""Deprecated case template type model has been removed."""
+
+__all__: list[str] = []

endoreg_db/models/administration/center/__init__.py

@@ -0,0 +1,13 @@
+from .center import Center
+from .center_product import CenterProduct
+from .center_resource import CenterResource
+from .center_waste import CenterWaste
+from .center_shift import CenterShift
+
+__all__ = [
+    "Center",
+    "CenterProduct",
+    "CenterResource",
+    "CenterWaste",
+    "CenterShift",
+]

endoreg_db/models/administration/center/center.py

@@ -0,0 +1,85 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from ...administration import CenterProduct, CenterResource, CenterWaste
+    from ...media import AnonymExaminationReport, AnonymHistologyReport
+    from ...medical import Endoscope, EndoscopyProcessor
+    from ..person.names.first_name import FirstName
+    from ..person.names.last_name import LastName
+
+
+class CenterManager(models.Manager):
+    def get_by_natural_key(self, name) -> "Center":
+        return self.get(name=name)
+
+
+class Center(models.Model):
+    objects = CenterManager()
+    name = models.CharField(max_length=255)
+    display_name = models.CharField(max_length=255, blank=True, default="")
+
+    first_names = models.ManyToManyField(
+        to="FirstName",
+        related_name="centers",
+    )
+    last_names = models.ManyToManyField("LastName", related_name="centers")
+
+    if TYPE_CHECKING:
+        from django.db.models.manager import RelatedManager
+
+        first_names = cast(RelatedManager[FirstName], first_names)
+        last_names = cast(RelatedManager[LastName], last_names)
+
+        @property
+        def center_products(self) -> RelatedManager[CenterProduct]: ...
+
+        @property
+        def center_resources(self) -> RelatedManager[CenterResource]: ...
+
+        @property
+        def center_wastes(self) -> RelatedManager[CenterWaste]: ...
+
+        @property
+        def endoscopy_processors(self) -> RelatedManager[EndoscopyProcessor]: ...
+
+        @property
+        def endoscopes(self) -> RelatedManager[Endoscope]: ...
+
+        @property
+        def anonymexaminationreport_set(
+            self,
+        ) -> RelatedManager[AnonymExaminationReport]: ...
+
+        @property
+        def anonymhistologyreport_set(
+            self,
+        ) -> RelatedManager[AnonymHistologyReport]: ...
+
+    @classmethod
+    def get_by_name(cls, name):
+        return cls.objects.get(name=name)
+
+    def natural_key(self) -> tuple[str]:
+        return (self.name,)
+
+    def save(self, *args, **kwargs):
+        if not self.display_name:
+            self.display_name = self.name
+        super().save(*args, **kwargs)
+
+    def __str__(self) -> str:
+        return str(self.display_name or self.name)
+
+    def get_first_names(self):
+        return self.first_names.all()
+
+    def get_last_names(self):
+        return self.last_names.all()
+
+    def get_endoscopes(self):
+        """
+        Returns all Endoscope instances associated with this center.
+        """
+        return self.endoscopes.all()

endoreg_db/models/administration/center/center_product.py

@@ -0,0 +1,67 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from ..product import Product
+    from .center import Center
+
+
+class CenterProduct(models.Model):
+    """
+    Associates a Product with a Center, indicating its usage on a specific date.
+
+    Attributes:
+        product (Product): The product used.
+        date_used (date): The date the product was used.
+        center (Center): The center where the product was used.
+    """
+
+    product = models.ForeignKey(
+        "Product",
+        on_delete=models.CASCADE,
+        related_name="center_products",  # Changed related_name for clarity
+    )
+    date_used = models.DateField()
+    center = models.ForeignKey(
+        "Center",
+        on_delete=models.CASCADE,
+        related_name="center_products",
+    )
+
+    if TYPE_CHECKING:
+        product: models.ForeignKey["Product"]
+        center: models.ForeignKey["Center"]
+
+    class Meta:
+        ordering = ["center", "-date_used", "product"]
+        verbose_name = "Center Product Usage"
+        verbose_name_plural = "Center Product Usages"
+
+    def __str__(self) -> str:
+        return f"{self.product} - {self.center} - {self.date_used}"
+
+    def get_product_name(self) -> str:
+        """Returns the name of the product."""
+        return self.product.name
+
+    def get_product_group(self):
+        """Returns the ProductGroup associated with this product."""
+        return self.product.product_group
+
+    def get_reference_product(self):
+        """Returns the reference Product for this product's group."""
+        product_group = self.get_product_group()
+        if product_group:
+            return product_group.reference_product
+        return None
+
+    def get_product_weight(self):
+        product = self.product
+
+        return product.get_product_weight()
+
+    def get_package_weight(self):
+        product = self.product
+
+        return product.get_package_weight()

endoreg_db/models/administration/center/center_resource.py

@@ -0,0 +1,69 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from ...other.emission import EmissionFactor
+    from ...other.resource import Resource
+    from ...other.unit import Unit
+    from .center import Center
+
+
+class CenterResource(models.Model):
+    name = models.CharField(max_length=255, null=True)
+    center = models.ForeignKey(
+        "Center",
+        on_delete=models.CASCADE,
+        related_name="center_resources",
+    )
+    quantity = models.FloatField()
+    resource = models.ForeignKey("Resource", on_delete=models.CASCADE)
+    transport_emission_factor = models.ForeignKey(
+        "EmissionFactor",
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name="center_resource_transport_emission_factor",
+    )
+    use_emission_factor = models.ForeignKey(
+        "EmissionFactor",
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name="center_resource_use_emission_factor",
+    )
+    year = models.IntegerField()
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+
+    if TYPE_CHECKING:
+        center: models.ForeignKey["Center"]
+        resource: models.ForeignKey["Resource"]
+        transport_emission_factor: models.ForeignKey["EmissionFactor|None"]
+        use_emission_factor: models.ForeignKey["EmissionFactor|None"]
+        unit: models.ForeignKey["Unit|None"]
+
+    def __str__(self):
+        return f"CenterResource {self.pk} - {self.name if self.name else 'No Name'}"
+
+    def display_str(self) -> str:
+        """Return a verbose description of the center resource."""
+        result_string = f"{self.name}:\n"
+
+        result_string += "\tCenter\t-\t" + str(self.center) + "\n"
+        result_string += "\tResource\t-\t" + str(self.resource) + "\n"
+        result_string += "\tQuantity\t-\t" + str(self.quantity) + "\n"
+        result_string += "\tYear\t-\t" + str(self.year) + "\n"
+        result_string += "\tUnit\t-\t" + str(self.unit) + "\n"
+
+        if self.transport_emission_factor is not None:
+            result_string += (
+                "\tTransport Emission Factor\t-\t"
+                + str(self.transport_emission_factor)
+                + "\n"
+            )
+
+        result_string += (
+            "\tUse Emission Factor\t-\t" + str(self.use_emission_factor) + "\n"
+        )
+
+        result_string += "\n"
+
+        return result_string

endoreg_db/models/administration/center/center_shift.py

@@ -0,0 +1,94 @@
+from decimal import Decimal
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Center,
+        ScheduledDays,
+        Shift,
+    )
+
+
+class CenterShiftManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a CenterShift instance by its unique name.
+
+        Args:
+            name: The unique identifier of the CenterShift.
+
+        Returns:
+            The CenterShift instance with the specified name.
+        """
+        return self.get(name=name)
+
+
+class CenterShift(models.Model):
+    """
+    Model representing a center shift.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    center = models.ForeignKey(
+        "Center",
+        on_delete=models.CASCADE,
+        related_name="center_shifts",
+    )
+    shift = models.ForeignKey(
+        "Shift",
+        on_delete=models.CASCADE,
+        related_name="center_shifts",
+    )
+
+    start_time = models.TimeField()
+    end_time = models.TimeField()
+    scheduled_days = models.ManyToManyField(
+        "ScheduledDays",
+        related_name="center_shifts",
+    )
+
+    # TODO add validator; the value should be between 0 and 1
+    estimated_presence_fraction = models.DecimalField(
+        max_digits=5,
+        decimal_places=4,
+        default=Decimal("0"),
+    )
+
+    if TYPE_CHECKING:
+        center: models.ForeignKey["Center"]
+        shift: models.ForeignKey["Shift"]
+        scheduled_days = cast(
+            models.manager.RelatedManager["ScheduledDays"], scheduled_days
+        )
+
+    def __str__(self):
+        """
+        Returns a string representation of the center shift, combining the center and shift.
+        """
+        return f"{self.center} - {self.shift}"
+
+    def initialize_scheduled_days(self):
+        # shift_types
+        """
+        Initializes scheduled days for the center shift.
+
+        This method is a placeholder and does not perform any actions.
+        """
+        pass
+
+    def get_scheduled_days(self, infer=True):
+        """
+        Retrieves the scheduled days associated with this center shift.
+
+        If no scheduled days are found and `infer` is False, raises a ValueError. Otherwise, returns the queryset of scheduled days, which may be empty.
+        """
+        sd = self.scheduled_days.all()
+        if not sd.exists():
+            if not infer:
+                raise ValueError("No scheduled days found for this center shift.")
+
+        return sd

endoreg_db/models/administration/center/center_waste.py

@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from ...other.emission import EmissionFactor
+    from ...other.unit import Unit
+    from ...other.waste import Waste
+    from .center import Center
+
+
+class CenterWaste(models.Model):
+    center: models.ForeignKey["Center"] = models.ForeignKey(
+        "Center",
+        on_delete=models.CASCADE,
+        related_name="center_wastes",
+    )
+    year = models.IntegerField()
+    waste: models.ForeignKey["Waste"] = models.ForeignKey(
+        "Waste", on_delete=models.CASCADE
+    )
+    quantity = models.FloatField()
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    emission_factor = models.ForeignKey(
+        "EmissionFactor", on_delete=models.SET_NULL, null=True
+    )
+
+    if TYPE_CHECKING:
+        center: models.ForeignKey["Center"]
+        waste: models.ForeignKey["Waste"]
+        unit: models.ForeignKey["Unit|None"]
+        emission_factor: models.ForeignKey["EmissionFactor|None"]
+
+    def __str__(self) -> str:
+        """
+        Returns a formatted string summarizing the waste record, including quantity, unit,
+        waste type, emission factor, center, and year.
+        """
+        result = f"{self.quantity} {self.unit}"
+        result += f" -\t{self.waste}, EmissionFactor: {self.emission_factor}\t\t- {self.center} - {self.year}"
+
+        return result

endoreg_db/models/administration/person/__init__.py

@@ -0,0 +1,26 @@
+from .person import Person
+from .patient import (
+    Patient,
+    PatientExternalID,
+)
+from .examiner import Examiner
+from .user.portal_user_information import PortalUserInfo
+from .names.first_name import FirstName
+from .names.last_name import LastName
+from .profession import Profession
+from .employee import Employee, EmployeeType, EmployeeQualification
+
+
+__all__ = [
+    "Person",
+    "Patient",
+    "PatientExternalID",
+    "Examiner",
+    "PortalUserInfo",
+    "FirstName",
+    "LastName",
+    "Profession",
+    "Employee",
+    "EmployeeType",
+    "EmployeeQualification",
+]

endoreg_db/models/administration/person/employee/__init__.py

@@ -0,0 +1,3 @@
+from .employee import Employee
+from .employee_type import EmployeeType
+from .employee_qualification import EmployeeQualification

endoreg_db/models/administration/person/employee/employee.py

@@ -0,0 +1,40 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+from ..person import Person
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        EmployeeQualification,
+        EmployeeType,
+    )
+
+
+class Employee(Person):
+    """
+    Model representing an employee.
+    """
+
+    employee_type = models.ForeignKey(
+        "EmployeeType",
+        on_delete=models.CASCADE,
+        related_name="employees",
+    )
+
+    if TYPE_CHECKING:
+        employee_type: models.ForeignKey["EmployeeType"]
+        # qualification is a OneToOneField defined in the EmployeeQualification model
+        qualification: models.OneToOneField["EmployeeQualification"]
+
+    def __str__(self):
+        """
+        Returns a string representation of the Employee, including the class name, full name if available, and employee type if set.
+        """
+        str_repr = self.__class__.__name__
+        if self.first_name and self.last_name:
+            str_repr += f" {self.first_name} {self.last_name}"
+
+        if self.employee_type:
+            str_repr += f" ({self.employee_type})"
+        return str_repr

endoreg_db/models/administration/person/employee/employee_qualification.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from django.db.models.manager import RelatedManager
+
+    from endoreg_db.models import (
+        Employee,
+        Qualification,
+    )
+
+
+class EmployeeQualification(models.Model):
+    """
+    Model representing an employee's qualification.
+    """
+
+    employee = models.OneToOneField(
+        "Employee",
+        on_delete=models.CASCADE,
+        related_name="qualification",
+    )
+    qualifications = models.ManyToManyField(
+        "Qualification",
+        related_name="employee_qualifications",
+    )
+
+    if TYPE_CHECKING:
+        employee: models.ForeignKey["Employee"]
+        qualifications = cast(RelatedManager[Qualification], qualifications)
+
+    def __str__(self):
+        """
+        Returns a human-readable string summarizing the employee and their qualifications.
+
+        If the employee has qualifications, lists them separated by commas; otherwise, indicates that no qualifications are assigned.
+        """
+        qualification_list = self.qualifications.all()
+        if qualification_list:
+            # Assuming Qualification model has a decent __str__ representation
+            qual_names = ", ".join(str(q) for q in qualification_list)
+            return f"{self.employee} - Qualifications: {qual_names}"
+        return f"{self.employee} - No qualifications assigned"

endoreg_db/models/administration/person/employee/employee_type.py

@@ -0,0 +1,50 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Employee,
+        Qualification,
+    )
+
+
+class EmployeeTypeManager(models.Manager):
+    def get_queryset(self):
+        """
+        Returns a queryset of active employee types.
+
+        Only employee types with is_active set to True are included in the queryset.
+        """
+        return super().get_queryset().filter(is_active=True)
+
+
+class EmployeeType(models.Model):
+    """
+    Model representing an employee type.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    qualifications = models.ManyToManyField(
+        "Qualification",
+        related_name="employee_types",
+    )
+
+    if TYPE_CHECKING:
+        qualifications = cast(
+            models.manager.RelatedManager["Qualification"], qualifications
+        )
+
+        @property
+        def employees(self) -> models.QuerySet["Employee"]: ...
+
+    objects = EmployeeTypeManager()
+
+    def __str__(self):
+        """
+        Returns the name of the employee type as its string representation.
+        """
+        return str(self.name)

endoreg_db/models/administration/person/examiner/__init__.py

@@ -0,0 +1,4 @@
+from .examiner import Examiner
+
+
+__all__ = ["Examiner"]