sonar issues

condition in add junior

account/custom_middleware.py

@@ -45,11 +45,12 @@ class CustomMiddleware(object):
         device_type = str(request.META.get('HTTP_TYPE'))
 
         api_endpoint = request.path
+        unrestricted_api = ('/api/v1/user/login/', '/api/v1/logout/', '/api/v1/generate-token/')
         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/':
+                if not device_details and api_endpoint not in unrestricted_api:
                     custom_error = custom_error_response(ERROR_CODE['2037'], response_status=status.HTTP_404_NOT_FOUND)
                     response = custom_response(custom_error)
             if user_type and str(user_type) == str(NUMBER['one']):

account/templates/templated_email/support_mail.email

@@ -1,7 +1,7 @@
 {% extends "templated_email/email_base.email" %}
 
 {% block subject %}
-    {{subject}}
+    Support Mail
 {% endblock %}
 
 {% block plain %}

account/utils.py

@@ -1,6 +1,6 @@
 """Account utils"""
 from celery import shared_task
-
+import random
 """Import django"""
 from django.conf import settings
 from rest_framework import viewsets, status
@@ -167,7 +167,7 @@ def user_device_details(user, device_id):
     return False
 
 
-def send_support_email(name, sender, subject, message):
+def send_support_email(name, sender, message):
     """Send otp on email with template"""
     to_email = [settings.EMAIL_FROM_ADDRESS]
     from_email = settings.DEFAULT_ADDRESS
@@ -179,19 +179,19 @@ def send_support_email(name, sender, subject, message):
         context={
             'name': name.title(),
             'sender': sender,
-            'subject': subject,
             'message': message
         }
     )
     return name
 
 
-def custom_response(detail, data=None, response_status=status.HTTP_200_OK, count=None):
+def custom_response(detail, data=None, total_pages=None, current_page=None, response_status=status.HTTP_200_OK, count=None):
     """Custom response code"""
     if not data:
         """when data is none"""
         data = None
-    return Response({"data": data, "message": detail, "status": "success", "code": response_status, "count": count})
+    return Response({"data": data, "message": detail, "total_pages":total_pages, "current_page":current_page,
+                     "status": "success", "code": response_status, "count": count})
 
 
 def custom_error_response(detail, response_status):
@@ -288,3 +288,36 @@ 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.first_name or user_obj.last_name else "User"
+
+def make_special_password(length=10):
+    # Define character sets
+    lowercase_letters = string.ascii_lowercase
+    uppercase_letters = string.ascii_uppercase
+    digits = string.digits
+    special_characters = '!@#$%^&*()_-+=<>?/[]{}|'
+
+    # Combine character sets
+    all_characters = lowercase_letters + uppercase_letters + digits + special_characters
+
+    # Create a password with random characters
+    password = (
+        random.choice(lowercase_letters) +
+        random.choice(uppercase_letters) +
+        random.choice(digits) +
+        random.choice(special_characters) +
+        ''.join(random.choice(all_characters) for _ in range(length - 4))
+    )
+
+    # Shuffle the characters to make it more random
+    password_list = list(password)
+    random.shuffle(password_list)
+    return ''.join(password_list)
+
+def task_status_fun(status_value):
+    """task status"""
+    task_status_value = ['1']
+    if str(status_value) == '2':
+        task_status_value = ['2', '4']
+    elif str(status_value) == '3':
+        task_status_value = ['3', '5', '6']
+    return task_status_value

account/views.py

@@ -322,7 +322,7 @@ class ForgotPasswordAPIView(views.APIView):
         send_all_email.delay(
             'email_reset_verification.email', email, verification_code
         )
-        expiry = OTP_EXPIRY
+        expiry = timezone.now() + timezone.timedelta(days=1)
         user_data, created = UserEmailOtp.objects.get_or_create(
             email=email
         )
@@ -689,11 +689,10 @@ class SendSupportEmail(views.APIView):
     def post(self, request):
         name = request.data.get('name')
         sender = request.data.get('email')
-        subject = request.data.get('subject')
         message = request.data.get('message')
-        if name and sender and subject and message:
+        if name and sender and message:
             try:
-                send_support_email(name, sender, subject, message)
+                send_support_email(name, sender, message)
                 return custom_response(SUCCESS_CODE['3019'], response_status=status.HTTP_200_OK)
             except Exception as e:
                 return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)

base/messages.py

@@ -111,7 +111,10 @@ ERROR_CODE = {
     "2080": "Can not add App version",
     "2081": "A junior can only be associated with a maximum of 3 guardian",
     # guardian code not exist
-    "2082": "Guardian code does not exist"
+    "2082": "Guardian code does not exist",
+    "2083": "You can not start this task because guardian is not associate with you",
+    "2084": "You can not complete this task because guardian is not associate with you",
+    "2085": "You can not take action on this task because junior is not associate with you"
 
 }
 """Success message code"""
@@ -147,8 +150,8 @@ SUCCESS_CODE = {
     "3018": "Task created successfully",
     "3019": "Support Email sent successfully",
     "3020": "Logged out successfully.",
-    "3021": "Add junior successfully",
-    "3022": "Remove junior successfully",
+    "3021": "Added junior successfully",
+    "3022": "Removed junior successfully",
     "3023": "Junior is approved successfully",
     "3024": "Junior request is rejected successfully",
     "3025": "Task is approved successfully",

guardian/serializers.py

@@ -218,7 +218,7 @@ class TaskSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = JuniorTask
-        fields = ['id', 'task_name','task_description','points', 'due_date', 'junior', 'default_image']
+        fields = ['id', 'task_name','task_description','points', 'due_date','default_image']
 
     def validate_due_date(self, value):
         """validation on due date"""
@@ -229,11 +229,21 @@ class TaskSerializer(serializers.ModelSerializer):
         return value
     def create(self, validated_data):
         """create default task image data"""
-        validated_data['guardian'] = Guardian.objects.filter(user=self.context['user']).last()
+        guardian = Guardian.objects.filter(user=self.context['user']).last()
         # update image of the task
         images = self.context['image']
-        validated_data['default_image'] = images
-        instance = JuniorTask.objects.create(**validated_data)
+        junior_ids = self.context['junior_data']
+        junior_data = junior_ids[0].split(',')
+        tasks_created = []
+
+        for junior_id in junior_data:
+            # create task
+            task_data = validated_data.copy()
+            task_data['guardian'] = guardian
+            task_data['default_image'] = images
+            task_data['junior'] = Junior.objects.filter(id=junior_id).last()
+            instance = JuniorTask.objects.create(**task_data)
+            tasks_created.append(instance)
         return instance
 
 class GuardianDetailSerializer(serializers.ModelSerializer):

guardian/views.py

@@ -1,4 +1,5 @@
 """Views of Guardian"""
+import math
 
 # django imports
 # Import IsAuthenticated
@@ -36,7 +37,7 @@ from .models import Guardian, JuniorTask
 from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
 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 account.utils import custom_response, custom_error_response, send_otp_email, task_status_fun
 from base.messages import ERROR_CODE, SUCCESS_CODE
 from base.constants import NUMBER, GUARDIAN_CODE_STATUS, GUARDIAN
 from .utils import upload_image_to_alibaba
@@ -135,7 +136,8 @@ class TaskListAPIView(viewsets.ModelViewSet):
     Params
     status
     search
-    page"""
+    page
+    junior"""
     serializer_class = TaskDetailsSerializer
     permission_classes = [IsAuthenticated]
     filter_backends = (SearchFilter,)
@@ -154,15 +156,23 @@ class TaskListAPIView(viewsets.ModelViewSet):
     def list(self, request, *args, **kwargs):
         """Create guardian profile"""
         status_value = self.request.GET.get('status')
+        current_page = self.request.GET.get('page')
+        junior = self.request.GET.get('junior')
         queryset = self.get_queryset()
-        if status_value and status_value != '0':
-            queryset = queryset.filter(task_status=status_value)
+        task_status = task_status_fun(status_value)
+        if status_value and not junior:
+            queryset = queryset.filter(task_status__in=task_status)
+        elif status_value and junior:
+            queryset = queryset.filter(task_status__in=task_status,junior=int(junior))
         paginator = self.pagination_class()
+        total_count = len(queryset)
+        total_pages = math.ceil(total_count/10)
         # use Pagination
         paginated_queryset = paginator.paginate_queryset(queryset, request)
         # use TaskDetailsSerializer serializer
         serializer = self.serializer_class(paginated_queryset, many=True)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        return custom_response(None, serializer.data, total_pages=total_pages, current_page=current_page,
+                               response_status=status.HTTP_200_OK)
 
 
 class CreateTaskAPIView(viewsets.ModelViewSet):
@@ -177,42 +187,46 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
         """
         try:
             image = request.data['default_image']
-            junior = request.data['junior']
-            junior_id = Junior.objects.filter(id=junior).last()
-            if junior_id:
-                guardian_data = Guardian.objects.filter(user=request.user).last()
-                index = junior_id.guardian_code.index(guardian_data.guardian_code)
-                status_index = junior_id.guardian_code_status[index]
-                if status_index == str(NUMBER['three']):
-                    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):
-                    return custom_error_response(ERROR_CODE['2048'], response_status=status.HTTP_400_BAD_REQUEST)
-                if not junior.isnumeric():
-                    """junior value must be integer"""
-                    return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
-                data = request.data
-                if 'https' in str(image):
-                    image_data = image
-                else:
-                    filename = f"images/{image}"
-                    if image and image.size == NUMBER['zero']:
-                        return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
-                    image_url = upload_image_to_alibaba(image, filename)
-                    image_data = image_url
-                    data.pop('default_image')
-                # use TaskSerializer serializer
-                serializer = TaskSerializer(context={"user":request.user, "image":image_data}, data=data)
-                if serializer.is_valid():
-                    # save serializer
-                    task = serializer.save()
+            juniors = request.data['junior'].split(',')
+            for junior in juniors:
+                junior_id = Junior.objects.filter(id=junior).last()
+                if junior_id:
+                    guardian_data = Guardian.objects.filter(user=request.user).last()
+                    index = junior_id.guardian_code.index(guardian_data.guardian_code)
+                    status_index = junior_id.guardian_code_status[index]
+                    if status_index == str(NUMBER['three']):
+                        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):
+                        return custom_error_response(ERROR_CODE['2048'], response_status=status.HTTP_400_BAD_REQUEST)
+                    if not junior.isnumeric():
+                        """junior value must be integer"""
+                        return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
+                    data = request.data
+                    if 'https' in str(image):
+                        image_data = image
+                    else:
+                        filename = f"images/{image}"
+                        if image and image.size == NUMBER['zero']:
+                            return custom_error_response(ERROR_CODE['2035'],
+                                                         response_status=status.HTTP_400_BAD_REQUEST)
+                        image_url = upload_image_to_alibaba(image, filename)
+                        image_data = image_url
+                        data.pop('default_image')
+                    junior_data = data.pop('junior')
+                    # use TaskSerializer serializer
+                    serializer = TaskSerializer(context={"user":request.user, "image":image_data,
+                                                         "junior_data":junior_data}, data=data)
+                    if serializer.is_valid():
+                        # save serializer
+                        task = serializer.save()
 
-                    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)
-            else:
-                return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
+                        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'], response_status=status.HTTP_200_OK)
+                    return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
+                else:
+                    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)
 
@@ -344,6 +358,8 @@ class ApproveTaskAPIView(viewsets.ModelViewSet):
             task_queryset = JuniorTask.objects.filter(id=self.request.data.get('task_id'),
                                                       guardian=guardian,
                                                       junior=self.request.data.get('junior_id')).last()
+            if task_queryset and guardian.guardian_code not in task_queryset.junior.guardian_code:
+                return custom_error_response(ERROR_CODE['2084'], response_status=status.HTTP_400_BAD_REQUEST)
             if task_queryset and (task_queryset.junior.is_deleted or not task_queryset.junior.is_active):
                 return custom_error_response(ERROR_CODE['2072'], response_status=status.HTTP_400_BAD_REQUEST)
             # use ApproveJuniorSerializer serializer

junior/serializers.py

@@ -11,7 +11,7 @@ from django.utils import timezone
 from rest_framework_simplejwt.tokens import RefreshToken
 
 # local imports
-from account.utils import send_otp_email, generate_code
+from account.utils import send_otp_email, generate_code, make_special_password
 from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship, JuniorArticlePoints, FAQ
 from guardian.tasks import generate_otp
 from base.messages import ERROR_CODE, SUCCESS_CODE
@@ -297,8 +297,8 @@ class AddJuniorSerializer(serializers.ModelSerializer):
             user_data = User.objects.create(username=email, email=email,
                                             first_name=self.context['first_name'],
                                             last_name=self.context['last_name'])
-            password = User.objects.make_random_password()
-            user_data.set_password(password)
+            special_password = make_special_password()
+            user_data.set_password(special_password)
             user_data.save()
             junior_data = Junior.objects.create(auth=user_data, gender=validated_data.get('gender'),
                                                 image=profile_image,
@@ -321,7 +321,7 @@ class AddJuniorSerializer(serializers.ModelSerializer):
             # add push notification
             UserNotification.objects.get_or_create(user=user_data)
             """Notification email"""
-            junior_notification_email.delay(email, full_name, email, password)
+            junior_notification_email.delay(email, full_name, email, special_password)
             # push notification
             send_notification.delay(ASSOCIATE_JUNIOR, None, None, junior_data.auth.id, {})
             return junior_data

junior/views.py

@@ -12,6 +12,7 @@ import datetime
 import requests
 
 from rest_framework.viewsets import GenericViewSet, mixins
+import math
 """Django app import"""
 from drf_yasg.utils import swagger_auto_schema
 from drf_yasg import openapi
@@ -43,7 +44,7 @@ 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, ARTICLE_STATUS, none, GUARDIAN
-from account.utils import custom_response, custom_error_response
+from account.utils import custom_response, custom_error_response, task_status_fun
 from guardian.utils import upload_image_to_alibaba
 from .utils import update_positions_based_on_points
 from notifications.utils import send_notification
@@ -211,19 +212,24 @@ 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:
+        if junior is None:
             return none
         if junior.guardian_code and (guardian.guardian_code in junior.guardian_code):
             return False
+        if junior.guardian_code and ('-' in junior.guardian_code):
+            junior.guardian_code.remove('-')
         if not junior.guardian_code:
             junior.guardian_code = [guardian.guardian_code]
-        if type(junior.guardian_code) is list and len(junior.guardian_code) < 3:
+        elif type(junior.guardian_code) is list and len(junior.guardian_code) < 3:
             junior.guardian_code.append(guardian.guardian_code)
         else:
             return "Max"
-        junior.guardian_code_status.append(str(NUMBER['two']))
+        if junior.guardian_code_status and ('-' in junior.guardian_code_status):
+            junior.guardian_code_status.remove('-')
+        if not junior.guardian_code_status:
+            junior.guardian_code_status = [str(NUMBER['two'])]
+        else:
+            junior.guardian_code_status.append(str(NUMBER['two']))
         junior.save()
         jun_data, created = JuniorGuardianRelationship.objects.get_or_create(guardian=guardian, junior=junior)
         if jun_data:
@@ -341,9 +347,19 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
     """Junior task list"""
     serializer_class = TaskDetailsjuniorSerializer
     permission_classes = [IsAuthenticated]
+    filter_backends = (SearchFilter,)
+    search_fields = ['task_name', ]
     pagination_class = PageNumberPagination
     http_method_names = ('get',)
 
+    def get_queryset(self):
+        queryset = JuniorTask.objects.filter(junior__auth=self.request.user
+                                             ).prefetch_related('junior', 'junior__auth'
+                                                                ).order_by('due_date', 'created_at')
+
+        queryset = self.filter_queryset(queryset)
+        return queryset
+
     def list(self, request, *args, **kwargs):
         """Junior task list
         status=0
@@ -351,28 +367,20 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
         page=1"""
         try:
             status_value = self.request.GET.get('status')
-            search = self.request.GET.get('search')
-            if search and str(status_value) == '0':
-                # search with title and for all task list
-                queryset = JuniorTask.objects.filter(junior__auth=request.user,
-                                                     task_name__icontains=search).order_by('due_date', 'created_at')
-            elif search and str(status_value) != '0':
-                # search with title and fetch task list with status wise
-                queryset = JuniorTask.objects.filter(junior__auth=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':
-                # fetch all task list
-                queryset = JuniorTask.objects.filter(junior__auth=request.user).order_by('due_date', 'created_at')
-            elif search is None and str(status_value) != '0':
-                # fetch task list with status wise
-                queryset = JuniorTask.objects.filter(junior__auth=request.user,
-                                                     task_status=status_value).order_by('due_date','created_at')
+            current_page = self.request.GET.get('page')
+            queryset = self.get_queryset()
+            task_status = task_status_fun(status_value)
+            if status_value:
+                queryset = queryset.filter(task_status__in=task_status)
             paginator = self.pagination_class()
+            total_count = len(queryset)
+            total_pages = math.ceil(total_count / 10)
             # use Pagination
             paginated_queryset = paginator.paginate_queryset(queryset, request)
-            # use TaskDetailsSerializer serializer
-            serializer = TaskDetailsjuniorSerializer(paginated_queryset, many=True)
-            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+            # use TaskDetails juniorSerializer serializer
+            serializer = self.serializer_class(paginated_queryset, many=True)
+            return custom_response(None, serializer.data,  total_pages=total_pages, current_page=current_page,
+                                   response_status=status.HTTP_200_OK)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
@@ -401,10 +409,12 @@ class CompleteJuniorTaskAPIView(views.APIView):
             task_queryset = JuniorTask.objects.filter(id=task_id, junior__auth__email=self.request.user
                                                       ).select_related('guardian', 'junior').last()
             if task_queryset:
-                if task_queryset.junior.is_deleted or not task_queryset.junior.is_active:
+                if task_queryset.guardian.guardian_code not in task_queryset.junior.guardian_code:
+                    return custom_error_response(ERROR_CODE['2085'], response_status=status.HTTP_400_BAD_REQUEST)
+                elif task_queryset.junior.is_deleted or not task_queryset.junior.is_active:
                     return custom_error_response(ERROR_CODE['2074'], response_status=status.HTTP_400_BAD_REQUEST)
                 # use CompleteTaskSerializer serializer
-                if task_queryset.task_status in [str(NUMBER['four']), str(NUMBER['five'])]:
+                elif task_queryset.task_status in [str(NUMBER['four']), str(NUMBER['five'])]:
                     """Already request send """
                     return custom_error_response(ERROR_CODE['2049'], response_status=status.HTTP_400_BAD_REQUEST)
                 serializer = CompleteTaskSerializer(task_queryset, data={'image': image_url}, partial=True)
@@ -509,7 +519,10 @@ class StartTaskAPIView(views.APIView):
         try:
             task_id = self.request.data.get('task_id')
             task_queryset = JuniorTask.objects.filter(id=task_id, junior__auth__email=self.request.user).last()
+            print("task_queryset==>",task_queryset)
             if task_queryset and task_queryset.task_status == str(NUMBER['one']):
+                if task_queryset.guardian.guardian_code not in task_queryset.junior.guardian_code:
+                    return custom_error_response(ERROR_CODE['2083'], response_status=status.HTTP_400_BAD_REQUEST)
                 # use StartTaskSerializer serializer
                 serializer = StartTaskSerializer(task_queryset, data=request.data, partial=True)
                 if serializer.is_valid():
@@ -593,8 +606,8 @@ class StartAssessmentAPIView(viewsets.ModelViewSet):
         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')
+            'article_survey'
+        )
         return article
     def list(self, request, *args, **kwargs):
         """Params

notifications/constants.py

@@ -22,7 +22,7 @@ ARTICLE_REWARD_POINTS = 17
 REMOVE_JUNIOR = 18
 
 TEST_NOTIFICATION = 99
-
+# notification dictionary
 NOTIFICATION_DICT = {
     REGISTRATION: {
         "title": "Successfully registered!",

web_admin/serializers/article_serializer.py

@@ -306,8 +306,9 @@ class StartAssessmentSerializer(serializers.ModelSerializer):
         """current page"""
         context_data = self.context.get('user')
         data = JuniorArticle.objects.filter(junior__auth=context_data, article=obj).last()
+        total_count = obj.article_survey.all().count()
         if data:
-            return data.current_que_page
+            return data.current_que_page if data.current_que_page < total_count else data.current_que_page - 1
         return NUMBER['zero']
     class Meta(object):
         """