endoreg-db 0.6.3__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/models/logging/log_type.py

@@ -1,23 +0,0 @@
-from django.db import models
-
-class LogTypeManager(models.Manager):
-    # Custom manager for LogType; defines name as natural key
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-
-class LogType(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 = LogTypeManager()
-    
-    def __str__(self):
-        return self.name
-    
-    class Meta:
-        ordering = ['name']
-        
-    def natural_key(self):
-        return (self.name,)

endoreg_db/models/logging/network_device.py

@@ -1,27 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,57 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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/network/__init__.py

@@ -1,9 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,23 +0,0 @@
-# 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/other/distribution.py

@@ -1,5 +0,0 @@
-
-
-
-
-   

endoreg_db/models/patient/__init__.py

@@ -1,24 +0,0 @@
-from .patient_examination import PatientExamination
-from .patient_finding import (
-    PatientFinding
-)
-from .patient_finding_location import (
-    PatientFindingLocation
-)
-from .patient_finding_morphology import (
-    PatientFindingMorphology
-)
-
-from .patient_finding_intervention import (
-    PatientFindingIntervention
-)
-
-# TODO Migrate to persons/patient
-
-__all__ = [
-    "PatientExamination",
-    "PatientFinding",
-    "PatientFindingLocation",
-    "PatientFindingMorphology",
-    "PatientFindingIntervention"
-]

endoreg_db/models/patient/patient_examination.py

@@ -1,182 +0,0 @@
-from django.db import models
-from typing import List
-
-# Serializer located in serializers/examination.py
-from typing import Optional
-from datetime import datetime
-
-
-class PatientExamination(models.Model):
-    patient = models.ForeignKey(
-        "Patient", on_delete=models.CASCADE, related_name="patient_examinations"
-    )
-    examination = models.ForeignKey(
-        "Examination", on_delete=models.CASCADE, null=True, blank=True
-    )
-    video = models.OneToOneField(
-        "Video",
-        on_delete=models.CASCADE,
-        null=True,
-        blank=True,
-        related_name="patient_examination",
-    )
-    date_start = models.DateField(null=True, blank=True)
-    date_end = models.DateField(null=True, blank=True)
-    hash = models.CharField(max_length=255, unique=True)
-
-    # report_files
-    class Meta:
-        verbose_name = "Patient Examination"
-        verbose_name_plural = "Patient Examinations"
-        ordering = ["patient", "examination", "date_start"]
-
-    @classmethod
-    def get_or_create_pseudo_patient_examination_by_hash(
-        cls,
-        patient_hash: str,
-        examination_hash: str,
-        examination_name: Optional[str] = None,
-    ):
-        from endoreg_db.models import Patient, Examination
-
-        created = False
-
-        if PatientExamination.objects.filter(
-            patient__patient_hash=patient_hash, hash=examination_hash
-        ).exists():
-            return PatientExamination.objects.get(
-                patient__patient_hash=patient_hash, hash=examination_hash
-            ), created
-
-        patient, created = Patient.get_or_create_pseudo_patient_by_hash(patient_hash)
-        if examination_name is not None:
-            examination = Examination.objects.get(name=examination_name)
-        else:
-            examination = None
-
-        patient_examination = cls.objects.create(
-            patient=patient, examination=examination, hash=examination_hash
-        )
-
-        patient_examination.save()
-
-        created = True
-        return patient_examination, created
-
-    def __str__(self):
-        return f"{self.patient} - {self.examination} - {self.date_start}"
-
-    # override save method to make sure that the hash is always set,
-    # if none is existing generate an unique string
-
-    def generate_default_hash(self):
-        # create random hash
-        import random
-        import string
-
-        _hash = "DEFAULT_HASH_" + "".join(
-            random.choices(string.ascii_uppercase + string.digits, k=10)
-        )
-
-        return _hash
-
-    def save(self, *args, **kwargs):
-        if not self.hash:
-            self.hash = self.generate_default_hash()
-        super().save(*args, **kwargs)
-
-    def get_patient_age_at_examination(self) -> int:
-        """
-        Returns the patient's age at the time of the examination.
-        """
-        from endoreg_db.models import Patient
-        from datetime import datetime
-
-        patient: Patient = self.patient
-        dob = patient.get_dob()
-        date_start = self.date_start
-        return (date_start - dob).days // 365
-
-    def get_available_findings(self):
-        """
-        Returns all findings that are associated with the examination of this patient examination.
-        """
-        from endoreg_db.models import Finding, Examination
-
-        examination: Examination = self.examination
-        findings: List[Finding] = [_ for _ in examination.get_available_findings()]
-        return findings
-
-    def get_findings(self):
-        """
-        Returns all findings that are associated with this patient examination.
-        """
-        from endoreg_db.models import PatientFinding
-
-        patient_findings: List[PatientFinding] = [
-            _ for _ in self.patient_findings.all()
-        ]
-        return patient_findings
-
-    def get_indications(self):
-        """
-        Returns all indications that are associated with this patient examination.
-        """
-        from endoreg_db.models import PatientExaminationIndication
-
-        indications: List[PatientExaminationIndication] = [
-            _ for _ in self.indications.all()
-        ]
-        return indications
-
-    def get_indication_choices(self):
-        """
-        Returns all indication choices that are associated with this patient examination.
-        """
-        from endoreg_db.models import ExaminationIndicationClassificationChoice
-
-        choices: List[ExaminationIndicationClassificationChoice] = [
-            _.indication_choice for _ in self.get_indications()
-        ]
-        return choices
-
-    def create_finding(self, finding):
-        """
-        Adds a finding to this patient examination.
-        """
-        from endoreg_db.models import Finding, Examination, PatientFinding
-
-        examination: Examination = self.examination
-        assert examination
-
-        finding: Finding
-
-        patient_finding = PatientFinding.objects.create(
-            patient_examination=self, finding=finding
-        )
-
-        patient_finding.save()
-
-        return patient_finding
-
-    def find_matching_video_from_patient(self):
-        """
-        Finds a video for this patient examination based on the patient's videos.
-        For this, the videos date must be the same as the report file's date.
-        #TODO add more criteria for matching: Examination type
-        """
-        videos = self.patient.video_set.filter(
-            date=self.report_file.date, patient_examination__isnull=True
-        )
-        if videos:
-            if len(videos) > 1:
-                print(
-                    f"Warning: Found more than one video for patient {self.patient} on date {self.report_file.date}. Choosing the first one."
-                )
-            return videos[0]
-        else:
-            videos = self.patient.video_set.filter(patient_examination__isnull=True)
-            if len(videos) == 1:
-                return videos[0]
-
-        return None

endoreg_db/models/patient/patient_finding.py

@@ -1,143 +0,0 @@
-from django.db import models
-from typing import List
-
-class PatientFinding(models.Model):
-    patient_examination = models.ForeignKey('PatientExamination', on_delete=models.CASCADE, related_name='patient_findings')
-    finding = models.ForeignKey('Finding', on_delete=models.CASCADE, related_name='patient_findings')
-    locations = models.ManyToManyField(
-        'PatientFindingLocation',
-        blank=True,
-        related_name='patient_findings'
-    )
-    morphologies = models.ManyToManyField(
-        'PatientFindingMorphology',
-        blank=True,
-        related_name='patient_findings'
-    )
-    
-
-    class Meta:
-        verbose_name = 'Patient Finding'
-        verbose_name_plural = 'Patient Findings'
-        ordering = ['patient_examination', 'finding']
-
-    def __str__(self):
-        return f"{self.patient_examination} - {self.finding}"
-
-   # functions to get all associated location and morphology choices
-    def get_locations(self):
-        """
-        Returns all location choices that are associated with this patient finding.
-        """
-        from endoreg_db.models import PatientFindingLocation
-        locations:List[PatientFindingLocation] = [_ for _ in self.locations.all()]
-        return locations
-    
-    def get_morphologies(self):
-        """
-        Returns all morphology choices that are associated with this patient finding.
-        """
-        from endoreg_db.models import PatientFindingMorphology
-        morphologies:List[PatientFindingMorphology] = [_ for _ in self.morphologies.all()]
-        return morphologies   
-
-    def add_morphology_choice(self, morphology_choice, morphology_classification):
-        """
-        Adds a morphology choice to this patient finding morphology.
-        """
-        from endoreg_db.models import (
-            FindingMorphologyClassificationChoice,
-            FindingMorphologyClassification,
-            PatientFindingMorphology
-        )
-        morphology_choice: FindingMorphologyClassificationChoice
-        morphology_classification: FindingMorphologyClassification
-        
-        patient_finding_morphology = PatientFindingMorphology.objects.create(
-            morphology_classification=morphology_classification,
-            morphology_choice=morphology_choice
-        )
-        patient_finding_morphology.save()
-
-        self.morphologies.add(patient_finding_morphology)
-        self.save()
-
-        return patient_finding_morphology
-
-    def add_intervention(self, intervention, state="pending", date=None):
-        """
-        Adds an intervention to this patient finding.
-        """
-        from endoreg_db.models import PatientFindingIntervention
-        patient_finding_intervention = PatientFindingIntervention.objects.create(
-            patient_finding=self,
-            intervention=intervention,
-            state = state,
-            date = date
-        )
-        patient_finding_intervention.save()
-
-        return patient_finding_intervention
-
-    def add_location_choice(self, location_choice, location_classification):
-        """
-        Adds a location choice to this patient finding location.
-        """
-        from endoreg_db.models import (
-            FindingLocationClassificationChoice,
-            FindingLocationClassification,
-            PatientFindingLocation
-        )
-        location_choice: FindingLocationClassificationChoice
-        location_classification: FindingLocationClassification
-        
-        patient_finding_location = PatientFindingLocation.objects.create(
-            location_classification=location_classification,
-            location_choice=location_choice
-        )
-        patient_finding_location.save()
-
-        self.locations.add(patient_finding_location)
-        self.save()
-
-        return patient_finding_location
-
-    def get_interventions(self):
-        """
-        Returns all interventions that are associated with this patient finding.
-        """
-        from endoreg_db.models import PatientFindingIntervention
-        interventions:List[PatientFindingIntervention] = [_ for _ in self.interventions.all()]
-        return interventions
-
-    def set_random_location(
-            self, location_classification
-        ):
-        """
-        Sets a random location for this finding based on the location classification.
-        """
-        from endoreg_db.models import (
-            FindingLocationClassificationChoice,
-            FindingLocationClassification, 
-            PatientFindingLocation
-        )
-        import random
-        from typing import List
-        location_classification:FindingLocationClassification
-
-        # assert location_classification in self.finding.location_classifications.all()
-
-        location_choices:List[FindingLocationClassificationChoice] = location_classification.choices.all()
-        location_choice = random.choice(location_choices)
-
-        patient_finding_location = PatientFindingLocation.objects.create(
-            location_classification=location_classification,
-            location_choice=location_choice
-        )
-
-        self.locations.add(patient_finding_location)
-        self.save()
-
-        return patient_finding_location
-    
-