endoreg-db 0.8.6.4__py3-none-any.whl

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/administration/person/names/first_name.py

@@ -0,0 +1,18 @@
+# class to represent unique first-names
+# name attribute is natural key
+
+from django.db import models
+
+class FirstNameManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class FirstName(models.Model):
+    objects = FirstNameManager()
+    name = models.CharField(max_length=255, unique=True)
+    
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/administration/person/names/last_name.py

@@ -0,0 +1,19 @@
+
+from django.db import models
+
+class LastNameManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class LastName(models.Model):
+    objects = LastNameManager()
+    name = models.CharField(max_length=255, unique=True)
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        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",
+]