login api with user type

guardian code chnages

account/serializers.py

@@ -216,10 +216,17 @@ class GuardianSerializer(serializers.ModelSerializer):
 
     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'])
+        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"""

account/utils.py

@@ -1,4 +1,6 @@
 """Account utils"""
+from celery import shared_task
+
 """Import django"""
 from django.conf import settings
 from rest_framework import viewsets, status
@@ -20,7 +22,7 @@ from rest_framework import serializers
 # Import messages from base package"""
 from junior.models import Junior
 from guardian.models import Guardian
-from account.models import UserDelete
+from account.models import UserDelete, UserDeviceDetails
 from base.messages import ERROR_CODE
 from django.utils import timezone
 from base.constants import NUMBER
@@ -44,7 +46,7 @@ from junior.models import JuniorPoints
 # referral code,
 # Define function for generating
 # alphanumeric code
-
+# otp expiry
 def delete_user_account_condition(user, user_type_data, user_type, user_tb, data, random_num):
     """delete user account"""
     if user_type == '1' and user_type_data == '1':
@@ -109,6 +111,7 @@ def guardian_account_update(user_tb):
         for data in jun_data:
             data.guardian_code.remove(guardian_data.guardian_code)
             data.save()
+@shared_task()
 def send_otp_email(recipient_email, otp):
     """Send otp on email with template"""
     from_email = settings.EMAIL_FROM_ADDRESS
@@ -124,6 +127,20 @@ def send_otp_email(recipient_email, otp):
     )
     return otp
 
+@shared_task
+def user_device_details(user, device_id):
+    """
+    Used to store the device id of the user
+    user: user object
+    device_id: string
+    return
+    """
+    device_details, created = UserDeviceDetails.objects.get_or_create(user=user)
+    if device_details:
+        device_details.device_id = device_id
+        device_details.save()
+
+
 def send_support_email(name, sender, subject, message):
     """Send otp on email with template"""
     to_email = [settings.EMAIL_FROM_ADDRESS]

account/views.py

@@ -1,11 +1,12 @@
 """Account view """
+import threading
+
 from notifications.utils import remove_fcm_token
 
 # django imports
 from datetime import datetime, timedelta
 from rest_framework import viewsets, status, views
 from rest_framework.decorators import action
-import random
 import logging
 from django.utils import timezone
 import jwt
@@ -35,10 +36,10 @@ from .serializers import (SuperUserSerializer, GuardianSerializer, JuniorSeriali
                           AdminLoginSerializer)
 from rest_framework_simplejwt.tokens import RefreshToken
 from base.messages import ERROR_CODE, SUCCESS_CODE
-from base.constants import NUMBER, ZOD, JUN, GRD
+from base.constants import NUMBER, ZOD, JUN, GRD, USER_TYPE_FLAG
 from guardian.tasks import generate_otp
 from account.utils import (send_otp_email, send_support_email, custom_response, custom_error_response,
-                           generate_code, OTP_EXPIRY)
+                           generate_code, OTP_EXPIRY, user_device_details)
 from junior.serializers import JuniorProfileSerializer
 from guardian.serializers import GuardianProfileSerializer
 
@@ -280,29 +281,48 @@ class UserPhoneVerification(viewsets.ModelViewSet):
             return custom_error_response(ERROR_CODE["2008"], response_status=status.HTTP_400_BAD_REQUEST)
 
 
-
 class UserLogin(viewsets.ViewSet):
     """User login"""
     @action(methods=['post'], detail=False)
     def login(self, request):
         username = request.data.get('username')
         password = request.data.get('password')
+        user_type = request.data.get('user_type')
         device_id = request.META.get('HTTP_DEVICE_ID')
         user = authenticate(request, username=username, password=password)
 
         try:
             if user is not None:
                 login(request, user)
-                guardian_data = Guardian.objects.filter(user__username=username, is_verified=True).last()
-                if guardian_data:
-                    serializer = GuardianSerializer(guardian_data).data
-                junior_data = Junior.objects.filter(auth__username=username, is_verified=True).last()
-                if junior_data:
-                    serializer = JuniorSerializer(junior_data).data
-                device_details, created = UserDeviceDetails.objects.get_or_create(user=user)
-                if device_details:
-                    device_details.device_id = device_id
-                    device_details.save()
+                if user_type == USER_TYPE_FLAG["TWO"]:
+                    guardian_data = Guardian.objects.filter(user__username=username, is_verified=True).last()
+                    if guardian_data:
+                        serializer = GuardianSerializer(
+                            guardian_data, context={'user_type': user_type}
+                        ).data
+                    else:
+                        return custom_error_response(
+                            ERROR_CODE["2070"],
+                            response_status=status.HTTP_401_UNAUTHORIZED
+                        )
+                elif user_type == USER_TYPE_FLAG["FIRST"]:
+                    junior_data = Junior.objects.filter(auth__username=username, is_verified=True).last()
+                    if junior_data:
+                        serializer = JuniorSerializer(
+                            junior_data, context={'user_type': user_type}
+                        ).data
+                    else:
+                        return custom_error_response(
+                            ERROR_CODE["2071"],
+                            response_status=status.HTTP_401_UNAUTHORIZED
+                        )
+                else:
+                    return custom_error_response(
+                        ERROR_CODE["2069"],
+                        response_status=status.HTTP_401_UNAUTHORIZED
+                    )
+                # storing device id in using thread so the time would be reduced
+                threading.Thread(target=user_device_details, args=(user, device_id))
                 return custom_response(SUCCESS_CODE['3003'], serializer, response_status=status.HTTP_200_OK)
             else:
                 return custom_error_response(ERROR_CODE["2002"], response_status=status.HTTP_401_UNAUTHORIZED)
@@ -312,9 +332,12 @@ class UserLogin(viewsets.ViewSet):
             refresh = RefreshToken.for_user(user)
             access_token = str(refresh.access_token)
             refresh_token = str(refresh)
-            data = {"auth_token":access_token, "refresh_token":refresh_token, "is_profile_complete": False,
-                    "user_type": email_verified.user_type,
-                    }
+            data = {
+                "auth_token":access_token,
+                "refresh_token":refresh_token,
+                "is_profile_complete": False,
+                "user_type": user_type,
+            }
             is_verified = False
             if email_verified:
                 is_verified = email_verified.is_verified
@@ -323,11 +346,18 @@ class UserLogin(viewsets.ViewSet):
                 email_verified.otp = otp
                 email_verified.save()
                 data.update({"email_otp":otp})
-                send_otp_email(username, otp)
-                return custom_response(ERROR_CODE['2024'], {"email_otp": otp, "is_email_verified": is_verified},
-                                       response_status=status.HTTP_200_OK)
+                send_otp_email.delay(username, otp)
+                return custom_response(
+                    ERROR_CODE['2024'],
+                    {"email_otp": otp, "is_email_verified": is_verified},
+                    response_status=status.HTTP_200_OK
+                )
             data.update({"is_email_verified": is_verified})
-            return custom_response(SUCCESS_CODE['3003'], data, response_status=status.HTTP_200_OK)
+            return custom_response(
+                SUCCESS_CODE['3003'],
+                data,
+                response_status=status.HTTP_200_OK
+            )
 
     @action(methods=['post'], detail=False)
     def admin_login(self, request):

base/constants.py

@@ -50,6 +50,13 @@ USER_TYPE = (
     ('2', 'guardian'),
     ('3', 'superuser')
 )
+
+USER_TYPE_FLAG = {
+    "FIRST" : "1",
+    "TWO" : "2",
+    "THREE": "3"
+}
+
 """gender"""
 GENDERS = (
     ('1', 'Male'),

base/messages.py

@@ -94,7 +94,10 @@ ERROR_CODE = {
     "2065": "Passwords do not match. Please try again.",
     "2066": "Task does not exist or not in expired state",
     "2067": "Action not allowed. User type missing.",
-    "2068": "No guardian associated with this junior"
+    "2068": "No guardian associated with this junior",
+    "2069": "Invalid user type",
+    "2070": "You did not find as a guardian",
+    "2071": "You did not find as a junior"
 
 }
 """Success message code"""

junior/serializers.py

@@ -146,8 +146,8 @@ class JuniorDetailSerializer(serializers.ModelSerializer):
         """Meta info"""
         model = Junior
         fields = ['id', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'gender', 'dob',
-                  'guardian_code', 'image', 'is_invited', 'referral_code','is_active', 'is_complete_profile', 'created_at',
-                  'image', 'updated_at']
+                  'guardian_code', 'image', 'is_invited', 'referral_code','is_active', 'is_complete_profile',
+                  'created_at', 'image', 'updated_at']
 
 class JuniorDetailListSerializer(serializers.ModelSerializer):
     """junior serializer"""
@@ -502,6 +502,7 @@ class RemoveGuardianCodeSerializer(serializers.ModelSerializer):
         model = Junior
         fields = ('id', )
     def update(self, instance, validated_data):
+        instance.guardian_code = None
         instance.guardian_code_status = str(NUMBER['one'])
         instance.save()
         return instance

notifications/views.py

@@ -11,8 +11,10 @@ from rest_framework import viewsets, status, views
 from account.utils import custom_response, custom_error_response
 from base.messages import SUCCESS_CODE, ERROR_CODE
 from notifications.constants import TEST_NOTIFICATION
+# Import serializer
 from notifications.serializers import RegisterDevice, NotificationListSerializer, ReadNotificationSerializer
 from notifications.utils import send_notification
+# Import model
 from notifications.models import Notification
 
 

web_admin/pagination.py

@@ -0,0 +1,13 @@
+"""
+web_admin pagination file
+"""
+from rest_framework.pagination import PageNumberPagination
+
+
+class CustomPageNumberPagination(PageNumberPagination):
+    """
+    custom paginator class
+    """
+    page_size = 10  # Set the desired page size
+    page_size_query_param = 'page_size'
+    max_page_size = 100  # Set a maximum page size if needed

web_admin/serializers/article_serializer.py

@@ -224,7 +224,7 @@ class ArticleListSerializer(serializers.ModelSerializer):
     total_points = serializers.SerializerMethodField('get_total_points')
     is_completed = serializers.SerializerMethodField('get_is_completed')
 
-    class Meta:
+    class Meta(object):
         """
         meta class
         """
@@ -238,9 +238,10 @@ class ArticleListSerializer(serializers.ModelSerializer):
 
     def get_is_completed(self, obj):
         """complete all question"""
-        junior_article = JuniorArticle.objects.filter(article=obj).last()
+        context_data = self.context.get('user')
+        junior_article = JuniorArticle.objects.filter(junior__auth=context_data, article=obj).last()
         if junior_article:
-            junior_article.is_completed
+            return junior_article.is_completed
         return False
 
 class ArticleQuestionSerializer(serializers.ModelSerializer):
@@ -278,7 +279,7 @@ class ArticleQuestionSerializer(serializers.ModelSerializer):
             return junior_article_obj.submitted_answer.id
         return None
 
-    class Meta:
+    class Meta(object):
         """
         meta class
         """
@@ -299,7 +300,7 @@ class StartAssessmentSerializer(serializers.ModelSerializer):
         if data:
             return data.current_que_page
         return NUMBER['zero']
-    class Meta:
+    class Meta(object):
         """
         meta class
         """
@@ -325,7 +326,7 @@ class ArticleCardlistSerializer(serializers.ModelSerializer):
             return data.current_card_page
         return NUMBER['zero']
 
-    class Meta:
+    class Meta(object):
         """
         meta class
         """

web_admin/views/analytics.py

@@ -1,10 +1,15 @@
 """
 web_admin analytics view file
 """
+# python imports
 import datetime
 
+# third party imports
 from rest_framework.viewsets import GenericViewSet
 from rest_framework.decorators import action
+from rest_framework.permissions import IsAuthenticated
+
+# django imports
 from django.contrib.auth import get_user_model
 from django.db.models import Q
 from django.db.models import Count
@@ -12,10 +17,13 @@ from django.db.models.functions import TruncDate
 from django.db.models import F, Window
 from django.db.models.functions.window import Rank
 
+# local imports
 from account.utils import custom_response
 from base.constants import PENDING, IN_PROGRESS, REJECTED, REQUESTED, COMPLETED, EXPIRED, DATE_FORMAT
 from guardian.models import JuniorTask
 from junior.models import JuniorPoints
+from web_admin.pagination import CustomPageNumberPagination
+from web_admin.permission import AdminPermission
 from web_admin.serializers.analytics_serializer import LeaderboardSerializer
 
 USER = get_user_model()
@@ -30,6 +38,7 @@ class AnalyticsViewSet(GenericViewSet):
     to get junior leaderboard and ranking
     """
     serializer_class = None
+    permission_classes = [IsAuthenticated, AdminPermission]
 
     def get_queryset(self):
         user_qs = USER.objects.filter(
@@ -128,7 +137,7 @@ class AnalyticsViewSet(GenericViewSet):
             expression=Rank(),
             order_by=[F('total_points').desc(), 'junior__created_at']
         )).order_by('-total_points', 'junior__created_at')
-        paginator = self.pagination_class()
+        paginator = CustomPageNumberPagination()
         paginated_queryset = paginator.paginate_queryset(queryset, request)
         serializer = self.serializer_class(paginated_queryset, many=True)
         return custom_response(None, serializer.data)

web_admin/views/article.py

@@ -221,10 +221,7 @@ class ArticleListViewSet(GenericViewSet, mixins.ListModelMixin):
         :return: list of article
         """
         queryset = self.get_queryset()
-        count = queryset.count()
-        paginator = self.pagination_class()
-        paginated_queryset = paginator.paginate_queryset(queryset, request)
-        serializer = self.serializer_class(paginated_queryset, many=True)
+        serializer = self.serializer_class(queryset, context={"user": request.user}, many=True)
         return custom_response(None, data=serializer.data)
 
 class ArticleCardListViewSet(viewsets.ModelViewSet):