conflict resolved

account/templates/templated_email/junior_approval_mail.email

@@ -8,7 +8,7 @@
     <tr>
         <td style="padding: 0 27px 15px;">
             <p style="margin: 0; font-size: 16px; line-height: 20px; padding: 36px 0 0; font-weight: 500; color: #1f2532;">
-                Hi {{full_name}},
+                Hello,
             </p>
         </td>
     </tr>

account/utils.py

@@ -22,7 +22,7 @@ from junior.models import Junior
 from guardian.models import Guardian
 from account.models import UserDelete
 from base.messages import ERROR_CODE
-
+from django.utils import timezone
 
 # Define delete
 # user account condition,
@@ -228,3 +228,4 @@ def generate_code(value, user_id):
     return code
 
 
+OTP_EXPIRY = timezone.now() + timezone.timedelta(days=1)

account/views.py

@@ -22,7 +22,7 @@ from django.conf import settings
 """App Import"""
 from guardian.models import Guardian
 from junior.models import Junior
-from guardian.utils import upload_image_to_alibaba
+from guardian.utils import upload_image_to_alibaba, OTP_EXPIRY
 from account.models import UserDeviceDetails, UserPhoneOtp, UserEmailOtp, DefaultTaskImages, UserNotification
 from django.contrib.auth.models import User
 """Account serializer"""
@@ -228,7 +228,7 @@ class ForgotPasswordAPIView(views.APIView):
                     'verification_code': verification_code
                 }
             )
-            expiry = timezone.now() + timezone.timedelta(days=1)
+            expiry = OTP_EXPIRY
             user_data, created = UserEmailOtp.objects.get_or_create(email=email)
             if created:
                 user_data.expired_at = expiry
@@ -399,7 +399,7 @@ class ReSendEmailOtp(viewsets.ModelViewSet):
     def create(self, request, *args, **kwargs):
         otp = generate_otp()
         if User.objects.filter(email=request.data['email']):
-            expiry = timezone.now() + timezone.timedelta(days=1)
+            expiry = OTP_EXPIRY
             email_data, created = UserEmailOtp.objects.get_or_create(email=request.data['email'])
             if created:
                 email_data.expired_at = expiry

base/messages.py

@@ -76,12 +76,15 @@ ERROR_CODE = {
     "2043": "Article Survey with given id doesn't exist.",
     "2044": "Task does not exist",
     "2045": "Invalid guardian",
+    # past due date
     "2046": "Due date must be future date",
     # invalid junior id msg
     "2047": "Invalid Junior ID ",
     "2048": "Choose right file for image",
+    # task request
     "2049": "This task is already requested ",
     "2059": "Already exist junior",
+    # task status
     "2060": "Task does not exist or not in pending state",
     "2061": "Please insert image or check the image is valid or not.",
 }

guardian/serializers.py

@@ -215,6 +215,7 @@ class TaskDetailsSerializer(serializers.ModelSerializer):
 
     junior = JuniorDetailSerializer()
     remaining_time = serializers.SerializerMethodField('get_remaining_time')
+    is_expired = serializers.SerializerMethodField('get_is_expired')
 
     def get_remaining_time(self, obj):
         """ remaining time to complete task"""
@@ -228,12 +229,16 @@ class TaskDetailsSerializer(serializers.ModelSerializer):
             return str(time_difference.days) + ' days ' + str(time_only)
         return str(NUMBER['zero']) + ' days ' + '00:00:00:00000'
 
-
+    def get_is_expired(self, obj):
+        """ task expired or not"""
+        if obj.due_date < datetime.today().date():
+            return True
+        return False
     class Meta(object):
         """Meta info"""
         model = JuniorTask
         fields = ['id', 'guardian', 'task_name', 'task_description', 'points', 'due_date','default_image', 'image',
-                  'requested_on', 'rejected_on', 'completed_on',
+                  'requested_on', 'rejected_on', 'completed_on', 'is_expired',
                   'junior', 'task_status', 'is_active', 'remaining_time', 'created_at','updated_at']
 
 

guardian/views.py

@@ -1,6 +1,11 @@
 """Views of Guardian"""
 
 # django imports
+# Import IsAuthenticated
+# Import viewsets and status
+# Import PageNumberPagination
+# Import User
+# Import timezone
 from rest_framework.permissions import IsAuthenticated
 from rest_framework import viewsets, status
 from rest_framework.pagination import PageNumberPagination
@@ -18,15 +23,15 @@ from django.utils import timezone
 # from utils file
 # Import account's serializer
 # Import account's task
-
+# Import notification constant
+# Import send_notification function
 from .serializers import (UserSerializer, CreateGuardianSerializer, TaskSerializer, TaskDetailsSerializer,
                           TopJuniorSerializer, ApproveJuniorSerializer, ApproveTaskSerializer)
 from .models import Guardian, JuniorTask
 from junior.models import Junior, JuniorPoints
 from account.models import UserEmailOtp, UserNotification
 from .tasks import generate_otp
-from account.utils import send_otp_email
+from account.utils import custom_response, custom_error_response, OTP_EXPIRY, send_otp_email
-from account.utils import custom_response, custom_error_response
 from base.messages import ERROR_CODE, SUCCESS_CODE
 from base.constants import NUMBER
 from .utils import upload_image_to_alibaba
@@ -58,13 +63,15 @@ class SignupViewset(viewsets.ModelViewSet):
                     user = serializer.save()
                     """Generate otp"""
                     otp = generate_otp()
-                    expiry = timezone.now() + timezone.timedelta(days=1)
+                    # expire otp after 1 day
+                    expiry = OTP_EXPIRY
                     # create user email otp object
                     UserEmailOtp.objects.create(email=request.data['email'], otp=otp,
                                                 user_type=str(request.data['user_type']), expired_at=expiry)
                     """Send email to the register user"""
                     send_otp_email(request.data['email'], otp)
-                    send_notification(REGISTRATION, None, user.id, {})
+                    # send push notification for registration
+                    send_notification.delay(REGISTRATION, None, user.id, {})
                     return custom_response(SUCCESS_CODE['3001'],
                                            response_status=status.HTTP_200_OK)
                 return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)

junior/admin.py

@@ -2,7 +2,7 @@
 """Third party Django app"""
 from django.contrib import admin
 """Import Django app"""
-from .models import Junior, JuniorPoints
+from .models import Junior, JuniorPoints, JuniorGuardianRelationship
 # Register your models here.
 @admin.register(Junior)
 class JuniorAdmin(admin.ModelAdmin):
@@ -21,3 +21,9 @@ class JuniorPointsAdmin(admin.ModelAdmin):
     def __str__(self):
         """Return email id"""
         return self.junior.auth.email
+
+@admin.register(JuniorGuardianRelationship)
+class JuniorGuardianRelationshipAdmin(admin.ModelAdmin):
+    """Junior Admin"""
+    list_display = ['guardian', 'junior', 'relationship']
+

junior/models.py

@@ -49,9 +49,6 @@ class Junior(models.Model):
     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,
-                                    default='1')
     # Sign up method"""
     signup_method = models.CharField(max_length=31, choices=SIGNUP_METHODS, default='1')
     # Codes"""
@@ -115,7 +112,8 @@ class JuniorPoints(models.Model):
 
 class JuniorGuardianRelationship(models.Model):
     """Junior Guardian relationship  model"""
-    guardian = models.ForeignKey(Guardian, on_delete=models.CASCADE, related_name='guardian_relation', verbose_name='Guardian')
+    guardian = models.ForeignKey(Guardian, on_delete=models.CASCADE, related_name='guardian_relation',
+                                 verbose_name='Guardian')
     # associated junior with the task
     junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='junior_relation', verbose_name='Junior')
     # relation between guardian and junior"""

junior/serializers.py

@@ -9,14 +9,14 @@ from rest_framework_simplejwt.tokens import RefreshToken
 
 """Import django app"""
 from account.utils import send_otp_email, generate_code
-from junior.models import Junior, JuniorPoints
+from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
 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
 from guardian.models import Guardian, JuniorTask
-from account.models import UserEmailOtp
+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
+from guardian.utils import real_time, update_referral_points, convert_timedelta_into_datetime
 from notifications.utils import send_notification
 from notifications.constants import INVITED_GUARDIAN, APPROVED_JUNIOR
 
@@ -249,18 +249,11 @@ class JuniorProfileSerializer(serializers.ModelSerializer):
 
 class AddJuniorSerializer(serializers.ModelSerializer):
     """Add junior serializer"""
-    auth_token = serializers.SerializerMethodField('get_auth_token')
-
-    def get_auth_token(self, obj):
-        """auth token"""
-        refresh = RefreshToken.for_user(obj)
-        access_token = str(refresh.access_token)
-        return access_token
 
     class Meta(object):
         """Meta info"""
         model = Junior
-        fields = ['id', 'gender','dob', 'relationship', 'auth_token', 'is_invited']
+        fields = ['id', 'gender','dob', 'is_invited']
 
 
     def create(self, validated_data):
@@ -268,6 +261,7 @@ class AddJuniorSerializer(serializers.ModelSerializer):
         with transaction.atomic():
             email = self.context['email']
             guardian = self.context['user']
+            relationship = self.context['relationship']
             full_name = self.context['first_name'] + ' ' + self.context['last_name']
             guardian_data = Guardian.objects.filter(user__username=guardian).last()
             user_data = User.objects.create(username=email, email=email,
@@ -278,11 +272,13 @@ class AddJuniorSerializer(serializers.ModelSerializer):
             user_data.save()
             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'),
+                                                guardian_code=[guardian_data.guardian_code],
                                                 junior_code=generate_code(JUN, user_data.id),
                                                 referral_code=generate_code(ZOD, user_data.id),
                                                 referral_code_used=guardian_data.referral_code,
                                                 is_password_set=False, is_verified=True)
+            JuniorGuardianRelationship.objects.create(guardian=guardian_data, junior=junior_data,
+                                                      relationship=relationship)
             """Generate otp"""
             otp_value = generate_otp()
             expiry_time = timezone.now() + timezone.timedelta(days=1)
@@ -375,18 +371,11 @@ class JuniorPointsSerializer(serializers.ModelSerializer):
 
 class AddGuardianSerializer(serializers.ModelSerializer):
     """Add guardian serializer"""
-    auth_token = serializers.SerializerMethodField('get_auth_token')
-
-    def get_auth_token(self, obj):
-        """auth token"""
-        refresh = RefreshToken.for_user(obj)
-        access_token = str(refresh.access_token)
-        return access_token
 
     class Meta(object):
         """Meta info"""
         model = Guardian
-        fields = ['id', 'auth_token']
+        fields = ['id']
 
 
     def create(self, validated_data):
@@ -394,15 +383,17 @@ class AddGuardianSerializer(serializers.ModelSerializer):
         with transaction.atomic():
             email = self.context['email']
             junior = self.context['user']
+            relationship = self.context['relationship']
             full_name = self.context['first_name'] + ' ' + self.context['last_name']
             junior_data = Junior.objects.filter(auth__username=junior).last()
             instance = User.objects.filter(username=email).last()
             if instance:
-                guardian_data = Guardian.objects.filter(user=user).update(is_invited=True,
+                guardian_data = Guardian.objects.filter(user=instance).update(is_invited=True,
                                                                           referral_code=generate_code(ZOD,
                                                                                                       instance.id),
                                                                           referral_code_used=junior_data.referral_code,
                                                                           is_verified=True)
+                UserNotification.objects.create(user=instance)
                 return guardian_data
             else:
                 user = User.objects.create(username=email, email=email,
@@ -412,7 +403,7 @@ class AddGuardianSerializer(serializers.ModelSerializer):
                 password = User.objects.make_random_password()
                 user.set_password(password)
                 user.save()
-                Guardian.objects.create(user=user, is_invited=True,
+                guardian_data = Guardian.objects.create(user=user, is_invited=True,
                                                         referral_code=generate_code(ZOD, user.id),
                                                         referral_code_used=junior_data.referral_code,
                                                         is_password_set=False, is_verified=True)
@@ -422,19 +413,36 @@ class AddGuardianSerializer(serializers.ModelSerializer):
                 UserEmailOtp.objects.create(email=email, otp=otp_value,
                                             user_type=str(NUMBER['two']), expired_at=expiry_time,
                                             is_verified=True)
+                UserNotification.objects.create(user=user)
+            JuniorGuardianRelationship.objects.create(guardian=guardian_data, junior=junior_data,
+                                                      relationship=relationship)
+
             """Notification email"""
             junior_notification_email(email, full_name, email, password)
             junior_approval_mail(email, full_name)
-            send_notification(INVITED_GUARDIAN, None, junior_data.auth.id, {})
+            send_notification.delay(INVITED_GUARDIAN, None, junior_data.auth.id, {})
-            send_notification(APPROVED_JUNIOR, None, email, {})
+            send_notification.delay(APPROVED_JUNIOR, None, guardian_data.user.id, {})
-            return instance
+            return guardian_data
 
 class StartTaskSerializer(serializers.ModelSerializer):
     """User task Serializer"""
+    task_duration = serializers.SerializerMethodField('get_task_duration')
+
+    def get_task_duration(self, obj):
+        """ remaining time to complete task"""
+        due_date = datetime.combine(obj.due_date, datetime.max.time())
+        # fetch real time
+        real_datetime = real_time()
+        # Perform the subtraction
+        if due_date > real_datetime:
+            time_difference = due_date - real_datetime
+            time_only = convert_timedelta_into_datetime(time_difference)
+            return str(time_difference.days) + ' days ' + str(time_only)
+        return str(NUMBER['zero']) + ' days ' + '00:00:00:00000'
     class Meta(object):
         """Meta class"""
         model = JuniorTask
-        fields = ('id', 'task_status')
+        fields = ('id', 'task_duration')
     def update(self, instance, validated_data):
         instance.task_status = str(NUMBER['two'])
         instance.save()

junior/views.py

@@ -20,6 +20,10 @@ import requests
 # Import account's serializer
 # Import account's task
 # import junior serializer
+# Import update_positions_based_on_points
+# Import upload_image_to_alibaba
+# Import custom_response, custom_error_response
+# Import constants
 from junior.models import Junior, JuniorPoints
 from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,\
                           RemoveJuniorSerializer, CompleteTaskSerializer, JuniorPointsSerializer,
@@ -43,7 +47,10 @@ from .utils import update_positions_based_on_points
 # approve junior API
 # create referral code
 # validation API
-
+# invite guardian API
+# by junior
+# Start task
+# by junior API
 # Create your views here.
 class UpdateJuniorProfile(viewsets.ViewSet):
     """Update junior profile"""
@@ -58,6 +65,7 @@ class UpdateJuniorProfile(viewsets.ViewSet):
             image = request.data.get('image')
             image_url = ''
             if image:
+                # check image size
                 if image.size == NUMBER['zero']:
                     return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
                 # convert into file
@@ -91,6 +99,7 @@ class ValidateGuardianCode(viewsets.ViewSet):
                 # fetch guardian object
                 guardian_data = Guardian.objects.filter(guardian_code=code).exists()
                 if guardian_data:
+                    # successfully check guardian code
                     return custom_response(SUCCESS_CODE['3013'], response_status=status.HTTP_200_OK)
                 else:
                     return custom_error_response(ERROR_CODE["2022"], response_status=status.HTTP_400_BAD_REQUEST)
@@ -129,13 +138,13 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
     def create(self, request, *args, **kwargs):
         """ junior list"""
         try:
-            info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
+            info_data = {'user': request.user, 'relationship': str(request.data['relationship']), 'email': request.data['email'], 'first_name': request.data['first_name'],
                          'last_name': request.data['last_name']}
             if User.objects.filter(username=request.data['email']):
                 return custom_error_response(ERROR_CODE['2059'], response_status=status.HTTP_400_BAD_REQUEST)
 
             # use AddJuniorSerializer serializer
-            serializer = AddJuniorSerializer(data=request.data, context=info)
+            serializer = AddJuniorSerializer(data=request.data, context=info_data)
             if serializer.is_valid():
                 # save serializer
                 serializer.save()
@@ -365,7 +374,7 @@ class InviteGuardianAPIView(viewsets.ModelViewSet):
         """ junior list"""
         try:
             info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
-                    'last_name': request.data['last_name']}
+                    'last_name': request.data['last_name'], 'relationship': str(request.data['relationship'])}
             # use AddJuniorSerializer serializer
             serializer = AddGuardianSerializer(data=request.data, context=info)
             if serializer.is_valid():
@@ -393,9 +402,10 @@ class StartTaskAPIView(views.APIView):
                 if serializer.is_valid():
                     # save serializer
                     serializer.save()
-                    return custom_response(SUCCESS_CODE['3035'], None, response_status=status.HTTP_200_OK)
+                    return custom_response(SUCCESS_CODE['3035'], serializer.data, response_status=status.HTTP_200_OK)
                 return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
             else:
+                # task in another state
                 return custom_error_response(ERROR_CODE['2060'], response_status=status.HTTP_400_BAD_REQUEST)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)