1310 lines
37 KiB
Python
1310 lines
37 KiB
Python
"""
|
|
Core models for the Tenhal Multidisciplinary Healthcare Platform.
|
|
|
|
This module contains the base models and mixins used throughout the application,
|
|
as well as core entities like User, Patient, Tenant, File, Consent, etc.
|
|
"""
|
|
|
|
import uuid
|
|
from django.contrib.auth.models import AbstractUser
|
|
from django.contrib.contenttypes.fields import GenericForeignKey
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.db import models
|
|
from django.utils.translation import gettext_lazy as _
|
|
from phonenumber_field.modelfields import PhoneNumberField
|
|
from simple_history.models import HistoricalRecords
|
|
|
|
|
|
# ============================================================================
|
|
# BASE MIXINS
|
|
# ============================================================================
|
|
|
|
class UUIDPrimaryKeyMixin(models.Model):
|
|
"""Mixin to use UUID as primary key for all models."""
|
|
|
|
id = models.UUIDField(
|
|
primary_key=True,
|
|
default=uuid.uuid4,
|
|
editable=False,
|
|
verbose_name=_("ID")
|
|
)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
|
|
class TimeStampedMixin(models.Model):
|
|
"""Mixin to add created_at and updated_at timestamps."""
|
|
|
|
created_at = models.DateTimeField(
|
|
auto_now_add=True,
|
|
verbose_name=_("Created At")
|
|
)
|
|
updated_at = models.DateTimeField(
|
|
auto_now=True,
|
|
verbose_name=_("Updated At")
|
|
)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
|
|
class TenantOwnedMixin(models.Model):
|
|
"""Mixin for models that belong to a tenant."""
|
|
|
|
tenant = models.ForeignKey(
|
|
'core.Tenant',
|
|
on_delete=models.CASCADE,
|
|
related_name='%(app_label)s_%(class)s_related',
|
|
verbose_name=_("Tenant")
|
|
)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
|
|
class ClinicallySignableMixin(models.Model):
|
|
"""Mixin for clinical documents that can be signed."""
|
|
|
|
signed_by = models.ForeignKey(
|
|
'core.User',
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name='%(app_label)s_%(class)s_signed',
|
|
verbose_name=_("Signed By")
|
|
)
|
|
signed_at = models.DateTimeField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Signed At")
|
|
)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
|
|
class SoftDeleteMixin(models.Model):
|
|
"""Mixin for soft delete functionality."""
|
|
|
|
is_deleted = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_("Is Deleted")
|
|
)
|
|
deleted_at = models.DateTimeField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Deleted At")
|
|
)
|
|
deleted_by = models.ForeignKey(
|
|
'User',
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name='deleted_%(class)s_set',
|
|
verbose_name=_("Deleted By")
|
|
)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
|
|
# ============================================================================
|
|
# CORE MODELS
|
|
# ============================================================================
|
|
|
|
class Tenant(UUIDPrimaryKeyMixin, TimeStampedMixin):
|
|
"""
|
|
Tenant model for multi-tenancy support.
|
|
Each clinic/organization is a tenant.
|
|
"""
|
|
|
|
name = models.CharField(
|
|
max_length=200,
|
|
verbose_name=_("Name")
|
|
)
|
|
name_ar = models.CharField(
|
|
max_length=200,
|
|
blank=True,
|
|
verbose_name=_("Name (Arabic)")
|
|
)
|
|
code = models.CharField(
|
|
max_length=50,
|
|
unique=True,
|
|
verbose_name=_("Code")
|
|
)
|
|
|
|
# ZATCA E-Invoice Required Fields
|
|
vat_number = models.CharField(
|
|
max_length=15,
|
|
unique=True,
|
|
blank=True,
|
|
verbose_name=_("VAT Registration Number"),
|
|
help_text=_("15 digits, must start and end with 3 (e.g., 300000000000003)")
|
|
)
|
|
|
|
# Address Information (for ZATCA invoices)
|
|
address = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Address")
|
|
)
|
|
city = models.CharField(
|
|
max_length=100,
|
|
default='Riyadh',
|
|
verbose_name=_("City")
|
|
)
|
|
postal_code = models.CharField(
|
|
max_length=20,
|
|
default='12345',
|
|
verbose_name=_("Postal Code")
|
|
)
|
|
country_code = models.CharField(
|
|
max_length=2,
|
|
default='SA',
|
|
verbose_name=_("Country Code")
|
|
)
|
|
|
|
is_active = models.BooleanField(
|
|
default=True,
|
|
verbose_name=_("Is Active")
|
|
)
|
|
settings = models.JSONField(
|
|
default=dict,
|
|
blank=True,
|
|
verbose_name=_("Settings")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Tenant")
|
|
verbose_name_plural = _("Tenants")
|
|
ordering = ['name']
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
class User(AbstractUser, UUIDPrimaryKeyMixin):
|
|
"""
|
|
Custom User model extending Django's AbstractUser.
|
|
Supports role-based access control and user profiles.
|
|
"""
|
|
|
|
class Role(models.TextChoices):
|
|
ADMIN = 'ADMIN', _('Administrator')
|
|
DOCTOR = 'DOCTOR', _('Doctor')
|
|
NURSE = 'NURSE', _('Nurse')
|
|
OT = 'OT', _('Occupational Therapist')
|
|
SLP = 'SLP', _('Speech-Language Pathologist')
|
|
ABA = 'ABA', _('ABA Therapist')
|
|
FRONT_DESK = 'FRONT_DESK', _('Front Desk')
|
|
FINANCE = 'FINANCE', _('Finance')
|
|
|
|
tenant = models.ForeignKey(
|
|
Tenant,
|
|
on_delete=models.CASCADE,
|
|
related_name='users',
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Tenant")
|
|
)
|
|
role = models.CharField(
|
|
max_length=20,
|
|
choices=Role.choices,
|
|
default=Role.FRONT_DESK,
|
|
verbose_name=_("Role")
|
|
)
|
|
phone_number = PhoneNumberField(
|
|
blank=True,
|
|
verbose_name=_("Phone Number")
|
|
)
|
|
employee_id = models.CharField(
|
|
max_length=50,
|
|
blank=True,
|
|
verbose_name=_("Employee ID")
|
|
)
|
|
|
|
# Profile fields
|
|
profile_picture = models.ImageField(
|
|
upload_to='profile_pictures/',
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Profile Picture")
|
|
)
|
|
bio = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Bio"),
|
|
help_text=_("Brief description about yourself")
|
|
)
|
|
preferences = models.JSONField(
|
|
default=dict,
|
|
blank=True,
|
|
verbose_name=_("Preferences"),
|
|
help_text=_("User preferences (language, notifications, etc.)")
|
|
)
|
|
email_verified = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_("Email Verified")
|
|
)
|
|
last_login_ip = models.GenericIPAddressField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Last Login IP")
|
|
)
|
|
timezone = models.CharField(
|
|
max_length=50,
|
|
default='Asia/Riyadh',
|
|
verbose_name=_("Timezone")
|
|
)
|
|
|
|
history = HistoricalRecords()
|
|
|
|
class Meta:
|
|
verbose_name = _("User")
|
|
verbose_name_plural = _("Users")
|
|
ordering = ['last_name', 'first_name']
|
|
|
|
def __str__(self):
|
|
return f"{self.get_full_name()} ({self.get_role_display()})"
|
|
|
|
def get_profile_completion(self):
|
|
"""Calculate profile completion percentage."""
|
|
fields = [
|
|
self.first_name,
|
|
self.last_name,
|
|
self.email,
|
|
self.phone_number,
|
|
self.employee_id,
|
|
self.profile_picture,
|
|
self.bio,
|
|
]
|
|
completed = sum(1 for field in fields if field)
|
|
return int((completed / len(fields)) * 100)
|
|
|
|
def get_initials(self):
|
|
"""Get user initials for avatar."""
|
|
if self.first_name and self.last_name:
|
|
return f"{self.first_name[0]}{self.last_name[0]}".upper()
|
|
elif self.first_name:
|
|
return self.first_name[0].upper()
|
|
elif self.username:
|
|
return self.username[0].upper()
|
|
return "U"
|
|
|
|
|
|
class Patient(UUIDPrimaryKeyMixin, TimeStampedMixin, TenantOwnedMixin):
|
|
"""
|
|
Patient model storing demographic and contact information.
|
|
"""
|
|
|
|
class Sex(models.TextChoices):
|
|
MALE = 'M', _('Male')
|
|
FEMALE = 'F', _('Female')
|
|
|
|
# Medical Record Number (auto-generated)
|
|
mrn = models.CharField(
|
|
max_length=20,
|
|
unique=True,
|
|
editable=False,
|
|
verbose_name=_("MRN")
|
|
)
|
|
|
|
# Identification
|
|
national_id = models.CharField(
|
|
max_length=20,
|
|
blank=True,
|
|
verbose_name=_("National ID")
|
|
)
|
|
|
|
# Names (bilingual)
|
|
first_name_en = models.CharField(
|
|
max_length=100,
|
|
verbose_name=_("First Name (English)")
|
|
)
|
|
father_name_en = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("Father Name (English)")
|
|
)
|
|
grandfather_name_en = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("Grandfather Name (English)")
|
|
)
|
|
last_name_en = models.CharField(
|
|
max_length=100,
|
|
verbose_name=_("Last Name (English)")
|
|
)
|
|
first_name_ar = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("First Name (Arabic)")
|
|
)
|
|
father_name_ar = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("Father Name (Arabic)")
|
|
)
|
|
grandfather_name_ar = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("Grandfather Name (Arabic)")
|
|
)
|
|
last_name_ar = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("Last Name (Arabic)")
|
|
)
|
|
|
|
# Demographics
|
|
date_of_birth = models.DateField(
|
|
verbose_name=_("Date of Birth")
|
|
)
|
|
sex = models.CharField(
|
|
max_length=1,
|
|
choices=Sex.choices,
|
|
verbose_name=_("Sex")
|
|
)
|
|
|
|
# Contact Information
|
|
phone = PhoneNumberField(
|
|
blank=True,
|
|
verbose_name=_("Phone Number")
|
|
)
|
|
email = models.EmailField(
|
|
blank=True,
|
|
verbose_name=_("Email")
|
|
)
|
|
|
|
# Caregiver Information
|
|
caregiver_name = models.CharField(
|
|
max_length=200,
|
|
blank=True,
|
|
verbose_name=_("Caregiver Name")
|
|
)
|
|
caregiver_phone = PhoneNumberField(
|
|
blank=True,
|
|
verbose_name=_("Caregiver Phone")
|
|
)
|
|
caregiver_relationship = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("Caregiver Relationship")
|
|
)
|
|
|
|
# Address
|
|
address = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Address")
|
|
)
|
|
city = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("City")
|
|
)
|
|
postal_code = models.CharField(
|
|
max_length=20,
|
|
blank=True,
|
|
verbose_name=_("Postal Code")
|
|
)
|
|
|
|
# Emergency Contact
|
|
emergency_contact = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Emergency Contact")
|
|
)
|
|
|
|
history = HistoricalRecords()
|
|
|
|
class Meta:
|
|
verbose_name = _("Patient")
|
|
verbose_name_plural = _("Patients")
|
|
ordering = ['-created_at']
|
|
indexes = [
|
|
models.Index(fields=['mrn']),
|
|
models.Index(fields=['national_id']),
|
|
models.Index(fields=['tenant', 'created_at']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"{self.first_name_en} {self.last_name_en} ({self.mrn})"
|
|
|
|
@property
|
|
def full_name_en(self):
|
|
"""Full name in English with father and grandfather names."""
|
|
parts = [self.first_name_en]
|
|
if self.father_name_en:
|
|
parts.append(self.father_name_en)
|
|
if self.grandfather_name_en:
|
|
parts.append(self.grandfather_name_en)
|
|
parts.append(self.last_name_en)
|
|
return " ".join(parts)
|
|
|
|
@property
|
|
def full_name_ar(self):
|
|
"""Full name in Arabic with father and grandfather names."""
|
|
if not self.first_name_ar or not self.last_name_ar:
|
|
return ""
|
|
parts = [self.first_name_ar]
|
|
if self.father_name_ar:
|
|
parts.append(self.father_name_ar)
|
|
if self.grandfather_name_ar:
|
|
parts.append(self.grandfather_name_ar)
|
|
parts.append(self.last_name_ar)
|
|
return " ".join(parts)
|
|
|
|
@property
|
|
def age(self):
|
|
from datetime import date
|
|
today = date.today()
|
|
return today.year - self.date_of_birth.year - (
|
|
(today.month, today.day) < (self.date_of_birth.month, self.date_of_birth.day)
|
|
)
|
|
|
|
|
|
class Clinic(UUIDPrimaryKeyMixin, TimeStampedMixin, TenantOwnedMixin):
|
|
"""
|
|
Clinic/Department model representing different specialties.
|
|
"""
|
|
|
|
class Specialty(models.TextChoices):
|
|
MEDICAL = 'MEDICAL', _('Medical')
|
|
NURSING = 'NURSING', _('Nursing')
|
|
ABA = 'ABA', _('ABA Therapy')
|
|
OT = 'OT', _('Occupational Therapy')
|
|
SLP = 'SLP', _('Speech-Language Pathology')
|
|
|
|
name_en = models.CharField(
|
|
max_length=200,
|
|
verbose_name=_("Name (English)")
|
|
)
|
|
name_ar = models.CharField(
|
|
max_length=200,
|
|
blank=True,
|
|
verbose_name=_("Name (Arabic)")
|
|
)
|
|
specialty = models.CharField(
|
|
max_length=20,
|
|
choices=Specialty.choices,
|
|
verbose_name=_("Specialty")
|
|
)
|
|
code = models.CharField(
|
|
max_length=50,
|
|
verbose_name=_("Code")
|
|
)
|
|
is_active = models.BooleanField(
|
|
default=True,
|
|
verbose_name=_("Is Active")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Clinic")
|
|
verbose_name_plural = _("Clinics")
|
|
ordering = ['name_en']
|
|
unique_together = [['tenant', 'code']]
|
|
|
|
def __str__(self):
|
|
return f"{self.name_en} ({self.get_specialty_display()})"
|
|
|
|
|
|
class File(UUIDPrimaryKeyMixin, TimeStampedMixin, TenantOwnedMixin):
|
|
"""
|
|
Main patient file (medical record).
|
|
Auto-created when a patient is registered.
|
|
"""
|
|
|
|
class Status(models.TextChoices):
|
|
ACTIVE = 'ACTIVE', _('Active')
|
|
CLOSED = 'CLOSED', _('Closed')
|
|
ARCHIVED = 'ARCHIVED', _('Archived')
|
|
|
|
file_number = models.CharField(
|
|
max_length=20,
|
|
unique=True,
|
|
editable=False,
|
|
verbose_name=_("File Number")
|
|
)
|
|
patient = models.OneToOneField(
|
|
Patient,
|
|
on_delete=models.CASCADE,
|
|
related_name='file',
|
|
verbose_name=_("Patient")
|
|
)
|
|
opened_date = models.DateField(
|
|
auto_now_add=True,
|
|
verbose_name=_("Opened Date")
|
|
)
|
|
status = models.CharField(
|
|
max_length=20,
|
|
choices=Status.choices,
|
|
default=Status.ACTIVE,
|
|
verbose_name=_("Status")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("File")
|
|
verbose_name_plural = _("Files")
|
|
ordering = ['-opened_date']
|
|
indexes = [
|
|
models.Index(fields=['file_number']),
|
|
models.Index(fields=['patient']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"File #{self.file_number} - {self.patient}"
|
|
|
|
|
|
class SubFile(UUIDPrimaryKeyMixin, TimeStampedMixin):
|
|
"""
|
|
Sub-file per clinic/specialty.
|
|
Created when patient first visits a specific clinic.
|
|
"""
|
|
|
|
class Status(models.TextChoices):
|
|
ACTIVE = 'ACTIVE', _('Active')
|
|
CLOSED = 'CLOSED', _('Closed')
|
|
|
|
file = models.ForeignKey(
|
|
File,
|
|
on_delete=models.CASCADE,
|
|
related_name='subfiles',
|
|
verbose_name=_("File")
|
|
)
|
|
clinic = models.ForeignKey(
|
|
Clinic,
|
|
on_delete=models.CASCADE,
|
|
related_name='subfiles',
|
|
verbose_name=_("Clinic")
|
|
)
|
|
sub_file_number = models.CharField(
|
|
max_length=20,
|
|
verbose_name=_("Sub-File Number")
|
|
)
|
|
opened_date = models.DateField(
|
|
auto_now_add=True,
|
|
verbose_name=_("Opened Date")
|
|
)
|
|
status = models.CharField(
|
|
max_length=20,
|
|
choices=Status.choices,
|
|
default=Status.ACTIVE,
|
|
verbose_name=_("Status")
|
|
)
|
|
assigned_provider = models.ForeignKey(
|
|
User,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name='assigned_subfiles',
|
|
verbose_name=_("Assigned Provider")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Sub-File")
|
|
verbose_name_plural = _("Sub-Files")
|
|
ordering = ['-opened_date']
|
|
unique_together = [['file', 'clinic']]
|
|
|
|
def __str__(self):
|
|
return f"SubFile #{self.sub_file_number} - {self.clinic.name_en}"
|
|
|
|
|
|
class ConsentTemplate(UUIDPrimaryKeyMixin, TimeStampedMixin, TenantOwnedMixin):
|
|
"""
|
|
Predefined consent text templates for different consent types.
|
|
"""
|
|
|
|
class ConsentType(models.TextChoices):
|
|
GENERAL_TREATMENT = 'GENERAL_TREATMENT', _('General Treatment')
|
|
SERVICE_SPECIFIC = 'SERVICE_SPECIFIC', _('Service Specific')
|
|
PHOTO_VIDEO = 'PHOTO_VIDEO', _('Photo/Video')
|
|
DATA_SHARING = 'DATA_SHARING', _('Data Sharing')
|
|
|
|
consent_type = models.CharField(
|
|
max_length=30,
|
|
choices=ConsentType.choices,
|
|
verbose_name=_("Consent Type")
|
|
)
|
|
title_en = models.CharField(
|
|
max_length=200,
|
|
verbose_name=_("Title (English)")
|
|
)
|
|
title_ar = models.CharField(
|
|
max_length=200,
|
|
blank=True,
|
|
verbose_name=_("Title (Arabic)")
|
|
)
|
|
content_en = models.TextField(
|
|
verbose_name=_("Content (English)"),
|
|
help_text=_("Consent text in English. Use {patient_name}, {patient_mrn}, {date} as placeholders.")
|
|
)
|
|
content_ar = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Content (Arabic)"),
|
|
help_text=_("Consent text in Arabic. Use {patient_name}, {patient_mrn}, {date} as placeholders.")
|
|
)
|
|
is_active = models.BooleanField(
|
|
default=True,
|
|
verbose_name=_("Is Active")
|
|
)
|
|
version = models.PositiveIntegerField(
|
|
default=1,
|
|
verbose_name=_("Version")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Consent Template")
|
|
verbose_name_plural = _("Consent Templates")
|
|
ordering = ['consent_type', '-version']
|
|
unique_together = [['tenant', 'consent_type', 'version']]
|
|
|
|
def __str__(self):
|
|
return f"{self.get_consent_type_display()} - v{self.version}"
|
|
|
|
def get_populated_content(self, patient, language='en'):
|
|
"""
|
|
Populate template with patient data.
|
|
|
|
Args:
|
|
patient: Patient instance
|
|
language: 'en' or 'ar'
|
|
|
|
Returns:
|
|
Populated consent text
|
|
"""
|
|
from django.utils import timezone
|
|
|
|
content = self.content_en if language == 'en' else self.content_ar
|
|
if not content:
|
|
content = self.content_en # Fallback to English
|
|
|
|
# Prepare replacement values
|
|
replacements = {
|
|
'{patient_name}': patient.full_name_en if language == 'en' else patient.full_name_ar or patient.full_name_en,
|
|
'{patient_mrn}': patient.mrn,
|
|
'{date}': timezone.now().strftime('%Y-%m-%d'),
|
|
'{patient_dob}': patient.date_of_birth.strftime('%Y-%m-%d'),
|
|
'{patient_age}': str(patient.age),
|
|
}
|
|
|
|
# Replace placeholders
|
|
for placeholder, value in replacements.items():
|
|
content = content.replace(placeholder, value)
|
|
|
|
return content
|
|
|
|
|
|
class Consent(UUIDPrimaryKeyMixin, TimeStampedMixin, TenantOwnedMixin):
|
|
"""
|
|
Consent forms with e-signature support.
|
|
"""
|
|
|
|
class ConsentType(models.TextChoices):
|
|
GENERAL_TREATMENT = 'GENERAL_TREATMENT', _('General Treatment')
|
|
SERVICE_SPECIFIC = 'SERVICE_SPECIFIC', _('Service Specific')
|
|
PHOTO_VIDEO = 'PHOTO_VIDEO', _('Photo/Video')
|
|
DATA_SHARING = 'DATA_SHARING', _('Data Sharing')
|
|
|
|
class SignatureMethod(models.TextChoices):
|
|
DRAWN = 'DRAWN', _('Drawn')
|
|
TYPED = 'TYPED', _('Typed')
|
|
UPLOADED = 'UPLOADED', _('Uploaded')
|
|
EXTERNAL = 'EXTERNAL', _('External Provider')
|
|
|
|
patient = models.ForeignKey(
|
|
Patient,
|
|
on_delete=models.CASCADE,
|
|
related_name='consents',
|
|
verbose_name=_("Patient")
|
|
)
|
|
consent_type = models.CharField(
|
|
max_length=30,
|
|
choices=ConsentType.choices,
|
|
verbose_name=_("Consent Type")
|
|
)
|
|
content_text = models.TextField(
|
|
verbose_name=_("Content Text")
|
|
)
|
|
|
|
# Signature Information
|
|
signed_by_name = models.CharField(
|
|
max_length=200,
|
|
blank=True,
|
|
verbose_name=_("Signed By Name")
|
|
)
|
|
signed_by_relationship = models.CharField(
|
|
max_length=100,
|
|
blank=True,
|
|
verbose_name=_("Relationship to Patient")
|
|
)
|
|
signed_at = models.DateTimeField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Signed At")
|
|
)
|
|
signature_method = models.CharField(
|
|
max_length=20,
|
|
choices=SignatureMethod.choices,
|
|
blank=True,
|
|
verbose_name=_("Signature Method")
|
|
)
|
|
signature_image = models.ImageField(
|
|
upload_to='consents/signatures/',
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Signature Image")
|
|
)
|
|
signature_hash = models.CharField(
|
|
max_length=64,
|
|
blank=True,
|
|
verbose_name=_("Signature Hash")
|
|
)
|
|
signed_ip = models.GenericIPAddressField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Signed IP Address")
|
|
)
|
|
signed_user_agent = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Signed User Agent")
|
|
)
|
|
|
|
# Version Control
|
|
version = models.PositiveIntegerField(
|
|
default=1,
|
|
verbose_name=_("Version")
|
|
)
|
|
is_active = models.BooleanField(
|
|
default=True,
|
|
verbose_name=_("Is Active")
|
|
)
|
|
|
|
# Expiry Management
|
|
expiry_date = models.DateField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Expiry Date"),
|
|
help_text=_("Date when this consent expires and needs renewal")
|
|
)
|
|
|
|
history = HistoricalRecords()
|
|
|
|
class Meta:
|
|
verbose_name = _("Consent")
|
|
verbose_name_plural = _("Consents")
|
|
ordering = ['-created_at']
|
|
indexes = [
|
|
models.Index(fields=['patient', 'consent_type']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"{self.get_consent_type_display()} - {self.patient}"
|
|
|
|
@property
|
|
def is_expired(self):
|
|
"""Check if consent has expired."""
|
|
if not self.expiry_date:
|
|
return False
|
|
from datetime import date
|
|
return date.today() > self.expiry_date
|
|
|
|
@property
|
|
def days_until_expiry(self):
|
|
"""Calculate days until consent expires."""
|
|
if not self.expiry_date:
|
|
return None
|
|
from datetime import date
|
|
delta = self.expiry_date - date.today()
|
|
return delta.days
|
|
|
|
@property
|
|
def needs_renewal(self):
|
|
"""Check if consent needs renewal (within 30 days of expiry or expired)."""
|
|
if not self.expiry_date:
|
|
return False
|
|
days = self.days_until_expiry
|
|
return days is not None and days <= 30
|
|
|
|
|
|
class ConsentToken(UUIDPrimaryKeyMixin, TimeStampedMixin):
|
|
"""
|
|
Secure token for email-based consent signing.
|
|
|
|
Allows parents/guardians to sign consent without logging in.
|
|
"""
|
|
|
|
consent = models.ForeignKey(
|
|
'Consent',
|
|
on_delete=models.CASCADE,
|
|
related_name='tokens',
|
|
verbose_name=_("Consent")
|
|
)
|
|
token = models.CharField(
|
|
max_length=64,
|
|
unique=True,
|
|
verbose_name=_("Token"),
|
|
help_text=_("Secure token for accessing consent form")
|
|
)
|
|
email = models.EmailField(
|
|
verbose_name=_("Email Address"),
|
|
help_text=_("Email address where consent link was sent")
|
|
)
|
|
expires_at = models.DateTimeField(
|
|
verbose_name=_("Expires At"),
|
|
help_text=_("Token expiration date/time")
|
|
)
|
|
used_at = models.DateTimeField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Used At"),
|
|
help_text=_("When the token was used to sign consent")
|
|
)
|
|
is_active = models.BooleanField(
|
|
default=True,
|
|
verbose_name=_("Is Active")
|
|
)
|
|
sent_by = models.ForeignKey(
|
|
'User',
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
related_name='sent_consent_tokens',
|
|
verbose_name=_("Sent By")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Consent Token")
|
|
verbose_name_plural = _("Consent Tokens")
|
|
ordering = ['-created_at']
|
|
indexes = [
|
|
models.Index(fields=['token']),
|
|
models.Index(fields=['email']),
|
|
models.Index(fields=['expires_at']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"Token for {self.consent} - {self.email}"
|
|
|
|
def is_valid(self):
|
|
"""Check if token is still valid."""
|
|
from django.utils import timezone
|
|
return (
|
|
self.is_active and
|
|
not self.used_at and
|
|
self.expires_at > timezone.now()
|
|
)
|
|
|
|
def mark_as_used(self):
|
|
"""Mark token as used."""
|
|
from django.utils import timezone
|
|
self.used_at = timezone.now()
|
|
self.is_active = False
|
|
self.save()
|
|
|
|
@staticmethod
|
|
def generate_token():
|
|
"""Generate a secure random token."""
|
|
import secrets
|
|
return secrets.token_urlsafe(48)
|
|
|
|
|
|
class Attachment(UUIDPrimaryKeyMixin, TimeStampedMixin, TenantOwnedMixin):
|
|
"""
|
|
Generic attachment model for any document.
|
|
Uses GenericForeignKey to attach to any model.
|
|
"""
|
|
|
|
class FileType(models.TextChoices):
|
|
PDF = 'PDF', _('PDF')
|
|
IMAGE = 'IMAGE', _('Image')
|
|
DOCUMENT = 'DOCUMENT', _('Document')
|
|
OTHER = 'OTHER', _('Other')
|
|
|
|
# Generic Foreign Key
|
|
content_type = models.ForeignKey(
|
|
ContentType,
|
|
on_delete=models.CASCADE,
|
|
verbose_name=_("Content Type")
|
|
)
|
|
object_id = models.UUIDField(
|
|
verbose_name=_("Object ID")
|
|
)
|
|
content_object = GenericForeignKey('content_type', 'object_id')
|
|
|
|
file = models.FileField(
|
|
upload_to='attachments/%Y/%m/%d/',
|
|
verbose_name=_("File")
|
|
)
|
|
file_type = models.CharField(
|
|
max_length=20,
|
|
choices=FileType.choices,
|
|
verbose_name=_("File Type")
|
|
)
|
|
description = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Description")
|
|
)
|
|
uploaded_by = models.ForeignKey(
|
|
User,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
related_name='uploaded_attachments',
|
|
verbose_name=_("Uploaded By")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Attachment")
|
|
verbose_name_plural = _("Attachments")
|
|
ordering = ['-created_at']
|
|
indexes = [
|
|
models.Index(fields=['content_type', 'object_id']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"{self.file.name} ({self.get_file_type_display()})"
|
|
|
|
|
|
class AuditLog(UUIDPrimaryKeyMixin, TenantOwnedMixin):
|
|
"""
|
|
Audit log for tracking all actions in the system.
|
|
Complements simple_history for additional tracking.
|
|
"""
|
|
|
|
class Action(models.TextChoices):
|
|
CREATE = 'CREATE', _('Create')
|
|
UPDATE = 'UPDATE', _('Update')
|
|
DELETE = 'DELETE', _('Delete')
|
|
VIEW = 'VIEW', _('View')
|
|
EXPORT = 'EXPORT', _('Export')
|
|
PRINT = 'PRINT', _('Print')
|
|
|
|
# Generic Foreign Key
|
|
content_type = models.ForeignKey(
|
|
ContentType,
|
|
on_delete=models.CASCADE,
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Content Type")
|
|
)
|
|
object_id = models.UUIDField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Object ID")
|
|
)
|
|
content_object = GenericForeignKey('content_type', 'object_id')
|
|
|
|
action = models.CharField(
|
|
max_length=20,
|
|
choices=Action.choices,
|
|
verbose_name=_("Action")
|
|
)
|
|
user = models.ForeignKey(
|
|
User,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
related_name='audit_logs',
|
|
verbose_name=_("User")
|
|
)
|
|
timestamp = models.DateTimeField(
|
|
auto_now_add=True,
|
|
verbose_name=_("Timestamp")
|
|
)
|
|
changes = models.JSONField(
|
|
default=dict,
|
|
blank=True,
|
|
verbose_name=_("Changes")
|
|
)
|
|
ip_address = models.GenericIPAddressField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("IP Address")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Audit Log")
|
|
verbose_name_plural = _("Audit Logs")
|
|
ordering = ['-timestamp']
|
|
indexes = [
|
|
models.Index(fields=['content_type', 'object_id']),
|
|
models.Index(fields=['user', 'timestamp']),
|
|
models.Index(fields=['action', 'timestamp']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"{self.user} - {self.get_action_display()} - {self.timestamp}"
|
|
|
|
|
|
class SettingTemplate(UUIDPrimaryKeyMixin, TimeStampedMixin):
|
|
"""
|
|
Template defining available tenant settings with validation rules.
|
|
Defines the structure and constraints for tenant configuration.
|
|
"""
|
|
|
|
class Category(models.TextChoices):
|
|
BASIC = 'BASIC', _('Basic Information')
|
|
VAT = 'VAT', _('VAT Registration')
|
|
ADDRESS = 'ADDRESS', _('Address Information')
|
|
ZATCA = 'ZATCA', _('ZATCA E-Invoicing')
|
|
NPHIES = 'NPHIES', _('NPHIES Integration')
|
|
SMS = 'SMS', _('SMS/WhatsApp Integration')
|
|
LAB = 'LAB', _('Lab Integration')
|
|
RADIOLOGY = 'RADIOLOGY', _('Radiology Integration')
|
|
|
|
class DataType(models.TextChoices):
|
|
STRING = 'STRING', _('String')
|
|
INTEGER = 'INTEGER', _('Integer')
|
|
BOOLEAN = 'BOOLEAN', _('Boolean')
|
|
CHOICE = 'CHOICE', _('Choice')
|
|
FILE = 'FILE', _('File')
|
|
ENCRYPTED = 'ENCRYPTED', _('Encrypted')
|
|
TEXT = 'TEXT', _('Text (Multi-line)')
|
|
EMAIL = 'EMAIL', _('Email')
|
|
URL = 'URL', _('URL')
|
|
PHONE = 'PHONE', _('Phone Number')
|
|
COLOR = 'COLOR', _('Color')
|
|
|
|
key = models.CharField(
|
|
max_length=100,
|
|
unique=True,
|
|
verbose_name=_("Key"),
|
|
help_text=_("Unique identifier for this setting (e.g., 'basic_clinic_name_en')")
|
|
)
|
|
category = models.CharField(
|
|
max_length=20,
|
|
choices=Category.choices,
|
|
verbose_name=_("Category")
|
|
)
|
|
label_en = models.CharField(
|
|
max_length=200,
|
|
verbose_name=_("Label (English)")
|
|
)
|
|
label_ar = models.CharField(
|
|
max_length=200,
|
|
blank=True,
|
|
verbose_name=_("Label (Arabic)")
|
|
)
|
|
data_type = models.CharField(
|
|
max_length=20,
|
|
choices=DataType.choices,
|
|
verbose_name=_("Data Type")
|
|
)
|
|
is_required = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_("Is Required"),
|
|
help_text=_("Whether this setting must be provided")
|
|
)
|
|
default_value = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Default Value")
|
|
)
|
|
help_text_en = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Help Text (English)")
|
|
)
|
|
help_text_ar = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Help Text (Arabic)")
|
|
)
|
|
validation_regex = models.CharField(
|
|
max_length=500,
|
|
blank=True,
|
|
verbose_name=_("Validation Regex"),
|
|
help_text=_("Regular expression for validation (optional)")
|
|
)
|
|
choices = models.JSONField(
|
|
default=list,
|
|
blank=True,
|
|
verbose_name=_("Choices"),
|
|
help_text=_("List of choices for CHOICE data type (e.g., [{'value': 'opt1', 'label': 'Option 1'}])")
|
|
)
|
|
order = models.PositiveIntegerField(
|
|
default=0,
|
|
verbose_name=_("Display Order"),
|
|
help_text=_("Order in which this setting appears in the form")
|
|
)
|
|
is_active = models.BooleanField(
|
|
default=True,
|
|
verbose_name=_("Is Active")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Setting Template")
|
|
verbose_name_plural = _("Setting Templates")
|
|
ordering = ['category', 'order', 'label_en']
|
|
indexes = [
|
|
models.Index(fields=['category', 'order']),
|
|
models.Index(fields=['key']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"{self.get_category_display()} - {self.label_en}"
|
|
|
|
|
|
class TenantSetting(UUIDPrimaryKeyMixin, TimeStampedMixin):
|
|
"""
|
|
Actual setting values for each tenant.
|
|
Stores configuration based on SettingTemplate definitions.
|
|
"""
|
|
|
|
tenant = models.ForeignKey(
|
|
Tenant,
|
|
on_delete=models.CASCADE,
|
|
related_name='tenant_settings',
|
|
verbose_name=_("Tenant")
|
|
)
|
|
template = models.ForeignKey(
|
|
SettingTemplate,
|
|
on_delete=models.CASCADE,
|
|
related_name='tenant_values',
|
|
verbose_name=_("Setting Template")
|
|
)
|
|
value = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Value"),
|
|
help_text=_("Stores string, integer, boolean, and choice values")
|
|
)
|
|
encrypted_value = models.BinaryField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Encrypted Value"),
|
|
help_text=_("Stores encrypted sensitive data (API keys, tokens, etc.)")
|
|
)
|
|
file_value = models.FileField(
|
|
upload_to='tenant_settings/%Y/%m/%d/',
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("File Value"),
|
|
help_text=_("Stores file uploads (logos, certificates, etc.)")
|
|
)
|
|
updated_by = models.ForeignKey(
|
|
User,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name='updated_settings',
|
|
verbose_name=_("Updated By")
|
|
)
|
|
|
|
history = HistoricalRecords()
|
|
|
|
class Meta:
|
|
verbose_name = _("Tenant Setting")
|
|
verbose_name_plural = _("Tenant Settings")
|
|
ordering = ['tenant', 'template__category', 'template__order']
|
|
unique_together = [['tenant', 'template']]
|
|
indexes = [
|
|
models.Index(fields=['tenant', 'template']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"{self.tenant.name} - {self.template.label_en}"
|
|
|
|
def get_typed_value(self):
|
|
"""
|
|
Returns the value converted to the appropriate type based on template data_type.
|
|
"""
|
|
if self.template.data_type == SettingTemplate.DataType.BOOLEAN:
|
|
return self.value.lower() in ('true', '1', 'yes') if self.value else False
|
|
elif self.template.data_type == SettingTemplate.DataType.INTEGER:
|
|
try:
|
|
return int(self.value) if self.value else None
|
|
except (ValueError, TypeError):
|
|
return None
|
|
elif self.template.data_type == SettingTemplate.DataType.FILE:
|
|
return self.file_value
|
|
elif self.template.data_type == SettingTemplate.DataType.ENCRYPTED:
|
|
# Will be decrypted by the service layer
|
|
return self.encrypted_value
|
|
else:
|
|
return self.value
|
|
|
|
|
|
class ContactMessage(UUIDPrimaryKeyMixin, TimeStampedMixin):
|
|
"""
|
|
Contact form submissions from the landing page.
|
|
|
|
Stores inquiries from potential clients and visitors.
|
|
Admins are notified via email and in-app notifications.
|
|
"""
|
|
|
|
name = models.CharField(
|
|
max_length=200,
|
|
verbose_name=_("Name")
|
|
)
|
|
email = models.EmailField(
|
|
verbose_name=_("Email")
|
|
)
|
|
phone = PhoneNumberField(
|
|
blank=True,
|
|
verbose_name=_("Phone Number")
|
|
)
|
|
message = models.TextField(
|
|
verbose_name=_("Message")
|
|
)
|
|
|
|
# Metadata for security and tracking
|
|
submitted_at = models.DateTimeField(
|
|
auto_now_add=True,
|
|
verbose_name=_("Submitted At")
|
|
)
|
|
ip_address = models.GenericIPAddressField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("IP Address")
|
|
)
|
|
user_agent = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("User Agent"),
|
|
help_text=_("Browser and device information")
|
|
)
|
|
|
|
# Admin tracking
|
|
is_read = models.BooleanField(
|
|
default=False,
|
|
verbose_name=_("Is Read"),
|
|
help_text=_("Whether an admin has viewed this message")
|
|
)
|
|
responded_at = models.DateTimeField(
|
|
null=True,
|
|
blank=True,
|
|
verbose_name=_("Responded At")
|
|
)
|
|
responded_by = models.ForeignKey(
|
|
User,
|
|
on_delete=models.SET_NULL,
|
|
null=True,
|
|
blank=True,
|
|
related_name='responded_contact_messages',
|
|
verbose_name=_("Responded By")
|
|
)
|
|
notes = models.TextField(
|
|
blank=True,
|
|
verbose_name=_("Admin Notes"),
|
|
help_text=_("Internal notes about this inquiry")
|
|
)
|
|
|
|
class Meta:
|
|
verbose_name = _("Contact Message")
|
|
verbose_name_plural = _("Contact Messages")
|
|
ordering = ['-submitted_at']
|
|
indexes = [
|
|
models.Index(fields=['email']),
|
|
models.Index(fields=['is_read', 'submitted_at']),
|
|
models.Index(fields=['submitted_at']),
|
|
]
|
|
|
|
def __str__(self):
|
|
return f"{self.name} - {self.email} ({self.submitted_at.strftime('%Y-%m-%d %H:%M')})"
|
|
|
|
def mark_as_read(self):
|
|
"""Mark this message as read."""
|
|
if not self.is_read:
|
|
self.is_read = True
|
|
self.save(update_fields=['is_read'])
|
|
|
|
def mark_as_responded(self, user):
|
|
"""Mark this message as responded to."""
|
|
from django.utils import timezone
|
|
self.responded_at = timezone.now()
|
|
self.responded_by = user
|
|
self.is_read = True
|
|
self.save(update_fields=['responded_at', 'responded_by', 'is_read'])
|