endoreg-db 0.8.9.32__py3-none-any.whl

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

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import PortalUserInfo
+
+
+class ProfessionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class Profession(models.Model):
+    objects = ProfessionManager()
+    name = models.CharField(max_length=100)
+    description = models.TextField(blank=True, null=True)
+
+    if TYPE_CHECKING:
+
+        @property
+        def portal_user_infos(self) -> models.QuerySet["PortalUserInfo"]: ...
+
+    def __str__(self):
+        """
+        Return the profession's name as its string representation.
+        """
+        return str(self.name)

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

@@ -0,0 +1,5 @@
+from .portal_user_information import PortalUserInfo
+
+__all__ = [
+    "PortalUserInfo",
+]

endoreg_db/models/administration/person/user/portal_user_information.py

@@ -0,0 +1,41 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+# models.py in your main app
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import User
+
+    from endoreg_db.models import Examiner
+
+    from ..profession import Profession
+
+
+class PortalUserInfo(models.Model):
+    user = models.OneToOneField("auth.User", on_delete=models.CASCADE)
+    profession = models.ForeignKey(
+        "endoreg_db.Profession",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        related_name="portal_user_infos",
+    )
+    works_in_endoscopy = models.BooleanField(blank=True, null=True)
+    # Add other fields as needed
+
+    examiner = models.OneToOneField(
+        "endoreg_db.Examiner",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        related_name="portal_user_info",
+    )
+
+    if TYPE_CHECKING:
+        user: models.OneToOneField["User"]
+        profession: models.ForeignKey["Profession|None"]
+        examiner: models.OneToOneField["Examiner|None"]
+
+    def __str__(self):
+        return self.user.username

endoreg_db/models/administration/product/__init__.py

@@ -0,0 +1,15 @@
+"""Module for product models"""
+
+from .product import Product
+from .product_material import ProductMaterial
+from .product_group import ProductGroup
+from .reference_product import ReferenceProduct
+from .product_weight import ProductWeight
+
+__all__ = [
+    "Product",
+    "ProductMaterial",
+    "ProductGroup",
+    "ReferenceProduct",
+    "ProductWeight",
+]

endoreg_db/models/administration/product/product.py

@@ -0,0 +1,106 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+from endoreg_db.utils.product.sum_emissions import sum_emissions
+from endoreg_db.utils.product.sum_weights import sum_weights
+
+if TYPE_CHECKING:
+    from ...other.transport_route import TransportRoute
+    from .product_group import ProductGroup
+    from .product_material import ProductMaterial
+    from .reference_product import ReferenceProduct
+    # from .product_weight import ProductWeight
+
+
+class ProductManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class Product(models.Model):
+    objects = ProductManager()
+
+    name = models.CharField(max_length=255)
+
+    transport_route = models.ForeignKey(
+        "TransportRoute", on_delete=models.SET_NULL, null=True
+    )
+    product_group = models.ForeignKey(
+        "ProductGroup",
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name="products",
+    )
+
+    if TYPE_CHECKING:
+        transport_route: models.ForeignKey["TransportRoute|None"]
+        product_group: models.ForeignKey["ProductGroup|None"]
+        reference_products: models.QuerySet["ReferenceProduct"]
+        product_product_materials: models.QuerySet["ProductMaterial"]
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        result = f"{self.name}"
+        if self.product_group:
+            result += f" ({self.product_group}, "
+        else:
+            result += " (no product group, "
+
+        if self.transport_route:
+            result += f"{self.transport_route})"
+        else:
+            result += "no transport route)"
+
+        return result
+
+    def _calculate_material_metric(self, component: str, calculation_func):
+        """Helper method to calculate weight or emission for materials of a specific component."""
+        from .product_material import (
+            ProductMaterial,
+        )  # Import locally to avoid circular dependency issues at module level
+
+        materials = ProductMaterial.objects.filter(product=self, component=component)
+        return calculation_func(materials)
+
+    def get_product_weight(self):
+        """Get the product weight, prioritizing material definitions."""
+        from .product_material import ProductMaterial
+
+        # Check if there are specific material definitions for the product component
+        if ProductMaterial.objects.filter(product=self, component="product").exists():
+            return self.get_product_material_weight()
+
+        # Fallback: check if there is a direct product weight defined (Not implemented yet)
+        # TODO: Implement logic for ProductWeight lookup
+        return None  # Or appropriate default/error
+
+    def get_package_weight(self):
+        """Get the package weight, prioritizing material definitions."""
+        from .product_material import ProductMaterial
+
+        # Check if there are specific material definitions for the package component
+        if ProductMaterial.objects.filter(product=self, component="package").exists():
+            return self.get_package_material_weight()
+
+        # Fallback: check if there is a direct package weight defined (Not implemented yet)
+        # TODO: Implement logic for PackageWeight lookup (if different from ProductWeight)
+        return None  # Or appropriate default/error
+
+    def get_product_material_weight(self):
+        """Calculate the total weight based on defined product materials."""
+        return self._calculate_material_metric("product", sum_weights)
+
+    def get_package_material_weight(self):
+        """Calculate the total weight based on defined package materials."""
+        return self._calculate_material_metric("package", sum_weights)
+
+    def get_product_material_emission(self):
+        """Calculate the total emissions based on defined product materials."""
+        return self._calculate_material_metric("product", sum_emissions)
+
+    def get_package_material_emission(self):
+        """Calculate the total emissions based on defined package materials."""
+        return self._calculate_material_metric("package", sum_emissions)

endoreg_db/models/administration/product/product_group.py

@@ -0,0 +1,41 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Product,
+        ReferenceProduct,
+    )
+
+
+class ProductGroupManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class ProductGroup(models.Model):
+    objects = ProductGroupManager()
+
+    name = models.CharField(max_length=255)
+
+    if TYPE_CHECKING:
+        reference_product: "ReferenceProduct"
+        products: models.QuerySet["Product"]
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+
+    def get_products(self) -> models.QuerySet["Product"]:
+        from .product import Product
+
+        products = self.products.all()
+        if products:
+            return products
+        else:
+            return Product.objects.none()
+
+    def get_reference_product(self) -> "None | ReferenceProduct":
+        return self.reference_product

endoreg_db/models/administration/product/product_material.py

@@ -0,0 +1,60 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+from endoreg_db.models.other.unit import Unit
+
+if TYPE_CHECKING:
+    from ...other.material import Material
+    from ...other.unit import Unit
+    from .product import Product
+
+
+class ProductMaterial(models.Model):
+    component = models.CharField(max_length=255)
+    material = models.ForeignKey(
+        "Material",
+        on_delete=models.CASCADE,
+        related_name="material_product_materials",  # Changed related_name
+    )
+    product = models.ForeignKey(
+        "Product",
+        on_delete=models.CASCADE,
+        related_name="product_product_materials",  # Changed related_name
+    )
+    unit = models.ForeignKey(
+        "Unit",
+        on_delete=models.CASCADE,
+        related_name="unit_product_materials",  # Changed related_name
+    )
+    quantity = models.FloatField()
+
+    if TYPE_CHECKING:
+        product: models.ForeignKey["Product"]
+        material: models.ForeignKey["Material"]
+        unit: models.ForeignKey["Unit"]
+
+    def get_emission(self) -> tuple[float, Unit]:
+        emission_factor = self.material.emission_factor
+        if emission_factor is None:
+            raise Exception(
+                "No emission factor for material " + self.material.name + " found."
+            )
+
+        # make sure product_material.unit is the same as emission_factor.unit
+        if self.unit is not None and emission_factor.unit is not None:
+            if self.unit != emission_factor.unit:
+                raise Exception(
+                    "Unit mismatch: "
+                    + self.unit.name
+                    + " != "
+                    + emission_factor.unit.name
+                )
+
+        emmision_value = emission_factor.value * self.quantity
+        assert isinstance(emission_factor.unit, Unit)
+        emission_unit = emission_factor.unit
+        return emmision_value, emission_unit
+
+    def __str__(self) -> str:
+        return f"{self.product.name} - {self.material.name} - {self.quantity} {self.unit.name}"

endoreg_db/models/administration/product/product_weight.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING
+
+import pandas as pd
+from django.db import models
+
+if TYPE_CHECKING:
+    from ...other.unit import Unit
+    from .product import Product
+
+
+class ProductWeightManager(models.Manager):
+    def get_by_natural_key(self, product, product_group, weight):
+        return self.get(product=product, product_group=product_group, weight=weight)
+
+
+class ProductWeight(models.Model):
+    objects = ProductWeightManager()
+
+    name = models.CharField(max_length=255, null=True)
+    product = models.ForeignKey("Product", on_delete=models.CASCADE)
+    measured = models.FloatField(null=True)
+    verified = models.FloatField(null=True)
+    manufacturer = models.FloatField(null=True)
+    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
+
+    if TYPE_CHECKING:
+        product: models.ForeignKey["Product"]
+        unit: models.ForeignKey["Unit|None"]
+
+    def get_weight(self):
+        if not pd.isnull(self.verified):
+            return self.verified
+        elif not pd.isnull(self.measured):
+            return self.measured
+        elif not pd.isnull(self.manufacturer):
+            return self.manufacturer
+        else:
+            return None
+
+    def get_weight_source(self):
+        if not pd.isnull(self.verified):
+            return "verified"
+        elif not pd.isnull(self.measured):
+            return "measured"
+        elif not pd.isnull(self.manufacturer):
+            return "manufacturer"
+        else:
+            return None
+
+    def __str__(self):
+        return f"{self.product} - {self.get_weight()} {self.unit} (Source: {self.get_weight_source()})"

endoreg_db/models/administration/product/reference_product.py

@@ -0,0 +1,147 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from ...other.emission import EmissionFactor
+    from .product import Product
+    from .product_group import ProductGroup
+
+
+class ReferenceProductManager(models.Manager):
+    def get_by_natural_key(self, product_name: str, product_group_name: str):
+        return self.get(
+            product__name=product_name, product_group__name=product_group_name
+        )
+
+
+class ReferenceProduct(models.Model):
+    name = models.CharField(max_length=255)
+    product = models.ForeignKey(
+        "Product",
+        on_delete=models.CASCADE,
+        related_name="reference_products",
+    )
+    product_group = models.OneToOneField(
+        "ProductGroup",
+        on_delete=models.CASCADE,
+        related_name="reference_product",  # Changed from "reference_products"
+    )
+    emission_factor_total = models.ForeignKey(
+        "EmissionFactor",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="reference_products",
+    )
+    emission_factor_package = models.ForeignKey(
+        "EmissionFactor",
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name="reference_product_package",
+    )
+    emission_factor_product = models.ForeignKey(
+        "EmissionFactor",
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name="reference_product_product",
+    )
+
+    if TYPE_CHECKING:
+        product: models.ForeignKey["Product"]
+        product_group: models.ForeignKey["ProductGroup"]
+        emission_factor_total: models.ForeignKey["EmissionFactor|None"]
+        emission_factor_package: models.ForeignKey["EmissionFactor|None"]
+        emission_factor_product: models.ForeignKey["EmissionFactor|None"]
+
+    objects = ReferenceProductManager()
+
+    def __str__(self):
+        return self.product.name + " (" + self.product_group.name + ")"
+
+    def set_emission_factors(self):
+        from ...other.emission import EmissionFactor
+
+        product = self.product
+        emission_factor_name = (
+            f"{self.product_group.name}_{product.name}_total_emission_factor"
+        )
+        emission_factor_package_name = (
+            f"{self.product_group.name}_{product.name}_package_emission_factor"
+        )
+        emission_factor_product_name = (
+            f"{self.product_group.name}_{product.name}_product_emission_factor"
+        )
+
+        product_weight, product_weight_unit = product.get_product_material_weight()
+        package_weight, package_weight_unit = product.get_package_material_weight()
+        product_emission, product_emission_unit = (
+            product.get_product_material_emission()
+        )
+        package_emission, package_emission_unit = (
+            product.get_package_material_emission()
+        )
+
+        total_weight = product_weight + package_weight
+        total_emission = product_emission + package_emission
+
+        reference_unit = product_weight_unit
+        assert reference_unit == package_weight_unit, (
+            "Package weight units do not match"
+        )
+        assert reference_unit == product_emission_unit, (
+            "Product emission units do not match"
+        )
+        assert reference_unit == package_emission_unit, (
+            "Package emission units do not match"
+        )
+
+        product_emission_factor_value = product_emission / product_weight
+        package_emission_factor_value = package_emission / package_weight
+        total_emission_factor_value = total_emission / total_weight
+
+        emission_factor, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_name,
+            defaults={
+                "name": emission_factor_name,
+                "value": total_emission_factor_value,
+                "unit": reference_unit,
+            },
+        )
+        self.emission_factor_total = emission_factor
+
+        emission_factor_package, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_package_name,
+            defaults={
+                "name": emission_factor_package_name,
+                "value": package_emission_factor_value,
+                "unit": reference_unit,
+            },
+        )
+        self.emission_factor_package = emission_factor_package
+
+        emission_factor_product, created = EmissionFactor.objects.get_or_create(
+            name=emission_factor_product_name,
+            defaults={
+                "name": emission_factor_product_name,
+                "value": product_emission_factor_value,
+                "unit": reference_unit,
+            },
+        )
+        self.emission_factor_product = emission_factor_product
+
+        self.save()
+
+    def get_emission_factor(self, component: str):
+        # check if emission_factor_total exists:
+        if self.emission_factor_total is None:
+            self.set_emission_factors()
+
+        if component == "total":
+            return self.emission_factor_total
+        elif component == "package":
+            return self.emission_factor_package
+        elif component == "product":
+            return self.emission_factor_product
+        else:
+            raise Exception("Unknown component: " + component)

endoreg_db/models/administration/qualification/__init__.py

@@ -0,0 +1,7 @@
+from .qualification import Qualification
+from .qualification_type import QualificationType
+
+__all__ = [
+    "Qualification",
+    "QualificationType",
+]

endoreg_db/models/administration/qualification/qualification.py

@@ -0,0 +1,43 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        QualificationType,
+    )
+
+
+class QualificationManager(models.Manager):
+    def get_queryset(self):
+        """
+        Returns a queryset of qualifications filtered to include only active entries.
+        """
+        return super().get_queryset().filter(is_active=True)
+
+
+class Qualification(models.Model):
+    """
+    Model representing a qualification.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    qualification_types = models.ManyToManyField(
+        "QualificationType",
+        related_name="qualifications",
+    )
+    if TYPE_CHECKING:
+        qualification_types = cast(
+            models.manager.RelatedManager["QualificationType"], qualification_types
+        )
+
+    objects = QualificationManager()
+
+    def __str__(self):
+        """
+        Returns the string representation of the qualification's name.
+        """
+        return str(self.name)

endoreg_db/models/administration/qualification/qualification_type.py

@@ -0,0 +1,39 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Qualification,
+    )
+
+
+class QualificationTypeManager(models.Manager):
+    def get_queryset(self):
+        """
+        Returns a queryset of active qualification types.
+
+        Only includes records where the `is_active` field is set to True.
+        """
+        return super().get_queryset().filter(is_active=True)
+
+
+class QualificationType(models.Model):
+    """
+    Model representing a qualification type.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    objects = QualificationTypeManager()
+
+    if TYPE_CHECKING:
+        qualification: models.QuerySet["Qualification"]
+
+    def __str__(self):
+        """
+        Returns the string representation of the qualification type's name.
+        """
+        return str(self.name)

endoreg_db/models/administration/shift/__init__.py

@@ -0,0 +1,9 @@
+from .shift import Shift
+from .shift_type import ShiftType
+from .scheduled_days import ScheduledDays
+
+__all__ = [
+    "Shift",
+    "ShiftType",
+    "ScheduledDays",
+]

endoreg_db/models/administration/shift/scheduled_days.py

@@ -0,0 +1,72 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        CenterShift,
+    )
+
+
+class ScheduledDaysManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a ScheduledDays instance by its unique name.
+
+        Args:
+            name: The unique name of the ScheduledDays instance to retrieve.
+
+        Returns:
+            The ScheduledDays instance matching the given name.
+        """
+        return self.get(name=name)
+
+
+class ScheduledDays(models.Model):
+    """
+    Model representing scheduled days for a shift.
+    """
+
+    name = models.CharField(
+        max_length=255,
+        unique=True,
+        help_text="Name of the scheduled days.",
+    )
+    working_days = models.BooleanField(
+        null=True,
+        blank=True,
+        default=True,
+    )
+
+    non_working_days = models.BooleanField(
+        null=True,
+        blank=True,
+        default=False,
+    )
+
+    limited_time = models.BooleanField(
+        null=True,
+        blank=True,
+        default=False,
+    )
+
+    start_date = models.DateField(
+        null=True,
+        blank=True,
+    )
+
+    end_date = models.DateField(
+        null=True,
+        blank=True,
+    )
+
+    objects = ScheduledDaysManager()
+
+    if TYPE_CHECKING:
+        center_shifts: models.QuerySet["CenterShift"]
+
+    def __str__(self):
+        """
+        Returns a string representation of the scheduled day, including its name and date range.
+        """
+        return f"{self.name} - {self.start_date} to {self.end_date}"