zod-backend/account/serializers.py

from rest_framework import serializers
from django.contrib.auth.models import User
from guardian.models import Guardian
from junior.models import Junior
from account.models import UserProfile, UserEmailOtp, UserPhoneOtp
from base.constants import GUARDIAN, JUNIOR, SUPERUSER
from django.db import transaction
from base.messages import ERROR_CODE_REQUIRED, ERROR_CODE, SUCCESS_CODE, STATUS_CODE_ERROR
from django.core.exceptions import ObjectDoesNotExist
from django.contrib.auth import authenticate
from rest_framework import viewsets, status
from rest_framework.decorators import action
from django.contrib.auth import authenticate, login
from rest_framework_simplejwt.tokens import RefreshToken
from guardian.utils import upload_image_to_alibaba
from .utils import get_token
class GoogleSignInSerializer(serializers.Serializer):
    """Google login Serializer"""
    email = serializers.EmailField()

    def create(self, validated_data):
        """Create or update user model"""
        with transaction.atomic():
            if User.objects.filter(email__iexact=self.validated_data['email']).exists():
                return User.objects.get(email__iexact=self.validated_data['email'])

            if not User.objects.filter(email__iexact=self.validated_data['email']).exists():
                instance = User.objects.create(username=self.validated_data['email'],
                                               email=self.validated_data['email'])
            return instance

class GoogleLoginSerializer1(serializers.Serializer):
    access_token = serializers.CharField(max_length=5000, required=True)

    class Meta:
        """meta class"""
        fields = ('access_token',)

class UpdateGuardianImageSerializer(serializers.ModelSerializer):
    """Reset Password after verification"""
    class Meta(object):
        """Meta info"""
        model = Guardian
        fields = '__all__'

    def update(self, instance, validated_data):
        """update image """
        instance.image = validated_data.get('image', instance.image)
        instance.save()
        return instance

class UpdateJuniorProfileImageSerializer(serializers.ModelSerializer):
    """Reset Password after verification"""
    class Meta(object):
        """Meta info"""
        model = Junior
        fields = '__all__'

    def update(self, instance, validated_data):
        """update image """
        image = validated_data.get('image', instance.image)
        filename = f"images/{image.name}"
        image_url = upload_image_to_alibaba(image, filename)
        instance.image = image_url
        instance.save()
        return instance
class ResetPasswordSerializer(serializers.Serializer):
    """Reset Password after verification"""
    verification_code = serializers.CharField(max_length=10)
    password = serializers.CharField(required=True)
    class Meta(object):
        """Meta info"""
        model = User

    def create(self, validated_data):
        verification_code = validated_data.pop('verification_code')
        password = validated_data.pop('password')
        user_opt_details = UserEmailOtp.objects.filter(otp=verification_code, is_verified=True).last()
        if user_opt_details:
            user_details = User.objects.filter(email=user_opt_details.email).last()
            if user_details:
                if user_details.check_password(password):
                    raise serializers.ValidationError({"details":ERROR_CODE['2001'],"code":"400", "status":"failed"})
                user_details.set_password(password)
                user_details.save()
                return {'password':password}
            return user_opt_details
        return ''

class ChangePasswordSerializer(serializers.Serializer):
    """Update Password after verification"""
    current_password = serializers.CharField(max_length=100)
    new_password = serializers.CharField(required=True)
    class Meta(object):
        """Meta info"""
        model = User

    def validate_current_password(self, value):
        user = self.context
        if self.context.password not in ('', None):
            if user.check_password(value):
                return value
        raise serializers.ValidationError({"details":ERROR_CODE['2015']})
    def create(self, validated_data):
        new_password = validated_data.pop('new_password')
        current_password = validated_data.pop('current_password')
        if new_password == current_password:
            raise serializers.ValidationError({"details": ERROR_CODE['2026']})
        user_details = User.objects.filter(email=self.context).last()
        if user_details:
            user_details.set_password(new_password)
            user_details.save()
            return {'password':new_password}
        return ''



class ForgotPasswordSerializer(serializers.Serializer):
    """Forget password serializer"""
    email = serializers.EmailField()

class SuperUserSerializer(serializers.ModelSerializer):
    user_type = serializers.SerializerMethodField('get_user_type')

    def get_user_type(self, obj):
        """user type"""
        return SUPERUSER

    class Meta(object):
        """Meta info"""
        model = User
        fields = ['id', 'username', 'email', 'first_name', 'last_name', 'is_active', 'user_type']


class GuardianSerializer(serializers.ModelSerializer):
    """guardian serializer"""
    user_type = serializers.SerializerMethodField('get_user_type')
    email = serializers.SerializerMethodField('get_auth')
    first_name = serializers.SerializerMethodField('get_first_name')
    last_name = serializers.SerializerMethodField('get_last_name')
    auth_token = serializers.SerializerMethodField('get_auth_token')
    refresh_token = serializers.SerializerMethodField('get_refresh_token')

    def get_auth_token(self, obj):
        return get_token()['access']
    def get_refresh_token(self, obj):
        return get_token()['refresh']


    def get_user_type(self, obj):
        """user type"""
        return GUARDIAN

    def get_auth(self, obj):
        """user email address"""
        return obj.user.username

    def get_first_name(self, obj):
        """user first name"""
        return obj.user.first_name

    def get_last_name(self, obj):
        """user last name"""
        return obj.user.last_name

    class Meta(object):
        """Meta info"""
        model = Guardian
        fields = ['auth_token', 'refresh_token', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'family_name', 'gender', 'dob',
                  'referral_code', 'is_active', 'is_complete_profile', 'passcode',
                  'created_at', 'updated_at', 'user_type']


class JuniorSerializer(serializers.ModelSerializer):
    """junior serializer"""
    user_type = serializers.SerializerMethodField('get_user_type')
    email = serializers.SerializerMethodField('get_auth')
    first_name = serializers.SerializerMethodField('get_first_name')
    last_name = serializers.SerializerMethodField('get_last_name')
    auth_token = serializers.SerializerMethodField('get_auth_token')
    refresh_token = serializers.SerializerMethodField('get_refresh_token')

    def get_auth_token(self, obj):
        return get_token()['access']
    def get_refresh_token(self, obj):
        return get_token()['refresh']

    def get_user_type(self, obj):
        return JUNIOR

    def get_auth(self, obj):
        return obj.auth.username

    def get_first_name(self, obj):
        return obj.auth.first_name

    def get_last_name(self, obj):
        return obj.auth.last_name

    class Meta(object):
        """Meta info"""
        model = Junior
        fields = ['auth_token', 'refresh_token', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'gender', 'dob',
                  'guardian_code', 'referral_code','is_active', 'is_complete_profile', 'created_at',
                  'updated_at', 'user_type']

class EmailVerificationSerializer(serializers.ModelSerializer):
    """Email verification serializer"""
    class Meta(object):
        """Meta info"""
        model = UserEmailOtp
        fields = '__all__'