endoreg-db 0.8.5.1__py3-none-any.whl

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

@@ -0,0 +1,269 @@
+from django.db import models
+
+class CaseTemplateRuleTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class CaseTemplateRuleType(models.Model):
+    """
+    Represents a type of rule for a case template.
+
+    Attributes:
+        name (str): The name of the rule type.
+        description (str): A description of the rule type.
+    """
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = CaseTemplateRuleTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+    
+    def __str__(self):
+        return str(self.name)
+
+class CaseTemplateRuleManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+    def get_default_create_patient_rule(self):
+        """Get the default create patient rule."""
+        return self.get(name="create-patient-default")
+    
+    def get_default_create_patient_lab_sample_rules(self):
+        """Get the default create patient lab sample rules."""
+        return self.get(name="create-patient_lab_sample-default")
+    
+    def get_default_create_patient_medication_schedule_rule(self):
+        """Get the create patient medication schedule rule."""
+        r = self.get(name="create-patient_medication_schedule")
+        assert r, "No create patient medication schedule rule found"
+        return r
+    
+class CaseTemplateRule(models.Model):
+    """
+    A class representing a case template rule.
+
+    Attributes:
+        name (str): The name of the case template rule.
+        description (str): A description of the case template rule.
+        rule_type (CaseTemplateRuleType): The type of the rule.
+        parent_model (str): The model on which the rule is applied.
+        target_field (str): The field of the parent model on which the rule is applied.
+        target_model (str): The model to which the foreign key points (used for foreign key and many-to-many rules).
+        rule_values (list): A list of string values for the rule.
+        extra_parameters (dict): A dictionary of extra parameters for the rule.
+        value_type (CaseTemplateRuleValueType): The type of the rule value.
+        chained_rules (QuerySet): The chained rules associated with the current rule.
+        single_categorical_value_distribution (SingleCategoricalValueDistribution): The single categorical value distribution for the rule.
+        numerical_value_distribution (NumericValueDistribution): The numerical value distribution for the rule.
+        multiple_categorical_value_distribution (MultipleCategoricalValueDistribution): The multiple categorical value distribution for the rule.
+        date_value_distribution (DateValueDistribution): The date value distribution for the rule.
+        objects (CaseTemplateRuleManager): The manager for the CaseTemplateRule model.
+
+    Methods:
+        natural_key(): Returns the natural key of the rule.
+        __str__(): Returns a string representation of the rule.
+        get_rule_type(): Returns the name of the rule type.
+        get_chained_rules(): Returns all the chained rules associated with the current rule.
+        get_all_downward_chained_rules(): Returns all the chained rules of the current rule, including indirectly chained rules.
+        chained_rules_has_self_reference(): Checks if any directly or indirectly chained rules reference this rule, creating a non-terminating loop.
+        save(*args, **kwargs): Customizes the save method to check for self-references.
+
+    """
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+    rule_type = models.ForeignKey(
+        "CaseTemplateRuleType", on_delete=models.CASCADE
+    )
+    parent_model = models.CharField(max_length=255, blank=True, null=True)
+    parent_field = models.CharField(max_length=255, blank=True, null=True)
+    target_field = models.CharField(max_length=255, blank=True, null=True)
+    target_model = models.CharField(max_length=255, blank=True, null=True)
+    rule_values = models.JSONField(blank=True, null=True)
+    extra_parameters = models.JSONField(blank=True, null=True)
+    value_type = models.ForeignKey("CaseTemplateRuleValueType", on_delete=models.SET_NULL, null=True)
+    chained_rules = models.ManyToManyField(
+        "CaseTemplateRule",
+        related_name="calling_rules"
+    )
+    single_categorical_value_distribution = models.ForeignKey(
+        "SingleCategoricalValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    numerical_value_distribution = models.ForeignKey(
+        "NumericValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    multiple_categorical_value_distribution = models.ForeignKey(
+        "MultipleCategoricalValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    date_value_distribution = models.ForeignKey(
+        "DateValueDistribution", on_delete=models.SET_NULL, null=True
+    )
+    objects = CaseTemplateRuleManager()
+
+    def natural_key(self):
+        """
+        Returns the natural key of the rule.
+
+        :return: A tuple representing the natural key of the rule.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Returns a string representation of the rule.
+
+        :return: A string representation of the rule.
+        """
+        return str(self.name)
+
+    def get_rule_type(self):
+        """
+        Returns the name of the rule type.
+
+        :return: The name of the rule type.
+        """
+        return self.rule_type.name
+
+    def get_chained_rules(self):
+        """
+        Returns all the chained rules associated with the current rule.
+
+        :return: A queryset of all the chained rules associated with the current rule.
+        """
+        return self.chained_rules.all()
+    
+    def get_distribution(self):
+        """
+        Returns the value distribution of the rule.
+
+        :return: The value distribution of the rule.
+        """
+        DEBUG = True
+        if DEBUG:
+            print("Rule: ", self.name)
+            print(f"single_categorical_value_distribution: {self.single_categorical_value_distribution}")
+            print(f"numerical_value_distribution: {self.numerical_value_distribution}")
+            print(f"multiple_categorical_value_distribution: {self.multiple_categorical_value_distribution}")
+            print(f"date_value_distribution: {self.date_value_distribution}")
+
+
+        if self.single_categorical_value_distribution:
+            return self.single_categorical_value_distribution
+        elif self.numerical_value_distribution:
+            return self.numerical_value_distribution
+        elif self.multiple_categorical_value_distribution:
+            return self.multiple_categorical_value_distribution
+        elif self.date_value_distribution:
+            return self.date_value_distribution
+        return None
+
+    def get_all_downward_chained_rules(self):
+        """
+        Get all chained rules of the current rule, including indirectly chained rules.
+
+        :return: A set of all chained rules of the current rule.
+        """
+        all_chained_rules = set()
+
+        def traverse_chained_rules(rule):
+            """
+            Helper function to recursively traverse chained rules.
+
+            :param rule: The current CaseTemplateRule being checked.
+            :return: None
+            """
+            for chained_rule in rule.chained_rules.all():
+                if chained_rule not in all_chained_rules:
+                    all_chained_rules.add(chained_rule)
+                    traverse_chained_rules(chained_rule)
+
+        # Initialize the traversal starting with the current rule
+        traverse_chained_rules(self)
+        return all_chained_rules
+
+    def chained_rules_has_self_reference(self):
+        """
+        :noindex:
+        Check if any directly or indirectly chained rules reference this rule, creating a non-terminating loop.
+        Return a list containing a tuple (first_rule, self_referencing_rule) for each self-reference.
+        first_rule is the most upward rule in the chain that references the rule.
+        self_referencing_rule is the rule that references the current rule itself.
+
+        :return: A list of tuples representing the self-referencing rules.
+        """
+        result_list = []
+
+        def traverse_chained_rules(rule, visited_rules):
+            """
+            Helper function to recursively traverse chained rules and check for self-references.
+
+            :param rule: The current CaseTemplateRule being checked.
+            :param visited_rules: A list of tuples representing the path of rules visited so far.
+            :return: None
+            """
+            for chained_rule in rule.chained_rules.all():
+                if chained_rule == self:
+                    # A self-reference is detected
+                    first_rule = visited_rules[0][0]
+                    self_referencing_rule = visited_rules[-1][1]
+                    result_list.append((first_rule, self_referencing_rule))
+                elif chained_rule not in [r[1] for r in visited_rules]:
+                    # Continue to check chained rules of the current chained rule
+                    traverse_chained_rules(chained_rule, visited_rules + [(rule, chained_rule)])
+
+        # Initialize the traversal starting with the current rule
+        traverse_chained_rules(self, [(self, self)])
+        return result_list
+    
+    def get_target_model(self):
+        """
+        Returns the target model of the rule.
+
+        :return: The target model of the rule.
+        """
+        from django.apps import apps
+
+        if not self.target_model:
+            return None
+
+        try:
+            target_model = apps.get_model("endoreg_db", self.target_model)
+        except LookupError:
+            raise ValueError(f"Model {self.target_model} not found.")
+        return target_model
+    
+    def get_target_field(self):
+        """
+        Returns the target field of the rule.
+
+        :return: The target field of the rule.
+        """
+        return self.target_field
+    
+    def get_parent_model(self):
+        """
+        Returns the parent model of the rule.
+
+        :return: The parent model of the rule.
+        """
+        from django.apps import apps
+
+        if not self.parent_model:
+            return None
+
+        try:
+            self.parent_model = apps.get_model("endoreg_db", self.parent_model)
+        except LookupError:
+            raise ValueError(f"Model {self.parent_model} not found.")
+        return self.parent_model
+
+    # customize the save method to check for self-references
+    # def save(self, *args, **kwargs):
+    #     # Check for self-references
+    #     self_referencing_rules = self.chained_rules_has_self_reference()
+    #     if self_referencing_rules:
+    #         raise ValueError(f"Self-references detected: {self_referencing_rules}")
+    #     super().save(*args, **kwargs)
+

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

@@ -0,0 +1,86 @@
+from django.db import models
+
+class CaseTemplateRuleValueTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class CaseTemplateRuleValueType(models.Model):
+    """
+    A class representing a case template rule value type.
+
+    Attributes:
+        name (str): The name of the case template rule value type.
+        distribution_type: One of "single_categorical", "multiple_categorical", "numeric"
+        description (str): A description of the case template rule value type.
+    """
+    DISTRIBUTION_TYPES = [
+        ("single_categorical", "single_categorical"),
+        ("multiple_categorical", "multiple_categorical"),
+        ("numeric", "numeric")
+    ]
+    objects = CaseTemplateRuleValueTypeManager()
+
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    distribution_type = models.CharField(max_length=255, choices=DISTRIBUTION_TYPES)
+
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+
+class CaseTemplateRuleValueManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class CaseTemplateRuleValue(models.Model):
+    """
+    Represents a case template rule value.
+
+    Attributes:
+        name (str): The name of the rule value.
+        description (str): A description of the rule value.
+        fk_value (str): Foreign key value stored as a string.
+        numeric_value (float): Numeric value for the rule.
+        text_value (str): Text value for the rule.
+    """
+    objects = CaseTemplateRuleValueManager()
+
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    fk_value = models.CharField(max_length=255, null=True, blank=True)
+    numeric_value = models.FloatField(null=True, blank=True)
+    text_value = models.CharField(max_length=255, null=True, blank=True)
+
+    def natural_key(self):
+        """
+        Returns the natural key for the object.
+        """
+        return (self.name,)
+    
+    def __str__(self):
+        """
+        String representation of the object.
+        """
+        return str(self.name)
+    
+    def get_value(self):
+        """
+        Retrieves the value based on priority:
+        - fk_value > numeric_value > text_value > None.
+        
+        Returns:
+            str | float | None: The value based on the type hierarchy.
+        """
+        if self.fk_value:
+            return self.fk_value
+        elif self.numeric_value:
+            return self.numeric_value
+        elif self.text_value:
+            return self.text_value
+        else:
+            return None

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

@@ -0,0 +1,26 @@
+from django.db import models
+
+
+class CaseTemplateTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class CaseTemplateType(models.Model):
+    """
+    A class representing a case template type.
+
+    Attributes:
+        name (str): The name of the case template type.
+        description (str): A description of the case template type.
+
+    """
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = CaseTemplateTypeManager()
+
+    def natural_key(self):
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

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,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