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'), ] TIME_SLOT_CHOICES = [ ('morning', 'Morning (9AM - 12PM)'), ('afternoon', 'Afternoon (1PM - 5PM)'), ('evening', 'Evening (6PM - 9PM)'), ] availability_schedule = models.JSONField( default=dict, help_text="Dictionary with days as keys and lists of time slots as values" ) 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 set_availability(self, day, time_slots): if not self.availability_schedule: self.availability_schedule = {} if day not in [str(d[0]) for d in self.DAYS_OF_WEEK]: raise ValueError(f"Invalid day: {day}") valid_slots = [slot[0] for slot in self.TIME_SLOT_CHOICES] for slot in time_slots: if slot not in valid_slots: raise ValueError(f"Invalid time slot: {slot}") self.availability_schedule[str(day)] = time_slots def get_availability_for_day(self, day): return self.availability_schedule.get(str(day), []) def is_available(self, day, time_slot): return time_slot in self.get_availability_for_day(day) def get_all_available_slots(self): available_slots = [] for day_num, time_slots in self.availability_schedule.items(): day_name = dict(self.DAYS_OF_WEEK).get(int(day_num)) for time_slot in time_slots: time_display = dict(self.TIME_SLOT_CHOICES).get(time_slot) available_slots.append({ 'day_num': int(day_num), 'day_name': day_name, 'time_slot': time_slot, 'time_display': time_display }) return available_slots def clear_availability(self, day=None): if day is None: self.availability_schedule = {} else: day_str = str(day) if day_str in self.availability_schedule: del self.availability_schedule[day_str] def __str__(self): if not self.availability_schedule: return "No availability set" display_strings = [] for day_num, time_slots in sorted(self.availability_schedule.items()): day_name = dict(self.DAYS_OF_WEEK).get(int(day_num)) slot_displays = [dict(self.TIME_SLOT_CHOICES).get(slot) for slot in time_slots] display_strings.append(f"{day_name}: {', '.join(slot_displays)}") return " | ".join(display_strings) 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=255) last_name = EncryptedCharField(max_length=255) email = EncryptedEmailField() phone = EncryptedCharField(max_length=255, 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, null=True, help_text="Jitsi Meet URL for the video session") jitsi_room_id = models.CharField(max_length=100, unique=True, null=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 get_available_time_slots_for_date(self, date_str): try: from datetime import datetime date_obj = datetime.strptime(date_str, '%Y-%m-%d').date() day_of_week = date_obj.weekday() availability = AdminWeeklyAvailability.objects.first() if not availability: return [] return availability.get_availability_for_day(day_of_week) except Exception as e: print(f"Error getting available slots: {e}") return [] def are_preferences_available(self): availability = AdminWeeklyAvailability.objects.first() if not availability: return False for date_str in self.preferred_dates: try: from datetime import datetime date_obj = datetime.strptime(date_str, '%Y-%m-%d').date() day_of_week = date_obj.weekday() available_slots = availability.get_availability_for_day(day_of_week) if any(slot in available_slots for slot in self.preferred_time_slots): return True except Exception as e: print(f"Error checking availability for {date_str}: {e}") continue return False def get_matching_availability(self): availability = AdminWeeklyAvailability.objects.first() if not availability: return [] matching_slots = [] for date_str in self.preferred_dates: try: from datetime import datetime date_obj = datetime.strptime(date_str, '%Y-%m-%d').date() day_of_week = date_obj.weekday() day_name = dict(AdminWeeklyAvailability.DAYS_OF_WEEK).get(day_of_week) available_slots = availability.get_availability_for_day(day_of_week) matching_time_slots = [slot for slot in self.preferred_time_slots if slot in available_slots] if matching_time_slots: matching_slots.append({ 'date': date_str, 'day_name': day_name, 'available_slots': matching_time_slots, 'date_obj': date_obj }) except Exception as e: print(f"Error processing {date_str}: {e}") continue return matching_slots def __str__(self): return f"{self.full_name} - {self.get_status_display()} - {self.created_at.strftime('%Y-%m-%d')}" def get_admin_availability(): availability, created = AdminWeeklyAvailability.objects.get_or_create( id=1 ) return availability def set_admin_availability(availability_dict): availability = get_admin_availability() for day, time_slots in availability_dict.items(): availability.set_availability(day, time_slots) availability.save() return availability def get_available_slots_for_week(): availability = get_admin_availability() return availability.get_all_available_slots() def check_date_availability(date_str): try: from datetime import datetime date_obj = datetime.strptime(date_str, '%Y-%m-%d').date() day_of_week = date_obj.weekday() availability = get_admin_availability() return availability.get_availability_for_day(day_of_week) except Exception as e: print(f"Error checking date availability: {e}") return []