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, ForceUpdate
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, required=True)
    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 = self.context
        user_details.set_password(new_password)
        user_details.save()
        return {'password':new_password}


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

    def validate_email(self, value):
        """
        validate email exist ot not
        value: string
        return none
        """
        if not User.objects.get(email=value):
            raise serializers.ValidationError({'details': ERROR_CODE['2004']})
        return value

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',
                                          'username', 'is_active', 'is_superuser').first()

        if not user or not user.check_password(attrs['password']):
            raise serializers.ValidationError({'details': ERROR_CODE['2002']})

        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"""
        if self.context.get('user_type', ''):
            return self.context.get('user_type')
        # remove the below code once user_type can be passed
        # from everywhere from where this serializer is being called
        else:
            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_deleted',
                  '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',
                  'is_deleted']

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



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__'

class ForceUpdateSerializer(serializers.ModelSerializer):
    # ForceUpdate Serializer

    class Meta(object):
        """ meta info """
        model = ForceUpdate
        fields = ('id', 'version', 'device_type')