sonar issues

account/admin.py

@@ -2,7 +2,7 @@
 from django.contrib import admin
 
 """Import django app"""
-from .models import UserEmailOtp, UserPhoneOtp, DefaultTaskImages, UserNotification, UserDelete
+from .models import UserEmailOtp, DefaultTaskImages, UserNotification, UserDelete
 # Register your models here.
 
 @admin.register(UserDelete)
@@ -37,11 +37,3 @@ class UserEmailOtpAdmin(admin.ModelAdmin):
         """Return object in email and otp format"""
         return self.email + '-' + self.otp
 
-@admin.register(UserPhoneOtp)
-class UserPhoneOtpAdmin(admin.ModelAdmin):
-    """User Phone otp admin"""
-    list_display = ['phone']
-
-    def __str__(self):
-        """Return object in phone number and otp format"""
-        return self.phone + '-' + self.otp

account/models.py

@@ -90,6 +90,8 @@ class DefaultTaskImages(models.Model):
     class Meta(object):
         """ Meta information """
         db_table = 'default_task_image'
+        verbose_name = 'Default Task images'
+        verbose_name_plural = 'Default Task images'
 
     def __str__(self):
         """return phone as an object"""
@@ -112,6 +114,8 @@ class UserDelete(models.Model):
     class Meta(object):
         """ Meta information """
         db_table = 'user_delete_information'
+        verbose_name = 'Deleted User'
+        verbose_name_plural = 'Deleted User'
 
     def __str__(self):
         return self.user.email

account/utils.py

@@ -183,13 +183,15 @@ def get_token(data: dict = dict):
 
 
 def generate_alphanumeric_code(length):
+    """Generate alphanumeric code"""
     alphabet = string.ascii_letters + string.digits
     code = ''.join(secrets.choice(alphabet) for _ in range(length))
     return code
 
 
 def generate_code(value, user_id):
-    alphabet = value + user_id.zfill(3)
+    """generate referral, junior and guardian code"""
-    return alphabet
+    code = value + str(user_id).zfill(3)
+    return code
 
 

account/views.py

@@ -25,10 +25,10 @@ from .serializers import (SuperUserSerializer, GuardianSerializer, JuniorSeriali
                           UserNotificationSerializer, UpdateUserNotificationSerializer, UserPhoneOtpSerializer)
 from rest_framework_simplejwt.tokens import RefreshToken
 from base.messages import ERROR_CODE, SUCCESS_CODE
-from base.constants import NUMBER
+from base.constants import NUMBER, ZOD, JUN, GRD
 from guardian.tasks import generate_otp
 from account.utils import (send_otp_email, send_support_email, custom_response, custom_error_response,
-                           generate_alphanumeric_code)
+                           generate_code)
 from rest_framework.permissions import IsAuthenticated
 from templated_email import send_templated_mail
 import google.oauth2.credentials
@@ -42,6 +42,7 @@ from guardian.serializers import GuardianProfileSerializer
 
 class GoogleLoginMixin:
     """google login mixin"""
+    @staticmethod
     def google_login(self, request):
         """google login function"""
         access_token = request.data.get('access_token')
@@ -90,15 +91,15 @@ class GoogleLoginMixin:
             if str(user_type) == '1':
                 junior_query = Junior.objects.create(auth=user_obj, is_verified=True, is_active=True,
                                                      image=profile_picture, signup_method='2',
-                                                     junior_code=generate_alphanumeric_code(6),
+                                                     junior_code=generate_code(JUN, user_obj.id),
-                                                     referral_code=generate_alphanumeric_code(6)
+                                                     referral_code=generate_code(ZOD, user_obj.id)
                                                      )
                 serializer = JuniorSerializer(junior_query)
             if str(user_type) == '2':
                 guardian_query = Guardian.objects.create(user=user_obj, is_verified=True, is_active=True,
                                                          image=profile_picture,signup_method='2',
-                                                         guardian_code=generate_alphanumeric_code(6),
+                                                         guardian_code=generate_code(GRD, user_obj.id),
-                                                         referral_code=generate_alphanumeric_code(6)
+                                                         referral_code=generate_code(ZOD, user_obj.id)
                                                          )
                 serializer = GuardianSerializer(guardian_query)
         # Return a JSON response with the user's email and name
@@ -141,14 +142,14 @@ class SigninWithApple(views.APIView):
                     if str(user_type) == '1':
                         junior_query = Junior.objects.create(auth=user, is_verified=True, is_active=True,
                                                              signup_method='3',
-                                                             junior_code=generate_alphanumeric_code(6),
+                                                             junior_code=generate_code(JUN, user.id),
-                                                             referral_code=generate_alphanumeric_code(6))
+                                                             referral_code=generate_code(ZOD, user.id))
                         serializer = JuniorSerializer(junior_query)
                     if str(user_type) == '2':
                         guardian_query = Guardian.objects.create(user=user, is_verified=True, is_active=True,
                                                                  signup_method='3',
-                                                                 guardian_code=generate_alphanumeric_code(6),
+                                                                 guardian_code=generate_code(GRD, user.id),
-                                                                 referral_code=generate_alphanumeric_code(6))
+                                                                 referral_code=generate_code(ZOD, user.id))
                         serializer = GuardianSerializer(guardian_query)
                     return custom_response(SUCCESS_CODE['3003'], serializer.data,
                                            response_status=status.HTTP_200_OK)
@@ -181,6 +182,7 @@ class UpdateProfileImage(views.APIView):
                 return custom_response(SUCCESS_CODE['3017'], 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:
+            logging.error(e)
             return custom_error_response(ERROR_CODE['2036'],response_status=status.HTTP_400_BAD_REQUEST)
 
 class ChangePasswordAPIView(views.APIView):
@@ -512,6 +514,7 @@ class SendSupportEmail(views.APIView):
 
 
 class LogoutAPIView(views.APIView):
+    """Log out API"""
     permission_classes = (IsAuthenticated,)
 
     def post(self, request):

base/constants.py

@@ -6,6 +6,9 @@ import os
 # GOOGLE_URL used for interact with google server to verify user existence.
 #GOOGLE_URL = "https://www.googleapis.com/plus/v1/"
 
+ZOD = 'ZOD'
+JUN = 'JUN'
+GRD = 'GRD'
 NUMBER = {
     'point_zero': 0.0,
     'zero': 0,

base/messages.py

@@ -61,6 +61,7 @@ ERROR_CODE = {
     "2035": "Image should not be 0 kb",
     "2036": "Choose valid user"
 }
+"""Success message code"""
 SUCCESS_CODE = {
     # Success code for password
     "3001": "Sign up successfully",
@@ -97,7 +98,7 @@ SUCCESS_CODE = {
     "3023": "Approved junior successfully",
     "3024": "Reject junior request successfully"
 }
-
+"""status code error"""
 STATUS_CODE_ERROR = {
     # Status code for Invalid Input
     "4001": ["Invalid input."],

guardian/models.py

@@ -4,6 +4,7 @@ from django.db import models
 from django.contrib.auth import get_user_model
 """Import Django app"""
 from base.constants import GENDERS, TASK_STATUS, PENDING, TASK_POINTS, SIGNUP_METHODS
+"""import Junior model"""
 from junior.models import Junior
 """Add user model"""
 User = get_user_model()
@@ -15,23 +16,31 @@ class Guardian(models.Model):
     """Contact details"""
     country_code = models.IntegerField(blank=True, null=True)
     phone = models.CharField(max_length=31, null=True, blank=True, default=None)
+    """country name of the guardian"""
     country_name = models.CharField(max_length=100, null=True, blank=True, default=None)
     """Image info"""
     image = models.URLField(null=True, blank=True, default=None)
     """Personal info"""
     family_name = models.CharField(max_length=50, null=True, blank=True, default=None)
+    """gender of the guardian"""
     gender = models.CharField(choices=GENDERS, max_length=15, null=True, blank=True, default=None)
+    """date of birth of the guardian"""
     dob = models.DateField(max_length=15, null=True, blank=True, default=None)
     """Profile activity"""
     is_active = models.BooleanField(default=True)
+    """guardian is verified or not"""
     is_verified = models.BooleanField(default=False)
+    """guardian profile is complete or not"""
     is_complete_profile = models.BooleanField(default=False)
+    """passcode of the guardian profile"""
     passcode = models.IntegerField(null=True, blank=True, default=None)
     """Sign up method"""
     signup_method = models.CharField(max_length=31, choices=SIGNUP_METHODS, default='1')
-    """Codes"""
+    """Guardian Codes"""
     guardian_code = models.CharField(max_length=10, null=True, blank=True, default=None)
+    """Referral code"""
     referral_code = models.CharField(max_length=10, null=True, blank=True, default=None)
+    """Referral code that is used by guardian while signup"""
     referral_code_used = models.CharField(max_length=10, null=True, blank=True, default=None)
     """Profile created and updated time"""
     created_at = models.DateTimeField(auto_now_add=True)
@@ -40,7 +49,10 @@ class Guardian(models.Model):
     class Meta(object):
         """ Meta class """
         db_table = 'guardians'
+        """verbose name of the model"""
         verbose_name = 'Guardian'
+        """change another name"""
+        verbose_name_plural = 'Guardian'
 
     def __str__(self):
         """Return email id"""
@@ -51,19 +63,23 @@ class JuniorTask(models.Model):
     guardian = models.ForeignKey(Guardian, on_delete=models.CASCADE, related_name='guardian', verbose_name='Guardian')
     """task details"""
     task_name = models.CharField(max_length=100)
+    """task description"""
     task_description = models.CharField(max_length=500)
     """points of the task"""
     points = models.IntegerField(default=TASK_POINTS)
+    """last date of the task"""
     due_date = models.DateField(auto_now_add=False, null=True, blank=True)
-    """Images of task"""
+    """Images of task that is upload by guardian"""
     default_image = models.URLField(null=True, blank=True, default=None)
+    """image that is uploaded by junior"""
     image = models.URLField(null=True, blank=True, default=None)
     """associated junior with the task"""
     junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='junior', verbose_name='Junior')
     """task status"""
     task_status = models.CharField(choices=TASK_STATUS, max_length=15, default=PENDING)
-    """task stage"""
+    """task is active or not"""
     is_active = models.BooleanField(default=True)
+    """Task is approved or not"""
     is_approved = models.BooleanField(default=False)
     """Profile created and updated time"""
     created_at = models.DateTimeField(auto_now_add=True)
@@ -72,7 +88,9 @@ class JuniorTask(models.Model):
     class Meta(object):
         """ Meta class """
         db_table = 'junior_task'
+        """verbose name of the model"""
         verbose_name = 'Junior Task'
+        verbose_name_plural = 'Junior Task'
 
     def __str__(self):
         """Return email id"""

guardian/serializers.py

@@ -9,11 +9,11 @@ from django.contrib.auth.models import User
 """Import Django app"""
 from .models import Guardian, JuniorTask
 from account.models import UserProfile, UserEmailOtp, UserNotification
-from account.utils import generate_alphanumeric_code
+from account.utils import generate_code
 from account.serializers import JuniorSerializer
 from junior.serializers import JuniorDetailSerializer
 from base.messages import ERROR_CODE, SUCCESS_CODE
-from base.constants import NUMBER
+from base.constants import NUMBER, JUN, ZOD, GRD
 from junior.models import Junior, JuniorPoints
 class UserSerializer(serializers.ModelSerializer):
     """User serializer"""
@@ -39,11 +39,11 @@ class UserSerializer(serializers.ModelSerializer):
             user = User.objects.create_user(username=email, email=email, password=password)
             UserNotification.objects.create(user=user)
             if user_type == '1':
-                Junior.objects.create(auth=user, junior_code=generate_alphanumeric_code(6),
+                Junior.objects.create(auth=user, junior_code=generate_code(JUN, user.id),
-                                      referral_code=generate_alphanumeric_code(6))
+                                      referral_code=generate_code(ZOD, user.id))
             if user_type == '2':
-                Guardian.objects.create(user=user, guardian_code=generate_alphanumeric_code(6),
+                Guardian.objects.create(user=user, guardian_code=generate_code(GRD, user.id),
-                                        referral_code=generate_alphanumeric_code(6))
+                                        referral_code=generate_code(ZOD, user.id))
             return user
         except Exception as e:
             """Error handling"""

junior/models.py

@@ -1,10 +1,13 @@
 """Junior model """
 """Import django"""
 from django.db import models
+"""Import get_user_model function"""
 from django.contrib.auth import get_user_model
+"""Import ArrayField"""
 from django.contrib.postgres.fields import ArrayField
 """Import django app"""
 from base.constants import GENDERS, SIGNUP_METHODS, RELATIONSHIP
+"""Define User model"""
 User = get_user_model()
 # Create your models here.
 
@@ -14,10 +17,13 @@ class Junior(models.Model):
     """Contact details"""
     phone = models.CharField(max_length=31, null=True, blank=True, default=None)
     country_code = models.IntegerField(blank=True, null=True)
+    """country name of the guardian"""
     country_name = models.CharField(max_length=100, null=True, blank=True, default=None)
     """Personal info"""
     gender = models.CharField(max_length=10, choices=GENDERS, null=True, blank=True, default=None)
+    """Date of birth"""
     dob = models.DateField(max_length=15, null=True, blank=True, default=None)
+    """Image of the junior"""
     image = models.URLField(null=True, blank=True, default=None)
     """relationship"""
     relationship = models.CharField(max_length=31, choices=RELATIONSHIP, null=True, blank=True,
@@ -26,15 +32,21 @@ class Junior(models.Model):
     signup_method = models.CharField(max_length=31, choices=SIGNUP_METHODS, default='1')
     """Codes"""
     junior_code = models.CharField(max_length=10, null=True, blank=True, default=None)
+    """Guardian Codes"""
     guardian_code = ArrayField(models.CharField(max_length=10, null=True, blank=True, default=None),null=True)
+    """Referral code"""
     referral_code = models.CharField(max_length=10, null=True, blank=True, default=None)
+    """Referral code that is used by junior while signup"""
     referral_code_used = models.CharField(max_length=10, null=True, blank=True, default=None)
     """invited junior"""
     is_invited = models.BooleanField(default=False)
     """Profile activity"""
     is_active = models.BooleanField(default=True)
+    """junior profile is complete or not"""
     is_complete_profile = models.BooleanField(default=False)
+    """passcode of the junior profile"""
     passcode = models.IntegerField(null=True, blank=True, default=None)
+    """junior is verified or not"""
     is_verified = models.BooleanField(default=False)
     """Profile created and updated time"""
     created_at = models.DateTimeField(auto_now_add=True)
@@ -44,6 +56,8 @@ class Junior(models.Model):
         """ Meta class """
         db_table = 'junior'
         verbose_name = 'Junior'
+        """another name of the model"""
+        verbose_name_plural = 'Junior'
 
     def __str__(self):
         """Return email id"""
@@ -64,6 +78,8 @@ class JuniorPoints(models.Model):
         """ Meta class """
         db_table = 'junior_task_points'
         verbose_name = 'Junior Task Points'
+        """another name of the model"""
+        verbose_name_plural = 'Junior Task Points'
 
     def __str__(self):
         """Return email id"""

junior/serializers.py

@@ -8,11 +8,11 @@ from django.utils import timezone
 from rest_framework_simplejwt.tokens import RefreshToken
 
 """Import django app"""
-from account.utils import send_otp_email, generate_alphanumeric_code
+from account.utils import send_otp_email, generate_code
 from junior.models import Junior, JuniorPoints
 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
+from base.constants import PENDING, IN_PROGRESS, REJECTED, REQUESTED, COMPLETED, NUMBER, JUN, ZOD
 from guardian.models import Guardian, JuniorTask
 from account.models import UserEmailOtp
 from junior.utils import junior_notification_email, junior_approval_mail
@@ -275,8 +275,8 @@ class AddJuniorSerializer(serializers.ModelSerializer):
             junior_data = Junior.objects.create(auth=user_data, gender=validated_data.get('gender'),
                                                 dob=validated_data.get('dob'), is_invited=True,
                                                 relationship=validated_data.get('relationship'),
-                                                junior_code=generate_alphanumeric_code(6),
+                                                junior_code=generate_code(JUN, user_data.id),
-                                                referral_code=generate_alphanumeric_code(6),
+                                                referral_code=generate_code(ZOD, user_data.id),
                                                 referral_code_used=guardian_data.referral_code)
             """Generate otp"""
             otp_value = generate_otp()

junior/utils.py

@@ -1,28 +1,17 @@
 """Account utils"""
 """Import django"""
 from django.conf import settings
-from rest_framework import viewsets, status
-from rest_framework.response import Response
 """Third party Django app"""
 from templated_email import send_templated_mail
-import jwt
-import string
-from datetime import datetime
-from calendar import timegm
-from uuid import uuid4
-import secrets
-from rest_framework import serializers
-from junior.models import Junior
-from guardian.models import Guardian
-from account.models import UserDelete
-from base.messages import ERROR_CODE
 
 
 
 def junior_notification_email(recipient_email, full_name, email, password):
     """Notification email"""
     from_email = settings.EMAIL_FROM_ADDRESS
+    """recipient email"""
     recipient_list = [recipient_email]
+    """use send template mail for sending email"""
     send_templated_mail(
         template_name='junior_notification_email.email',
         from_email=from_email,
@@ -40,6 +29,7 @@ def junior_approval_mail(guardian, full_name):
     """junior approval mail"""
     from_email = settings.EMAIL_FROM_ADDRESS
     recipient_list = [guardian]
+    """use send tempolate mail for sending email"""
     send_templated_mail(
         template_name='junior_approval_mail.email',
         from_email=from_email,