login api with user type

guardian code chnages

account/serializers.py

@@ -152,12 +152,12 @@ class AdminLoginSerializer(serializers.ModelSerializer):
 
     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()
+                                   ).only('id', 'first_name', 'last_name', 'email',
+                                          'username', 'is_active', 'is_superuser').first()
 
-        if not user:
+        if not user or not user.check_password(attrs['password']):
-            raise serializers.ValidationError({'details': ERROR_CODE['2002']})
-        elif not user.check_password(attrs['password']):
             raise serializers.ValidationError({'details': ERROR_CODE['2002']})
+
         self.context.update({'user': user})
         return attrs
 
@@ -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 self.context.get('user_type', ''):
-        if email_verified and email_verified.user_type is not None:
+            return self.context.get('user_type')
-            return email_verified.user_type
+        # remove the below code once user_type can be passed
-        return str(NUMBER['two'])
+        # 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,10 +22,11 @@ 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
+from junior.models import JuniorPoints
 # Define delete
 # user account condition,
 # Define delete
@@ -43,7 +46,7 @@ from django.utils import timezone
 # 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':
@@ -91,7 +94,9 @@ def junior_account_update(user_tb):
         junior_data.is_active = False
         junior_data.is_verified = False
         junior_data.guardian_code = '{}'
+        junior_data.guardian_code_status = str(NUMBER['one'])
         junior_data.save()
+        JuniorPoints.objects.filter(junior=junior_data).delete()
 
 def guardian_account_update(user_tb):
     """update guardian account after delete the user account"""
@@ -106,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
@@ -121,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,4 +1,6 @@
 """Account view """
+import threading
+
 from notifications.utils import remove_fcm_token
 
 # django imports
@@ -23,7 +25,7 @@ from django.conf import settings
 
 # local imports
 from guardian.models import Guardian
-from junior.models import Junior
+from junior.models import Junior, JuniorPoints
 from guardian.utils import upload_image_to_alibaba
 from account.models import UserDeviceDetails, UserPhoneOtp, UserEmailOtp, DefaultTaskImages, UserNotification
 from django.contrib.auth.models import User
@@ -35,10 +37,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
 
@@ -97,6 +99,8 @@ class GoogleLoginMixin(object):
                                                      referral_code=generate_code(ZOD, user_obj.id)
                                                      )
                 serializer = JuniorSerializer(junior_query)
+                position = Junior.objects.all().count()
+                JuniorPoints.objects.create(junior=junior_query, position=position)
             if str(user_type) == '2':
                 guardian_query = Guardian.objects.create(user=user_obj, is_verified=True, is_active=True,
                                                          image=profile_picture,signup_method='2',
@@ -147,6 +151,8 @@ class SigninWithApple(views.APIView):
                                                              junior_code=generate_code(JUN, user.id),
                                                              referral_code=generate_code(ZOD, user.id))
                         serializer = JuniorSerializer(junior_query)
+                        position = Junior.objects.all().count()
+                        JuniorPoints.objects.create(junior=junior_query, position=position)
                     if str(user_type) == '2':
                         guardian_query = Guardian.objects.create(user=user, is_verified=True, is_active=True,
                                                                  signup_method='3',
@@ -245,7 +251,6 @@ class ForgotPasswordAPIView(views.APIView):
 
 class SendPhoneOtp(viewsets.ModelViewSet):
     """Send otp on phone"""
-    queryset = UserPhoneOtp.objects.all()
     serializer_class = UserPhoneOtpSerializer
     def create(self, request, *args, **kwargs):
         otp = generate_otp()
@@ -262,7 +267,6 @@ class SendPhoneOtp(viewsets.ModelViewSet):
 
 class UserPhoneVerification(viewsets.ModelViewSet):
     """Send otp on phone"""
-    queryset = UserPhoneOtp.objects.all()
     serializer_class = UserPhoneOtpSerializer
     def list(self, request, *args, **kwargs):
         try:
@@ -278,29 +282,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 user_type == USER_TYPE_FLAG["TWO"]:
-                if guardian_data:
+                    guardian_data = Guardian.objects.filter(user__username=username, is_verified=True).last()
-                    serializer = GuardianSerializer(guardian_data).data
+                    if guardian_data:
-                junior_data = Junior.objects.filter(auth__username=username, is_verified=True).last()
+                        serializer = GuardianSerializer(
-                if junior_data:
+                            guardian_data, context={'user_type': user_type}
-                    serializer = JuniorSerializer(junior_data).data
+                        ).data
-                device_details, created = UserDeviceDetails.objects.get_or_create(user=user)
+                    else:
-                if device_details:
+                        return custom_error_response(
-                    device_details.device_id = device_id
+                            ERROR_CODE["2070"],
-                    device_details.save()
+                            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)
@@ -310,9 +333,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,
+            data = {
-                    "user_type": email_verified.user_type,
+                "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
@@ -321,23 +347,30 @@ class UserLogin(viewsets.ViewSet):
                 email_verified.otp = otp
                 email_verified.save()
                 data.update({"email_otp":otp})
-                send_otp_email(username, otp)
+                send_otp_email.delay(username, otp)
-                return custom_response(ERROR_CODE['2024'], {"email_otp": otp, "is_email_verified": is_verified},
+                return custom_response(
-                                       response_status=status.HTTP_200_OK)
+                    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):
         email = request.data.get('email')
         password = request.data.get('password')
         user = User.objects.filter(email__iexact=email, is_superuser=True
-                                   ).only('id', 'first_name', 'last_name', 'email', 'is_superuser').first()
+                                   ).only('id', 'first_name', 'last_name', 'email',
+                                          'username', 'is_active', 'is_superuser').first()
 
-        if not user:
+        if not user or not user.check_password(password):
-            return custom_error_response(ERROR_CODE["2002"], response_status=status.HTTP_400_BAD_REQUEST)
-        elif not user.check_password(password):
             return custom_error_response(ERROR_CODE["2002"], response_status=status.HTTP_400_BAD_REQUEST)
+
         serializer = SuperUserSerializer(user)
         return custom_response(SUCCESS_CODE['3003'], serializer.data, response_status=status.HTTP_200_OK)
 
@@ -369,7 +402,6 @@ class AdminLoginViewSet(viewsets.GenericViewSet):
 class UserEmailVerification(viewsets.ModelViewSet):
     """User Email verification"""
     serializer_class = EmailVerificationSerializer
-    queryset = UserEmailOtp.objects.all()
 
     def list(self, request, *args, **kwargs):
         try:
@@ -412,7 +444,6 @@ class UserEmailVerification(viewsets.ModelViewSet):
 
 class ReSendEmailOtp(viewsets.ModelViewSet):
     """Send otp on phone"""
-    queryset = UserEmailOtp.objects.all()
     serializer_class = EmailVerificationSerializer
     permission_classes = [IsAuthenticated]
 
@@ -435,7 +466,6 @@ class ReSendEmailOtp(viewsets.ModelViewSet):
 
 class ProfileAPIViewSet(viewsets.ModelViewSet):
     """Profile viewset"""
-    queryset = User.objects.all()
     serializer_class = JuniorProfileSerializer
     permission_classes = [IsAuthenticated]
 
@@ -454,7 +484,6 @@ class ProfileAPIViewSet(viewsets.ModelViewSet):
 
 class UploadImageAPIViewSet(viewsets.ModelViewSet):
     """upload  task image"""
-    queryset = DefaultTaskImages.objects.all()
     serializer_class = DefaultTaskImagesSerializer
     def create(self, request, *args, **kwargs):
         """upload images"""
@@ -473,7 +502,6 @@ class UploadImageAPIViewSet(viewsets.ModelViewSet):
 
 class DefaultImageAPIViewSet(viewsets.ModelViewSet):
     """Profile viewset"""
-    queryset = DefaultTaskImages.objects.all()
     serializer_class = DefaultTaskImagesDetailsSerializer
     permission_classes = [IsAuthenticated]
     def list(self, request, *args, **kwargs):
@@ -504,7 +532,6 @@ class DeleteUserProfileAPIViewSet(viewsets.GenericViewSet):
 
 class UserNotificationAPIViewSet(viewsets.ModelViewSet):
     """notification viewset"""
-    queryset = UserNotification.objects.all()
     serializer_class = UserNotificationSerializer
     permission_classes = [IsAuthenticated]
     def list(self, request, *args, **kwargs):
@@ -516,7 +543,6 @@ class UserNotificationAPIViewSet(viewsets.ModelViewSet):
 
 class UpdateUserNotificationAPIViewSet(viewsets.ModelViewSet):
     """Update notification viewset"""
-    queryset = UserNotification.objects.all()
     serializer_class = UpdateUserNotificationSerializer
     permission_classes = [IsAuthenticated]
 

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'),
@@ -70,6 +77,18 @@ SIGNUP_METHODS = (
     ('2', 'google'),
     ('3', 'apple')
 )
+# guardian code status
+GUARDIAN_CODE_STATUS = (
+    ('1', 'no guardian code'),
+    ('2', 'exist guardian code'),
+    ('3', 'request for guardian code')
+)
+# article status
+ARTICLE_STATUS = (
+    ('1', 'read'),
+    ('2', 'in_progress'),
+    ('3', 'completed')
+)
 # relationship
 RELATIONSHIP = (
     ('1', 'parent'),
@@ -106,7 +125,9 @@ MAX_ARTICLE_CARD = 6
 MIN_ARTICLE_SURVEY = 5
 MAX_ARTICLE_SURVEY = 10
 
-# real time url
+# already register
-time_url = "http://worldtimeapi.org/api/timezone/Asia/Riyadh"
+Already_register_user = "duplicate key value violates unique constraint"
 
 ARTICLE_CARD_IMAGE_FOLDER = 'article-card-images'
+
+DATE_FORMAT = '%Y-%m-%d'

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"""
@@ -149,7 +152,18 @@ SUCCESS_CODE = {
     "3037": "Profile has been updated successfully.",
     "3038": "Status has been changed successfully.",
     # notification read
-    "3039": "Notification read successfully"
+    "3039": "Notification read successfully",
+    # start article
+    "3040": "Start article successfully",
+    # complete article
+    "3041": "Article completed successfully",
+    # submit assessment successfully
+    "3042": "Assessment completed successfully",
+    # read article
+    "3043": "Read article card successfully",
+    # remove guardian code request
+    "3044": "Remove guardian code request successfully",
+
 }
 """status code error"""
 STATUS_CODE_ERROR = {

guardian/serializers.py

@@ -23,7 +23,7 @@ from account.models import UserProfile, UserEmailOtp, UserNotification
 from account.utils import generate_code
 from junior.serializers import JuniorDetailSerializer
 from base.messages import ERROR_CODE, SUCCESS_CODE
-from base.constants import NUMBER, JUN, ZOD, GRD
+from base.constants import NUMBER, JUN, ZOD, GRD, Already_register_user
 from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
 from .utils import real_time, convert_timedelta_into_datetime, update_referral_points
 # notification's constant
@@ -68,8 +68,10 @@ class UserSerializer(serializers.ModelSerializer):
             UserNotification.objects.get_or_create(user=user)
             if user_type == str(NUMBER['one']):
                 # create junior profile
-                Junior.objects.create(auth=user, junior_code=generate_code(JUN, user.id),
+                junior = Junior.objects.create(auth=user, junior_code=generate_code(JUN, user.id),
-                                      referral_code=generate_code(ZOD, user.id))
+                                               referral_code=generate_code(ZOD, user.id))
+                position = Junior.objects.all().count()
+                JuniorPoints.objects.create(junior=junior, position=position)
             if user_type == str(NUMBER['two']):
                 # create guardian profile
                 Guardian.objects.create(user=user, guardian_code=generate_code(GRD, user.id),
@@ -82,7 +84,7 @@ class UserSerializer(serializers.ModelSerializer):
             otp_verified = False
             if otp and otp.is_verified:
                 otp_verified = True
-            raise serializers.ValidationError({"details":ERROR_CODE['2021'], "otp_verified":bool(otp_verified),
+            raise serializers.ValidationError({"details": ERROR_CODE['2021'], "otp_verified":bool(otp_verified),
                                                "code": 400, "status":"failed",
                                                })
 
@@ -353,6 +355,7 @@ class ApproveJuniorSerializer(serializers.ModelSerializer):
         instance = self.context['junior']
         instance.guardian_code = [self.context['guardian_code']]
         instance.guardian_code_approved = True
+        instance.guardian_code_status = str(NUMBER['two'])
         instance.save()
         return instance
 
@@ -385,8 +388,6 @@ class ApproveTaskSerializer(serializers.ModelSerializer):
                 # reject the task
                 instance.task_status = str(NUMBER['three'])
                 instance.is_approved = False
-                # update total task point
-                junior_data.total_points = junior_data.total_points - instance.points
                 # update reject time of task
                 # instance.rejected_on = real_time()
                 instance.rejected_on = timezone.now().astimezone(pytz.utc)
@@ -403,11 +404,20 @@ class GuardianDetailListSerializer(serializers.ModelSerializer):
     email = serializers.SerializerMethodField('get_email')
     image = serializers.SerializerMethodField('get_image')
     guardian_id = serializers.SerializerMethodField('get_guardian_id')
+    guardian_code = serializers.SerializerMethodField('get_guardian_code')
+    gender = serializers.SerializerMethodField('get_gender')
+    phone = serializers.SerializerMethodField('get_phone')
+    country_name = serializers.SerializerMethodField('get_country_name')
+    dob = serializers.SerializerMethodField('get_dob')
+    guardian_code_status = serializers.SerializerMethodField('get_guardian_code_status')
+    # code info
+
 
     class Meta(object):
         """Meta info"""
         model = JuniorGuardianRelationship
-        fields = ['guardian_id', 'first_name', 'last_name', 'email', 'relationship', 'image', 'created_at',
+        fields = ['guardian_id', 'first_name', 'last_name', 'email', 'relationship', 'image', 'dob',
+                  'guardian_code', 'gender', 'phone', 'country_name', 'created_at', 'guardian_code_status',
                   'updated_at']
 
     def get_guardian_id(self,obj):
@@ -422,9 +432,33 @@ class GuardianDetailListSerializer(serializers.ModelSerializer):
         return obj.guardian.user.last_name
 
     def get_email(self,obj):
-        """emailof guardian"""
+        """email of guardian"""
         return obj.guardian.user.email
 
     def get_image(self,obj):
-        """first name of guardian"""
+        """guardian image"""
         return obj.guardian.image
+
+    def get_guardian_code(self,obj):
+        """ guardian code"""
+        return obj.guardian.guardian_code
+
+    def get_gender(self,obj):
+        """ guardian gender"""
+        return obj.guardian.gender
+
+    def get_phone(self,obj):
+        """guardian phone"""
+        return obj.guardian.phone
+
+    def get_country_name(self,obj):
+        """ guardian country name """
+        return obj.guardian.country_name
+
+    def get_dob(self,obj):
+        """guardian dob """
+        return obj.guardian.dob
+
+    def get_guardian_code_status(self,obj):
+        """guardian code status"""
+        return obj.junior.guardian_code_status

guardian/utils.py

@@ -11,7 +11,7 @@ import tempfile
 # Import date time module's function
 from datetime import datetime, time
 # import Number constant
-from base.constants import NUMBER, time_url
+from base.constants import NUMBER
 # Import Junior's model
 from junior.models import Junior, JuniorPoints
 # Import guardian's model

guardian/views.py

@@ -10,8 +10,8 @@ from rest_framework.permissions import IsAuthenticated
 from rest_framework import viewsets, status
 from rest_framework.pagination import PageNumberPagination
 from django.contrib.auth.models import User
-from rest_framework.filters import SearchFilter
 
+from rest_framework.filters import SearchFilter
 from django.utils import timezone
 
 # Import guardian's model,
@@ -36,7 +36,7 @@ from account.models import UserEmailOtp, UserNotification
 from .tasks import generate_otp
 from account.utils import custom_response, custom_error_response, OTP_EXPIRY, send_otp_email
 from base.messages import ERROR_CODE, SUCCESS_CODE
-from base.constants import NUMBER
+from base.constants import NUMBER, GUARDIAN_CODE_STATUS
 from .utils import upload_image_to_alibaba
 from notifications.constants import REGISTRATION, TASK_CREATED, LEADERBOARD_RANKING
 from notifications.utils import send_notification
@@ -59,33 +59,29 @@ class SignupViewset(viewsets.ModelViewSet):
     serializer_class = UserSerializer
     def create(self, request, *args, **kwargs):
         """Create user profile"""
-        try:
+        if request.data['user_type'] in [str(NUMBER['one']), str(NUMBER['two'])]:
-            if request.data['user_type'] in [str(NUMBER['one']), str(NUMBER['two'])]:
+            serializer = UserSerializer(context=request.data['user_type'], data=request.data)
-                serializer = UserSerializer(context=request.data['user_type'], data=request.data)
+            if serializer.is_valid():
-                if serializer.is_valid():
+                user = serializer.save()
-                    user = serializer.save()
+                """Generate otp"""
-                    """Generate otp"""
+                otp = generate_otp()
-                    otp = generate_otp()
+                # expire otp after 1 day
-                    # expire otp after 1 day
+                expiry = OTP_EXPIRY
-                    expiry = OTP_EXPIRY
+                # create user email otp object
-                    # create user email otp object
+                UserEmailOtp.objects.create(email=request.data['email'], otp=otp,
-                    UserEmailOtp.objects.create(email=request.data['email'], otp=otp,
+                                            user_type=str(request.data['user_type']), expired_at=expiry)
-                                                user_type=str(request.data['user_type']), expired_at=expiry)
+                """Send email to the register user"""
-                    """Send email to the register user"""
+                send_otp_email(request.data['email'], otp)
-                    send_otp_email(request.data['email'], otp)
+                # send push notification for registration
-                    # send push notification for registration
+                send_notification.delay(REGISTRATION, None, user.id, {})
-                    send_notification.delay(REGISTRATION, None, user.id, {})
+                return custom_response(SUCCESS_CODE['3001'],
-                    return custom_response(SUCCESS_CODE['3001'],
+                                       response_status=status.HTTP_200_OK)
-                                           response_status=status.HTTP_200_OK)
+            return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
-                return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
+        else:
-            else:
+            return custom_error_response(ERROR_CODE['2028'], response_status=status.HTTP_400_BAD_REQUEST)
-                return custom_error_response(ERROR_CODE['2028'], response_status=status.HTTP_400_BAD_REQUEST)
-        except Exception as e:
-            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class UpdateGuardianProfile(viewsets.ViewSet):
     """Update guardian profile"""
-    queryset = Guardian.objects.all()
     serializer_class = CreateGuardianSerializer
     permission_classes = [IsAuthenticated]
 
@@ -119,7 +115,6 @@ class UpdateGuardianProfile(viewsets.ViewSet):
 class AllTaskListAPIView(viewsets.ModelViewSet):
     """Update guardian profile"""
     serializer_class = TaskDetailsSerializer
-    queryset = JuniorTask.objects.all()
     permission_classes = [IsAuthenticated]
 
     def list(self, request, *args, **kwargs):
@@ -129,38 +124,6 @@ class AllTaskListAPIView(viewsets.ModelViewSet):
         serializer = TaskDetailsSerializer(queryset, many=True)
         return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
 
-# class TaskListAPIView(viewsets.ModelViewSet):
-#     """Update guardian profile"""
-#     serializer_class = TaskDetailsSerializer
-#     permission_classes = [IsAuthenticated]
-#     pagination_class = PageNumberPagination
-#     http_method_names = ('get',)
-#
-#     def list(self, request, *args, **kwargs):
-#         """Create guardian profile"""
-#         try:
-#             status_value = self.request.GET.get('status')
-#             search = self.request.GET.get('search')
-#             if search and str(status_value) == '0':
-#                 queryset = JuniorTask.objects.filter(guardian__user=request.user,
-#                                                      task_name__icontains=search).order_by('due_date', 'created_at')
-#             elif search and str(status_value) != '0':
-#                 queryset = JuniorTask.objects.filter(guardian__user=request.user,task_name__icontains=search,
-#                                                      task_status=status_value).order_by('due_date', 'created_at')
-#             if search is None and str(status_value) == '0':
-#                 queryset = JuniorTask.objects.filter(guardian__user=request.user).order_by('due_date', 'created_at')
-#             elif search is None and str(status_value) != '0':
-#                 queryset = JuniorTask.objects.filter(guardian__user=request.user,
-#                                                      task_status=status_value).order_by('due_date','created_at')
-#             paginator = self.pagination_class()
-#             # use Pagination
-#             paginated_queryset = paginator.paginate_queryset(queryset, request)
-#             # use TaskDetailsSerializer serializer
-#             serializer = TaskDetailsSerializer(paginated_queryset, many=True)
-#             return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
-#         except Exception as e:
-#             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
-
 
 class TaskListAPIView(viewsets.ModelViewSet):
     """Update guardian profile"""
@@ -261,9 +224,9 @@ class SearchTaskListAPIView(viewsets.ModelViewSet):
 
 class TopJuniorListAPIView(viewsets.ModelViewSet):
     """Top juniors list"""
+    queryset = JuniorPoints.objects.all()
     serializer_class = TopJuniorSerializer
     permission_classes = [IsAuthenticated]
-    queryset = JuniorPoints.objects.all()
 
     def get_serializer_context(self):
         # context list
@@ -275,14 +238,12 @@ class TopJuniorListAPIView(viewsets.ModelViewSet):
         """Fetch junior list of those who complete their tasks"""
         try:
             junior_total_points = self.get_queryset().order_by('-total_points')
-
             # Update the position field for each JuniorPoints object
             for index, junior in enumerate(junior_total_points):
                 junior.position = index + 1
                 send_notification.delay(LEADERBOARD_RANKING, None, junior.junior.auth.id, {})
                 junior.save()
-
+            serializer = self.get_serializer(junior_total_points[:NUMBER['fifteen']], many=True)
-            serializer = self.get_serializer(junior_total_points, many=True)
             return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
@@ -316,6 +277,7 @@ class ApproveJuniorAPIView(viewsets.ViewSet):
                     return custom_response(SUCCESS_CODE['3023'], serializer.data, response_status=status.HTTP_200_OK)
             else:
                 queryset[1].guardian_code = None
+                queryset[1].guardian_code_status = str(NUMBER['one'])
                 queryset[1].save()
                 return custom_response(SUCCESS_CODE['3024'], response_status=status.HTTP_200_OK)
         except Exception as e:
@@ -379,6 +341,6 @@ class GuardianListAPIView(viewsets.ModelViewSet):
                 # use GuardianDetailListSerializer serializer
                 serializer = GuardianDetailListSerializer(guardian_data, many=True)
                 return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
-            return custom_error_response(ERROR_CODE['2068'], response_status=status.HTTP_200_OK)
+            return custom_response({"status": GUARDIAN_CODE_STATUS[1][0]}, response_status=status.HTTP_200_OK)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)

junior/admin.py

@@ -2,8 +2,26 @@
 """Third party Django app"""
 from django.contrib import admin
 """Import Django app"""
-from .models import Junior, JuniorPoints, JuniorGuardianRelationship
+from .models import (Junior, JuniorPoints, JuniorGuardianRelationship, JuniorArticlePoints, JuniorArticle,
+                     JuniorArticleCard)
 # Register your models here.
+@admin.register(JuniorArticle)
+class JuniorArticleAdmin(admin.ModelAdmin):
+    """Junior Admin"""
+    list_display = ['junior', 'article', 'status', 'is_completed']
+
+    def __str__(self):
+        """Return email id"""
+        return self.junior__auth__email
+
+@admin.register(JuniorArticleCard)
+class JuniorArticleCardAdmin(admin.ModelAdmin):
+    """Junior Admin"""
+    list_display = ['junior', 'article', 'article_card', 'is_read']
+
+    def __str__(self):
+        """Return email id"""
+        return self.junior__auth__email
 @admin.register(Junior)
 class JuniorAdmin(admin.ModelAdmin):
     """Junior Admin"""
@@ -27,3 +45,7 @@ class JuniorGuardianRelationshipAdmin(admin.ModelAdmin):
     """Junior Admin"""
     list_display = ['guardian', 'junior', 'relationship']
 
+@admin.register(JuniorArticlePoints)
+class JuniorArticlePointsAdmin(admin.ModelAdmin):
+    """Junior Admin"""
+    list_display = ['junior', 'article', 'question', 'submitted_answer', 'is_answer_correct']

junior/migrations/0019_juniorarticlepoints.py

@@ -0,0 +1,30 @@
+# Generated by Django 4.2.2 on 2023-08-07 13:29
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('web_admin', '0004_alter_surveyoption_survey'),
+        ('junior', '0018_remove_junior_relationship_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='JuniorArticlePoints',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('earn_points', models.IntegerField(blank=True, default=5, null=True)),
+                ('is_attempt', models.BooleanField(default=False)),
+                ('is_answer_correct', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('article', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='junior_articles', to='web_admin.article')),
+                ('junior', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='juniors_details', to='junior.junior', verbose_name='Junior')),
+                ('question', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='questions', to='web_admin.articlesurvey')),
+                ('submitted_answer', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='submitted_answer', to='web_admin.surveyoption')),
+            ],
+        ),
+    ]

junior/migrations/0020_junior_guardian_code_status.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.2 on 2023-08-08 05:43
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('junior', '0019_juniorarticlepoints'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='junior',
+            name='guardian_code_status',
+            field=models.CharField(blank=True, choices=[('1', 'no guardian code'), ('2', 'exist guardian code'), ('3', 'request for guardian code')], default='1', max_length=31, null=True),
+        ),
+    ]

junior/migrations/0021_alter_juniorarticlepoints_submitted_answer.py

@@ -0,0 +1,20 @@
+# Generated by Django 4.2.2 on 2023-08-08 09:45
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('web_admin', '0004_alter_surveyoption_survey'),
+        ('junior', '0020_junior_guardian_code_status'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='juniorarticlepoints',
+            name='submitted_answer',
+            field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='submitted_answer', to='web_admin.surveyoption'),
+        ),
+    ]

junior/migrations/0022_juniorarticle.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.2 on 2023-08-09 09:34
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('web_admin', '0004_alter_surveyoption_survey'),
+        ('junior', '0021_alter_juniorarticlepoints_submitted_answer'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='JuniorArticle',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_completed', models.BooleanField(default=False)),
+                ('status', models.CharField(blank=True, choices=[('1', 'read'), ('2', 'in_progress'), ('3', 'completed')], default='1', max_length=10, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('article', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='junior_articles_details', to='web_admin.article')),
+                ('junior', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='juniors_article', to='junior.junior', verbose_name='Junior')),
+            ],
+        ),
+    ]

junior/migrations/0023_juniorarticlecard.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.2 on 2023-08-09 10:47
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('web_admin', '0004_alter_surveyoption_survey'),
+        ('junior', '0022_juniorarticle'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='JuniorArticleCard',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_read', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('article', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='junior_articles_detail', to='web_admin.article')),
+                ('article_card', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='junior_article_card', to='web_admin.articlecard')),
+                ('junior', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='juniors_article_card', to='junior.junior', verbose_name='Junior')),
+            ],
+        ),
+    ]

junior/migrations/0024_juniorarticle_current_card_page_and_more.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.2 on 2023-08-10 08:53
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('junior', '0023_juniorarticlecard'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='juniorarticle',
+            name='current_card_page',
+            field=models.IntegerField(blank=True, default=0, null=True),
+        ),
+        migrations.AddField(
+            model_name='juniorarticle',
+            name='current_que_page',
+            field=models.IntegerField(blank=True, default=0, null=True),
+        ),
+    ]

junior/migrations/0025_alter_juniorarticle_junior.py

@@ -0,0 +1,19 @@
+# Generated by Django 4.2.2 on 2023-08-10 14:46
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('junior', '0024_juniorarticle_current_card_page_and_more'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='juniorarticle',
+            name='junior',
+            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='juniors_article', to='junior.junior', verbose_name='Junior'),
+        ),
+    ]

junior/models.py

@@ -6,10 +6,11 @@ from django.contrib.auth import get_user_model
 """Import ArrayField"""
 from django.contrib.postgres.fields import ArrayField
 """Import django app"""
-from base.constants import GENDERS, SIGNUP_METHODS, RELATIONSHIP
+from base.constants import GENDERS, SIGNUP_METHODS, RELATIONSHIP, GUARDIAN_CODE_STATUS, ARTICLE_STATUS
 # Import guardian's model
 from guardian.models import Guardian
-
+# Import web admin's model
+from web_admin.models import SurveyOption, ArticleSurvey, Article, ArticleCard
 """Define User model"""
 User = get_user_model()
 # Create your models here.
@@ -73,6 +74,9 @@ class Junior(models.Model):
     is_verified = models.BooleanField(default=False)
     """guardian code is approved or not"""
     guardian_code_approved = models.BooleanField(default=False)
+    # guardian code status"""
+    guardian_code_status = models.CharField(max_length=31, choices=GUARDIAN_CODE_STATUS, default='1',
+                                            null=True, blank=True)
     # Profile created and updated time"""
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
@@ -137,3 +141,62 @@ class JuniorGuardianRelationship(models.Model):
         return f'{self.guardian.user}'
 
 
+class JuniorArticlePoints(models.Model):
+    """
+    Survey Options model
+    """
+    # associated junior with the task
+    junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='juniors_details', verbose_name='Junior')
+    article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name='junior_articles')
+    question = models.ForeignKey(ArticleSurvey, on_delete=models.CASCADE, related_name='questions')
+    submitted_answer = models.ForeignKey(SurveyOption, on_delete=models.SET_NULL, null=True,
+                                         related_name='submitted_answer')
+    # earn points"""
+    earn_points = models.IntegerField(blank=True, null=True, default=5)
+    is_attempt = models.BooleanField(default=False)
+    is_answer_correct = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        """Return title"""
+        return f'{self.id} | {self.question}'
+
+class JuniorArticle(models.Model):
+    """
+    Survey Options model
+    """
+    # associated junior with the task
+    junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='juniors_article',
+                                  verbose_name='Junior')
+    article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name='junior_articles_details')
+    # article completed"""
+    is_completed = models.BooleanField(default=False)
+    status = models.CharField(max_length=10, choices=ARTICLE_STATUS, null=True, blank=True, default='1')
+    current_card_page = models.IntegerField(blank=True, null=True, default=0)
+    current_que_page = models.IntegerField(blank=True, null=True, default=0)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        """Return title"""
+        return f'{self.id} | {self.article}'
+
+class JuniorArticleCard(models.Model):
+    """
+    Survey Options model
+    """
+    # associated junior with the task
+    junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='juniors_article_card',
+                               verbose_name='Junior')
+    article = models.ForeignKey(Article, on_delete=models.CASCADE, related_name='junior_articles_detail')
+    article_card = models.ForeignKey(ArticleCard, on_delete=models.CASCADE, related_name='junior_article_card')
+
+    # article card read"""
+    is_read = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        """Return title"""
+        return f'{self.id} | {self.article}'

junior/serializers.py

@@ -12,10 +12,11 @@ from rest_framework_simplejwt.tokens import RefreshToken
 
 # local imports
 from account.utils import send_otp_email, generate_code
-from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
+from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship, JuniorArticlePoints
 from guardian.tasks import generate_otp
 from base.messages import ERROR_CODE, SUCCESS_CODE
-from base.constants import PENDING, IN_PROGRESS, REJECTED, REQUESTED, COMPLETED, NUMBER, JUN, ZOD, EXPIRED
+from base.constants import (PENDING, IN_PROGRESS, REJECTED, REQUESTED, COMPLETED, NUMBER, JUN, ZOD, EXPIRED,
+                            GUARDIAN_CODE_STATUS)
 from guardian.models import Guardian, JuniorTask
 from account.models import UserEmailOtp, UserNotification
 from junior.utils import junior_notification_email, junior_approval_mail
@@ -95,6 +96,9 @@ class CreateJuniorSerializer(serializers.ModelSerializer):
                 guardian_data = Guardian.objects.filter(guardian_code=guardian_code[0]).last()
                 if guardian_data:
                     JuniorGuardianRelationship.objects.get_or_create(guardian=guardian_data, junior=junior)
+                junior.guardian_code_status = str(NUMBER['three'])
+                junior_approval_mail(user.email, user.first_name)
+                send_notification.delay(APPROVED_JUNIOR, None, guardian_data.user.id, {})
             junior.dob = validated_data.get('dob', junior.dob)
             junior.passcode = validated_data.get('passcode', junior.passcode)
             junior.country_name = validated_data.get('country_name', junior.country_name)
@@ -142,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', 'is_invited', 'referral_code','is_active', 'is_complete_profile', 'created_at',
+                  'guardian_code', 'image', 'is_invited', 'referral_code','is_active', 'is_complete_profile',
-                  'image', 'updated_at']
+                  'created_at', 'image', 'updated_at']
 
 class JuniorDetailListSerializer(serializers.ModelSerializer):
     """junior serializer"""
@@ -178,10 +182,11 @@ class JuniorDetailListSerializer(serializers.ModelSerializer):
         data = JuniorPoints.objects.filter(junior=obj).last()
         if data:
             return data.position
-        return 99999
     def get_points(self, obj):
-        data = sum(JuniorTask.objects.filter(junior=obj, task_status=COMPLETED).values_list('points', flat=True))
+        data = JuniorPoints.objects.filter(junior=obj).last()
-        return data
+        if data:
+            return data.total_points
+        return NUMBER['zero']
 
     def get_in_progress_task(self, obj):
         data = JuniorTask.objects.filter(junior=obj, task_status=IN_PROGRESS).count()
@@ -206,10 +211,10 @@ class JuniorDetailListSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = Junior
-        fields = ['id', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'gender', 'dob',
+        fields = ['id', 'email', 'first_name', 'last_name', 'country_code', 'country_name', 'phone', 'gender', 'dob',
                   'guardian_code', 'referral_code','is_active', 'is_complete_profile', 'created_at', 'image',
                   'updated_at', 'assigned_task','points', 'pending_task', 'in_progress_task', 'completed_task',
-                  'requested_task', 'rejected_task', 'position', 'is_invited']
+                  'requested_task', 'rejected_task', 'position', 'is_invited', 'guardian_code_status']
 
 class JuniorProfileSerializer(serializers.ModelSerializer):
     """junior serializer"""
@@ -256,11 +261,10 @@ class JuniorProfileSerializer(serializers.ModelSerializer):
 
 class AddJuniorSerializer(serializers.ModelSerializer):
     """Add junior serializer"""
-
     class Meta(object):
         """Meta info"""
         model = Junior
-        fields = ['id', 'gender','dob', 'is_invited']
+        fields = ['id', 'gender', 'dob', 'is_invited']
 
 
     def create(self, validated_data):
@@ -269,6 +273,7 @@ class AddJuniorSerializer(serializers.ModelSerializer):
             email = self.context['email']
             guardian = self.context['user']
             relationship = self.context['relationship']
+            profile_image = self.context['image']
             full_name = self.context['first_name'] + ' ' + self.context['last_name']
             guardian_data = Guardian.objects.filter(user__username=guardian).last()
             user_data = User.objects.create(username=email, email=email,
@@ -278,14 +283,18 @@ class AddJuniorSerializer(serializers.ModelSerializer):
             user_data.set_password(password)
             user_data.save()
             junior_data = Junior.objects.create(auth=user_data, gender=validated_data.get('gender'),
+                                                image=profile_image,
                                                 dob=validated_data.get('dob'), is_invited=True,
                                                 guardian_code=[guardian_data.guardian_code],
                                                 junior_code=generate_code(JUN, user_data.id),
                                                 referral_code=generate_code(ZOD, user_data.id),
                                                 referral_code_used=guardian_data.referral_code,
-                                                is_password_set=False, is_verified=True)
+                                                is_password_set=False, is_verified=True,
+                                                guardian_code_status=GUARDIAN_CODE_STATUS[1][0])
             JuniorGuardianRelationship.objects.create(guardian=guardian_data, junior=junior_data,
                                                       relationship=relationship)
+            total_junior = Junior.objects.all().count()
+            JuniorPoints.objects.create(junior=junior_data, position=total_junior)
             """Generate otp"""
             otp_value = generate_otp()
             expiry_time = timezone.now() + timezone.timedelta(days=1)
@@ -311,6 +320,7 @@ class RemoveJuniorSerializer(serializers.ModelSerializer):
         if instance:
             instance.is_invited = False
             instance.guardian_code = '{}'
+            instance.guardian_code_status = str(NUMBER['1'])
             instance.save()
             return instance
 
@@ -323,7 +333,6 @@ class CompleteTaskSerializer(serializers.ModelSerializer):
         fields = ('id', 'image')
     def update(self, instance, validated_data):
         instance.image = validated_data.get('image', instance.image)
-        # instance.requested_on = real_time()
         instance.requested_on = timezone.now().astimezone(pytz.utc)
         instance.task_status = str(NUMBER['four'])
         instance.is_approved = False
@@ -403,13 +412,15 @@ class AddGuardianSerializer(serializers.ModelSerializer):
             relationship = self.context['relationship']
             full_name = self.context['first_name'] + ' ' + self.context['last_name']
             junior_data = Junior.objects.filter(auth__username=junior).last()
+            junior_data.guardian_code_status = GUARDIAN_CODE_STATUS[2][0]
+            junior_data.save()
             instance = User.objects.filter(username=email).last()
             if instance:
                 guardian_data = Guardian.objects.filter(user=instance).update(is_invited=True,
-                                                                          referral_code=generate_code(ZOD,
+                                                                              referral_code=generate_code(ZOD,
                                                                                                       instance.id),
                                                                           referral_code_used=junior_data.referral_code,
-                                                                          is_verified=True)
+                                                                              is_verified=True)
                 UserNotification.objects.get_or_create(user=instance)
                 return guardian_data
             else:
@@ -481,3 +492,17 @@ class ReAssignTaskSerializer(serializers.ModelSerializer):
         instance.requested_on = None
         instance.save()
         return instance
+
+
+
+class RemoveGuardianCodeSerializer(serializers.ModelSerializer):
+    """User task Serializer"""
+    class Meta(object):
+        """Meta class"""
+        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

junior/urls.py

@@ -4,7 +4,9 @@ from django.urls import path, include
 from .views import (UpdateJuniorProfile, ValidateGuardianCode, JuniorListAPIView, AddJuniorAPIView,
                     InvitedJuniorAPIView, FilterJuniorAPIView, RemoveJuniorAPIView, JuniorTaskListAPIView,
                     CompleteJuniorTaskAPIView, JuniorPointsListAPIView, ValidateReferralCode,
-                    InviteGuardianAPIView, StartTaskAPIView, ReAssignJuniorTaskAPIView)
+                    InviteGuardianAPIView, StartTaskAPIView, ReAssignJuniorTaskAPIView, StartArticleAPIView,
+                    StartAssessmentAPIView, CheckAnswerAPIView, CompleteArticleAPIView, ReadArticleCardAPIView,
+                    CreateArticleCardAPIView, RemoveGuardianCodeAPIView)
 """Third party import"""
 from rest_framework import routers
 
@@ -41,6 +43,14 @@ router.register('junior-points', JuniorPointsListAPIView, basename='junior-point
 router.register('validate-referral-code', ValidateReferralCode, basename='validate-referral-code')
 # invite guardian API"""
 router.register('invite-guardian', InviteGuardianAPIView, basename='invite-guardian')
+# start article"""
+router.register('start-article', StartArticleAPIView, basename='start-article')
+# start assessment api"""
+router.register('start-assessment', StartAssessmentAPIView, basename='start-assessment')
+# check answer api"""
+router.register('check-answer', CheckAnswerAPIView, basename='check-answer')
+# start article"""
+router.register('create-article-card', CreateArticleCardAPIView, basename='create-article-card')
 # Define url pattern"""
 urlpatterns = [
     path('api/v1/', include(router.urls)),
@@ -48,4 +58,7 @@ urlpatterns = [
     path('api/v1/complete-task/', CompleteJuniorTaskAPIView.as_view()),
     path('api/v1/start-task/', StartTaskAPIView.as_view()),
     path('api/v1/reassign-task/', ReAssignJuniorTaskAPIView.as_view()),
+    path('api/v1/complete-article/', CompleteArticleAPIView.as_view()),
+    path('api/v1/read-article-card/', ReadArticleCardAPIView.as_view()),
+    path('api/v1/remove-guardian-code-request/', RemoveGuardianCodeAPIView.as_view()),
 ]

junior/utils.py

@@ -4,6 +4,7 @@ from django.conf import settings
 """Third party Django app"""
 from templated_email import send_templated_mail
 from .models import JuniorPoints
+from base.constants import NUMBER
 from django.db.models import F
 # junior notification
 # email for sending email
@@ -50,11 +51,11 @@ def junior_approval_mail(guardian, full_name):
 def update_positions_based_on_points():
     """Update position of the junior"""
     # First, retrieve all the JuniorPoints instances ordered by total_points in descending order.
-    juniors_points = JuniorPoints.objects.order_by('-total_points')
+    juniors_points = JuniorPoints.objects.order_by('-total_points', 'created_at')
 
     # Now, iterate through the queryset and update the position field based on the order.
-    position = 1
+    position = NUMBER['one']
     for junior_point in juniors_points:
         junior_point.position = position
         junior_point.save()
-        position += 1
+        position += NUMBER['one']

junior/views.py

@@ -6,6 +6,7 @@ from rest_framework.permissions import IsAuthenticated
 from rest_framework.pagination import PageNumberPagination
 from django.contrib.auth.models import User
 from rest_framework.filters import SearchFilter
+from django.db.models import F
 
 import datetime
 import requests
@@ -27,20 +28,25 @@ import requests
 # Import upload_image_to_alibaba
 # Import custom_response, custom_error_response
 # Import constants
-from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
+from django.db.models import Sum
-from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,\
+from junior.models import (Junior, JuniorPoints, JuniorGuardianRelationship, JuniorArticlePoints, JuniorArticle,
+                           JuniorArticleCard)
+from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,
                           RemoveJuniorSerializer, CompleteTaskSerializer, JuniorPointsSerializer,
-                          AddGuardianSerializer, StartTaskSerializer, ReAssignTaskSerializer)
+                          AddGuardianSerializer, StartTaskSerializer, ReAssignTaskSerializer,
+                          RemoveGuardianCodeSerializer)
 from guardian.models import Guardian, JuniorTask
 from guardian.serializers import TaskDetailsSerializer, TaskDetailsjuniorSerializer
 from base.messages import ERROR_CODE, SUCCESS_CODE
-from base.constants import NUMBER
+from base.constants import NUMBER, ARTICLE_STATUS
 from account.utils import custom_response, custom_error_response
 from guardian.utils import upload_image_to_alibaba
 from .utils import update_positions_based_on_points
 from notifications.utils import send_notification
 from notifications.constants import REMOVE_JUNIOR
-
+from web_admin.models import Article, ArticleSurvey, SurveyOption, ArticleCard
+from web_admin.serializers.article_serializer import (ArticleSerializer, ArticleListSerializer,
+                                                      StartAssessmentSerializer)
 """ Define APIs """
 # Define validate guardian code API,
 # update junior profile,
@@ -59,7 +65,6 @@ from notifications.constants import REMOVE_JUNIOR
 # Create your views here.
 class UpdateJuniorProfile(viewsets.ViewSet):
     """Update junior profile"""
-    queryset = Junior.objects.all()
     serializer_class = CreateJuniorSerializer
     permission_classes = [IsAuthenticated]
 
@@ -93,7 +98,6 @@ class UpdateJuniorProfile(viewsets.ViewSet):
 
 class ValidateGuardianCode(viewsets.ViewSet):
     """Check guardian code exist or not"""
-    queryset = Guardian.objects.all()
     permission_classes = [IsAuthenticated]
 
     def list(self, request, *args, **kwargs):
@@ -151,8 +155,19 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
     def create(self, request, *args, **kwargs):
         """ junior list"""
         try:
-            info_data = {'user': request.user, 'relationship': str(request.data['relationship']), 'email': request.data['email'], 'first_name': request.data['first_name'],
+            info_data = {'user': request.user, 'relationship': str(request.data['relationship']),
-                         'last_name': request.data['last_name']}
+                         'email': request.data['email'], 'first_name': request.data['first_name'],
+                         'last_name': request.data['last_name'], 'image':None}
+            profile_image = request.data.get('image')
+            if profile_image:
+                # check image size
+                if profile_image.size == NUMBER['zero']:
+                    return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
+                # convert into file
+                filename = f"images/{profile_image.name}"
+                # upload image on ali baba
+                image_url = upload_image_to_alibaba(profile_image, filename)
+                info_data.update({"image": image_url})
             if user := User.objects.filter(username=request.data['email']).first():
                 self.associate_guardian(user)
                 return custom_response(SUCCESS_CODE['3021'], response_status=status.HTTP_200_OK)
@@ -162,7 +177,7 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
                 # save serializer
                 serializer.save()
                 return custom_response(SUCCESS_CODE['3021'], serializer.data, response_status=status.HTTP_200_OK)
-            return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)
+            return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
@@ -170,6 +185,7 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
         junior = Junior.objects.filter(auth=user).first()
         guardian = Guardian.objects.filter(user=self.request.user).first()
         junior.guardian_code = [guardian.guardian_code]
+        junior.guardian_code_status = str(NUMBER['two'])
         junior.save()
         JuniorGuardianRelationship.objects.get_or_create(guardian=guardian, junior=junior,
                                                          relationship=str(self.request.data['relationship']))
@@ -180,7 +196,6 @@ class InvitedJuniorAPIView(viewsets.ModelViewSet):
     """Junior list of assosicated guardian"""
 
     serializer_class = JuniorDetailListSerializer
-    queryset = Junior.objects.all()
     permission_classes = [IsAuthenticated]
     pagination_class = PageNumberPagination
     http_method_names = ('get',)
@@ -210,7 +225,6 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
     serializer_class = JuniorDetailListSerializer
     permission_classes = [IsAuthenticated]
     pagination_class = PageNumberPagination
-    queryset = Junior.objects.all()
     http_method_names = ('get',)
 
     def get_queryset(self):
@@ -247,7 +261,8 @@ class RemoveJuniorAPIView(views.APIView):
             junior_id = self.request.GET.get('id')
             guardian = Guardian.objects.filter(user__email=self.request.user).last()
             # fetch junior query
-            junior_queryset = Junior.objects.filter(id=junior_id, guardian_code__icontains=str(guardian.guardian_code)).last()
+            junior_queryset = Junior.objects.filter(id=junior_id,
+                                                    guardian_code__icontains=str(guardian.guardian_code)).last()
             if junior_queryset:
                 # use RemoveJuniorSerializer serializer
                 serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
@@ -268,7 +283,6 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
     serializer_class = TaskDetailsjuniorSerializer
     permission_classes = [IsAuthenticated]
     pagination_class = PageNumberPagination
-    queryset = JuniorTask.objects.all()
     http_method_names = ('get',)
 
     def list(self, request, *args, **kwargs):
@@ -343,16 +357,12 @@ class JuniorPointsListAPIView(viewsets.ModelViewSet):
     permission_classes = [IsAuthenticated]
     http_method_names = ('get',)
 
-    def get_queryset(self):
-        """get queryset"""
-        return JuniorTask.objects.filter(junior__auth__email=self.request.user).last()
     def list(self, request, *args, **kwargs):
         """profile view"""
-
         try:
-            queryset = self.get_queryset()
-            # update position of junior
             update_positions_based_on_points()
+            queryset = JuniorPoints.objects.filter(junior__auth__email=self.request.user).last()
+            # update position of junior
             serializer = JuniorPointsSerializer(queryset)
             return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
         except Exception as e:
@@ -458,3 +468,184 @@ class ReAssignJuniorTaskAPIView(views.APIView):
                 return custom_error_response(ERROR_CODE['2066'], response_status=status.HTTP_400_BAD_REQUEST)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+class StartArticleAPIView(viewsets.ModelViewSet):
+    """Start article"""
+    permission_classes = [IsAuthenticated]
+    http_method_names = ('post',)
+
+    def create(self, request, *args, **kwargs):
+        """ junior list"""
+        try:
+            junior_instance = Junior.objects.filter(auth=self.request.user).last()
+            article_id = request.data.get('article_id')
+            article_data = Article.objects.filter(id=article_id).last()
+            if not JuniorArticle.objects.filter(junior=junior_instance, article=article_data).last():
+                JuniorArticle.objects.create(junior=junior_instance, article=article_data, status=str(NUMBER['two']),
+                                             current_card_page=NUMBER['zero'], current_que_page=NUMBER['zero'])
+            if article_data:
+                question_query = ArticleSurvey.objects.filter(article=article_id)
+                for question in question_query:
+                    if not JuniorArticlePoints.objects.filter(junior=junior_instance,
+                                                              article=article_data,
+                                                              question=question):
+                        JuniorArticlePoints.objects.create(junior=junior_instance,
+                                                           article=article_data,
+                                                           question=question)
+            return custom_response(SUCCESS_CODE['3040'], response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+class StartAssessmentAPIView(viewsets.ModelViewSet):
+    """Junior Points viewset"""
+    serializer_class = StartAssessmentSerializer
+    permission_classes = [IsAuthenticated]
+    http_method_names = ('get',)
+
+    def get_queryset(self):
+        article_id = self.request.GET.get('article_id')
+        # if referral_code:
+        article = Article.objects.filter(id=article_id, is_deleted=False).prefetch_related(
+            'article_cards', 'article_survey', 'article_survey__options'
+        ).order_by('-created_at')
+        return article
+    def list(self, request, *args, **kwargs):
+        """profile view"""
+
+        try:
+            queryset = self.get_queryset()
+            paginator = self.pagination_class()
+            paginated_queryset = paginator.paginate_queryset(queryset, request)
+            serializer = self.serializer_class(paginated_queryset, context={"user":request.user}, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+class CheckAnswerAPIView(viewsets.ModelViewSet):
+    """Junior Points viewset"""
+    permission_classes = [IsAuthenticated]
+    http_method_names = ('get',)
+
+    def get_queryset(self):
+        question_id = self.request.GET.get('question_id')
+        article = ArticleSurvey.objects.filter(id=question_id).last()
+        return article
+    def list(self, request, *args, **kwargs):
+        """profile view"""
+
+        try:
+            answer_id = self.request.GET.get('answer_id')
+            current_page = self.request.GET.get('current_page')
+            queryset = self.get_queryset()
+            submit_ans = SurveyOption.objects.filter(id=answer_id, is_answer=True).last()
+            junior_article_points = JuniorArticlePoints.objects.filter(junior__auth=self.request.user,
+                                                                       question=queryset)
+            if submit_ans:
+                junior_article_points.update(submitted_answer=submit_ans, is_attempt=True, is_answer_correct=True)
+                JuniorPoints.objects.filter(junior__auth=self.request.user).update(total_points=
+                                                                                   F('total_points') + queryset.points)
+            else:
+                junior_article_points.update(submitted_answer=submit_ans, is_attempt=True, earn_points=0,
+                                             is_answer_correct=False)
+            JuniorArticle.objects.filter(junior__auth=self.request.user,
+                                         article=queryset.article).update(
+                current_que_page=int(current_page) + NUMBER['one'])
+            return custom_response(None, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+class CompleteArticleAPIView(views.APIView):
+    """Remove junior API"""
+    permission_classes = [IsAuthenticated]
+    http_method_names = ('put', 'get',)
+    def put(self, request, format=None):
+        try:
+            article_id = self.request.data.get('article_id')
+            JuniorArticle.objects.filter(junior__auth=request.user, article__id=article_id).update(
+                is_completed=True, status=str(NUMBER['three'])
+            )
+            return custom_response(SUCCESS_CODE['3041'], response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+    def get(self, request, *args, **kwargs):
+        """ junior list"""
+        try:
+            article_id = self.request.GET.get('article_id')
+            total_earn_points = JuniorArticlePoints.objects.filter(junior__auth=request.user,
+                                                       article__id=article_id,
+                                                       is_answer_correct=True).aggregate(
+                total_earn_points=Sum('earn_points'))['total_earn_points']
+            data = {"total_earn_points":total_earn_points}
+            return custom_response(SUCCESS_CODE['3042'], data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+
+class ReadArticleCardAPIView(views.APIView):
+    """Remove junior API"""
+    permission_classes = [IsAuthenticated]
+    http_method_names = ('put',)
+
+    def put(self, request, *args, **kwargs):
+        """ junior list"""
+        try:
+            junior_instance = Junior.objects.filter(auth=self.request.user).last()
+            article = self.request.data.get('article_id')
+            article_card = self.request.data.get('article_card')
+            current_page = self.request.data.get('current_page')
+            JuniorArticleCard.objects.filter(junior=junior_instance,
+                                             article__id=article,
+                                             article_card__id=article_card).update(is_read=True)
+            JuniorArticle.objects.filter(junior=junior_instance,
+                                         article__id=article).update(current_card_page=int(current_page)+NUMBER['one'])
+            return custom_response(SUCCESS_CODE['3043'], response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+
+class CreateArticleCardAPIView(viewsets.ModelViewSet):
+    """Start article"""
+    permission_classes = [IsAuthenticated]
+    http_method_names = ('post',)
+
+    def create(self, request, *args, **kwargs):
+        """ junior list"""
+        try:
+            junior_instance = Junior.objects.filter(auth=self.request.user).last()
+            article_id = request.data.get('article_id')
+            article_data = Article.objects.filter(id=article_id).last()
+            if article_data:
+                article_cards = ArticleCard.objects.filter(article=article_id)
+                for article_card in article_cards:
+                    if not JuniorArticleCard.objects.filter(junior=junior_instance,
+                                                            article=article_data,
+                                                            article_card=article_card):
+                        JuniorArticleCard.objects.create(junior=junior_instance,
+                                                         article=article_data,
+                                                         article_card=article_card)
+            return custom_response(None, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+class RemoveGuardianCodeAPIView(views.APIView):
+    """Update junior task API"""
+    serializer_class = RemoveGuardianCodeSerializer
+    permission_classes = [IsAuthenticated]
+
+    def put(self, request, format=None):
+        try:
+            junior_queryset = Junior.objects.filter(auth=self.request.user).last()
+            if junior_queryset:
+                # use RemoveGuardianCodeSerializer serializer
+                serializer = RemoveGuardianCodeSerializer(junior_queryset, data=request.data, partial=True)
+                if serializer.is_valid():
+                    # save serializer
+                    serializer.save()
+                    return custom_response(SUCCESS_CODE['3044'], response_status=status.HTTP_200_OK)
+                return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
+            else:
+                # task in another state
+                return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)

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/models.py

@@ -49,7 +49,7 @@ class ArticleSurvey(models.Model):
 
     def __str__(self):
         """Return title"""
-        return f'{self.id} | {self.article}'
+        return f'{self.id} | {self.question}'
 
 
 class SurveyOption(models.Model):
@@ -64,7 +64,7 @@ class SurveyOption(models.Model):
 
     def __str__(self):
         """Return title"""
-        return f'{self.id} | {self.survey}'
+        return f'{self.id} | {self.option}'
 
 
 class DefaultArticleCardImage(models.Model):

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/analytics_serializer.py

@@ -0,0 +1,52 @@
+"""
+web_admin analytics serializer file
+"""
+from rest_framework import serializers
+
+from junior.models import JuniorPoints, Junior
+
+
+class JuniorLeaderboardSerializer(serializers.ModelSerializer):
+    name = serializers.SerializerMethodField()
+    first_name = serializers.SerializerMethodField()
+    last_name = serializers.SerializerMethodField()
+
+    class Meta:
+        """
+        meta class
+        """
+        model = Junior
+        fields = ('id', 'name', 'first_name', 'last_name', 'is_active', 'image')
+
+    @staticmethod
+    def get_name(obj):
+        """
+        :param obj: junior object
+        :return: full name
+        """
+        return f"{obj.auth.first_name} {obj.auth.last_name}" if obj.auth.last_name else obj.auth.first_name
+
+    @staticmethod
+    def get_first_name(obj):
+        """
+        :param obj: junior object
+        :return: first name
+        """
+        return obj.auth.first_name
+
+    @staticmethod
+    def get_last_name(obj):
+        """
+        :param obj: junior object
+        :return: last name
+        """
+        return obj.auth.last_name
+
+
+class LeaderboardSerializer(serializers.ModelSerializer):
+    junior = JuniorLeaderboardSerializer()
+    rank = serializers.IntegerField()
+
+    class Meta:
+        model = JuniorPoints
+        fields = ('total_points', 'rank', 'junior')

web_admin/serializers/article_serializer.py

@@ -12,7 +12,7 @@ from base.messages import ERROR_CODE
 from guardian.utils import upload_image_to_alibaba
 from web_admin.models import Article, ArticleCard, SurveyOption, ArticleSurvey, DefaultArticleCardImage
 from web_admin.utils import pop_id, get_image_url
-
+from junior.models import JuniorArticlePoints, JuniorArticle
 USER = get_user_model()
 
 
@@ -220,16 +220,115 @@ class ArticleListSerializer(serializers.ModelSerializer):
     serializer for article API
     """
     article_cards = ArticleCardSerializer(many=True)
+    article_survey = ArticleSurveySerializer(many=True)
     total_points = serializers.SerializerMethodField('get_total_points')
+    is_completed = serializers.SerializerMethodField('get_is_completed')
 
-    class Meta:
+    class Meta(object):
         """
         meta class
         """
         model = Article
-        fields = ('id', 'title', 'description', 'article_cards', 'total_points')
+        fields = ('id', 'title', 'description', 'article_cards', 'article_survey', 'total_points', 'is_completed')
 
     def get_total_points(self, obj):
         """total points of article"""
         total_question = ArticleSurvey.objects.filter(article=obj).count()
-        return total_question * 5
+        return total_question * NUMBER['five']
+
+    def get_is_completed(self, obj):
+        """complete all question"""
+        context_data = self.context.get('user')
+        junior_article = JuniorArticle.objects.filter(junior__auth=context_data, article=obj).last()
+        if junior_article:
+            return junior_article.is_completed
+        return False
+
+class ArticleQuestionSerializer(serializers.ModelSerializer):
+    """
+    article survey serializer
+    """
+    id = serializers.IntegerField(required=False)
+    options = SurveyOptionSerializer(many=True)
+    is_attempt = serializers.SerializerMethodField('get_is_attempt')
+    correct_answer = serializers.SerializerMethodField('get_correct_answer')
+    attempted_answer = serializers.SerializerMethodField('get_attempted_answer')
+
+
+    def get_is_attempt(self, obj):
+        """attempt question or not"""
+        context_data = self.context.get('user')
+        junior_article_obj = JuniorArticlePoints.objects.filter(junior__auth=context_data, question=obj).last()
+        if junior_article_obj:
+            return junior_article_obj.is_attempt
+        return False
+
+    def get_correct_answer(self, obj):
+        """attempt question or not"""
+        ans_obj = SurveyOption.objects.filter(survey=obj, is_answer=True).last()
+        if ans_obj:
+            return ans_obj.id
+        return str("None")
+
+    def get_attempted_answer(self, obj):
+        """attempt question or not"""
+        context_data = self.context.get('user')
+        junior_article_obj = JuniorArticlePoints.objects.filter(junior__auth=context_data,
+                                                                question=obj, is_answer_correct=True).last()
+        if junior_article_obj:
+            return junior_article_obj.submitted_answer.id
+        return None
+
+    class Meta(object):
+        """
+        meta class
+        """
+        model = ArticleSurvey
+        fields = ('id', 'question', 'options', 'points', 'is_attempt', 'correct_answer', 'attempted_answer')
+
+class StartAssessmentSerializer(serializers.ModelSerializer):
+    """
+    serializer for article API
+    """
+    article_survey = ArticleQuestionSerializer(many=True)
+    current_page = serializers.SerializerMethodField('get_current_page')
+
+    def get_current_page(self, obj):
+        """current page"""
+        context_data = self.context.get('user')
+        data = JuniorArticle.objects.filter(junior__auth=context_data, article=obj).last()
+        if data:
+            return data.current_que_page
+        return NUMBER['zero']
+    class Meta(object):
+        """
+        meta class
+        """
+        model = Article
+        fields = ('article_survey', 'current_page')
+
+
+
+class ArticleCardlistSerializer(serializers.ModelSerializer):
+    """
+    Article Card serializer
+    """
+    id = serializers.IntegerField(required=False)
+    image_name = serializers.CharField(required=False)
+    image_url = serializers.CharField(required=False)
+    current_page = serializers.SerializerMethodField('get_current_page')
+
+    def get_current_page(self, obj):
+        """current page"""
+        context_data = self.context.get('user')
+        data = JuniorArticle.objects.filter(junior__auth=context_data, article=obj.article).last()
+        if data:
+            return data.current_card_page
+        return NUMBER['zero']
+
+    class Meta(object):
+        """
+        meta class
+        """
+        model = ArticleCard
+        fields = ('id', 'title', 'description', 'image_name', 'image_url', 'current_page')

web_admin/serializers/auth_serializer.py

@@ -87,9 +87,9 @@ class AdminVerifyOTPSerializer(serializers.Serializer):
         # 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({'details': ERROR_CODE['2064']})
+            raise serializers.ValidationError({'details': ERROR_CODE['2008']})
         if user_otp_details.user_type != dict(USER_TYPE).get('3'):
-            raise serializers.ValidationError({'details': ERROR_CODE['2063']})
+            raise serializers.ValidationError({'details': ERROR_CODE['2008']})
         if user_otp_details.expired_at.replace(tzinfo=None) < datetime.utcnow():
             raise serializers.ValidationError({'details': ERROR_CODE['2029']})
         user_otp_details.is_verified = True

web_admin/urls.py

@@ -6,7 +6,9 @@ from django.urls import path, include
 from rest_framework import routers
 
 # local imports
-from web_admin.views.article import ArticleViewSet, DefaultArticleCardImagesViewSet, ArticleListViewSet
+from web_admin.views.analytics import AnalyticsViewSet
+from web_admin.views.article import (ArticleViewSet, DefaultArticleCardImagesViewSet, ArticleListViewSet,
+                                     ArticleCardListViewSet)
 from web_admin.views.auth import ForgotAndResetPasswordViewSet
 from web_admin.views.user_management import UserManagementViewSet
 
@@ -16,7 +18,11 @@ router = routers.SimpleRouter()
 router.register('article', ArticleViewSet, basename='article')
 router.register('default-card-images', DefaultArticleCardImagesViewSet, basename='default-card-images')
 router.register('user-management', UserManagementViewSet, basename='user')
+router.register('analytics', AnalyticsViewSet, basename='user-analytics')
+
 router.register('article-list', ArticleListViewSet, basename='article-list')
+router.register('article-card-list', ArticleCardListViewSet, basename='article-card-list')
+
 # forgot and reset password api for admin
 router.register('admin', ForgotAndResetPasswordViewSet, basename='admin')
 

web_admin/utils.py

@@ -29,7 +29,7 @@ def get_image_url(data):
         return data['image_url']
     elif 'image_url' in data and type(data['image_url']) == str and data['image_url'].startswith('data:image'):
         base64_image = base64.b64decode(data.get('image_url').split(',')[1])
-        image_name = f"{data['title']} | {data.pop('image_name')}" if 'image_name' in data else data['title']
+        image_name = f"{data['title']} {data.pop('image_name')}" if 'image_name' in data else data['title']
         filename = f"{ARTICLE_CARD_IMAGE_FOLDER}/{image_name}"
         # upload image on ali baba
         image_url = upload_image_to_alibaba(base64_image, filename)

web_admin/views/analytics.py

@@ -0,0 +1,143 @@
+"""
+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
+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()
+
+
+class AnalyticsViewSet(GenericViewSet):
+    """
+    analytics api view
+    to get user report (active users, guardians and juniors counts)
+    to get new user sign up report
+    to get task report (completed, in-progress, requested and rejected tasks count)
+    to get junior leaderboard and ranking
+    """
+    serializer_class = None
+    permission_classes = [IsAuthenticated, AdminPermission]
+
+    def get_queryset(self):
+        user_qs = USER.objects.filter(
+            (Q(junior_profile__is_verified=True) | Q(guardian_profile__is_verified=True)),
+            is_superuser=False
+                    ).prefetch_related('guardian_profile',
+                                       'junior_profile'
+                                       ).exclude(junior_profile__isnull=True,
+                                                 guardian_profile__isnull=True).order_by('date_joined')
+        return user_qs
+
+    @action(methods=['get'], url_name='users-count', url_path='users-count', detail=False)
+    def total_users_count(self, request, *args, **kwargs):
+        """
+        api method to get total users, guardians and juniors
+        :param request: start_date: date format (yyyy-mm-dd)
+        :param request: end_date: date format (yyyy-mm-dd)
+        :return:
+        """
+
+        end_date = datetime.date.today()
+        start_date = end_date - datetime.timedelta(days=6)
+
+        if request.query_params.get('start_date') and request.query_params.get('end_date'):
+            start_date = datetime.datetime.strptime(request.query_params.get('start_date'), DATE_FORMAT)
+            end_date = datetime.datetime.strptime(request.query_params.get('end_date'), DATE_FORMAT)
+
+        user_qs = self.get_queryset()
+        queryset = user_qs.filter(date_joined__range=(start_date, (end_date + datetime.timedelta(days=1))))
+
+        data = {'total_users': queryset.count(),
+                'total_guardians': queryset.filter(junior_profile__isnull=True).count(),
+                'total_juniors': queryset.filter(guardian_profile__isnull=True).count()}
+
+        return custom_response(None, data)
+
+    @action(methods=['get'], url_name='new-signups', url_path='new-signups', detail=False)
+    def new_signups(self, request, *args, **kwargs):
+        """
+        api method to get new signups
+        :param request: start_date: date format (yyyy-mm-dd)
+        :param request: end_date: date format (yyyy-mm-dd)
+        :return:
+        """
+        end_date = datetime.date.today()
+        start_date = end_date - datetime.timedelta(days=6)
+
+        if request.query_params.get('start_date') and request.query_params.get('end_date'):
+            start_date = datetime.datetime.strptime(request.query_params.get('start_date'), DATE_FORMAT)
+            end_date = datetime.datetime.strptime(request.query_params.get('end_date'), DATE_FORMAT)
+
+        user_qs = self.get_queryset()
+        signup_data = user_qs.filter(date_joined__range=[start_date, (end_date + datetime.timedelta(days=1))]
+                                     ).annotate(date=TruncDate('date_joined')
+                                                ).values('date').annotate(signups=Count('id')).order_by('date')
+
+        return custom_response(None, signup_data)
+
+    @action(methods=['get'], url_name='assign-tasks', url_path='assign-tasks', detail=False)
+    def assign_tasks_report(self, request, *args, **kwargs):
+        """
+        api method to get assign tasks count for (completed, in-progress, requested and rejected) task
+        :param request: start_date: date format (yyyy-mm-dd)
+        :param request: end_date: date format (yyyy-mm-dd)
+        :return:
+        """
+        end_date = datetime.date.today()
+        start_date = end_date - datetime.timedelta(days=6)
+
+        if request.query_params.get('start_date') and request.query_params.get('end_date'):
+            start_date = datetime.datetime.strptime(request.query_params.get('start_date'), DATE_FORMAT)
+            end_date = datetime.datetime.strptime(request.query_params.get('end_date'), DATE_FORMAT)
+
+        assign_tasks = JuniorTask.objects.filter(
+                                created_at__range=[start_date, (end_date + datetime.timedelta(days=1))]
+                                        ).exclude(task_status__in=[PENDING, EXPIRED])
+
+        data = {
+            'task_completed': assign_tasks.filter(task_status=COMPLETED).count(),
+            'task_in_progress': assign_tasks.filter(task_status=IN_PROGRESS).count(),
+            'task_requested': assign_tasks.filter(task_status=REQUESTED).count(),
+            'task_rejected': assign_tasks.filter(task_status=REJECTED).count(),
+        }
+
+        return custom_response(None, data)
+
+    @action(methods=['get'], url_name='junior-leaderboard', url_path='junior-leaderboard', detail=False,
+            serializer_class=LeaderboardSerializer)
+    def junior_leaderboard(self, request):
+        """
+        to get junior leaderboard and rank
+        :param request:
+        :return:
+        """
+        queryset = JuniorPoints.objects.prefetch_related('junior', 'junior__auth').annotate(rank=Window(
+            expression=Rank(),
+            order_by=[F('total_points').desc(), 'junior__created_at']
+        )).order_by('-total_points', 'junior__created_at')
+        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

@@ -4,7 +4,7 @@ web_admin views file
 # django imports
 from rest_framework.viewsets import GenericViewSet, mixins
 from rest_framework.filters import OrderingFilter, SearchFilter
-from rest_framework import status
+from rest_framework import status, viewsets
 from rest_framework.decorators import action
 from rest_framework.permissions import IsAuthenticated, AllowAny
 from django.contrib.auth import get_user_model
@@ -16,7 +16,8 @@ from base.messages import SUCCESS_CODE, ERROR_CODE
 from web_admin.models import Article, ArticleCard, ArticleSurvey, DefaultArticleCardImage
 from web_admin.permission import AdminPermission
 from web_admin.serializers.article_serializer import (ArticleSerializer, ArticleCardSerializer,
-                                                      DefaultArticleCardImageSerializer, ArticleListSerializer)
+                                                      DefaultArticleCardImageSerializer, ArticleListSerializer,
+                                                      ArticleCardlistSerializer)
 
 USER = get_user_model()
 
@@ -220,8 +221,25 @@ class ArticleListViewSet(GenericViewSet, mixins.ListModelMixin):
         :return: list of article
         """
         queryset = self.get_queryset()
-        count = queryset.count()
+        serializer = self.serializer_class(queryset, context={"user": request.user}, many=True)
-        paginator = self.pagination_class()
+        return custom_response(None, data=serializer.data)
-        paginated_queryset = paginator.paginate_queryset(queryset, request)
+
-        serializer = self.serializer_class(paginated_queryset, many=True)
+class ArticleCardListViewSet(viewsets.ModelViewSet):
-        return custom_response(None, data=serializer.data, count=count)
+    """Junior Points viewset"""
+    serializer_class = ArticleCardlistSerializer
+    permission_classes = [IsAuthenticated]
+    http_method_names = ('get',)
+
+    def get_queryset(self):
+        """get queryset"""
+        return ArticleCard.objects.filter(article=self.request.GET.get('article_id'))
+    def list(self, request, *args, **kwargs):
+        """profile view"""
+
+        try:
+            queryset = self.get_queryset()
+            # article card list
+            serializer = ArticleCardlistSerializer(queryset, context={"user": self.request.user}, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)

web_admin/views/user_management.py

@@ -29,11 +29,12 @@ class UserManagementViewSet(GenericViewSet, mixins.ListModelMixin,
     """
     serializer_class = UserManagementListSerializer
     permission_classes = [IsAuthenticated, AdminPermission]
-    queryset = USER.objects.filter(is_superuser=False
+    queryset = USER.objects.filter(
-                                   ).prefetch_related('guardian_profile',
+        (Q(junior_profile__is_verified=True) | Q(guardian_profile__is_verified=True)),
-                                                      'junior_profile'
+        is_superuser=False).prefetch_related('guardian_profile',
-                                                      ).exclude(junior_profile__isnull=True,
+                                             'junior_profile'
-                                                                guardian_profile__isnull=True).order_by('date_joined')
+                                             ).exclude(junior_profile__isnull=True,
+                                                       guardian_profile__isnull=True).order_by('-date_joined')
     filter_backends = (SearchFilter,)
     search_fields = ['first_name', 'last_name']
     http_method_names = ['get', 'post', 'patch']
@@ -55,8 +56,6 @@ class UserManagementViewSet(GenericViewSet, mixins.ListModelMixin,
         :return:
         """
         queryset = self.get_queryset()
-        queryset = queryset.filter(
-            (Q(junior_profile__is_verified=True) | Q(guardian_profile__is_verified=True)))
         paginator = self.pagination_class()
         paginated_queryset = paginator.paginate_queryset(queryset, request)
         serializer = self.serializer_class(paginated_queryset, many=True)

zod_bank/settings.py

@@ -177,6 +177,31 @@ AUTH_PASSWORD_VALIDATORS = [
     },
 ]
 
+LOGGING = {
+    "version": 1,
+    "filters": {
+        "require_debug_true": {
+            "()": "django.utils.log.RequireDebugTrue"
+        }
+    },
+    "handlers": {
+        "console": {
+            "level": "DEBUG",
+            "filters": [
+                "require_debug_true"
+            ],
+            "class": "logging.StreamHandler"
+        }
+    },
+    "loggers": {
+        "django.db.backends": {
+            "level": "DEBUG",
+            "handlers": [
+                "console"
+            ]
+        }
+    }
+}
 
 # Internationalization
 # https://docs.djangoproject.com/en/3.0/topics/i18n/