saani
1fc91d5949
- Enable meetings app in INSTALLED_APPS and add URL routing - Switch from PostgreSQL to SQLite for default database configuration - Remove meetings directory from .gitignore - Move API root endpoint from users app to main URL configuration - Remove HIPAA-specific email and compliance settings (EMAIL_ENCRYPTION_KEY, HIPAA_EMAIL_CONFIG, BAA_VERIFICATION) - Add SITE_NAME and ENCRYPTION_KEY environment variables - Regenerate initial user migrations These changes simplify the development setup by using SQLite as the default database and removing complex compliance configurations while enabling the core meetings functionality.
300 lines
9.7 KiB
Python
300 lines
9.7 KiB
Python
import uuid
|
|
from django.db import models
|
|
from django.conf import settings
|
|
from django.utils import timezone
|
|
from cryptography.fernet import Fernet
|
|
from cryptography.hazmat.primitives import hashes
|
|
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
|
|
import base64
|
|
import os
|
|
|
|
class EncryptionManager:
|
|
def __init__(self):
|
|
self.fernet = self._get_fernet()
|
|
|
|
def _get_fernet_key(self):
|
|
key = getattr(settings, 'ENCRYPTION_KEY', None) or os.environ.get('ENCRYPTION_KEY')
|
|
if not key:
|
|
key = Fernet.generate_key().decode()
|
|
key = key.encode()
|
|
return key
|
|
|
|
def _get_fernet(self):
|
|
key = self._get_fernet_key()
|
|
return Fernet(key)
|
|
|
|
def encrypt_value(self, value):
|
|
if value is None or value == "":
|
|
return value
|
|
encrypted_value = self.fernet.encrypt(value.encode())
|
|
return base64.urlsafe_b64encode(encrypted_value).decode()
|
|
|
|
def decrypt_value(self, encrypted_value):
|
|
if encrypted_value is None or encrypted_value == "":
|
|
return encrypted_value
|
|
try:
|
|
encrypted_bytes = base64.urlsafe_b64decode(encrypted_value.encode())
|
|
decrypted_value = self.fernet.decrypt(encrypted_bytes)
|
|
return decrypted_value.decode()
|
|
except Exception as e:
|
|
print(f"Decryption error: {e}")
|
|
return encrypted_value
|
|
|
|
encryption_manager = EncryptionManager()
|
|
|
|
class EncryptedCharField(models.CharField):
|
|
def from_db_value(self, value, expression, connection):
|
|
if value is None:
|
|
return value
|
|
return encryption_manager.decrypt_value(value)
|
|
|
|
def get_prep_value(self, value):
|
|
if value is None:
|
|
return value
|
|
return encryption_manager.encrypt_value(value)
|
|
|
|
class EncryptedEmailField(EncryptedCharField):
|
|
def __init__(self, *args, **kwargs):
|
|
kwargs['max_length'] = 254
|
|
super().__init__(*args, **kwargs)
|
|
|
|
def from_db_value(self, value, expression, connection):
|
|
if value is None:
|
|
return value
|
|
return encryption_manager.decrypt_value(value)
|
|
|
|
def get_prep_value(self, value):
|
|
if value is None:
|
|
return value
|
|
return encryption_manager.encrypt_value(value)
|
|
|
|
class EncryptedTextField(models.TextField):
|
|
def from_db_value(self, value, expression, connection):
|
|
if value is None:
|
|
return value
|
|
return encryption_manager.decrypt_value(value)
|
|
|
|
def get_prep_value(self, value):
|
|
if value is None:
|
|
return value
|
|
return encryption_manager.encrypt_value(value)
|
|
|
|
class AdminWeeklyAvailability(models.Model):
|
|
DAYS_OF_WEEK = [
|
|
(0, 'Monday'),
|
|
(1, 'Tuesday'),
|
|
(2, 'Wednesday'),
|
|
(3, 'Thursday'),
|
|
(4, 'Friday'),
|
|
(5, 'Saturday'),
|
|
(6, 'Sunday'),
|
|
]
|
|
|
|
available_days = models.JSONField(
|
|
default=list,
|
|
help_text="List of weekdays (0-6) when appointments are accepted"
|
|
)
|
|
created_at = models.DateTimeField(auto_now_add=True)
|
|
updated_at = models.DateTimeField(auto_now=True)
|
|
|
|
class Meta:
|
|
verbose_name = 'Admin Weekly Availability'
|
|
verbose_name_plural = 'Admin Weekly Availability'
|
|
|
|
def __str__(self):
|
|
days = [self.DAYS_OF_WEEK[day][1] for day in self.available_days]
|
|
return f"Available: {', '.join(days)}"
|
|
|
|
class AppointmentRequest(models.Model):
|
|
STATUS_CHOICES = [
|
|
('pending_review', 'Pending Review'),
|
|
('scheduled', 'Scheduled'),
|
|
('rejected', 'Rejected'),
|
|
('completed', 'Completed'),
|
|
('cancelled', 'Cancelled'),
|
|
]
|
|
|
|
TIME_SLOT_CHOICES = [
|
|
('morning', 'Morning (9AM - 12PM)'),
|
|
('afternoon', 'Afternoon (1PM - 5PM)'),
|
|
('evening', 'Evening (6PM - 9PM)'),
|
|
]
|
|
|
|
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
|
|
|
|
first_name = EncryptedCharField(max_length=100)
|
|
last_name = EncryptedCharField(max_length=100)
|
|
email = EncryptedEmailField()
|
|
phone = EncryptedCharField(max_length=20, blank=True)
|
|
reason = EncryptedTextField(blank=True)
|
|
|
|
preferred_dates = models.JSONField(
|
|
help_text="List of preferred dates (YYYY-MM-DD format)"
|
|
)
|
|
preferred_time_slots = models.JSONField(
|
|
help_text="List of preferred time slots (morning/afternoon/evening)"
|
|
)
|
|
|
|
status = models.CharField(
|
|
max_length=20,
|
|
choices=STATUS_CHOICES,
|
|
default='pending_review'
|
|
)
|
|
|
|
scheduled_datetime = models.DateTimeField(null=True, blank=True)
|
|
scheduled_duration = models.PositiveIntegerField(
|
|
default=60,
|
|
help_text="Duration in minutes"
|
|
)
|
|
rejection_reason = EncryptedTextField(blank=True)
|
|
|
|
jitsi_meet_url = models.URLField(blank=True, help_text="Jitsi Meet URL for the video session")
|
|
jitsi_room_id = models.CharField(max_length=100, unique=True, blank=True, help_text="Jitsi room ID")
|
|
|
|
created_at = models.DateTimeField(auto_now_add=True)
|
|
updated_at = models.DateTimeField(auto_now=True)
|
|
|
|
class Meta:
|
|
ordering = ['-created_at']
|
|
verbose_name = 'Appointment Request'
|
|
verbose_name_plural = 'Appointment Requests'
|
|
indexes = [
|
|
models.Index(fields=['status', 'scheduled_datetime']),
|
|
models.Index(fields=['email', 'created_at']),
|
|
]
|
|
|
|
@property
|
|
def full_name(self):
|
|
return f"{self.first_name} {self.last_name}"
|
|
|
|
@property
|
|
def formatted_created_at(self):
|
|
return self.created_at.strftime("%B %d, %Y at %I:%M %p")
|
|
|
|
@property
|
|
def formatted_scheduled_datetime(self):
|
|
if self.scheduled_datetime:
|
|
return self.scheduled_datetime.strftime("%B %d, %Y at %I:%M %p")
|
|
return None
|
|
|
|
@property
|
|
def has_jitsi_meeting(self):
|
|
return bool(self.jitsi_meet_url and self.jitsi_room_id)
|
|
|
|
@property
|
|
def meeting_in_future(self):
|
|
if not self.scheduled_datetime:
|
|
return False
|
|
return self.scheduled_datetime > timezone.now()
|
|
|
|
@property
|
|
def meeting_duration_display(self):
|
|
hours = self.scheduled_duration // 60
|
|
minutes = self.scheduled_duration % 60
|
|
if hours > 0:
|
|
return f"{hours}h {minutes}m"
|
|
return f"{minutes}m"
|
|
|
|
def get_preferred_dates_display(self):
|
|
try:
|
|
dates = [timezone.datetime.strptime(date, '%Y-%m-%d').strftime('%b %d, %Y')
|
|
for date in self.preferred_dates]
|
|
return ', '.join(dates)
|
|
except:
|
|
return ', '.join(self.preferred_dates)
|
|
|
|
def get_preferred_time_slots_display(self):
|
|
slot_display = {
|
|
'morning': 'Morning',
|
|
'afternoon': 'Afternoon',
|
|
'evening': 'Evening'
|
|
}
|
|
return ', '.join([slot_display.get(slot, slot) for slot in self.preferred_time_slots])
|
|
|
|
def generate_jitsi_room_id(self):
|
|
if not self.jitsi_room_id:
|
|
self.jitsi_room_id = f"therapy_session_{self.id.hex[:16]}"
|
|
return self.jitsi_room_id
|
|
|
|
def create_jitsi_meeting(self):
|
|
if not self.jitsi_room_id:
|
|
self.generate_jitsi_room_id()
|
|
|
|
jitsi_base_url = getattr(settings, 'JITSI_BASE_URL', 'https://meet.jit.si')
|
|
self.jitsi_meet_url = f"{jitsi_base_url}/{self.jitsi_room_id}"
|
|
return self.jitsi_meet_url
|
|
|
|
def get_jitsi_join_info(self):
|
|
if not self.has_jitsi_meeting:
|
|
return None
|
|
|
|
return {
|
|
'meeting_url': self.jitsi_meet_url,
|
|
'room_id': self.jitsi_room_id,
|
|
'scheduled_time': self.formatted_scheduled_datetime,
|
|
'duration': self.meeting_duration_display,
|
|
'join_instructions': 'Click the meeting URL to join the video session. No password required.'
|
|
}
|
|
|
|
def schedule_appointment(self, datetime_obj, duration=60, commit=True):
|
|
self.status = 'scheduled'
|
|
self.scheduled_datetime = datetime_obj
|
|
self.scheduled_duration = duration
|
|
self.rejection_reason = ''
|
|
|
|
self.create_jitsi_meeting()
|
|
|
|
if commit:
|
|
self.save()
|
|
|
|
def reject_appointment(self, reason='', commit=True):
|
|
self.status = 'rejected'
|
|
self.rejection_reason = reason
|
|
self.scheduled_datetime = None
|
|
self.jitsi_meet_url = ''
|
|
self.jitsi_room_id = ''
|
|
if commit:
|
|
self.save()
|
|
|
|
def cancel_appointment(self, reason='', commit=True):
|
|
self.status = 'cancelled'
|
|
self.rejection_reason = reason
|
|
if commit:
|
|
self.save()
|
|
|
|
def complete_appointment(self, commit=True):
|
|
self.status = 'completed'
|
|
if commit:
|
|
self.save()
|
|
|
|
def can_join_meeting(self):
|
|
if not self.scheduled_datetime or not self.has_jitsi_meeting:
|
|
return False
|
|
|
|
if self.status != 'scheduled':
|
|
return False
|
|
|
|
now = timezone.now()
|
|
meeting_start = self.scheduled_datetime
|
|
meeting_end = meeting_start + timezone.timedelta(minutes=self.scheduled_duration + 15) # 15 min buffer
|
|
|
|
return meeting_start - timezone.timedelta(minutes=10) <= now <= meeting_end
|
|
|
|
def get_meeting_status(self):
|
|
if not self.scheduled_datetime:
|
|
return "Not scheduled"
|
|
|
|
now = timezone.now()
|
|
meeting_start = self.scheduled_datetime
|
|
|
|
if now < meeting_start - timezone.timedelta(minutes=10):
|
|
return "Scheduled"
|
|
elif self.can_join_meeting():
|
|
return "Ready to join"
|
|
elif now > meeting_start + timezone.timedelta(minutes=self.scheduled_duration):
|
|
return "Completed"
|
|
else:
|
|
return "Ended"
|
|
|
|
def __str__(self):
|
|
return f"{self.full_name} - {self.get_status_display()} - {self.created_at.strftime('%Y-%m-%d')}" |