zod-backend/guardian/serializers.py

"""Serializer of Guardian"""
"""Third party Django app"""
import logging
import random
from rest_framework import serializers
from rest_framework_simplejwt.tokens import RefreshToken
from django.db import transaction
from django.contrib.auth.models import User
"""Import Django app"""
from .models import Guardian
from account.models import UserProfile, UserEmailOtp
from base.messages import ERROR_CODE, SUCCESS_CODE
from .utils import upload_image_to_alibaba
from junior.models import Junior
class UserSerializer(serializers.ModelSerializer):
    """User serializer"""
    auth_token = serializers.SerializerMethodField('get_auth_token')

    class Meta(object):
        """Meta info"""
        model = User
        fields = ['email', 'password', 'auth_token']

    def get_auth_token(self, obj):
        """generate auth token"""
        refresh = RefreshToken.for_user(obj)
        access_token = str(refresh.access_token)
        return access_token
    def create(self, validated_data):
        """fetch data"""
        email = validated_data.get('email')
        user_type = self.context
        password = validated_data.get('password')
        try:
            """Create user profile"""
            user = User.objects.create_user(username=email, email=email, password=password)
            UserProfile.objects.create(user=user, user_type=user_type)
            if user_type == '1':
                Junior.objects.create(auth=user)
            if user_type == '2':
                Guardian.objects.create(user=user)
            return user
        except Exception as e:
            """Error handling"""
            logging.error(e)
            otp = UserEmailOtp.objects.filter(email=email).last()
            otp_verified = False
            if otp and otp.is_verified:
                otp_verified = True
            raise serializers.ValidationError({"details":ERROR_CODE['2021'], "otp_verified":bool(otp_verified),
                                               "code": 400, "status":"failed",
                                               })

class CreateGuardianSerializer(serializers.ModelSerializer):
    """Create guardian serializer"""
    """Basic info"""
    first_name = serializers.SerializerMethodField('get_first_name')
    last_name = serializers.SerializerMethodField('get_last_name')
    email = serializers.SerializerMethodField('get_email')
    """Contact details"""
    phone = serializers.CharField(max_length=20, required=False)
    country_code = serializers.IntegerField(required=False)
    family_name = serializers.CharField(max_length=100, required=False)
    dob = serializers.DateField(required=False)
    referral_code = serializers.CharField(max_length=100, required=False)
    image = serializers.ImageField(required=False)

    class Meta(object):
        """Meta info"""
        model = Guardian
        fields = ['first_name', 'last_name', 'email', 'phone', 'family_name', 'gender', 'country_code',
                  'dob', 'referral_code', 'passcode', 'is_complete_profile', 'referral_code_used',
                  'country_name', 'image']

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

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

    def get_email(self,obj):
        """emailof guardian"""
        return obj.user.email

    def create(self, validated_data):
        """Create guardian profile"""
        # phone_number = validated_data.get('phone', None)
        # guardian_data = Guardian.objects.filter(phone=phone_number)
        # junior_data = Junior.objects.filter(phone=phone_number)
        # if phone_number and (guardian_data or junior_data):
        #     raise serializers.ValidationError({"details": ERROR_CODE['2012']})
        user = User.objects.filter(username=self.context['user']).last()
        if user:
            """Save first and last name of guardian"""
            if self.context.get('first_name') != '' and self.context.get('last_name') != '':
                user.first_name = self.context.get('first_name', user.first_name)
                user.last_name = self.context.get('last_name', user.last_name)
                user.save()
        """Create guardian data"""
        guardian, created = Guardian.objects.get_or_create(user=self.context['user'])
        if created:
            """Create referral code and guardian code"""
            guardian.referral_code = ''.join([str(random.randrange(9)) for _ in range(4)])
            guardian.guardian_code = ''.join([str(random.randrange(9)) for _ in range(4)])
        if guardian:
            """update details according to the data get from request"""
            guardian.gender = validated_data.get('gender',guardian.gender)
            guardian.family_name = validated_data.get('family_name', guardian.family_name)
            guardian.dob = validated_data.get('dob',guardian.dob)
            """Update country code and phone number"""
            guardian.phone = validated_data.get('phone', guardian.phone)
            guardian.country_code = validated_data.get('country_code', guardian.country_code)
            guardian.passcode = validated_data.get('passcode', guardian.passcode)
            guardian.country_name = validated_data.get('country_name', guardian.country_name)
            guardian.referral_code_used = validated_data.get('referral_code_used', guardian.referral_code_used)
            """Complete profile of the junior if below all data are filled"""
            complete_profile_field = all([guardian.phone, guardian.gender, guardian.family_name, guardian.country_name,
                                          guardian.dob, guardian.country_code, user.first_name, user.last_name])
            guardian.is_complete_profile = False
            if complete_profile_field:
                guardian.is_complete_profile = True
            image = validated_data.pop('image', None)
            if image:
                filename = f"images/{image.name}"
                image_url = upload_image_to_alibaba(image, filename)
                guardian.image = image_url
            guardian.save()
        return guardian

    def save(self, **kwargs):
        """Save the data into junior table"""
        with transaction.atomic():
            instance = super().save(**kwargs)
            return instance