endoreg-db 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

endoreg_db/models/logging/network_device.py

@@ -0,0 +1,27 @@
+from django.db import models
+from .base import AbstractLogEntry
+
+class NetworkDeviceLogEntry(AbstractLogEntry):
+    """
+    Model for log entries related to network devices.
+    """
+    device = models.ForeignKey("NetworkDevice", on_delete=models.CASCADE)
+    log_type = models.ForeignKey("LogType", on_delete=models.CASCADE, null=True, blank=True)
+
+    datetime = models.DateTimeField(default=None, null=True, blank=True)
+    # hostname = models.CharField(max_length=255, null=True, blank=True)
+    aglnet_ip = models.GenericIPAddressField(null=True, blank=True)
+    vpn_service_status = models.CharField(max_length=255, null=True, blank=True)
+    vpn_service_restart_attempt = models.BooleanField(default=False)
+    vpn_service_restart_success = models.BooleanField(null=True, blank=True)
+    ping_vpn = models.BooleanField(default=False)
+    ping_www = models.BooleanField(default=False)
+    transferred_to_host = models.BooleanField(default=False)
+
+    class Meta:
+        verbose_name = "Network Device Log Entry"
+        verbose_name_plural = "Network Device Log Entries"
+
+    def __str__(self):
+        return f"{self.timestamp} - {self.user} - {self.ip_address} - {self.device} - {self.message}"
+

endoreg_db/models/lx/__init__.py

@@ -0,0 +1,4 @@
+from .client import LxClientType, LxClientTag, LxClient
+from .identity import LxIdentity, LxIdentityType
+from .permission import LxPermission
+from .user import LxUser

endoreg_db/models/lx/client.py

@@ -0,0 +1,57 @@
+# Insert models for Client, Client Type, Client Tag
+
+from django.db import models
+
+class LxClientTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for client Type
+
+class LxClientType(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    abbreviation = models.CharField(max_length=10, unique=True)  # New field
+    description = models.TextField(blank=True)
+    objects = LxClientTypeManager()
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+    
+
+class LxClientTagManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for client Tag
+
+class LxClientTag(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    objects = LxClientTagManager()
+
+    # M2M relationship with LxPermission
+    permissions = models.ManyToManyField('LxPermission', blank=True, related_name="allowed_client_tags")
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+
+class LxClientManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for client
+
+class LxClient(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    client_type = models.ForeignKey(LxClientType, on_delete=models.CASCADE)
+    client_tags = models.ManyToManyField(LxClientTag, blank=True)
+    vpn_ip = models.GenericIPAddressField(blank=True, null=True)
+    objects = LxClientManager()
+

endoreg_db/models/lx/identity.py

@@ -0,0 +1,34 @@
+from django.db import models
+
+class LxIdentityTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for identity Type
+## ed25519, rsa, ecdsa, dsa, etc
+
+class LxIdentityType(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    objects = LxIdentityTypeManager()
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)
+
+class LxIdentity(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    identity_type = models.ForeignKey(LxIdentityType, on_delete=models.CASCADE)
+    objects = models.Manager()
+
+    # Foreign key to user, nullable
+    user = models.ForeignKey('LxUser', on_delete=models.CASCADE, null=True, blank=True)
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)

endoreg_db/models/lx/permission.py

@@ -0,0 +1,18 @@
+from django.db import models
+
+class LxPermissionManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+#TODO implement base population for permission
+
+class LxPermission(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+    objects = LxPermissionManager()
+    
+    def __str__(self):
+        return self.name
+    
+    def natural_key(self):
+        return (self.name,)

endoreg_db/models/lx/user.py

@@ -0,0 +1,16 @@
+from django.db import models
+
+class LxUserManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+
+class LxUser(models.Model):
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True)
+
+    
+
+    # to be extended
+
+

endoreg_db/models/medication/__init__.py

@@ -0,0 +1,19 @@
+"""Medication models initialization module."""
+from .medication import Medication, MedicationManager
+from .medication_schedule import MedicationSchedule, MedicationScheduleManager
+from .medication_intake_time import MedicationIntakeTime, MedicationIntakeTimeManager
+from .medication_indication_type import MedicationIndicationType, MedicationIndicationTypeManager
+from .medication_indication import MedicationIndication, MedicationIndicationManager
+
+__all__ = [
+    "Medication",
+    "MedicationManager",
+    "MedicationSchedule",
+    "MedicationScheduleManager",
+    "MedicationIntakeTime",
+    "MedicationIntakeTimeManager",
+    "MedicationIndicationType",
+    "MedicationIndicationTypeManager",
+    "MedicationIndication",
+    "MedicationIndicationManager"
+]

endoreg_db/models/medication/medication.py

@@ -0,0 +1,33 @@
+'''Model for the medication.'''
+from django.db import models
+
+
+class MedicationManager(models.Manager):
+    '''Manager for the medication model.'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a medication by its natural key.'''
+        return self.get(name=name)
+
+class Medication(models.Model):
+    '''Model representing a medication.'''
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    adapt_to_renal_function = models.BooleanField(default = False)
+    adapt_to_hepatic_function = models.BooleanField(default=False)
+    adapt_to_indication = models.BooleanField(default=False)
+    adapt_to_age = models.BooleanField(default=False)
+    adapt_to_weight = models.BooleanField(default=False)
+    adapt_to_risk = models.BooleanField(default=False)
+    default_unit = models.ForeignKey('Unit', on_delete=models.CASCADE)
+
+
+    objects = MedicationManager()
+
+    def natural_key(self):
+        '''Return the natural key for the medication.'''
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+    

endoreg_db/models/medication/medication_indication.py

@@ -0,0 +1,50 @@
+"""Model for medication indication."""
+
+from django.db import models
+
+
+class MedicationIndicationManager(models.Manager):
+    """Manager for the medication indication model."""
+
+    def get_by_natural_key(self, name):
+        """Retrieve a medication indication by its natural key."""
+        return self.get(name=name)
+
+
+class MedicationIndication(models.Model):
+    """Model representing a medication indication."""
+
+    name = models.CharField(max_length=255, unique=True)
+    indication_type = models.ForeignKey(
+        "MedicationIndicationType",
+        on_delete=models.CASCADE,
+        related_name="medication_indications",
+    )
+    medication_schedules = models.ManyToManyField(
+        "MedicationSchedule",
+    )
+    diseases = models.ManyToManyField("Disease")
+    events = models.ManyToManyField("Event")
+    disease_classification_choices = models.ManyToManyField(
+        "DiseaseClassificationChoice"
+    )
+    sources = models.ManyToManyField("InformationSource")
+
+    def get_indication_links(self) -> dict:
+        """Return a dictionary of all linked objects for this medication indication."""
+        links = {
+            "medication_schedules": self.medication_schedules,
+            "diseases": self.diseases,
+            "events": self.events,
+            "disease_classification_choices": self.disease_classification_choices,
+        }
+        return links
+
+    objects = MedicationIndicationManager()
+
+    def natural_key(self):
+        """Return the natural key for the medication indication."""
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/medication/medication_indication_type.py

@@ -0,0 +1,34 @@
+'''Model for medication indication type.'''
+from django.db import models
+
+class MedicationIndicationTypeManager(models.Manager):
+    '''Manager for the medication indication type model.'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a medication indication type by its natural key.'''
+        return self.get(name=name)
+
+class MedicationIndicationType(models.Model):
+    '''Model representing a medication indication type.'''
+    name = models.CharField(max_length=255, unique=True)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+
+    objects = MedicationIndicationTypeManager()
+
+    def natural_key(self):
+        '''Return the natural key for the medication indication type.'''
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+    
+    @classmethod
+    def get_random_indication_by_type(cls, name) -> "MedicationIndication":
+        '''Return a random medication indication of the given type.'''
+        return cls.objects.get(name=name).medication_indications.order_by('?').first()
+    
+
+    def get_random_medication_indication(self):
+        '''Return a random medication indication of this type.'''
+        from endoreg_db.models import MedicationIndication
+        return MedicationIndication.objects.filter(indication_type=self).order_by('?').first()

endoreg_db/models/medication/medication_intake_time.py

@@ -0,0 +1,26 @@
+'''Model for medication intake time'''
+from django.db import models
+
+
+class MedicationIntakeTimeManager(models.Manager):
+    '''Manager for the medication intake time model.'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a medication intake time by its natural key.'''
+        return self.get(name=name)
+    
+class MedicationIntakeTime(models.Model):
+    '''Model representing a medication intake time.'''
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    repeats = models.CharField(max_length=20, default = "daily")
+    time = models.TimeField()
+
+    objects = MedicationIntakeTimeManager()
+
+    def natural_key(self):
+        '''Return the natural key for the medication intake time.'''
+        return (self.name,)
+    
+    def __str__(self):
+        return self.name + " at " + str(self.time) + " (" + self.repeats + ")"

endoreg_db/models/medication/medication_schedule.py

@@ -0,0 +1,37 @@
+'''Model for the medication schedule.'''
+from typing import List
+from django.db import models
+
+class MedicationScheduleManager(models.Manager):
+    '''Manager for the medication schedule model.'''
+    def get_by_natural_key(self, name):
+        '''Retrieve a medication schedule by its natural key.'''
+        return self.get(name=name)
+    
+class MedicationSchedule(models.Model):
+    '''Model representing a medication schedule.'''
+    name = models.CharField(max_length=255)
+    name_de = models.CharField(max_length=255, blank=True, null=True)
+    name_en = models.CharField(max_length=255, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    medication = models.ForeignKey("Medication", on_delete=models.CASCADE)
+    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
+    therapy_duration_d = models.FloatField(blank=True, null=True)
+    dose = models.FloatField()
+    intake_times = models.ManyToManyField(
+        "MedicationIntakeTime", 
+    )
+
+    objects = MedicationScheduleManager()
+
+    def natural_key(self):
+        '''Return the natural key for the medication schedule.'''
+        return (self.name,)
+    
+    def __str__(self):
+        return str(self.name)
+    
+    def get_intake_times(self) -> List["MedicationIntakeTime"]:
+        '''Return a list of all intake times for this medication schedule.'''
+        return [_ for _ in self.intake_times.all()] # type: ignore # pylint: disable=E1101
+    

endoreg_db/models/network/__init__.py

@@ -0,0 +1,9 @@
+from .network_device import NetworkDevice
+from .network_device_type import NetworkDeviceType
+from .agl_service import AglService
+
+__all__ = [
+    "NetworkDevice",
+    "NetworkDeviceType",
+    "AglService",
+]

endoreg_db/models/network/agl_service.py

@@ -0,0 +1,38 @@
+from django.db import models
+
+class AglServiceManager(models.Manager):
+    # Custom manager for AglService; defines name as natural key
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+    
+class AglService(models.Model):
+    name = models.CharField(max_length=255)
+    description = models.CharField(max_length=255)
+    online = models.BooleanField(default=False)
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+    objects = AglServiceManager()
+    devices = models.ManyToManyField("NetworkDevice", related_name="services")
+    port = models.IntegerField(blank=True, null=True)
+    protocol = models.CharField(max_length=255, blank=True, null=True)
+    url = models.URLField(blank=True, null=True)
+
+    def alive_log(self, user, ip_address, user_agent):
+        from ..logging import AglServiceLogEntry
+        AglServiceLogEntry.objects.create(
+            user=user,
+            ip_address=ip_address,
+            user_agent=user_agent,
+            message=f"Service {self.name} is alive.",
+            service=self
+        )
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        ordering = ['name']
+        
+    def natural_key(self):
+        return (self.name,)
+    

endoreg_db/models/network/network_device.py

@@ -0,0 +1,58 @@
+import subprocess
+from django.db import models
+
+# Django db class to store network devices (e.g., servers, clients, switches, etc.)
+
+class NetworkDeviceManager(models.Manager):
+    """Custom manager for NetworkDevice that defines name as natural key."""
+    def get_by_natural_key(self, name):
+        """Return the network device with the given name as its natural key."""
+        return self.get(name=name)
+    
+class NetworkDevice(models.Model):
+    """Django model representing a network device."""
+    name = models.CharField(max_length=255)
+    ip = models.GenericIPAddressField(blank=True, null=True)
+    description = models.CharField(max_length=255)
+    device_type = models.ForeignKey("NetworkDeviceType", on_delete=models.CASCADE)
+    online = models.BooleanField(default=False)
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+    objects = NetworkDeviceManager()
+
+    def __str__(self):
+        """Return the device name."""
+        return str(self.name)
+
+    # pylint: disable=too-few-public-methods
+    class Meta:
+        """Meta options for the NetworkDevice model."""
+        db_table = 'network_devices'
+        ordering = ['name']
+        
+    def natural_key(self):
+        """Return a tuple representing the natural key for this network device."""
+        return (self.name,)
+    
+    def ping(self):
+        """Check device availability by sending one ping request."""
+        target_ip = self.ip
+
+        # Define the command
+        command = ['ping', '-c', '1', target_ip]
+
+        # Run the command
+        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+        # Wait for the process to terminate
+        process.wait()
+
+        # Check the return code
+        return_code = process.returncode
+        
+        # Return True if the return code is 0, False otherwise
+        self.online = return_code == 0
+        self.save()
+        return self.online
+
+

endoreg_db/models/network/network_device_type.py

@@ -0,0 +1,23 @@
+# Django db class to store network device types (e.g., server, client, switch, etc.)
+
+from django.db import models
+
+class NetworkDeviceTypeManager(models.Manager):
+    # Custom manager for NetworkDeviceType; defines name as natural key
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+class NetworkDeviceType(models.Model):
+    name = models.CharField(max_length=255)
+    description = models.CharField(max_length=255)
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+    objects = NetworkDeviceTypeManager()
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        db_table = 'network_device_types'
+        ordering = ['name']
+

endoreg_db/models/organ/__init__.py

@@ -0,0 +1,38 @@
+"""Module for Organ models."""
+from django.db import models
+
+class OrganManager(models.Manager):
+    """Manager for Organ model."""
+
+    def get_by_natural_key(self, name):
+        """Retrieve an Organ by its natural key."""
+        return self.get(name=name)
+    
+    def all_names(self):
+        """Return a list of all organ names."""
+        return list(self.all().values_list('name', flat=True))
+    
+class Organ(models.Model):
+    """Model representing an organ."""
+    
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    description_de = models.TextField(blank=True, null=True)
+    description_en = models.TextField(blank=True, null=True)
+
+    location_choices = models.ManyToManyField(
+        'FindingLocationClassificationChoice', 
+        blank=True, related_name='organs'
+    )
+
+    objects = OrganManager()
+    
+    def natural_key(self):
+        """Return the natural key for the organ."""
+        return (self.name,)
+    
+    def __str__(self):
+        """Return string representation of the organ."""
+        return str(self.name)

endoreg_db/models/other/__init__.py

@@ -0,0 +1,23 @@
+from .material import Material
+from .resource import Resource
+from .transport_route import TransportRoute
+from .waste import Waste
+from .distribution import (
+    BaseValueDistribution,
+    NumericValueDistribution,
+    SingleCategoricalValueDistribution,
+    MultipleCategoricalValueDistribution,
+    DateValueDistribution,
+)
+
+__all__ = [
+    'Material',
+    'Resource',
+    'TransportRoute',
+    'Waste',
+    'BaseValueDistribution',
+    'NumericValueDistribution',
+    'SingleCategoricalValueDistribution',
+    'MultipleCategoricalValueDistribution',
+    'DateValueDistribution',
+]

endoreg_db/models/other/distribution/__init__.py

@@ -0,0 +1,44 @@
+'''Module for distribution models.'''
+
+from .base_value_distribution import BaseValueDistribution
+from .numeric_value_distribution import NumericValueDistribution
+from .single_categorical_value_distribution import SingleCategoricalValueDistribution
+from .multiple_categorical_value_distribution import MultipleCategoricalValueDistribution
+from .date_value_distribution import DateValueDistribution
+
+
+__all__ = [
+    'BaseValueDistribution',
+    'NumericValueDistribution',
+    'SingleCategoricalValueDistribution',
+    'MultipleCategoricalValueDistribution',
+    'DateValueDistribution',
+]
+
+# Example Usage
+# Numeric distribution for age
+# age_distribution = NumericValueDistribution.objects.create(
+#     name='Age Distribution',
+#     distribution_type='normal',
+#     min_value=0,
+#     max_value=100,
+#     mean=50,
+#     std_dev=15
+# )
+
+# # Single categorical distribution for gender
+# gender_distribution = SingleCategoricalValueDistribution.objects.create(
+#     name='Gender Distribution',
+#     categories={'male': 0.5, 'female': 0.5}
+# )
+
+# # Multiple categorical distribution for symptoms
+# symptoms_distribution = MultipleCategoricalValueDistribution.objects.create(
+#     name='Symptoms Distribution',
+#     categories={'fever': 0.3, 'cough': 0.4, 'fatigue': 0.2, 'nausea': 0.1},
+#     min_count=1,
+#     max_count=3,
+#     count_distribution_type='normal',
+#     count_mean=2,
+#     count_std_dev=0.5
+# )

endoreg_db/models/other/distribution/base_value_distribution.py

@@ -0,0 +1,20 @@
+from django.db import models
+
+class BaseValueDistribution(models.Model):
+    """
+    Abstract base class for value distributions.
+    """
+    name = models.CharField(max_length=100)
+
+    class Meta:
+        abstract = True
+
+    def generate_value(self):
+        """
+        Generate a value based on the distribution rules.
+        Must be implemented by subclasses.
+        """
+        raise NotImplementedError("Subclasses must implement this method")
+    
+    def natural_key(self):
+        return (self.name,)