zod-backend/account/serializers.py

"""Account serializer"""
"""Django Import"""
# Import Refresh token of jwt
from rest_framework import serializers
from django.contrib.auth.models import User
from rest_framework_simplejwt.tokens import RefreshToken
import secrets
"""App import"""
# Import guardian's model,
# Import junior's model,
# Import account's model,
# Import constant from
# base package,
# Import messages from
# base package,
# Import some functions
# from utils file"""

from guardian.models import Guardian
from junior.models import Junior
from account.models import UserEmailOtp, DefaultTaskImages, UserDelete, UserNotification, UserPhoneOtp
from base.constants import GUARDIAN, JUNIOR, SUPERUSER, NUMBER
from base.messages import ERROR_CODE, SUCCESS_CODE, STATUS_CODE_ERROR
from .utils import delete_user_account_condition_social, delete_user_account_condition

# In this serializer file
# define google login serializer
# update junior profile,
# update guardian profile,
# super admin serializer,
# reset password,
# forgot password,
# change password,
# basic junior serializer,
# basic guardian serializer,
# user delete account serializer,
# user notification serializer,
# update user notification serializer,
# default task's images serializer,
# upload default task's images serializer,
# email verification serializer,
# phone otp serializer

# create all serializer here
class GoogleLoginSerializer(serializers.Serializer):
    """google login serializer"""
    access_token = serializers.CharField(max_length=5000, required=True)

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


class UpdateJuniorProfileImageSerializer(serializers.ModelSerializer):
    """update junior image"""
    class Meta(object):
        """Meta info"""
        model = Junior
        fields = ['id', 'image']

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


class UpdateGuardianImageSerializer(serializers.ModelSerializer):
    """update guardian image"""
    class Meta(object):
        """Meta info"""
        model = Guardian
        fields = ['id','image']

    def update(self, instance, validated_data):
        """update image """
        instance.image = validated_data.get('image', instance.image)
        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')
        # fetch email otp object of the user
        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
        # check old password
        if self.context.password not in ('', None) and user.check_password(value):
            return value
        raise serializers.ValidationError(ERROR_CODE['2015'])
    def create(self, validated_data):
        new_password = validated_data.pop('new_password')
        current_password = validated_data.pop('current_password')
        """Check new password is different from 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 AdminLoginSerializer(serializers.ModelSerializer):
    """admin login serializer"""
    email = serializers.EmailField(required=True)
    password = serializers.CharField(required=True)

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

    def validate(self, attrs):
        user = User.objects.filter(email__iexact=attrs['email'], is_superuser=True
                                   ).only('id', 'first_name', 'last_name', 'email', 'is_superuser').first()

        if not user:
            raise serializers.ValidationError({'details': ERROR_CODE['2063']})
        elif not user.check_password(attrs['password']):
            raise serializers.ValidationError({'details': ERROR_CODE['2031']})
        self.context.update({'user': user})
        return attrs

    def create(self, validated_data):
        """
        used to return the user object after validation
        """
        return self.context['user']


class SuperUserSerializer(serializers.ModelSerializer):
    """Super admin serializer"""
    user_type = serializers.SerializerMethodField('get_user_type')
    auth_token = serializers.SerializerMethodField('get_auth_token')
    refresh_token = serializers.SerializerMethodField('get_refresh_token')

    def get_auth_token(self, obj):
        refresh = RefreshToken.for_user(obj)
        access_token = str(refresh.access_token)
        return access_token

    def get_refresh_token(self, obj):
        refresh = RefreshToken.for_user(obj)
        refresh_token = str(refresh)
        return refresh_token

    def get_user_type(self, obj):
        """user type"""
        return str(NUMBER['three'])

    class Meta(object):
        """Meta info"""
        model = User
        fields = ['id', 'auth_token', 'refresh_token', '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):
        refresh = RefreshToken.for_user(obj.user)
        access_token = str(refresh.access_token)
        return access_token

    def get_refresh_token(self, obj):
        refresh = RefreshToken.for_user(obj.user)
        refresh_token = str(refresh)
        return refresh_token

    def get_user_type(self, obj):
        """user type"""
        email_verified = UserEmailOtp.objects.filter(email=obj.user.username).last()
        if email_verified and email_verified.user_type is not None:
            return email_verified.user_type
        return str(NUMBER['two'])

    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 = ['id', 'auth_token', 'refresh_token', 'email', 'first_name', 'last_name', 'country_code',
                  'phone', 'family_name', 'gender', 'dob', 'referral_code', 'is_active',
                  'is_complete_profile', 'passcode', 'image', 'created_at', 'updated_at', 'user_type', 'country_name']


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):
        refresh = RefreshToken.for_user(obj.auth)
        access_token = str(refresh.access_token)
        return access_token

    def get_refresh_token(self, obj):
        refresh = RefreshToken.for_user(obj.auth)
        refresh_token = str(refresh)
        return refresh_token

    def get_user_type(self, obj):
        email_verified = UserEmailOtp.objects.filter(email=obj.auth.username).last()
        if email_verified and email_verified.user_type is not None:
            return email_verified.user_type
        return str(NUMBER['one'])

    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 = ['id', 'auth_token', 'refresh_token', 'email', 'first_name', 'last_name', 'country_code',
                  'phone', 'gender', 'dob', 'guardian_code', 'referral_code','is_active', 'is_password_set',
                  'is_complete_profile', 'created_at', 'image', 'updated_at', 'user_type', 'country_name','is_invited']

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



class DefaultTaskImagesSerializer(serializers.ModelSerializer):
    """Update Password after verification"""
    class Meta(object):
        """Meta info"""
        model = DefaultTaskImages
        fields = ['id', 'task_name', 'image_url']
    def create(self, validated_data):
        # create default task object
        data = DefaultTaskImages.objects.create(**validated_data)
        return data

class DefaultTaskImagesDetailsSerializer(serializers.ModelSerializer):
    """Update Password after verification"""
    class Meta(object):
        """Meta info"""
        model = DefaultTaskImages
        fields = '__all__'

class UserDeleteSerializer(serializers.ModelSerializer):
    """User Delete Serializer"""
    class Meta(object):
        """Meta Information"""
        model = UserDelete
        fields = ['id','reason']
    def create(self, validated_data):
        user = self.context['user']
        user_type = str(self.context['user_type'])
        data = validated_data.get('reason')
        passwd = self.context['password']
        signup_method = self.context['signup_method']
        random_num = secrets.randbelow(10001)
        user_tb = User.objects.filter(id=user.id).last()
        user_type_datas = UserEmailOtp.objects.filter(email=user.email).last()
        # check password and sign up method
        if user_tb and user_tb.check_password(passwd) and signup_method == str(NUMBER['one']):
            user_type_data = user_type_datas.user_type
            instance = delete_user_account_condition(user, user_type_data, user_type, user_tb, data, random_num)
            return instance
        elif user_tb and passwd is None and signup_method in ['2','3']:
            inst = delete_user_account_condition_social(user, user_type, user_tb, data, random_num)
            return inst
        else:
            raise serializers.ValidationError({"details": ERROR_CODE['2031'], "code": "400", "status": "failed"})


class UserNotificationSerializer(serializers.ModelSerializer):
    """User Notification serializer"""
    class Meta(object):
        """Meta info"""
        model = UserNotification
        fields = '__all__'


class UpdateUserNotificationSerializer(serializers.ModelSerializer):
    """Update User Notification serializer"""
    class Meta(object):
        """Meta info"""
        model = UserNotification
        fields = ['push_notification', 'email_notification', 'sms_notification']

    def create(self, validated_data):
        instance = UserNotification.objects.filter(user=self.context).last()
        if instance:
            # change notification status
            instance.push_notification = validated_data.get('push_notification',instance.push_notification)
            instance.email_notification = validated_data.get('email_notification', instance.email_notification)
            instance.sms_notification = validated_data.get('sms_notification', instance.sms_notification)
            instance.save()
        else:
            instance = UserNotification.objects.create(user=self.context)
        return instance

class UserPhoneOtpSerializer(serializers.ModelSerializer):
    """User Phone serializers"""
    class Meta(object):
        """Meta info"""
        model = UserPhoneOtp
        fields = '__all__'