sonar issues

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

@@ -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"""

guardian/serializers.py

@@ -237,6 +237,7 @@ class TaskSerializer(serializers.ModelSerializer):
         tasks_created = []
 
         for junior_id in junior_data:
+            # create task
             task_data = validated_data.copy()
             task_data['guardian'] = guardian
             task_data['default_image'] = images

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):
@@ -198,7 +208,8 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
                     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)
+                            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')
@@ -347,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
@@ -366,15 +367,20 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
         page=1"""
         try:
             status_value = self.request.GET.get('status')
+            current_page = self.request.GET.get('page')
             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:
+                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 TaskDetails juniorSerializer 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)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
@@ -403,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)
@@ -511,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():

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!",