Welcome To Our Shell

Mister Spy & Souheyl Bypass Shell

from rest_framework import serializers
from django.contrib.auth.hashers import make_password
from django.utils.translation import gettext_lazy as _
from rest_framework_simplejwt.serializers import TokenObtainPairSerializer
from .models import User, Company, EmployeeProfile, Contribution, PlanRetraite

# --------- PLAN RETRAITE SERIALIZER ----------
class PlanRetraiteSerializer(serializers.ModelSerializer):
    class Meta:
        model = PlanRetraite
        fields = ['id', 'nom', 'taux']

# --------- USER SERIALIZER ----------
class CompanySerializer(serializers.ModelSerializer):
    class Meta:
        model = Company
        fields = ['id', 'name', 'siret', 'address', 'logo']
        read_only_fields = ['id', 'siret']
        
class UserSerializer(serializers.ModelSerializer):
    company = CompanySerializer(read_only=True)  # 🔥 Important : ajouté correctement ici

    class Meta:
        model = User
        fields = ['id', 'email', 'role', 'first_name', 'last_name', 'company']  # ✅ Assure-toi que 'company' est bien inclus ici


# --------- COMPANY SERIALIZER ----------
class CompanySerializer(serializers.ModelSerializer):
    class Meta:
        model = Company
        fields = ['id', 'name', 'siret', 'address', 'logo']
        read_only_fields = ['id']

# --------- COMPANY UPDATE SERIALIZER ----------
class CompanyUpdateSerializer(serializers.ModelSerializer):
    class Meta:
        model = Company
        fields = ['name', 'siret', 'address', 'logo']
        extra_kwargs = {'name': {'required': False}}

# --------- EMPLOYEE PROFILE SERIALIZER ----------
class EmployeeProfileSerializer(serializers.ModelSerializer):
    user = UserSerializer(read_only=True)
    company = CompanySerializer(read_only=True)
    plan = PlanRetraiteSerializer(read_only=True)

    class Meta:
        model = EmployeeProfile
        fields = [
            'id', 'user', 'company', 'matricule', 'salary',
            'hire_date', 'retirement_date', 'sexe',
            'date_naissance', 'plan'
        ]
        read_only_fields = ['id', 'matricule', 'user', 'company']

# --------- EMPLOYEE PROFILE CREATE SERIALIZER ----------
class EmployeeProfileCreateSerializer(serializers.ModelSerializer):
    email = serializers.EmailField(write_only=True)
    first_name = serializers.CharField(write_only=True)
    last_name = serializers.CharField(write_only=True)
    password = serializers.CharField(write_only=True)
    
    class Meta:
        model = EmployeeProfile
        fields = [
            'email', 'first_name', 'last_name', 'password',
            'matricule', 'sexe', 'date_naissance', 'hire_date',
            'salary', 'retirement_date', 'plan_retraite'
        ]

    def create(self, validated_data):
        # Extraire les données utilisateur
        email = validated_data.pop('email')
        first_name = validated_data.pop('first_name')
        last_name = validated_data.pop('last_name')
        password = validated_data.pop('password')

        request = self.context.get('request')
        company = request.user.company if request else None

        # Créer l'utilisateur employé
        user = User.objects.create(
            email=email,
            first_name=first_name,
            last_name=last_name,
            role=User.EMPLOYEE,
            company=company
        )
        user.set_password(password)
        user.save()

        # Créer le profil employé
        employee_profile = EmployeeProfile.objects.create(
            user=user,
            company=company,
            **validated_data
        )

        return employee_profile


# --------- CONTRIBUTION SERIALIZER ----------
class ContributionSerializer(serializers.ModelSerializer):
    employee_name = serializers.CharField(
        source='employee.user.get_full_name', read_only=True
    )

    class Meta:
        model = Contribution
        fields = ['id', 'employee_name', 'amount', 'date', 'fiscal_year']
        read_only_fields = ['id', 'fiscal_year']

# --------- EMPLOYEE REGISTRATION SERIALIZER ----------
class EmployeeRegistrationSerializer(serializers.Serializer):
    email = serializers.EmailField()
    password = serializers.CharField(write_only=True)
    first_name = serializers.CharField()
    last_name = serializers.CharField()
    profile = EmployeeProfileCreateSerializer()

    def validate_email(self, email):
        if User.objects.filter(email=email).exists():
            raise serializers.ValidationError("Cet email est déjà utilisé.")
        return email

    def create(self, validated_data):
        profile_data = validated_data.pop('profile')
        password = validated_data.pop('password')

        user = User.objects.create(
            email=validated_data['email'],
            first_name=validated_data['first_name'],
            last_name=validated_data['last_name'],
            role=User.EMPLOYEE,
            password=make_password(password),
            company=self.context['request'].user.company
        )

        EmployeeProfile.objects.create(
            user=user,
            company=user.company,
            **profile_data
        )
        return user

# --------- EMPLOYER REGISTRATION SERIALIZER ----------
class EmployerRegistrationSerializer(serializers.ModelSerializer):
    password = serializers.CharField(write_only=True, style={'input_type': 'password'})
    logo = serializers.ImageField(write_only=True, required=False)

    class Meta:
        model = User
        fields = [
            'email', 'password', 'first_name', 'last_name',
            'company_name', 'siret', 'address', 'logo'
        ]
        extra_kwargs = {
            'first_name': {'required': True},
            'last_name': {'required': True}
        }

    company_name = serializers.CharField(write_only=True)
    siret = serializers.CharField(write_only=True, allow_blank=True)
    address = serializers.CharField(write_only=True, allow_blank=True)

    def validate_email(self, email):
        if User.objects.filter(email=email).exists():
            raise serializers.ValidationError("Cet email est déjà utilisé.")
        return email

    def create(self, validated_data):
        logo = validated_data.pop('logo', None)
        company = Company.objects.create(
            name=validated_data.pop('company_name'),
            siret=validated_data.pop('siret'),
            address=validated_data.pop('address'),
            logo=logo
        )
        user = User.objects.create(
            email=validated_data['email'],
            first_name=validated_data['first_name'],
            last_name=validated_data['last_name'],
            role=User.EMPLOYER,
            password=make_password(validated_data['password']),
            company=company
        )
        return user

# --------- PENSION SIMULATION SERIALIZER ----------
class PensionSimulationSerializer(serializers.Serializer):
    retirement_date = serializers.DateField()
    salary_projection_rate = serializers.DecimalField(
        max_digits=5, decimal_places=2, min_value=0, max_value=100
    )

# --------- CUSTOM TOKEN SERIALIZER ----------
class CustomTokenObtainPairSerializer(TokenObtainPairSerializer):
    def validate(self, attrs):
        data = super().validate(attrs)
        user = self.user
        user_data = {
            'id': user.id,
            'email': user.email,
            'role': user.role
        }
        if user.company:
            user_data['company_id'] = user.company.id
        data['user'] = user_data
        return data

    @classmethod
    def get_token(cls, user):
        token = super().get_token(user)
        token['role'] = user.role
        token['email'] = user.email
        if user.company:
            token['company_id'] = user.company.id
        return token


class UserRegistrationSerializer(serializers.ModelSerializer):
    # Champs imbriqués pour employé
    user = serializers.DictField(required=False)
    profile = serializers.DictField(required=False)

    # Champs employeur
    company_name = serializers.CharField(required=False)
    company_siret = serializers.CharField(required=False)
    company_address = serializers.CharField(required=False)
    company_logo = serializers.ImageField(required=False)

    password = serializers.CharField(write_only=True)

    class Meta:
        model = User
        fields = [
            'email', 'password', 'role',
            'user', 'profile',  # pour employé
            'company_name', 'company_siret', 'company_address', 'company_logo',  # pour employeur
        ]

    def validate_email(self, value):
        if User.objects.filter(email=value).exists():
            raise serializers.ValidationError("Cet email est déjà utilisé.")
        return value

    def validate(self, data):
        print("Données reçues pour validation :", data)  # <- Ajout du print

        role = data.get('role')

        if role == 'EMPLOYER':
            required_fields = ['company_name', 'company_siret', 'company_address']
            for field in required_fields:
                if not data.get(field):
                    raise serializers.ValidationError({field: "Ce champ est requis pour un employeur."})

        elif role == 'EMPLOYEE':
            if not data.get('user') or not data.get('profile'):
                raise serializers.ValidationError("Les champs 'user' et 'profile' sont requis pour un employé.")
            required_user_fields = ['email', 'password']
            required_profile_fields = ['matricule', 'date_entree', 'salaire', 'entreprise']
            for field in required_user_fields:
                if not data['user'].get(field):
                    raise serializers.ValidationError({f"user.{field}": "Ce champ est requis."})
            for field in required_profile_fields:
                if not data['profile'].get(field):
                    raise serializers.ValidationError({f"profile.{field}": "Ce champ est requis."})

        else:
            raise serializers.ValidationError("Le rôle spécifié est invalide.")

        return data

    def create(self, validated_data):
        role = validated_data.get('role')

        if role == 'EMPLOYER':
            # Création de l'utilisateur employeur
            user = User.objects.create(
                email=validated_data['email'],
                role='EMPLOYER',
                password=make_password(validated_data['password']),
            )
            # Création de la société
            company = Company.objects.create(
                name=validated_data.get('company_name'),
                siret=validated_data.get('company_siret'),
                address=validated_data.get('company_address'),
                logo=validated_data.get('company_logo', None),
            )
            user.company = company
            user.save()
            return user

        elif role == 'EMPLOYEE':
            user_data = validated_data['user']
            profile_data = validated_data['profile']

            user = User.objects.create(
                email=user_data['email'],
                first_name=user_data.get('first_name', ''),
                last_name=user_data.get('last_name', ''),
                role='EMPLOYEE',
                password=make_password(user_data['password']),
            )

            EmployeeProfile.objects.create(
                user=user,
                matricule=profile_data.get('matricule'),
                hire_date=profile_data.get('date_entree'),
                salary=profile_data.get('salaire'),
                retirement_date=None,
                company=profile_data.get('entreprise'),
            )

            return user
        print(serializer.errors)
        raise serializers.ValidationError("Impossible de créer l'utilisateur.")