modified create task api, added badge count in notification list

guardian/serializers.py

@@ -28,7 +28,7 @@ from base.constants import NUMBER, JUN, ZOD, GRD, Already_register_user, GUARDIA
 from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
 from .utils import real_time, convert_timedelta_into_datetime, update_referral_points
 # notification's constant
-from notifications.constants import TASK_APPROVED, TASK_REJECTED
+from notifications.constants import TASK_APPROVED, TASK_REJECTED, TASK_ASSIGNED
 # send notification function
 from notifications.utils import send_notification
 from django.core.exceptions import ValidationError
@@ -229,21 +229,22 @@ class TaskSerializer(serializers.ModelSerializer):
         return value
     def create(self, validated_data):
         """create default task image data"""
-        guardian = Guardian.objects.filter(user=self.context['user']).last()
+        guardian = self.context['guardian']
         # update image of the task
         images = self.context['image']
-        junior_ids = self.context['junior_data']
-        junior_data = junior_ids[0].split(',')
+        junior_data = self.context['junior_data']
         tasks_created = []
 
-        for junior_id in junior_data:
+        for junior in junior_data:
             # create task
             task_data = validated_data.copy()
             task_data['guardian'] = guardian
             task_data['default_image'] = images
-            task_data['junior'] = Junior.objects.filter(id=junior_id).last()
+            task_data['junior'] = junior
             instance = JuniorTask.objects.create(**task_data)
             tasks_created.append(instance)
+            send_notification.delay(TASK_ASSIGNED, guardian.user.id, GUARDIAN,
+                                    junior.auth.id, {'task_id': instance.id})
         return instance
 
 class GuardianDetailSerializer(serializers.ModelSerializer):

guardian/views.py

@@ -184,49 +184,48 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
         """
         try:
             image = request.data['default_image']
-            juniors = request.data['junior'].split(',')
-            for junior in juniors:
-                junior_id = Junior.objects.filter(id=junior).last()
-                if junior_id:
-                    guardian_data = Guardian.objects.filter(user=request.user).last()
-                    index = junior_id.guardian_code.index(guardian_data.guardian_code)
-                    status_index = junior_id.guardian_code_status[index]
+            junior_ids = request.data['junior'].split(',')
+            # if not junior.isnumeric():
+            #     """junior value must be integer"""
+            #     return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
+            allowed_extensions = ['.jpg', '.jpeg', '.png']
+            if not any(extension in str(image) for extension in allowed_extensions):
+                return custom_error_response(ERROR_CODE['2048'], response_status=status.HTTP_400_BAD_REQUEST)
+            if '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_data = upload_image_to_alibaba(image, filename)
+                request.data.pop('default_image')
+
+            guardian = Guardian.objects.filter(user=request.user).select_related('user').last()
+            junior_data = Junior.objects.filter(id__in=junior_ids).select_related('auth')
+
+            for junior in junior_data:
+                if junior:
+                    index = junior.guardian_code.index(guardian.guardian_code)
+                    status_index = junior.guardian_code_status[index]
                     if status_index == str(NUMBER['three']):
                         return custom_error_response(ERROR_CODE['2078'], response_status=status.HTTP_400_BAD_REQUEST)
-                    allowed_extensions = ['.jpg', '.jpeg', '.png']
-                    if not any(extension in str(image) for extension in allowed_extensions):
-                        return custom_error_response(ERROR_CODE['2048'], response_status=status.HTTP_400_BAD_REQUEST)
-                    if not junior.isnumeric():
-                        """junior value must be integer"""
-                        return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
-                    data = request.data
-                    if 'https' in str(image):
-                        image_data = image
-                    else:
-                        filename = f"images/{image}"
-                        if image and image.size == NUMBER['zero']:
-                            return custom_error_response(ERROR_CODE['2035'],
-                                                         response_status=status.HTTP_400_BAD_REQUEST)
-                        image_url = upload_image_to_alibaba(image, filename)
-                        image_data = image_url
-                        data.pop('default_image')
-                    junior_data = data.pop('junior')
-                    # use TaskSerializer serializer
-                    serializer = TaskSerializer(context={"user":request.user, "image":image_data,
-                                                         "junior_data":junior_data}, data=data)
-                    if serializer.is_valid():
-                        # save serializer
-                        task = serializer.save()
-
-                        send_notification.delay(TASK_ASSIGNED, request.auth.payload['user_id'], GUARDIAN,
-                                                junior_id.auth.id, {'task_id': task.id})
-                        return custom_response(SUCCESS_CODE['3018'], response_status=status.HTTP_200_OK)
-                    return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
                 else:
                     return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
+
+            # use TaskSerializer serializer
+            serializer = TaskSerializer(context={"guardian": guardian, "image": image_data,
+                                                 "junior_data": junior_data}, data=request.data)
+            if serializer.is_valid():
+                # save serializer
+                serializer.save()
+                # removed send notification method and used in serializer
+                return custom_response(SUCCESS_CODE['3018'], response_status=status.HTTP_200_OK)
+            return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
+
 class SearchTaskListAPIView(viewsets.ModelViewSet):
     """Filter task"""
     serializer_class = TaskDetailsSerializer

notifications/serializers.py

@@ -31,11 +31,16 @@ class RegisterDevice(serializers.Serializer):
 
 class NotificationListSerializer(serializers.ModelSerializer):
     """List of notification"""
+    badge = serializers.SerializerMethodField()
 
     class Meta(object):
         """meta info"""
         model = Notification
-        fields = ['id', 'data', 'is_read', 'created_at']
+        fields = ['id', 'data', 'badge', 'is_read', 'created_at']
+
+    @staticmethod
+    def get_badge(obj):
+        return Notification.objects.filter(notification_to=obj.notification_to, is_read=False).count()
 
 
 class ReadNotificationSerializer(serializers.ModelSerializer):