Merge pull request #105 from KiwiTechLLC/sprint3

start task api

base/constants.py

@@ -61,7 +61,8 @@ TASK_STATUS = (
     ('2', 'in-progress'),
     ('3', 'rejected'),
     ('4', 'requested'),
-    ('5', 'completed')
+    ('5', 'completed'),
+    ('6', 'expired')
 )
 # sign up method
 SIGNUP_METHODS = (

base/messages.py

@@ -81,7 +81,8 @@ ERROR_CODE = {
     "2047": "Invalid Junior ID ",
     "2048": "Choose right file for image",
     "2049": "This task is already requested ",
-    "2059": "Already exist junior"
+    "2059": "Already exist junior",
+    "2060": "Task does not exist or not in pending state"
 }
 """Success message code"""
 SUCCESS_CODE = {
@@ -129,7 +130,8 @@ SUCCESS_CODE = {
     "3031": "Article Survey has been removed successfully.",
     "3032": "Task request sent successfully",
     "3033": "Valid Referral code",
-    "3034": "Invite guardian successfully"
+    "3034": "Invite guardian successfully",
+    "3035": "Task started successfully"
 }
 """status code error"""
 STATUS_CODE_ERROR = {

guardian/migrations/0020_alter_juniortask_task_status.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.2 on 2023-07-25 07:44
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('guardian', '0019_guardian_is_invited_guardian_is_password_set'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='juniortask',
+            name='task_status',
+            field=models.CharField(choices=[('1', 'pending'), ('2', 'in-progress'), ('3', 'rejected'), ('4', 'requested'), ('5', 'completed'), ('6', 'expired')], default=1, max_length=15),
+        ),
+    ]

guardian/models.py

@@ -5,7 +5,7 @@ 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
+import junior.models
 """Add user model"""
 User = get_user_model()
 
@@ -105,7 +105,7 @@ class JuniorTask(models.Model):
     """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')
+    junior = models.ForeignKey('junior.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 is active or not"""

guardian/views.py

@@ -51,24 +51,27 @@ class SignupViewset(viewsets.ModelViewSet):
     serializer_class = UserSerializer
     def create(self, request, *args, **kwargs):
         """Create user profile"""
-        if request.data['user_type'] in ['1', '2']:
-            serializer = UserSerializer(context=request.data['user_type'], data=request.data)
-            if serializer.is_valid():
-                user = serializer.save()
-                """Generate otp"""
-                otp = generate_otp()
-                expiry = timezone.now() + timezone.timedelta(days=1)
-                # 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, {})
-                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)
-        else:
-            return custom_error_response(ERROR_CODE['2028'], response_status=status.HTTP_400_BAD_REQUEST)
+        try:
+            if request.data['user_type'] in [str(NUMBER['one']), str(NUMBER['two'])]:
+                serializer = UserSerializer(context=request.data['user_type'], data=request.data)
+                if serializer.is_valid():
+                    user = serializer.save()
+                    """Generate otp"""
+                    otp = generate_otp()
+                    expiry = timezone.now() + timezone.timedelta(days=1)
+                    # 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, {})
+                    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)
+            else:
+                return custom_error_response(ERROR_CODE['2028'], response_status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class UpdateGuardianProfile(viewsets.ViewSet):
     """Update guardian profile"""
@@ -78,26 +81,29 @@ class UpdateGuardianProfile(viewsets.ViewSet):
 
     def create(self, request, *args, **kwargs):
         """Create guardian profile"""
-        data = request.data
-        image = request.data.get('image')
-        image_url = ''
-        if image:
-            if image and image.size == NUMBER['zero']:
-                return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
-            filename = f"images/{image.name}"
-            # upload image on ali baba
-            image_url = upload_image_to_alibaba(image, filename)
-            data = {"image":image_url}
-        serializer = CreateGuardianSerializer(context={"user":request.user,
-                                                       "first_name":request.data.get('first_name'),
-                                                       "last_name": request.data.get('last_name'),
-                                                       "image":image_url},
-                                              data=data)
-        if serializer.is_valid():
-            """save serializer"""
-            serializer.save()
-            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)
+        try:
+            data = request.data
+            image = request.data.get('image')
+            image_url = ''
+            if image:
+                if image and image.size == NUMBER['zero']:
+                    return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
+                filename = f"images/{image.name}"
+                # upload image on ali baba
+                image_url = upload_image_to_alibaba(image, filename)
+                data = {"image":image_url}
+            serializer = CreateGuardianSerializer(context={"user":request.user,
+                                                           "first_name":request.data.get('first_name'),
+                                                           "last_name": request.data.get('last_name'),
+                                                           "image":image_url},
+                                                  data=data)
+            if serializer.is_valid():
+                """save serializer"""
+                serializer.save()
+                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:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class AllTaskListAPIView(viewsets.ModelViewSet):
@@ -123,25 +129,28 @@ class TaskListAPIView(viewsets.ModelViewSet):
 
     def list(self, request, *args, **kwargs):
         """Create guardian profile"""
-        status_value = self.request.GET.get('status')
-        search = self.request.GET.get('search')
-        if search and str(status_value) == '0':
-            queryset = JuniorTask.objects.filter(guardian__user=request.user,
-                                                 task_name__icontains=search).order_by('due_date', 'created_at')
-        elif search and str(status_value) != '0':
-            queryset = JuniorTask.objects.filter(guardian__user=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':
-            queryset = JuniorTask.objects.filter(guardian__user=request.user).order_by('due_date', 'created_at')
-        elif search is None and str(status_value) != '0':
-            queryset = JuniorTask.objects.filter(guardian__user=request.user,
-                                                 task_status=status_value).order_by('due_date','created_at')
-        paginator = self.pagination_class()
-        # use Pagination
-        paginated_queryset = paginator.paginate_queryset(queryset, request)
-        # use TaskDetailsSerializer serializer
-        serializer = TaskDetailsSerializer(paginated_queryset, many=True)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        try:
+            status_value = self.request.GET.get('status')
+            search = self.request.GET.get('search')
+            if search and str(status_value) == '0':
+                queryset = JuniorTask.objects.filter(guardian__user=request.user,
+                                                     task_name__icontains=search).order_by('due_date', 'created_at')
+            elif search and str(status_value) != '0':
+                queryset = JuniorTask.objects.filter(guardian__user=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':
+                queryset = JuniorTask.objects.filter(guardian__user=request.user).order_by('due_date', 'created_at')
+            elif search is None and str(status_value) != '0':
+                queryset = JuniorTask.objects.filter(guardian__user=request.user,
+                                                     task_status=status_value).order_by('due_date','created_at')
+            paginator = self.pagination_class()
+            # use Pagination
+            paginated_queryset = paginator.paginate_queryset(queryset, request)
+            # use TaskDetailsSerializer serializer
+            serializer = TaskDetailsSerializer(paginated_queryset, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class CreateTaskAPIView(viewsets.ModelViewSet):
     """create task for junior"""
@@ -150,33 +159,36 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
     http_method_names = ('post', )
 
     def create(self, request, *args, **kwargs):
-        image = request.data['default_image']
-        junior = request.data['junior']
-        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
-            serializer.save()
-            junior_id = Junior.objects.filter(id=junior).last()
-            send_notification.delay(TASK_CREATED, None, junior_id.auth.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)
+        try:
+            image = request.data['default_image']
+            junior = request.data['junior']
+            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
+                serializer.save()
+                junior_id = Junior.objects.filter(id=junior).last()
+                send_notification.delay(TASK_CREATED, None, junior_id.auth.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:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class SearchTaskListAPIView(viewsets.ModelViewSet):
     """Update guardian profile"""
@@ -194,14 +206,16 @@ class SearchTaskListAPIView(viewsets.ModelViewSet):
 
     def list(self, request, *args, **kwargs):
         """Create guardian profile"""
-        queryset = self.get_queryset()
-
-        paginator = self.pagination_class()
-        # use pagination
-        paginated_queryset = paginator.paginate_queryset(queryset, request)
-        # use TaskSerializer serializer
-        serializer = TaskDetailsSerializer(paginated_queryset, many=True)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        try:
+            queryset = self.get_queryset()
+            paginator = self.pagination_class()
+            # use pagination
+            paginated_queryset = paginator.paginate_queryset(queryset, request)
+            # use TaskSerializer serializer
+            serializer = TaskDetailsSerializer(paginated_queryset, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class TopJuniorListAPIView(viewsets.ModelViewSet):
@@ -218,15 +232,18 @@ class TopJuniorListAPIView(viewsets.ModelViewSet):
 
     def list(self, request, *args, **kwargs):
         """Fetch junior list of those who complete their tasks"""
-        junior_total_points = self.get_queryset().order_by('-total_points')
+        try:
+            junior_total_points = self.get_queryset().order_by('-total_points')
 
-        # Update the position field for each JuniorPoints object
-        for index, junior in enumerate(junior_total_points):
-            junior.position = index + 1
-            junior.save()
+            # Update the position field for each JuniorPoints object
+            for index, junior in enumerate(junior_total_points):
+                junior.position = index + 1
+                junior.save()
 
-        serializer = self.get_serializer(junior_total_points, many=True)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+            serializer = self.get_serializer(junior_total_points, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class ApproveJuniorAPIView(viewsets.ViewSet):
@@ -243,19 +260,22 @@ class ApproveJuniorAPIView(viewsets.ViewSet):
 
     def create(self, request, *args, **kwargs):
         """ junior list"""
-        queryset = self.get_queryset()
-        # action 1 is use for approve and 2 for reject
-        if request.data['action'] == '1':
-            # use ApproveJuniorSerializer serializer
-            serializer = ApproveJuniorSerializer(context={"guardian_code": queryset[0].guardian_code,
-                                                          "junior": queryset[1], "action": request.data['action']},
-                                                 data=request.data)
-            if serializer.is_valid():
-                # save serializer
-                serializer.save()
-                return custom_response(SUCCESS_CODE['3023'], serializer.data, response_status=status.HTTP_200_OK)
-        else:
-            return custom_response(SUCCESS_CODE['3024'], response_status=status.HTTP_200_OK)
+        try:
+            queryset = self.get_queryset()
+            # action 1 is use for approve and 2 for reject
+            if request.data['action'] == '1':
+                # use ApproveJuniorSerializer serializer
+                serializer = ApproveJuniorSerializer(context={"guardian_code": queryset[0].guardian_code,
+                                                              "junior": queryset[1], "action": request.data['action']},
+                                                     data=request.data)
+                if serializer.is_valid():
+                    # save serializer
+                    serializer.save()
+                    return custom_response(SUCCESS_CODE['3023'], serializer.data, response_status=status.HTTP_200_OK)
+            else:
+                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)
 
 class ApproveTaskAPIView(viewsets.ViewSet):
     """approve junior by guardian"""
@@ -274,20 +294,24 @@ class ApproveTaskAPIView(viewsets.ViewSet):
     def create(self, request, *args, **kwargs):
         """ junior list"""
         # action 1 is use for approve and 2 for reject
-        queryset = self.get_queryset()
-        # use ApproveJuniorSerializer serializer
-        serializer = ApproveTaskSerializer(context={"guardian_code": queryset[0].guardian_code,
-                                                    "task_instance": queryset[1],
-                                                    "action": str(request.data['action']),
-                                                    "junior": self.request.data['junior_id']},
-                                           data=request.data)
-        if str(request.data['action']) == str(NUMBER['one']) and serializer.is_valid():
-            # save serializer
-            serializer.save()
-            return custom_response(SUCCESS_CODE['3025'], response_status=status.HTTP_200_OK)
-        elif str(request.data['action']) == str(NUMBER['two']) and serializer.is_valid():
-            # save serializer
-            serializer.save()
-            return custom_response(SUCCESS_CODE['3026'], response_status=status.HTTP_200_OK)
-        else:
-            return custom_response(ERROR_CODE['2038'], response_status=status.HTTP_400_BAD_REQUEST)
+        try:
+            queryset = self.get_queryset()
+            # use ApproveJuniorSerializer serializer
+            serializer = ApproveTaskSerializer(context={"guardian_code": queryset[0].guardian_code,
+                                                        "task_instance": queryset[1],
+                                                        "action": str(request.data['action']),
+                                                        "junior": self.request.data['junior_id']},
+                                               data=request.data)
+            if str(request.data['action']) == str(NUMBER['one']) and serializer.is_valid():
+                # save serializer
+                serializer.save()
+                return custom_response(SUCCESS_CODE['3025'], response_status=status.HTTP_200_OK)
+            elif str(request.data['action']) == str(NUMBER['two']) and serializer.is_valid():
+                # save serializer
+                serializer.save()
+                return custom_response(SUCCESS_CODE['3026'], response_status=status.HTTP_200_OK)
+            else:
+                return custom_response(ERROR_CODE['2038'], response_status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+

junior/migrations/0017_juniorguardianrelationship.py

@@ -0,0 +1,31 @@
+# Generated by Django 4.2.2 on 2023-07-25 07:44
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('guardian', '0020_alter_juniortask_task_status'),
+        ('junior', '0016_juniorpoints_referral_points'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='JuniorGuardianRelationship',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('relationship', models.CharField(blank=True, choices=[('1', 'parent'), ('2', 'legal_guardian')], default='1', max_length=31, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('guardian', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='guardian_relation', to='guardian.guardian', verbose_name='Guardian')),
+                ('junior', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='junior_relation', to='junior.junior', verbose_name='Junior')),
+            ],
+            options={
+                'verbose_name': 'Junior Guardian Relation',
+                'verbose_name_plural': 'Junior Guardian Relation',
+                'db_table': 'junior_guardian_relation',
+            },
+        ),
+    ]

junior/models.py

@@ -7,6 +7,9 @@ from django.contrib.auth import get_user_model
 from django.contrib.postgres.fields import ArrayField
 """Import django app"""
 from base.constants import GENDERS, SIGNUP_METHODS, RELATIONSHIP
+# Import guardian's model
+from guardian.models import Guardian
+
 """Define User model"""
 User = get_user_model()
 # Create your models here.
@@ -31,7 +34,7 @@ User = get_user_model()
 """Define junior points model"""
 # points of the junior
 # position of the junior
-
+# define junior guardian relation model
 class Junior(models.Model):
     """Junior model"""
     auth = models.ForeignKey(User, on_delete=models.CASCADE, related_name='junior_profile', verbose_name='Email')
@@ -109,3 +112,28 @@ class JuniorPoints(models.Model):
     def __str__(self):
         """Return email id"""
         return f'{self.junior.auth}'
+
+class JuniorGuardianRelationship(models.Model):
+    """Junior Guardian relationship  model"""
+    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"""
+    relationship = models.CharField(max_length=31, choices=RELATIONSHIP, null=True, blank=True,
+                                    default='1')
+    """Profile created and updated time"""
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta(object):
+        """ Meta class """
+        db_table = 'junior_guardian_relation'
+        """verbose name of the model"""
+        verbose_name = 'Junior Guardian Relation'
+        verbose_name_plural = 'Junior Guardian Relation'
+
+    def __str__(self):
+        """Return email id"""
+        return f'{self.guardian.user}'
+
+

junior/serializers.py

@@ -428,3 +428,14 @@ class AddGuardianSerializer(serializers.ModelSerializer):
             send_notification(INVITED_GUARDIAN, None, junior_data.auth.id, {})
             send_notification(APPROVED_JUNIOR, None, email, {})
             return instance
+
+class StartTaskSerializer(serializers.ModelSerializer):
+    """User task Serializer"""
+    class Meta(object):
+        """Meta class"""
+        model = JuniorTask
+        fields = ('id', 'task_status')
+    def update(self, instance, validated_data):
+        instance.task_status = str(NUMBER['two'])
+        instance.save()
+        return instance

junior/urls.py

@@ -4,7 +4,7 @@ from django.urls import path, include
 from .views import (UpdateJuniorProfile, ValidateGuardianCode, JuniorListAPIView, AddJuniorAPIView,
                     InvitedJuniorAPIView, FilterJuniorAPIView, RemoveJuniorAPIView, JuniorTaskListAPIView,
                     CompleteJuniorTaskAPIView, JuniorPointsListAPIView, ValidateReferralCode,
-                    InviteGuardianAPIView)
+                    InviteGuardianAPIView, StartTaskAPIView)
 """Third party import"""
 from rest_framework import routers
 
@@ -45,5 +45,6 @@ router.register('invite-guardian', InviteGuardianAPIView, basename='invite-guard
 urlpatterns = [
     path('api/v1/', include(router.urls)),
     path('api/v1/remove-junior/', RemoveJuniorAPIView.as_view()),
-    path('api/v1/complete-task/', CompleteJuniorTaskAPIView.as_view())
+    path('api/v1/complete-task/', CompleteJuniorTaskAPIView.as_view()),
+    path('api/v1/start-task/', StartTaskAPIView.as_view())
 ]

junior/views.py

@@ -23,7 +23,7 @@ import requests
 from junior.models import Junior, JuniorPoints
 from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,\
                           RemoveJuniorSerializer, CompleteTaskSerializer, JuniorPointsSerializer,
-                          AddGuardianSerializer)
+                          AddGuardianSerializer, StartTaskSerializer)
 from guardian.models import Guardian, JuniorTask
 from guardian.serializers import TaskDetailsSerializer
 from base.messages import ERROR_CODE, SUCCESS_CODE
@@ -53,27 +53,30 @@ class UpdateJuniorProfile(viewsets.ViewSet):
 
     def create(self, request, *args, **kwargs):
         """Use CreateJuniorSerializer"""
-        request_data = request.data
-        image = request.data.get('image')
-        image_url = ''
-        if image:
-            if image.size == NUMBER['zero']:
-                return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
-            # convert into file
-            filename = f"images/{image.name}"
-            # upload image on ali baba
-            image_url = upload_image_to_alibaba(image, filename)
-            request_data = {"image": image_url}
-        serializer = CreateJuniorSerializer(context={"user":request.user, "image":image_url,
-                                                     "first_name": request.data.get('first_name'),
-                                                     "last_name": request.data.get('last_name')
-                                                     },
-                                            data=request_data)
-        if serializer.is_valid():
-            """save serializer"""
-            serializer.save()
-            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)
+        try:
+            request_data = request.data
+            image = request.data.get('image')
+            image_url = ''
+            if image:
+                if image.size == NUMBER['zero']:
+                    return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
+                # convert into file
+                filename = f"images/{image.name}"
+                # upload image on ali baba
+                image_url = upload_image_to_alibaba(image, filename)
+                request_data = {"image": image_url}
+            serializer = CreateJuniorSerializer(context={"user":request.user, "image":image_url,
+                                                         "first_name": request.data.get('first_name'),
+                                                         "last_name": request.data.get('last_name')
+                                                         },
+                                                data=request_data)
+            if serializer.is_valid():
+                """save serializer"""
+                serializer.save()
+                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:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class ValidateGuardianCode(viewsets.ViewSet):
     """Check guardian code exist or not"""
@@ -82,14 +85,17 @@ class ValidateGuardianCode(viewsets.ViewSet):
 
     def list(self, request, *args, **kwargs):
         """check guardian code"""
-        guardian_code = self.request.GET.get('guardian_code').split(',')
-        for code in guardian_code:
-            # fetch guardian object
-            guardian_data = Guardian.objects.filter(guardian_code=code).exists()
-            if guardian_data:
-                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)
+        try:
+            guardian_code = self.request.GET.get('guardian_code').split(',')
+            for code in guardian_code:
+                # fetch guardian object
+                guardian_data = Guardian.objects.filter(guardian_code=code).exists()
+                if guardian_data:
+                    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)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class JuniorListAPIView(viewsets.ModelViewSet):
     """Junior list of assosicated guardian"""
@@ -97,38 +103,46 @@ class JuniorListAPIView(viewsets.ModelViewSet):
     serializer_class = JuniorDetailListSerializer
     queryset = Junior.objects.all()
     permission_classes = [IsAuthenticated]
+    http_method_names = ('get',)
 
     def list(self, request, *args, **kwargs):
         """ junior list"""
-        update_positions_based_on_points()
-        guardian_data = Guardian.objects.filter(user__email=request.user).last()
-        # fetch junior object
-        if guardian_data:
-            queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code))
-            # use JuniorDetailListSerializer serializer
-            serializer = JuniorDetailListSerializer(queryset, many=True)
-            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
-        return custom_error_response(ERROR_CODE['2045'], response_status=status.HTTP_200_OK)
+        try:
+            update_positions_based_on_points()
+            guardian_data = Guardian.objects.filter(user__email=request.user).last()
+            # fetch junior object
+            if guardian_data:
+                queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code))
+                # use JuniorDetailListSerializer serializer
+                serializer = JuniorDetailListSerializer(queryset, many=True)
+                return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+            return custom_error_response(ERROR_CODE['2045'], response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class AddJuniorAPIView(viewsets.ModelViewSet):
     """Add Junior by guardian"""
     queryset = Junior.objects.all()
     serializer_class = AddJuniorSerializer
     permission_classes = [IsAuthenticated]
+    http_method_names = ('post',)
     def create(self, request, *args, **kwargs):
         """ junior list"""
-        info = {'user': request.user, '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)
+        try:
+            info = {'user': request.user, '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)
-        if serializer.is_valid():
-            # save serializer
-            serializer.save()
-            return custom_response(SUCCESS_CODE['3021'], serializer.data, response_status=status.HTTP_200_OK)
-        return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)
+            # use AddJuniorSerializer serializer
+            serializer = AddJuniorSerializer(data=request.data, context=info)
+            if serializer.is_valid():
+                # save serializer
+                serializer.save()
+                return custom_response(SUCCESS_CODE['3021'], serializer.data, response_status=status.HTTP_200_OK)
+            return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class InvitedJuniorAPIView(viewsets.ModelViewSet):
     """Junior list of assosicated guardian"""
@@ -137,6 +151,7 @@ class InvitedJuniorAPIView(viewsets.ModelViewSet):
     queryset = Junior.objects.all()
     permission_classes = [IsAuthenticated]
     pagination_class = PageNumberPagination
+    http_method_names = ('get',)
 
     def get_queryset(self):
         """Get the queryset for the view"""
@@ -146,13 +161,16 @@ class InvitedJuniorAPIView(viewsets.ModelViewSet):
         return junior_queryset
     def list(self, request, *args, **kwargs):
         """ junior list"""
-        queryset = self.get_queryset()
-        paginator = self.pagination_class()
-        # pagination
-        paginated_queryset = paginator.paginate_queryset(queryset, request)
-        # use JuniorDetailListSerializer serializer
-        serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        try:
+            queryset = self.get_queryset()
+            paginator = self.pagination_class()
+            # pagination
+            paginated_queryset = paginator.paginate_queryset(queryset, request)
+            # use JuniorDetailListSerializer serializer
+            serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class FilterJuniorAPIView(viewsets.ModelViewSet):
@@ -161,6 +179,7 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
     permission_classes = [IsAuthenticated]
     pagination_class = PageNumberPagination
     queryset = Junior.objects.all()
+    http_method_names = ('get',)
 
     def get_queryset(self):
         """Get the queryset for the view"""
@@ -173,13 +192,16 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
 
     def list(self, request, *args, **kwargs):
         """Create guardian profile"""
-        queryset = self.get_queryset()
-        paginator = self.pagination_class()
-        # use Pagination
-        paginated_queryset = paginator.paginate_queryset(queryset, request)
-        # use JuniorDetailListSerializer serializer
-        serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        try:
+            queryset = self.get_queryset()
+            paginator = self.pagination_class()
+            # use Pagination
+            paginated_queryset = paginator.paginate_queryset(queryset, request)
+            # use JuniorDetailListSerializer serializer
+            serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class RemoveJuniorAPIView(views.APIView):
@@ -189,21 +211,24 @@ class RemoveJuniorAPIView(views.APIView):
     permission_classes = [IsAuthenticated]
 
     def put(self, request, format=None):
-        junior_id = self.request.GET.get('id')
-        guardian = Guardian.objects.filter(user__email=self.request.user).last()
-        # fetch junior query
-        junior_queryset = Junior.objects.filter(id=junior_id, guardian_code__icontains=str(guardian.guardian_code),
-                                                is_invited=True).last()
-        if junior_queryset:
-            # use RemoveJuniorSerializer serializer
-            serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
-            if serializer.is_valid():
-                # save serializer
-                serializer.save()
-                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:
-            return custom_error_response(ERROR_CODE['2034'], response_status=status.HTTP_400_BAD_REQUEST)
+        try:
+            junior_id = self.request.GET.get('id')
+            guardian = Guardian.objects.filter(user__email=self.request.user).last()
+            # fetch junior query
+            junior_queryset = Junior.objects.filter(id=junior_id, guardian_code__icontains=str(guardian.guardian_code),
+                                                    is_invited=True).last()
+            if junior_queryset:
+                # use RemoveJuniorSerializer serializer
+                serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
+                if serializer.is_valid():
+                    # save serializer
+                    serializer.save()
+                    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:
+                return custom_error_response(ERROR_CODE['2034'], response_status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class JuniorTaskListAPIView(viewsets.ModelViewSet):
@@ -212,32 +237,36 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
     permission_classes = [IsAuthenticated]
     pagination_class = PageNumberPagination
     queryset = JuniorTask.objects.all()
+    http_method_names = ('get',)
 
     def list(self, request, *args, **kwargs):
         """Create guardian profile"""
-        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')
-        paginator = self.pagination_class()
-        # use Pagination
-        paginated_queryset = paginator.paginate_queryset(queryset, request)
-        # use TaskDetailsSerializer serializer
-        serializer = TaskDetailsSerializer(paginated_queryset, many=True)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        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')
+            paginator = self.pagination_class()
+            # use Pagination
+            paginated_queryset = paginator.paginate_queryset(queryset, request)
+            # use TaskDetailsSerializer serializer
+            serializer = TaskDetailsSerializer(paginated_queryset, many=True)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 
 class CompleteJuniorTaskAPIView(views.APIView):
@@ -280,22 +309,28 @@ class JuniorPointsListAPIView(viewsets.ModelViewSet):
     """Junior Points viewset"""
     serializer_class = JuniorPointsSerializer
     permission_classes = [IsAuthenticated]
+    http_method_names = ('get',)
 
     def get_queryset(self):
         """get queryset"""
         return JuniorTask.objects.filter(junior__auth__email=self.request.user).last()
     def list(self, request, *args, **kwargs):
         """profile view"""
-        queryset = self.get_queryset()
-        # update position of junior
-        update_positions_based_on_points()
 
-        serializer = JuniorPointsSerializer(queryset)
-        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        try:
+            queryset = self.get_queryset()
+            # update position of junior
+            update_positions_based_on_points()
+            serializer = JuniorPointsSerializer(queryset)
+            return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
 
 class ValidateReferralCode(viewsets.ViewSet):
     """Check guardian code exist or not"""
     permission_classes = [IsAuthenticated]
+    http_method_names = ('get',)
 
     def get_queryset(self):
         """Get queryset based on referral_code."""
@@ -314,23 +349,53 @@ class ValidateReferralCode(viewsets.ViewSet):
 
     def list(self, request, *args, **kwargs):
         """check guardian code"""
-        if self.get_queryset():
-            return custom_response(SUCCESS_CODE['3033'], response_status=status.HTTP_200_OK)
-        return custom_error_response(ERROR_CODE["2019"], response_status=status.HTTP_400_BAD_REQUEST)
+        try:
+            if self.get_queryset():
+                return custom_response(SUCCESS_CODE['3033'], response_status=status.HTTP_200_OK)
+            return custom_error_response(ERROR_CODE["2019"], response_status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
 class InviteGuardianAPIView(viewsets.ModelViewSet):
     """Invite guardian by junior"""
     serializer_class = AddGuardianSerializer
     permission_classes = [IsAuthenticated]
-
+    http_method_names = ('post',)
     def create(self, request, *args, **kwargs):
         """ junior list"""
-        info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
-                'last_name': request.data['last_name']}
-        # use AddJuniorSerializer serializer
-        serializer = AddGuardianSerializer(data=request.data, context=info)
-        if serializer.is_valid():
-            # save serializer
-            serializer.save()
-            return custom_response(SUCCESS_CODE['3034'], serializer.data, response_status=status.HTTP_200_OK)
-        return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)
+        try:
+            info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
+                    'last_name': request.data['last_name']}
+            # use AddJuniorSerializer serializer
+            serializer = AddGuardianSerializer(data=request.data, context=info)
+            if serializer.is_valid():
+                # save serializer
+                serializer.save()
+                return custom_response(SUCCESS_CODE['3034'], serializer.data, response_status=status.HTTP_200_OK)
+            return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST)
+        except Exception as e:
+            return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
+
+
+class StartTaskAPIView(views.APIView):
+    """Update junior task API"""
+    serializer_class = StartTaskSerializer
+    model = JuniorTask
+    permission_classes = [IsAuthenticated]
+
+    def put(self, request, format=None):
+        try:
+            task_id = self.request.data.get('task_id')
+            task_queryset = JuniorTask.objects.filter(id=task_id, junior__auth__email=self.request.user).last()
+            if task_queryset and task_queryset.task_status == str(NUMBER['one']):
+                # use StartTaskSerializer serializer
+                serializer = StartTaskSerializer(task_queryset, data=request.data, partial=True)
+                if serializer.is_valid():
+                    # save serializer
+                    serializer.save()
+                    return custom_response(SUCCESS_CODE['3035'], None, 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['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)