endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/models/administration/center/center.py

@@ -0,0 +1,67 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...medical import Endoscope, EndoscopyProcessor
+    from ...administration import (
+        CenterProduct,
+        CenterWaste, CenterResource
+    )
+    from ...media import AnonymExaminationReport, AnonymHistologyReport
+
+class CenterManager(models.Manager):
+    def get_by_natural_key(self, name) -> "Center":
+        return self.get(name=name)
+
+
+class Center(models.Model):
+    objects = CenterManager()
+
+    # import_id = models.IntegerField(primary_key=True)
+    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:
+    #     first_names: RelatedManager["FirstName"]
+    #     last_names: RelatedManager["LastName"]
+        center_products: models.QuerySet["CenterProduct"]
+        center_resources: models.QuerySet["CenterResource"]
+        center_wastes: models.QuerySet["CenterWaste"]
+        endoscopy_processors: models.QuerySet["EndoscopyProcessor"]
+        endoscopes: models.QuerySet["Endoscope"]
+        anonymexaminationreport_set: models.QuerySet["AnonymExaminationReport"]
+        anonymhistologyreport_set: models.QuerySet["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(object=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,64 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..product import Product, ProductGroup
+    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: "Product"
+        center: "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) -> "ProductGroup | None":
+        """Returns the ProductGroup associated with this product."""
+        return self.product.product_group
+
+    def get_reference_product(self) -> "Product | None":
+        """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,49 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .center import Center
+    from ...other.resource import Resource
+    from ...other.unit import Unit
+    from ...other.emission import EmissionFactor
+    
+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: "Center"
+        resource: "Resource"
+        transport_emission_factor: "EmissionFactor"
+        use_emission_factor: "EmissionFactor"
+        unit: "Unit"
+
+    def __str__(self):
+        result_string = ""
+
+        if self.name is not None:
+            result_string += 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"
+        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,88 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Center,
+        Shift,
+        ScheduledDays,
+    )
+
+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=0.0,
+    )
+
+    if TYPE_CHECKING:
+        center: "Center"
+        shift: "Shift"
+        scheduled_days: models.QuerySet["ScheduledDays"]
+
+    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,30 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .center import Center
+    from ...other.waste import Waste
+    from ...other.unit import Unit
+    from ...other.emission import EmissionFactor
+    
+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"] = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+    emission_factor: models.ForeignKey["EmissionFactor"] = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+    
+    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/permissions/__init__.py

@@ -0,0 +1,44 @@
+# from django.contrib.contenttypes.models import ContentType
+# from django.contrib.auth.models import Permission
+# from endoreg_db.models import *  # Import your models here
+# from django.db import transaction
+
+# # Step 1: Define model to category mappings
+# # Assuming every model class name is unique across your entire Django project
+# model_categories = {
+#     'SensitiveModel1': 'sensitive',
+#     'SensitiveModel2': 'sensitive',
+#     'DevelopmentModel1': 'development',
+#     'DevelopmentModel2': 'development',
+#     # Add all models you have, mapping them to either 'sensitive', 'development', or 'all'
+# }
+
+# # Step 2: Define permissions for each category
+# category_permissions = {
+#     'sensitive': ['view', 'edit', 'delete'],
+#     'development': ['view', 'edit'],
+#     'all': ['view'],
+# }
+
+# @transaction.atomic
+# def create_permissions_for_all_models():
+#     for model_class_name, category in model_categories.items():
+#         model_class = globals().get(model_class_name)
+#         if model_class is None:
+#             print(f"Model {model_class_name} not found.")
+#             continue
+        
+#         content_type = ContentType.objects.get_for_model(model_class)
+#         permissions = category_permissions.get(category, [])
+
+#         for permission_codename in permissions:
+#             permission_name = f"Can {permission_codename} {model_class_name}"
+#             permission, created = Permission.objects.get_or_create(
+#                 codename=f"{permission_codename}_{model_class_name.lower()}",
+#                 defaults={'name': permission_name, 'content_type': content_type},
+#             )
+#             if created:
+#                 print(f"Created permission: {permission_name}")
+
+# # Run the function to create and assign permissions based on categories
+# create_permissions_for_all_models()

endoreg_db/models/administration/person/__init__.py

@@ -0,0 +1,24 @@
+from .person import Person
+from .patient import (
+    Patient,
+)
+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",
+    "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,35 @@
+from django.db import models
+from typing import TYPE_CHECKING
+from ..person import Person
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        EmployeeType,
+        EmployeeQualification,
+    )
+
+class Employee(Person):
+    """
+    Model representing an employee.
+    """
+    employee_type = models.ForeignKey(
+        "EmployeeType",
+        on_delete=models.CASCADE,
+        related_name="employees",
+    )
+
+    if TYPE_CHECKING:
+        employee_type: "EmployeeType"
+        qualification: "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,39 @@
+from django.db import models
+
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    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: models.QuerySet["Qualification"]
+
+    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,42 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Qualification,
+        Employee,
+    )
+
+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: models.QuerySet["Qualification"]
+        employees: 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"]

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

@@ -0,0 +1,54 @@
+from django.db import models
+from ..person import Person
+from endoreg_db.utils import get_examiner_hash, create_mock_examiner_name
+from typing import TYPE_CHECKING
+
+from ....utils import DJANGO_NAME_SALT
+if TYPE_CHECKING:
+    from endoreg_db.models import administration
+class Examiner(Person):
+    center = models.ForeignKey(
+        "Center", on_delete=models.CASCADE, blank=True, null=True
+    )
+    hash = models.CharField(max_length=255, unique=True)
+
+    if TYPE_CHECKING:
+        center: "administration.Center"
+        portal_user_info: "administration.PortalUserInfo"
+
+    def __str__(self):
+        return self.first_name + " " + self.last_name
+
+    @classmethod
+    def custom_get_or_create(cls, first_name: str, last_name: str, center: "administration.Center", substitute_names: bool = True):
+        from endoreg_db.models import (
+            FirstName,
+            LastName,
+        )
+
+        if isinstance(first_name, FirstName):
+            first_name = str(first_name.name)
+        
+        if isinstance(last_name, LastName):
+            last_name = str(last_name.name)
+
+
+        real_hash = get_examiner_hash(
+            first_name=first_name,
+            last_name=last_name,
+            center_name=center.name,
+            salt=DJANGO_NAME_SALT,
+        )
+
+        if substitute_names:
+            name_tuple = create_mock_examiner_name()
+        
+        else:
+            name_tuple = (first_name, last_name)
+        defaults = dict(
+            first_name=name_tuple[0],
+            last_name=name_tuple[1],
+            center=center,
+        )
+        examiner, created = cls.objects.get_or_create(hash=real_hash, defaults=defaults)
+        return examiner, created

endoreg_db/models/{persons → administration/person/names}/first_name.py

@@ -15,4 +15,4 @@ class FirstName(models.Model):
         return (self.name,)
     
     def __str__(self):
-        return self.name
+        return str(self.name)

endoreg_db/models/{persons → administration/person/names}/last_name.py

@@ -1,5 +1,4 @@
-# class to represent unique last_names
-# name attribute is natural key
+
 from django.db import models
 
 class LastNameManager(models.Manager):
@@ -14,7 +13,7 @@ class LastName(models.Model):
         return (self.name,)
 
     def __str__(self):
-        return self.name
+        return str(self.name)
     
 # Path: endoreg_db/models/persons/first_name.py
         

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

@@ -0,0 +1,5 @@
+from .patient import Patient
+
+__all__ = [
+    "Patient",
+]