added optional name as user

account/custom_middleware.py

@@ -17,8 +17,6 @@ from guardian.models import Guardian
 # multiple devices only
 # user can login in single
 # device at a time"""
-# force update
-# use 308 status code for force update
 
 def custom_response(custom_error, response_status = status.HTTP_404_NOT_FOUND):
     """custom response"""
@@ -47,11 +45,7 @@ class CustomMiddleware(object):
         api_endpoint = request.path
         if request.user.is_authenticated:
             # device details
-            if device_id:
-                device_details = UserDeviceDetails.objects.filter(user=request.user, device_id=device_id).last()
-                if not device_details and api_endpoint != '/api/v1/user/login/':
-                    custom_error = custom_error_response(ERROR_CODE['2037'], response_status=status.HTTP_404_NOT_FOUND)
-                    response = custom_response(custom_error)
+            device_details = UserDeviceDetails.objects.filter(user=request.user, device_id=device_id).last()
             if user_type and str(user_type) == str(NUMBER['one']):
                 junior = Junior.objects.filter(auth=request.user, is_active=False).last()
                 if junior:
@@ -62,11 +56,13 @@ class CustomMiddleware(object):
                 if guardian:
                     custom_error = custom_error_response(ERROR_CODE['2075'], response_status=status.HTTP_404_NOT_FOUND)
                     response = custom_response(custom_error)
-
-            if version and device_type:
-                force_update = ForceUpdate.objects.filter(version=version, device_type=device_type).last()
-                if not force_update:
-                    custom_error = custom_error_response(ERROR_CODE['2079'],
-                                                         response_status=status.HTTP_308_PERMANENT_REDIRECT)
-                    response = custom_response(custom_error, status.HTTP_308_PERMANENT_REDIRECT)
+            if device_id and not device_details and api_endpoint != '/api/v1/user/login/':
+                custom_error = custom_error_response(ERROR_CODE['2037'], response_status=status.HTTP_404_NOT_FOUND)
+                response = custom_response(custom_error)
+            force_update = ForceUpdate.objects.filter(version=version, device_type=device_type).last()
+            api_endpoint_checks = not any(endpoint in api_endpoint for endpoint in ['/admin/', '/api/v1/admin/'])
+            if not force_update and version and device_type:
+                custom_error = custom_error_response(ERROR_CODE['2079'],
+                                                     response_status=status.HTTP_308_PERMANENT_REDIRECT)
+                response = custom_response(custom_error, status.HTTP_308_PERMANENT_REDIRECT)
         return response

account/serializers.py

@@ -123,7 +123,7 @@ class ChangePasswordSerializer(serializers.Serializer):
 
     def create(self, validated_data):
         """
-        change password
+
         """
         new_password = validated_data.pop('new_password')
         current_password = validated_data.pop('current_password')
@@ -392,8 +392,7 @@ class UserPhoneOtpSerializer(serializers.ModelSerializer):
         fields = '__all__'
 
 class ForceUpdateSerializer(serializers.ModelSerializer):
-    """ ForceUpdate Serializer
-    """
+    # ForceUpdate Serializer
 
     class Meta(object):
         """ meta info """

account/utils.py

@@ -93,7 +93,7 @@ def junior_account_update(user_tb):
         # Update junior account
         junior_data.is_active = False
         junior_data.is_verified = False
-        junior_data.guardian_code = None
+        junior_data.guardian_code = '{}'
         junior_data.guardian_code_status = str(NUMBER['one'])
         junior_data.is_deleted = True
         junior_data.save()
@@ -282,8 +282,9 @@ def generate_code(value, user_id):
 
 OTP_EXPIRY = timezone.now() + timezone.timedelta(days=1)
 
+
 def get_user_full_name(user_obj):
     """
     to get user's full name
     """
-    return f"{user_obj.first_name} {user_obj.last_name}" if user_obj.last_name else user_obj.first_name
+    return f"{user_obj.first_name} {user_obj.last_name}" if user_obj.first_name or user_obj.last_name else "User"

base/constants.py

@@ -43,8 +43,7 @@ FILE_SIZE = 5 * 1024 * 1024
 
 # String constant for configurable date for allocation lock period
 ALLOCATION_LOCK_DATE = 1
-# guardian code status tuple
-guardian_code_tuple = ('1','3')
+
 """user type"""
 USER_TYPE = (
     ('1', 'junior'),

base/messages.py

@@ -101,17 +101,12 @@ ERROR_CODE = {
     "2072": "You can not approve or reject this task because junior does not exist in the system",
     "2073": "You can not approve or reject this junior because junior does not exist in the system",
     "2074": "You can not complete this task because you does not exist in the system",
-    # deactivate account
     "2075": "Your account is deactivated. Please contact with admin",
     "2076": "This junior already associate with you",
     "2077": "You can not add guardian",
     "2078": "This junior is not associate with you",
-    # force update
     "2079": "Please update your app version for enjoying uninterrupted services",
-    "2080": "Can not add App version",
-    "2081": "You can not add more than 3 guardian",
-    # guardian code not exist
-    "2082": "Guardian code does not exist"
+    "2080": "Can not add App version"
 
 }
 """Success message code"""

base/tasks.py

@@ -1,6 +1,8 @@
 """
 web_admin tasks file
 """
+import datetime
+
 # third party imports
 from celery import shared_task
 from templated_email import send_templated_mail
@@ -8,6 +10,12 @@ from templated_email import send_templated_mail
 # django imports
 from django.conf import settings
 
+# local imports
+from base.constants import PENDING, IN_PROGRESS, JUNIOR
+from guardian.models import JuniorTask
+from notifications.constants import PENDING_TASK_EXPIRING, IN_PROGRESS_TASK_EXPIRING
+from notifications.utils import send_notification
+
 
 @shared_task
 def send_email_otp(email, verification_code):
@@ -27,3 +35,45 @@ def send_email_otp(email, verification_code):
         }
     )
     return True
+
+
+@shared_task
+def send_mail(recipient_list, template, context: dict = None):
+    """
+    used to send otp on email
+    :param context:
+    :param recipient_list: e-mail list
+    :param template: email template
+    """
+    if context is None:
+        context = {}
+    from_email = settings.EMAIL_FROM_ADDRESS
+    recipient_list = recipient_list
+    send_templated_mail(
+        template_name=template,
+        from_email=from_email,
+        recipient_list=recipient_list,
+        context=context
+    )
+    return True
+
+
+@shared_task()
+def notify_task_expiry():
+    """
+    task to send notification for those task which expiring soon
+    :return:
+    """
+    all_pending_tasks = JuniorTask.objects.filter(
+        task_status__in=[PENDING, IN_PROGRESS],
+        due_date__range=[datetime.datetime.now().date(),
+                         (datetime.datetime.now().date() + datetime.timedelta(days=1))])
+    if pending_tasks := all_pending_tasks.filter(task_status=PENDING):
+        for task in pending_tasks:
+            send_notification(PENDING_TASK_EXPIRING, None, None, task.junior.auth.id,
+                              {'task_id': task.id})
+    if in_progress_tasks := all_pending_tasks.filter(task_status=IN_PROGRESS):
+        for task in in_progress_tasks:
+            send_notification(IN_PROGRESS_TASK_EXPIRING, task.junior.auth.id, JUNIOR, task.guardian.user.id,
+                              {'task_id': task.id})
+    return True

guardian/serializers.py

@@ -24,19 +24,18 @@ 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, Already_register_user
+from base.constants import NUMBER, JUN, ZOD, GRD, Already_register_user, GUARDIAN
 from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
 from .utils import real_time, convert_timedelta_into_datetime, update_referral_points
 # notification's constant
 from notifications.constants import TASK_APPROVED, TASK_REJECTED
 # send notification function
-from notifications.utils import send_notification, send_notification_to_junior
+from notifications.utils import send_notification
 from django.core.exceptions import ValidationError
 from django.utils.translation import gettext as _
 
 # In this serializer file
 # define user serializer,
-# define password validation
 # create guardian serializer,
 # task serializer,
 # guardian serializer,
@@ -48,7 +47,6 @@ from django.utils.translation import gettext as _
 from rest_framework import serializers
 
 class PasswordValidator:
-    """Password validation"""
     def __init__(self, min_length=8, max_length=None, require_uppercase=True, require_numbers=True):
         self.min_length = min_length
         self.max_length = max_length
@@ -59,7 +57,6 @@ class PasswordValidator:
         self.enforce_password_policy(value)
 
     def enforce_password_policy(self, password):
-        # add validation for password
         special_characters = "!@#$%^&*()_-+=<>?/[]{}|"
         if len(password) < self.min_length:
             raise serializers.ValidationError(
@@ -67,20 +64,16 @@ class PasswordValidator:
             )
 
         if self.max_length is not None and len(password) > self.max_length:
-            # must be 8 character
             raise serializers.ValidationError(
                 _("Password must be at most %(max_length)d characters long.") % {'max_length': self.max_length}
             )
 
         if self.require_uppercase and not any(char.isupper() for char in password):
-            # must contain upper case letter
             raise serializers.ValidationError(_("Password must contain at least one uppercase letter."))
 
         if self.require_numbers and not any(char.isdigit() for char in password):
-            # must contain digit
             raise serializers.ValidationError(_("Password must contain at least one digit."))
         if self.require_numbers and not any(char in special_characters for char in password):
-            # must contain special character
             raise serializers.ValidationError(_("Password must contain at least one special character."))
 
 
@@ -427,8 +420,8 @@ class ApproveTaskSerializer(serializers.ModelSerializer):
                 # update complete time of task
                 # instance.completed_on = real_time()
                 instance.completed_on = timezone.now().astimezone(pytz.utc)
-                send_notification_to_junior.delay(TASK_APPROVED, instance.guardian.user.id, junior_details.auth.id,
-                                                  {'task_id': instance.id})
+                send_notification.delay(TASK_APPROVED, instance.guardian.user.id, GUARDIAN,
+                                        junior_details.auth.id, {'task_id': instance.id})
             else:
                 # reject the task
                 instance.task_status = str(NUMBER['three'])
@@ -436,8 +429,8 @@ class ApproveTaskSerializer(serializers.ModelSerializer):
                 # update reject time of task
                 # instance.rejected_on = real_time()
                 instance.rejected_on = timezone.now().astimezone(pytz.utc)
-                send_notification_to_junior.delay(TASK_REJECTED, instance.guardian.user.id, junior_details.auth.id,
-                                                  {'task_id': instance.id})
+                send_notification.delay(TASK_REJECTED, instance.guardian.user.id, GUARDIAN,
+                                        junior_details.auth.id, {'task_id': instance.id})
             instance.save()
             junior_data.save()
             return junior_details

guardian/utils.py

@@ -21,7 +21,7 @@ from zod_bank.celery import app
 # notification's constant
 from notifications.constants import REFERRAL_POINTS
 # send notification function
-from notifications.utils import send_notification, send_notification_to_junior
+from notifications.utils import send_notification
 
 
 # Define upload image on
@@ -117,7 +117,7 @@ def update_referral_points(referral_code, referral_code_used):
             junior_query.total_points = junior_query.total_points + NUMBER['five']
             junior_query.referral_points = junior_query.referral_points + NUMBER['five']
             junior_query.save()
-            send_notification_to_junior.delay(REFERRAL_POINTS, None, junior_queryset.auth.id, {})
+            send_notification.delay(REFERRAL_POINTS, None, None, junior_queryset.auth.id, {})
 
 
 
@@ -127,7 +127,7 @@ def update_expired_task_status(data=None):
     Update task of the status if due date is in past
     """
     try:
-        task_status = [str(NUMBER['one']), str(NUMBER['two'])]
+        task_status = [str(NUMBER['one']), str(NUMBER['two']), str(NUMBER['four'])]
         JuniorTask.objects.filter(due_date__lt=datetime.today().date(),
                                   task_status__in=task_status).update(task_status=str(NUMBER['six']))
     except ObjectDoesNotExist as e:

guardian/views.py

@@ -10,7 +10,7 @@ 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 base.constants import guardian_code_tuple
+
 from rest_framework.filters import SearchFilter
 from django.utils import timezone
 
@@ -36,10 +36,10 @@ from account.models import UserEmailOtp, UserNotification, UserDeviceDetails
 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, GUARDIAN_CODE_STATUS
+from base.constants import NUMBER, GUARDIAN_CODE_STATUS, GUARDIAN
 from .utils import upload_image_to_alibaba
 from notifications.constants import REGISTRATION, TASK_ASSIGNED, ASSOCIATE_APPROVED, ASSOCIATE_REJECTED
-from notifications.utils import send_notification_to_junior
+from notifications.utils import send_notification
 
 """ Define APIs """
 # Define Signup API,
@@ -178,8 +178,7 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
             junior = request.data['junior']
             junior_id = Junior.objects.filter(id=junior).last()
             guardian_data = Guardian.objects.filter(user=request.user).last()
-            if (guardian_data.guardian_code not in junior_id.guardian_code or
-                    junior_id.guardian_code_status in guardian_code_tuple):
+            if guardian_data.guardian_code not in junior_id.guardian_code:
                 return custom_error_response(ERROR_CODE['2078'], response_status=status.HTTP_400_BAD_REQUEST)
             allowed_extensions = ['.jpg', '.jpeg', '.png']
             if not any(extension in str(image) for extension in allowed_extensions):
@@ -203,8 +202,8 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
                 # save serializer
                 task = serializer.save()
 
-                send_notification_to_junior.delay(TASK_ASSIGNED, request.auth.payload['user_id'],
-                                                  junior_id.auth.id, {'task_id': task.id})
+                send_notification.delay(TASK_ASSIGNED, request.auth.payload['user_id'], GUARDIAN,
+                                        junior_id.auth.id, {'task_id': task.id})
                 return custom_response(SUCCESS_CODE['3018'], serializer.data, response_status=status.HTTP_200_OK)
             return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
         except Exception as e:
@@ -288,19 +287,19 @@ class ApproveJuniorAPIView(viewsets.ModelViewSet):
             if request.data['action'] == '1':
                 # use ApproveJuniorSerializer serializer
                 serializer = ApproveJuniorSerializer(context={"guardian_code": guardian.guardian_code,
-                                                              "junior": junior_queryset,
-                                                              "action": request.data['action']},
+                                                              "junior": junior_queryset, "action": request.data['action']},
                                                      data=request.data)
                 if serializer.is_valid():
                     # save serializer
                     serializer.save()
-                    send_notification_to_junior.delay(ASSOCIATE_APPROVED, guardian.user.id, junior_queryset.auth.id)
+                    send_notification.delay(ASSOCIATE_APPROVED, guardian.user.id, GUARDIAN,
+                                            junior_queryset.auth.id)
                     return custom_response(SUCCESS_CODE['3023'], serializer.data, response_status=status.HTTP_200_OK)
             else:
                 junior_queryset.guardian_code = None
                 junior_queryset.guardian_code_status = str(NUMBER['one'])
                 junior_queryset.save()
-                send_notification_to_junior.delay(ASSOCIATE_REJECTED, guardian.user.id, junior_queryset.auth.id)
+                send_notification.delay(ASSOCIATE_REJECTED, guardian.user.id, GUARDIAN, junior_queryset.auth.id)
                 return custom_response(SUCCESS_CODE['3024'], response_status=status.HTTP_200_OK)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)

junior/serializers.py

@@ -16,12 +16,12 @@ from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship, Juni
 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,
-                            GUARDIAN_CODE_STATUS)
+                            GUARDIAN_CODE_STATUS, JUNIOR)
 from guardian.models import Guardian, JuniorTask
 from account.models import UserEmailOtp, UserNotification
 from junior.utils import junior_notification_email, junior_approval_mail
 from guardian.utils import real_time, update_referral_points, convert_timedelta_into_datetime
-from notifications.utils import send_notification, send_notification_to_junior, send_notification_to_guardian
+from notifications.utils import send_notification
 from notifications.constants import (ASSOCIATE_REQUEST, JUNIOR_ADDED, TASK_ACTION,
                                      )
 from web_admin.models import ArticleCard
@@ -88,22 +88,17 @@ class CreateJuniorSerializer(serializers.ModelSerializer):
         if junior:
             """update details according to the data get from request"""
             junior.gender = validated_data.get('gender',junior.gender)
-            # Update guardian code"""
-            # condition for guardian code
+            """Update guardian code"""
+            junior.guardian_code = validated_data.get('guardian_code', junior.guardian_code)
+            """condition for guardian code"""
             if guardian_code:
-                if not junior.guardian_code:
-                    junior.guardian_code = []
-                    junior.guardian_code.extend(guardian_code)
-                elif len(junior.guardian_code) < 3 and len(guardian_code) < 3:
-                    junior.guardian_code.extend(guardian_code)
-                else:
-                    raise serializers.ValidationError({"error":ERROR_CODE['2081'],"code":"400", "status":"failed"})
+                junior.guardian_code = guardian_code
                 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.delay(user.email, user.first_name)
-                send_notification_to_guardian.delay(ASSOCIATE_REQUEST, junior.auth.id, guardian_data.user.id, {})
+                send_notification.delay(ASSOCIATE_REQUEST, junior.auth.id, JUNIOR, guardian_data.user.id, {})
 
             junior.dob = validated_data.get('dob', junior.dob)
             junior.passcode = validated_data.get('passcode', junior.passcode)
@@ -312,7 +307,7 @@ class AddJuniorSerializer(serializers.ModelSerializer):
             """Notification email"""
             junior_notification_email.delay(email, full_name, email, password)
             # push notification
-            send_notification_to_junior.delay(JUNIOR_ADDED, None, junior_data.auth.id, {})
+            send_notification.delay(JUNIOR_ADDED, None, None, junior_data.auth.id, {})
             return junior_data
 
 
@@ -325,11 +320,9 @@ class RemoveJuniorSerializer(serializers.ModelSerializer):
         fields = ('id', 'is_invited')
     def update(self, instance, validated_data):
         if instance:
-            guardian_code = self.context['guardian_code']
             instance.is_invited = False
-            instance.guardian_code.remove(guardian_code)
-            if not instance.guardian_code:
-                instance.guardian_code_status = str(NUMBER['one'])
+            instance.guardian_code = '{}'
+            instance.guardian_code_status = str(NUMBER['one'])
             instance.save()
             return instance
 
@@ -346,8 +339,8 @@ class CompleteTaskSerializer(serializers.ModelSerializer):
         instance.task_status = str(NUMBER['four'])
         instance.is_approved = False
         instance.save()
-        send_notification_to_guardian.delay(TASK_ACTION, instance.junior.auth.id,
-                                            instance.guardian.user.id, {'task_id': instance.id})
+        send_notification.delay(TASK_ACTION, instance.junior.auth.id, JUNIOR,
+                                instance.guardian.user.id, {'task_id': instance.id})
         return instance
 
 class JuniorPointsSerializer(serializers.ModelSerializer):
@@ -457,7 +450,7 @@ class AddGuardianSerializer(serializers.ModelSerializer):
             """Notification email"""
             junior_notification_email(email, full_name, email, password)
             junior_approval_mail.delay(email, full_name)
-            send_notification_to_guardian.delay(ASSOCIATE_REQUEST, junior_data.auth.id, guardian_data.user.id, {})
+            send_notification.delay(ASSOCIATE_REQUEST, junior_data.auth.id, JUNIOR, guardian_data.user.id, {})
             return guardian_data
 
 class StartTaskSerializer(serializers.ModelSerializer):
@@ -501,6 +494,8 @@ class ReAssignTaskSerializer(serializers.ModelSerializer):
         instance.save()
         return instance
 
+
+
 class RemoveGuardianCodeSerializer(serializers.ModelSerializer):
     """User task Serializer"""
     class Meta(object):
@@ -508,33 +503,24 @@ class RemoveGuardianCodeSerializer(serializers.ModelSerializer):
         model = Junior
         fields = ('id', )
     def update(self, instance, validated_data):
-        guardian_code = self.context['guardian_code']
-        if guardian_code in instance.guardian_code:
-            instance.guardian_code.remove(guardian_code)
-        else:
-            raise serializers.ValidationError({"error":ERROR_CODE['2082'],"code":"400", "status":"failed"})
-        if not instance.guardian_code:
-            instance.guardian_code_status = str(NUMBER['one'])
-        elif instance.guardian_code and (len(instance.guardian_code) == 1 and '-' in instance.guardian_code):
-            instance.guardian_code_status = str(NUMBER['one'])
-        else:
-            instance.guardian_code_status = str(NUMBER['two'])
+        instance.guardian_code = None
+        instance.guardian_code_status = str(NUMBER['one'])
         instance.save()
         return instance
 
 class FAQSerializer(serializers.ModelSerializer):
-    """FAQ Serializer"""
+    # FAQ Serializer
 
     class Meta(object):
-        """meta info"""
+        # meta info
         model = FAQ
         fields = ('id', 'question', 'description')
 
 class CreateArticleCardSerializer(serializers.ModelSerializer):
-    """Article card Serializer"""
+    # Article card Serializer
 
     class Meta(object):
-        """meta info"""
+        # meta info
         model = ArticleCard
         fields = ('id', 'article')
 

junior/urls.py

@@ -62,5 +62,5 @@ urlpatterns = [
     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())
+    path('api/v1/remove-guardian-code-request/', RemoveGuardianCodeAPIView.as_view()),
 ]

junior/views.py

@@ -46,7 +46,7 @@ from base.constants import NUMBER, ARTICLE_STATUS, none
 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, send_notification_to_junior
+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,
@@ -99,8 +99,7 @@ class UpdateJuniorProfile(viewsets.ModelViewSet):
                 return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
             return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
         except Exception as e:
-            error_detail = e.detail.get('error', None)
-            return custom_error_response(error_detail, response_status=status.HTTP_400_BAD_REQUEST)
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class ValidateGuardianCode(viewsets.ModelViewSet):
     """Check guardian code exist or not"""
@@ -191,8 +190,6 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
                     return custom_error_response(ERROR_CODE['2077'], response_status=status.HTTP_400_BAD_REQUEST)
                 elif not data:
                     return custom_error_response(ERROR_CODE['2076'], response_status=status.HTTP_400_BAD_REQUEST)
-                if data == "Max":
-                    return custom_error_response(ERROR_CODE['2081'], response_status=status.HTTP_400_BAD_REQUEST)
                 return custom_response(SUCCESS_CODE['3021'], response_status=status.HTTP_200_OK)
             # use AddJuniorSerializer serializer
             serializer = AddJuniorSerializer(data=request.data, context=info_data)
@@ -207,18 +204,14 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
     def associate_guardian(self, user):
         junior = Junior.objects.filter(auth__email=self.request.data['email']).first()
         guardian = Guardian.objects.filter(user=self.request.user).first()
-        if junior.guardian_code and ('-' in junior.guardian_code):
-            junior.guardian_code.remove('-')
         if not junior:
             return none
         if junior.guardian_code and (guardian.guardian_code in junior.guardian_code):
             return False
-        if not junior.guardian_code:
-            junior.guardian_code = [guardian.guardian_code]
-        if type(junior.guardian_code) is list and len(junior.guardian_code) < 3:
+        if type(junior.guardian_code) is list:
             junior.guardian_code.append(guardian.guardian_code)
         else:
-            return "Max"
+            junior.guardian_code = [guardian.guardian_code]
         junior.guardian_code_status = str(NUMBER['two'])
         junior.save()
         JuniorGuardianRelationship.objects.get_or_create(guardian=guardian, junior=junior,
@@ -266,10 +259,10 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
         manual_parameters=[
             # Example of a query parameter
             openapi.Parameter(
-                'title',
-                openapi.IN_QUERY,
+                'title',  # Query parameter name
+                openapi.IN_QUERY,  # Parameter location
                 description='title of the name',
-                type=openapi.TYPE_STRING,
+                type=openapi.TYPE_STRING,  # Parameter type
             ),
             # Add more parameters as needed
         ]
@@ -315,12 +308,11 @@ class RemoveJuniorAPIView(views.APIView):
                                                     guardian_code__icontains=str(guardian.guardian_code)).last()
             if junior_queryset:
                 # use RemoveJuniorSerializer serializer
-                serializer = RemoveJuniorSerializer(junior_queryset, context={"guardian_code":guardian.guardian_code},
-                                                    data=request.data, partial=True)
+                serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
                 if serializer.is_valid():
                     # save serializer
                     serializer.save()
-                    send_notification_to_junior.delay(REMOVE_JUNIOR, None, junior_queryset.auth.id, {})
+                    send_notification.delay(REMOVE_JUNIOR, None, None, junior_queryset.auth.id, {})
                     return custom_response(SUCCESS_CODE['3022'], serializer.data, response_status=status.HTTP_200_OK)
                 return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
             else:
@@ -623,7 +615,7 @@ class CheckAnswerAPIView(viewsets.ModelViewSet):
             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).last()
+            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:
@@ -726,21 +718,16 @@ class CreateArticleCardAPIView(viewsets.ModelViewSet):
 
 class RemoveGuardianCodeAPIView(views.APIView):
     """Remove guardian code request API
-    Payload
-    {"guardian_code"
-    :"GRD037"
-    }"""
+    No Payload"""
     serializer_class = RemoveGuardianCodeSerializer
     permission_classes = [IsAuthenticated]
 
     def put(self, request, format=None):
         try:
-            guardian_code = self.request.data.get("guardian_code")
             junior_queryset = Junior.objects.filter(auth=self.request.user).last()
             if junior_queryset:
                 # use RemoveGuardianCodeSerializer serializer
-                serializer = RemoveGuardianCodeSerializer(junior_queryset, context = {"guardian_code":guardian_code},
-                                                          data=request.data, partial=True)
+                serializer = RemoveGuardianCodeSerializer(junior_queryset, data=request.data, partial=True)
                 if serializer.is_valid():
                     # save serializer
                     serializer.save()
@@ -750,8 +737,7 @@ class RemoveGuardianCodeAPIView(views.APIView):
                 # task in another state
                 return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
         except Exception as e:
-            error_detail = e.detail.get('error', None)
-            return custom_error_response(error_detail, response_status=status.HTTP_400_BAD_REQUEST)
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class FAQViewSet(GenericViewSet, mixins.CreateModelMixin,

notifications/constants.py

@@ -12,8 +12,9 @@ TASK_ASSIGNED = 8
 TASK_ACTION = 9
 TASK_REJECTED = 10
 TASK_APPROVED = 11
-
-REMOVE_JUNIOR = 13
+PENDING_TASK_EXPIRING = 12
+IN_PROGRESS_TASK_EXPIRING = 13
+REMOVE_JUNIOR = 15
 
 TEST_NOTIFICATION = 99
 
@@ -22,16 +23,18 @@ NOTIFICATION_DICT = {
         "title": "Successfully registered!",
         "body": "You have registered successfully. Now login and complete your profile."
     },
+    # user will receive notification as soon junior sign up application using their guardian code
+    # for association
     ASSOCIATE_REQUEST: {
         "title": "Associate request!",
         "body": "You have request from {from_user} to associate with you."
     },
-
+    # Juniors will receive notification when custodians reject their request for associate
     ASSOCIATE_REJECTED: {
         "title": "Associate request rejected!",
         "body": "Your request to associate has been rejected by {from_user}."
     },
-
+    # Juniors will receive notification when custodians approve their request for associate
     ASSOCIATE_APPROVED: {
         "title": "Associate request approved!",
         "body": "Your request to associate has been approved by {from_user}."
@@ -54,7 +57,7 @@ NOTIFICATION_DICT = {
     # Guardian will receive notification as soon as junior send task for approval
     TASK_ACTION: {
         "title": "Task completion approval!",
-        "body": "You have request from {from_user} for task completion."
+        "body": "{from_user} completed her task {task_name}."
     },
     # Juniors will receive notification as soon as their task is rejected by custodians
     TASK_REJECTED: {
@@ -68,11 +71,24 @@ NOTIFICATION_DICT = {
         "body": "Your task completion request has been approved by {from_user}. "
                 "Also you earned 5 points for successful completion."
     },
+    # Juniors will receive notification when their task end date about to end
+    PENDING_TASK_EXPIRING: {
+        "title": "Task expiring soon!",
+        "body": "Your task {task_name} is expiring soon. Please complete it."
+    },
+    # User will receive notification when their assigned task is about to end
+    # and juniors have not performed any action
+    IN_PROGRESS_TASK_EXPIRING: {
+        "title": "Task expiring soon!",
+        "body": "{from_user} didn't take any action on assigned task {task_name} and it's expiring soon. "
+                "Please assist to complete it."
+    },
     # Juniors will receive notification as soon as their custodians remove them from account
     REMOVE_JUNIOR: {
         "title": "Disassociate by guardian!",
         "body": "Your guardian has disassociated you."
     },
+    # Test notification
     TEST_NOTIFICATION: {
         "title": "Test Notification",
         "body": "This notification is for testing purpose from {from_user}."

notifications/utils.py

@@ -9,15 +9,15 @@ from firebase_admin.messaging import Message, Notification as FirebaseNotificati
 # django imports
 from django.contrib.auth import get_user_model
 
+# local imports
 from account.models import UserNotification
 from account.utils import get_user_full_name
-from guardian.models import Guardian
+from base.constants import GUARDIAN, JUNIOR
+from guardian.models import Guardian, JuniorTask
 from junior.models import Junior
 from notifications.constants import NOTIFICATION_DICT
 from notifications.models import Notification
 
-# local imports
-
 
 User = get_user_model()
 
@@ -42,49 +42,69 @@ def remove_fcm_token(user_id: int, access_token: str, registration_id) -> None:
         print(e)
 
 
-def get_basic_detail(from_user_id, to_user_id):
+def get_from_user_details(from_user_id, from_user_type):
     """
-    used to get the basic details
+    used to get from user details
     """
-    from_user = User.objects.get(id=from_user_id) if from_user_id else None
-    to_user = User.objects.get(id=to_user_id)
-    return from_user, to_user
+    from_user = None
+    from_user_name = None
+    from_user_image = None
+    if from_user_id:
+        if from_user_type == GUARDIAN:
+            guardian = Guardian.objects.filter(user_id=from_user_id).select_related('user').first()
+            from_user = guardian.user
+            from_user_name = get_user_full_name(from_user)
+            from_user_image = guardian.image
+        elif from_user_type == JUNIOR:
+            junior = Junior.objects.filter(auth_id=from_user_id).select_related('auth').first()
+            from_user = junior.auth
+            from_user_name = get_user_full_name(from_user)
+            from_user_image = junior.image
+    return from_user_name, from_user_image, from_user
 
 
-def get_notification_data(notification_type, from_user, to_user, extra_data):
+def get_notification_data(notification_type, from_user_id, from_user_type, to_user_id, extra_data):
     """
     get notification and push data
+    :param from_user_type: GUARDIAN or JUNIOR
     :param notification_type: notification_type
-    :param from_user: from_user obj
-    :param to_user: to_user obj
+    :param from_user_id: from_user obj
+    :param to_user_id: to_user obj
     :param extra_data: any extra data provided
     :return: notification and push data
     """
     push_data = NOTIFICATION_DICT[notification_type].copy()
     notification_data = push_data.copy()
-    notification_data['to_user'] = get_user_full_name(to_user)
-    if from_user:
-        from_user_name = get_user_full_name(from_user)
-        push_data['body'] = push_data['body'].format(from_user=from_user_name)
-        notification_data['body'] = notification_data['body'].format(from_user=from_user_name)
-        notification_data['from_user'] = from_user_name
+    task_name = None
+    if 'task_id' in extra_data:
+        task = JuniorTask.objects.filter(id=extra_data.get('task_id')).first()
+        task_name = task.task_name
+        extra_data['task_image'] = task.image if task.image else task.default_image
+
+    from_user_name, from_user_image, from_user = get_from_user_details(from_user_id, from_user_type)
+
+    push_data['body'] = push_data['body'].format(from_user=from_user_name, task_name=task_name)
+    notification_data['body'] = notification_data['body'].format(from_user=from_user_name, task_name=task_name)
+    notification_data['from_user'] = from_user_name
+    notification_data['from_user_image'] = from_user_image
 
     notification_data.update(extra_data)
-
-    return notification_data, push_data
+    to_user = User.objects.get(id=to_user_id)
+    return notification_data, push_data, from_user, to_user
 
 
-def send_notification(notification_type, from_user, to_user, extra_data):
+@shared_task()
+def send_notification(notification_type, from_user_id, from_user_type, to_user_id, extra_data):
     """
     used to send the push for the given notification type
     """
-    # (from_user, to_user) = get_basic_detail(from_user_id, to_user_id)
-    notification_data, push_data = get_notification_data(notification_type, from_user, to_user, extra_data)
+    notification_data, push_data, from_user, to_user = get_notification_data(notification_type, from_user_id,
+                                                                             from_user_type, to_user_id, extra_data)
     user_notification_type = UserNotification.objects.filter(user=to_user).first()
     notification_data.update({'badge': Notification.objects.filter(notification_to=to_user, is_read=False).count()})
     Notification.objects.create(notification_type=notification_type, notification_from=from_user,
                                 notification_to=to_user, data=notification_data)
-    if user_notification_type.push_notification:
+    if user_notification_type and user_notification_type.push_notification:
         send_push(to_user, push_data)
 
 
@@ -104,14 +124,10 @@ def send_notification_to_guardian(notification_type, from_user_id, to_user_id, e
     :param extra_data:
     :return:
     """
-    from_user = None
     if from_user_id:
-        from_user = Junior.objects.filter(auth_id=from_user_id).select_related('auth').first()
+        from_user = Junior.objects.filter(auth_id=from_user_id).first()
         extra_data['from_user_image'] = from_user.image
-        from_user = from_user.auth
-    to_user = Guardian.objects.filter(user_id=to_user_id).select_related('user').first()
-    extra_data['to_user_image'] = to_user.image
-    send_notification(notification_type, from_user, to_user.user, extra_data)
+    send_notification(notification_type, from_user_id, to_user_id, extra_data)
 
 
 @shared_task()
@@ -123,13 +139,9 @@ def send_notification_to_junior(notification_type, from_user_id, to_user_id, ext
     :param extra_data:
     :return:
     """
-    from_user = None
     if from_user_id:
-        from_user = Guardian.objects.filter(user_id=from_user_id).select_related('user').first()
+        from_user = Guardian.objects.filter(user_id=from_user_id).first()
         extra_data['from_user_image'] = from_user.image
-        from_user = from_user.user
-    to_user = Junior.objects.filter(auth_id=to_user_id).select_related('auth').first()
-    extra_data['to_user_image'] = to_user.image
-    send_notification(notification_type, from_user, to_user.auth, extra_data)
+    send_notification(notification_type, from_user_id, to_user_id, extra_data)
 
 

notifications/views.py

@@ -4,27 +4,33 @@ notifications views file
 # django imports
 from django.db.models import Q
 from rest_framework.decorators import action
-from rest_framework.permissions import IsAuthenticated
+from rest_framework.permissions import IsAuthenticated, AllowAny
 from rest_framework.response import Response
 from rest_framework import viewsets, status, views
+
 # local imports
 from account.utils import custom_response, custom_error_response
 from base.messages import SUCCESS_CODE, ERROR_CODE
+from base.tasks import notify_task_expiry
 from notifications.constants import TEST_NOTIFICATION
-# Import serializer
 from notifications.serializers import RegisterDevice, NotificationListSerializer, ReadNotificationSerializer
-from notifications.utils import send_notification, send_notification_to_guardian, send_notification_to_junior
-# Import model
+from notifications.utils import send_notification
 from notifications.models import Notification
 
 
 class NotificationViewSet(viewsets.GenericViewSet):
-    """ used to do the notification actions """
+    """
+    used to do the notification actions
+    """
     serializer_class = NotificationListSerializer
     permission_classes = [IsAuthenticated, ]
 
     def list(self, request, *args, **kwargs) -> Response:
-        """ list the notifications """
+        """
+        to list user's notifications
+        :param request:
+        :return:
+        """
         queryset = Notification.objects.filter(notification_to_id=request.auth.payload['user_id']
                                                ).select_related('notification_to').order_by('-id')
         paginator = self.pagination_class()
@@ -49,10 +55,8 @@ class NotificationViewSet(viewsets.GenericViewSet):
         to send test notification
         :return:
         """
-        send_notification_to_guardian.delay(TEST_NOTIFICATION, None, request.auth.payload['user_id'],
-                                            {'task_id': None})
-        send_notification_to_junior.delay(TEST_NOTIFICATION, None, request.auth.payload['user_id'],
-                                          {'task_id': None})
+        send_notification(TEST_NOTIFICATION, None, None, request.auth.payload['user_id'],
+                          {})
         return custom_response(SUCCESS_CODE["3000"])
 
     @action(methods=['patch'], url_path='mark-as-read', url_name='mark-as-read', detail=False,
@@ -63,3 +67,12 @@ class NotificationViewSet(viewsets.GenericViewSet):
         """
         Notification.objects.filter(id__in=request.data.get('id')).update(is_read=True)
         return custom_response(SUCCESS_CODE['3039'], response_status=status.HTTP_200_OK)
+
+    @action(methods=['get'], url_path='task', url_name='task', detail=False,
+            permission_classes=[AllowAny])
+    def task(self, request, *args, **kwargs):
+        """
+        notification list
+        """
+        notify_task_expiry()
+        return custom_response(SUCCESS_CODE['3039'], response_status=status.HTTP_200_OK)

web_admin/serializers/analytics_serializer.py

@@ -7,6 +7,7 @@ from rest_framework import serializers
 # django imports
 from django.contrib.auth import get_user_model
 
+from account.utils import get_user_full_name
 # local imports
 from base.constants import USER_TYPE
 
@@ -74,6 +75,7 @@ class UserCSVReportSerializer(serializers.ModelSerializer):
     """
     user csv/xls report serializer
     """
+    name = serializers.SerializerMethodField()
     phone_number = serializers.SerializerMethodField()
     user_type = serializers.SerializerMethodField()
     is_active = serializers.SerializerMethodField()
@@ -84,7 +86,15 @@ class UserCSVReportSerializer(serializers.ModelSerializer):
         meta class
         """
         model = USER
-        fields = ('first_name', 'last_name', 'email', 'phone_number', 'user_type', 'is_active', 'date_joined')
+        fields = ('name', 'email', 'phone_number', 'user_type', 'is_active', 'date_joined')
+
+    @staticmethod
+    def get_name(obj):
+        """
+        :param obj: user object
+        :return: full name
+        """
+        return get_user_full_name(obj)
 
     @staticmethod
     def get_phone_number(obj):

web_admin/serializers/article_serializer.py

@@ -219,7 +219,8 @@ class ArticleListSerializer(serializers.ModelSerializer):
     """
     serializer for article API
     """
-    image = serializers.SerializerMethodField('get_image')
+    article_cards = ArticleCardSerializer(many=True)
+    article_survey = ArticleSurveySerializer(many=True)
     total_points = serializers.SerializerMethodField('get_total_points')
     is_completed = serializers.SerializerMethodField('get_is_completed')
 
@@ -228,16 +229,12 @@ class ArticleListSerializer(serializers.ModelSerializer):
         meta class
         """
         model = Article
-        fields = ('id', 'title', 'description','image', 'total_points', 'is_completed')
+        fields = ('id', 'title', 'description', 'article_cards', 'article_survey', 'total_points', 'is_completed')
 
-    def get_image(self, obj):
-        """article image"""
-        if obj.article_cards.first():
-            return obj.article_cards.first().image_url
-        return None
     def get_total_points(self, obj):
         """total points of article"""
-        return obj.article_survey.all().count() * NUMBER['five']
+        total_question = ArticleSurvey.objects.filter(article=obj).count()
+        return total_question * NUMBER['five']
 
     def get_is_completed(self, obj):
         """complete all question"""
@@ -271,14 +268,14 @@ class ArticleQuestionSerializer(serializers.ModelSerializer):
         ans_obj = SurveyOption.objects.filter(survey=obj, is_answer=True).last()
         if ans_obj:
             return ans_obj.id
-        return None
+        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).last()
-        if junior_article_obj and junior_article_obj.submitted_answer:
+                                                                question=obj, is_answer_correct=True).last()
+        if junior_article_obj:
             return junior_article_obj.submitted_answer.id
         return None
 

web_admin/serializers/auth_serializer.py

@@ -14,7 +14,7 @@ from account.models import UserEmailOtp
 from base.constants import USER_TYPE
 from base.messages import ERROR_CODE
 from guardian.tasks import generate_otp
-from base.tasks import send_email_otp
+from base.tasks import send_mail
 
 USER = get_user_model()
 
@@ -48,11 +48,13 @@ class AdminOTPSerializer(serializers.ModelSerializer):
         :return: user_data
         """
         email = validated_data['email']
-
         verification_code = generate_otp()
-
+        template = 'email_reset_verification.email'
         # Send the verification code to the user's email
-        send_email_otp.delay(email, verification_code)
+        data = {
+            "verification_code": verification_code
+        }
+        send_mail.delay([email], template, data)
 
         expiry = timezone.now() + timezone.timedelta(days=1)
         user_data, created = UserEmailOtp.objects.update_or_create(email=email,

web_admin/serializers/user_management_serializer.py

@@ -5,6 +5,7 @@ web_admin user_management serializers file
 from rest_framework import serializers
 from django.contrib.auth import get_user_model
 
+from account.utils import get_user_full_name
 from base.constants import USER_TYPE, GUARDIAN, JUNIOR
 # local imports
 from base.messages import ERROR_CODE, SUCCESS_CODE
@@ -37,7 +38,7 @@ class UserManagementListSerializer(serializers.ModelSerializer):
         :param obj: user object
         :return: full name
         """
-        return f"{obj.first_name} {obj.last_name}" if obj.last_name else obj.first_name
+        return get_user_full_name(obj)
 
     @staticmethod
     def get_country_code(obj):
@@ -144,7 +145,7 @@ class GuardianSerializer(serializers.ModelSerializer):
         :param obj: guardian object
         :return: full name
         """
-        return f"{obj.user.first_name} {obj.user.last_name}" if obj.user.last_name else obj.user.first_name
+        return get_user_full_name(obj.user)
 
     @staticmethod
     def get_first_name(obj):
@@ -222,7 +223,7 @@ class JuniorSerializer(serializers.ModelSerializer):
         :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
+        return get_user_full_name(obj.auth)
 
     @staticmethod
     def get_first_name(obj):

web_admin/views/analytics.py

@@ -22,7 +22,7 @@ from django.db.models.functions.window import Rank
 from django.http import HttpResponse
 
 # local imports
-from account.utils import custom_response
+from account.utils import custom_response, get_user_full_name
 from base.constants import PENDING, IN_PROGRESS, REJECTED, REQUESTED, COMPLETED, EXPIRED, DATE_FORMAT, TASK_STATUS
 from guardian.models import JuniorTask
 from guardian.utils import upload_excel_file_to_alibaba
@@ -107,13 +107,15 @@ class AnalyticsViewSet(GenericViewSet):
 
         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_pending': assign_tasks.filter(task_status=PENDING).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(),
+            'task_expired': assign_tasks.filter(task_status=EXPIRED).count(),
         }
 
         return custom_response(None, data)
@@ -169,10 +171,9 @@ class AnalyticsViewSet(GenericViewSet):
                 serializer = UserCSVReportSerializer(queryset, many=True)
 
                 df_users = pd.DataFrame([
-                    {'Name': f"{user['first_name']} {user['last_name']}",
-                     'Email': user['email'], 'Phone Number': user['phone_number'],
-                     'User Type': user['user_type'], 'Status': user['is_active'],
-                     'Date Joined': user['date_joined']}
+                    {'Name': user['name'], 'Email': user['email'],
+                     'Phone Number': user['phone_number'], 'User Type': user['user_type'],
+                     'Status': user['is_active'], 'Date Joined': user['date_joined']}
                     for user in serializer.data
                 ])
                 write_excel_worksheet(worksheet, df_users)
@@ -181,10 +182,16 @@ class AnalyticsViewSet(GenericViewSet):
             elif sheet_name == 'Assign Tasks':
                 assign_tasks = JuniorTask.objects.filter(
                     created_at__range=[start_date, (end_date + datetime.timedelta(days=1))]
-                ).exclude(task_status__in=[PENDING, EXPIRED])
+                ).select_related('junior__auth', 'guardian__user').only('task_name', 'task_status',
+                                                                        'junior__auth__first_name',
+                                                                        'junior__auth__last_name',
+                                                                        'guardian__user__first_name',
+                                                                        'guardian__user__last_name',)
 
                 df_tasks = pd.DataFrame([
-                    {'Task Name': task.task_name, 'Task Status': dict(TASK_STATUS).get(task.task_status).capitalize()}
+                    {'Task Name': task.task_name, 'Assign To': get_user_full_name(task.junior.auth),
+                     'Assign By': get_user_full_name(task.guardian.user),
+                     'Task Status': dict(TASK_STATUS).get(task.task_status).capitalize()}
                     for task in assign_tasks
                 ])
 
@@ -198,8 +205,7 @@ class AnalyticsViewSet(GenericViewSet):
                 )).order_by('-total_points', 'junior__created_at')[:15]
                 df_leaderboard = pd.DataFrame([
                     {
-                        'Junior Name': f"{junior.junior.auth.first_name} {junior.junior.auth.last_name}"
-                        if junior.junior.auth.last_name else junior.junior.auth.first_name,
+                        'Name': get_user_full_name(junior.junior.auth),
                         'Points': junior.total_points,
                         'Rank': junior.rank
                     }

web_admin/views/article.py

@@ -229,7 +229,10 @@ class ArticleListViewSet(GenericViewSet, mixins.ListModelMixin):
     http_method_names = ['get',]
 
     def get_queryset(self):
-        queryset = self.queryset.objects.filter(is_deleted=False, is_published=True).order_by('-created_at')
+        article = self.queryset.objects.filter(is_deleted=False, is_published=True).prefetch_related(
+            'article_cards', 'article_survey', 'article_survey__options'
+        ).order_by('-created_at')
+        queryset = self.filter_queryset(article)
         return queryset
 
     def list(self, request, *args, **kwargs):

zod_bank/celery.py

@@ -27,6 +27,13 @@ app.config_from_object('django.conf:settings')
 # Load task modules from all registered Django apps.
 app.autodiscover_tasks()
 
+app.conf.beat_schedule = {
+    'notify_task_expiry': {
+        'task': 'base.tasks.notify_task_expiry',
+        'schedule': crontab(minute='0', hour='*/1'),
+    },
+}
+
 
 @app.task(bind=True)
 def debug_task(self):