zod-backend/web_admin/serializers/auth_serializer.py

"""
web_admin auth serializers file
"""
# python imports
from datetime import datetime

# django imports
from rest_framework import serializers
from django.contrib.auth import get_user_model
from django.conf import settings
from django.utils import timezone
from rest_framework import status
from templated_email import send_templated_mail

# local imports
from account.models import UserEmailOtp
from base.messages import ERROR_CODE
from guardian.tasks import generate_otp

USER = get_user_model()


class AdminOTPSerializer(serializers.ModelSerializer):
    """
    admin forgot password serializer
    """
    email = serializers.EmailField()

    class Meta:
        """
        meta class
        """
        model = USER
        fields = ('email',)

    def validate(self, attrs):
        """ used to validate the incoming data """
        user = USER.objects.filter(email=attrs['email']).first()
        if not user:
            raise serializers.ValidationError(ERROR_CODE['2004'])
        elif not user.is_superuser:
            raise serializers.ValidationError(ERROR_CODE['2036'])
        attrs.update({'user': user})
        return attrs

    def create(self, validated_data):
        """
        to send otp
        :return: user_data
        """
        email = validated_data['email']

        verification_code = generate_otp()

        # Send the verification code to the user's email
        from_email = settings.EMAIL_FROM_ADDRESS
        recipient_list = [email]
        send_templated_mail(
            template_name='email_reset_verification.email',
            from_email=from_email,
            recipient_list=recipient_list,
            context={
                'verification_code': verification_code
            }
        )
        expiry = timezone.now() + timezone.timedelta(days=1)
        user_data, created = UserEmailOtp.objects.get_or_create(email=email)
        if created:
            user_data.expired_at = expiry
        if user_data:
            user_data.otp = verification_code
            user_data.expired_at = expiry
        user_data.save()
        return user_data


class AdminVerifyOTPSerializer(serializers.Serializer):
    """
    admin verify otp serializer
    """
    email = serializers.EmailField()
    otp = serializers.CharField(max_length=6, min_length=6)

    class Meta:
        """ meta class """
        fields = ('email', 'otp',)

    def validate(self, attrs):
        """
        to validate data
        :return: validated data
        """
        email = attrs.get('email')
        otp = attrs.get('otp')

        user = USER.objects.filter(email=attrs['email']).first()
        if not user:
            raise serializers.ValidationError(ERROR_CODE['2004'])
        elif not user.is_superuser:
            raise serializers.ValidationError(ERROR_CODE['2036'])
        # fetch email otp object of the user
        user_otp_details = UserEmailOtp.objects.filter(email=email, otp=otp).last()
        if not user_otp_details:
            raise serializers.ValidationError(ERROR_CODE['2008'])
        if user_otp_details.expired_at.replace(tzinfo=None) < datetime.utcnow():
            raise serializers.ValidationError(ERROR_CODE['2029'])
        user_otp_details.is_verified = True
        user_otp_details.save()
        return attrs


class AdminCreatePasswordSerializer(serializers.ModelSerializer):
    """
    admin create new password serializer
    """
    email = serializers.EmailField()
    new_password = serializers.CharField()
    confirm_password = serializers.CharField()

    class Meta:
        """
        meta class
        """
        model = USER
        fields = ('email', 'new_password', 'confirm_password')

    def validate(self, attrs):
        """
        to validate data
        :return: validated data
        """
        email = attrs.get('email')
        new_password = attrs.get('new_password')
        confirm_password = attrs.get('confirm_password')

        # matching password
        if new_password != confirm_password:
            raise serializers.ValidationError('password do not match')

        user = USER.objects.filter(email=attrs['email']).first()
        if not user:
            raise serializers.ValidationError(ERROR_CODE['2004'])
        elif not user.is_superuser:
            raise serializers.ValidationError(ERROR_CODE['2036'])

        user_otp_details = UserEmailOtp.objects.filter(email=email).last()

        if user_otp_details and user_otp_details.is_verified:
            user_otp_details.delete()
            attrs.update({'user': user})
            return attrs
        raise serializers.ValidationError(ERROR_CODE['2036'])

    def create(self, validated_data):
        """
        to create password
        :return: user
        """
        user = validated_data.get('user')
        user.set_password(validated_data.get('password'))
        user.save()
        return user