<br />
<b>Warning</b>:  Undefined variable $auth in <b>/home/pevo0181/public_html/pia-soft.com/cleania/routes/index.php</b> on line <b>542</b><br />
<br />
<b>Warning</b>:  Trying to access array offset on value of type null in <b>/home/pevo0181/public_html/pia-soft.com/cleania/routes/index.php</b> on line <b>542</b><br />
from django.db import models
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager

class UserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('L\'email est obligatoire')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        return self.create_user(email, password, **extra_fields)

class Users(AbstractBaseUser):
    id = models.BigAutoField(primary_key=True)
    first_name = models.CharField(max_length=255, blank=True, null=True)
    last_name = models.CharField(max_length=255, blank=True, null=True)
    name = models.CharField(max_length=255, blank=True, null=True)
    phone = models.CharField(unique=True, max_length=255, blank=True, null=True)
    email = models.EmailField(unique=True, blank=True, null=True)
    address = models.CharField(max_length=255, blank=True, null=True)
    occupation = models.CharField(max_length=255, blank=True, null=True)
    organization = models.CharField(max_length=255, blank=True, null=True)
    email_verified_at = models.DateTimeField(blank=True, null=True)
    password = models.CharField(max_length=255)
    remember_token = models.CharField(max_length=100, blank=True, null=True)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)
    
    ROLE_CHOICES = [
        ('admin', 'Administrateur'),
        ('agent', 'Agent'),
        ('sender', 'Expéditeur'),
    ]
    role = models.CharField(max_length=10, choices=ROLE_CHOICES, default='sender')
    
    # Champs requis pour l'authentification Django
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)
    is_superuser = models.BooleanField(default=False)
    last_login = models.DateTimeField(blank=True, null=True)
    
    objects = UserManager()
    
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = []
    
    class Meta:
        managed = False
        db_table = 'users'
    
    def __str__(self):
        return self.email or self.name or f"User {self.id}"
    
    def has_perm(self, perm, obj=None):
        return self.is_superuser
    
    def has_module_perms(self, app_label):
        return self.is_superuser
    
    def is_admin(self):
        #"Vérifier si l'utilisateur est un administrateur"
        return self.role == 'admin'
    
    def is_agent(self):
         #"""Vérifier si l'utilisateur est un agent"""
        return self.role == 'agent'
    
    def is_sender(self):
         #"""Vérifier si l'utilisateur est un expéditeur"""
        return self.role == 'sender'
    def get_full_name(self):
        if self.name and self.email:
            return self.name or self.email or f"Admin"


class Categories(models.Model):
    id = models.BigAutoField(primary_key=True)
    name = models.CharField(unique=True, max_length=255)
    description = models.CharField(max_length=255, blank=True, null=True)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'categories'

    def __str__(self):
        return self.name


class Documents(models.Model):
    id = models.BigAutoField(primary_key=True)
    sender = models.ForeignKey('Users', on_delete=models.DO_NOTHING, db_column='sender_id')
    category = models.ForeignKey('Categories', on_delete=models.DO_NOTHING, db_column='category_id')
    title = models.CharField(max_length=255, blank=True, null=True)
    description = models.TextField(blank=True, null=True)
    file_path = models.CharField(max_length=255)
    text_content = models.TextField(blank=True, null=True)
    status = models.CharField(max_length=9, choices=[
        ('pending', 'Pending'),
        ('processed', 'Processed'),
        ('notified', 'Notified')
    ], default='pending')
    user = models.ForeignKey('Users', on_delete=models.DO_NOTHING, db_column='user_id', related_name='documents_user')
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'documents'

    def __str__(self):
        return self.title or f"Document {self.id}"
    def get_audio_url(self):
        """Retourner l'URL correcte pour l'audio"""
        if self.file_path:
            # Corriger les backslashes et ajouter MEDIA_URL
            corrected_path = self.file_path.replace('\\', '/')
            # Retourner le chemin complet
            return f"/media/{corrected_path}"
        return None
    
    def get_download_url(self):
        """URL pour télécharger l'audio"""
        return self.get_audio_url()
    def get_read_status(self, user):
        """Obtenir le statut de lecture pour un utilisateur spécifique"""
        try:
            doc_user = DocumentUsers.objects.get(document=self, user=user)
            return {
                'is_read': doc_user.is_read,
                'read_at': doc_user.read_at
            }
        except DocumentUsers.DoesNotExist:
            return {'is_read': False, 'read_at': None}
    
    def mark_as_read_by_user(self, user):
        """Marquer ce document comme lu par un utilisateur spécifique"""
        doc_user, created = DocumentUsers.objects.get_or_create(
            document=self,
            user=user,
            defaults={'is_read': True, 'read_at': timezone.now()}
        )
        if not created and not doc_user.is_read:
            doc_user.mark_as_read()
        return doc_user
    
    def get_read_by_users(self):
        """Liste des utilisateurs qui ont lu ce document"""
        return DocumentUsers.objects.filter(document=self, is_read=True)
    
    def get_unread_by_users(self):
        """Liste des utilisateurs qui n'ont pas lu ce document"""
        return DocumentUsers.objects.filter(document=self, is_read=False)


class Audios(models.Model):
    id = models.BigAutoField(primary_key=True)
    document = models.ForeignKey('Documents', on_delete=models.DO_NOTHING, db_column='document_id')
    file_path = models.CharField(max_length=255)
    duration = models.IntegerField(blank=True, null=True)
    voice_type = models.CharField(max_length=255, default='female_fr')
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'audios'
    
    def __str__(self):
        return f"Audio {self.id} for Document {self.document_id}"
    
    def get_audio_url(self):
        """Retourner l'URL correcte pour l'audio"""
        if self.file_path:
            # Corriger les backslashes et ajouter MEDIA_URL
            corrected_path = self.file_path.replace('\\', '/')
            # Retourner le chemin complet
            return f"/media/{corrected_path}"
        return None
    
    def get_download_url(self):
        """URL pour télécharger l'audio"""
        return self.get_audio_url()
    
    
class DocumentUsers(models.Model):
    id = models.BigAutoField(primary_key=True)
    document = models.ForeignKey('Documents', on_delete=models.DO_NOTHING, db_column='document_id')
    user = models.ForeignKey('Users', on_delete=models.DO_NOTHING, db_column='user_id')
    is_read = models.BooleanField(default=False)
    read_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'document_users'

    def mark_as_read(self):
        """Marquer le document comme lu par cet utilisateur"""
        from django.utils import timezone
        self.is_read = True
        self.read_at = timezone.now()
        self.save()
    
    def __str__(self):
        return f"{self.user} - {self.document} - Lu: {self.is_read}"


class Notifications(models.Model):
    id = models.BigAutoField(primary_key=True)
    user = models.ForeignKey('Users', on_delete=models.DO_NOTHING, db_column='user_id')
    document = models.ForeignKey('Documents', on_delete=models.DO_NOTHING, db_column='document_id', blank=True, null=True)
    message = models.CharField(max_length=255)
    is_read = models.BooleanField(default=False)
    created_at = models.DateTimeField(blank=True, null=True)
    updated_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'notifications'

    def __str__(self):
        return self.message


class FailedJobs(models.Model):
    id = models.BigAutoField(primary_key=True)
    uuid = models.CharField(unique=True, max_length=255)
    connection = models.TextField()
    queue = models.TextField()
    payload = models.TextField()
    exception = models.TextField()
    failed_at = models.DateTimeField()

    class Meta:
        managed = False
        db_table = 'failed_jobs'


class Migrations(models.Model):
    id = models.AutoField(primary_key=True)
    migration = models.CharField(max_length=255)
    batch = models.IntegerField()

    class Meta:
        managed = False
        db_table = 'migrations'


class PasswordResets(models.Model):
    email = models.CharField(max_length=255)
    token = models.CharField(max_length=255)
    created_at = models.DateTimeField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'password_resets'


class PersonalAccessTokens(models.Model):
    id = models.BigAutoField(primary_key=True)
    tokenable_type = models.CharField(max_length=255)
    tokenable_id = models.BigIntegerField()
    name = models.CharField(max_length=255)
    token = models.CharField(unique=True, max_length=64)
    abi