Merge pull request #275 from KiwiTechLLC/sprint6-bugs

Sprint6 bugs

guardian/serializers.py

@@ -402,9 +402,9 @@ class ApproveJuniorSerializer(serializers.ModelSerializer):
     def create(self, validated_data):
         """update guardian code"""
         instance = self.context['junior']
-        instance.guardian_code = [self.context['guardian_code']]
+        guardian_code = self.context['guardian_code']
-        instance.guardian_code_approved = True
+        index = instance.guardian_code.index(guardian_code)
-        instance.guardian_code_status = str(NUMBER['two'])
+        instance.guardian_code_status[index] = str(NUMBER['two'])
         instance.save()
         return instance
 
@@ -512,4 +512,7 @@ class GuardianDetailListSerializer(serializers.ModelSerializer):
 
     def get_guardian_code_status(self,obj):
         """guardian code status"""
-        return obj.junior.guardian_code_status
+        if obj.guardian.guardian_code in obj.junior.guardian_code:
+            index = obj.junior.guardian_code.index(obj.guardian.guardian_code)
+            data = obj.junior.guardian_code_status[index]
+            return data

guardian/views.py

@@ -179,36 +179,40 @@ class CreateTaskAPIView(viewsets.ModelViewSet):
             image = request.data['default_image']
             junior = request.data['junior']
             junior_id = Junior.objects.filter(id=junior).last()
-            guardian_data = Guardian.objects.filter(user=request.user).last()
+            if junior_id:
-            if (guardian_data.guardian_code not in junior_id.guardian_code or
+                guardian_data = Guardian.objects.filter(user=request.user).last()
-                    junior_id.guardian_code_status in guardian_code_tuple):
+                index = junior_id.guardian_code.index(guardian_data.guardian_code)
-                return custom_error_response(ERROR_CODE['2078'], response_status=status.HTTP_400_BAD_REQUEST)
+                status_index = junior_id.guardian_code_status[index]
-            allowed_extensions = ['.jpg', '.jpeg', '.png']
+                if status_index == str(NUMBER['three']):
-            if not any(extension in str(image) for extension in allowed_extensions):
+                    return custom_error_response(ERROR_CODE['2078'], response_status=status.HTTP_400_BAD_REQUEST)
-                return custom_error_response(ERROR_CODE['2048'], response_status=status.HTTP_400_BAD_REQUEST)
+                allowed_extensions = ['.jpg', '.jpeg', '.png']
-            if not junior.isnumeric():
+                if not any(extension in str(image) for extension in allowed_extensions):
-                """junior value must be integer"""
+                    return custom_error_response(ERROR_CODE['2048'], response_status=status.HTTP_400_BAD_REQUEST)
-                return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
+                if not junior.isnumeric():
-            data = request.data
+                    """junior value must be integer"""
-            if 'https' in str(image):
+                    return custom_error_response(ERROR_CODE['2047'], response_status=status.HTTP_400_BAD_REQUEST)
-                image_data = image
+                data = request.data
-            else:
+                if 'https' in str(image):
-                filename = f"images/{image}"
+                    image_data = image
-                if image and image.size == NUMBER['zero']:
+                else:
-                    return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
+                    filename = f"images/{image}"
-                image_url = upload_image_to_alibaba(image, filename)
+                    if image and image.size == NUMBER['zero']:
-                image_data = image_url
+                        return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
-                data.pop('default_image')
+                    image_url = upload_image_to_alibaba(image, filename)
-            # use TaskSerializer serializer
+                    image_data = image_url
-            serializer = TaskSerializer(context={"user":request.user, "image":image_data}, data=data)
+                    data.pop('default_image')
-            if serializer.is_valid():
+                # use TaskSerializer serializer
-                # save serializer
+                serializer = TaskSerializer(context={"user":request.user, "image":image_data}, data=data)
-                task = serializer.save()
+                if serializer.is_valid():
+                    # save serializer
+                    task = serializer.save()
 
-                send_notification.delay(TASK_ASSIGNED, request.auth.payload['user_id'], GUARDIAN,
+                    send_notification.delay(TASK_ASSIGNED, request.auth.payload['user_id'], GUARDIAN,
-                                        junior_id.auth.id, {'task_id': task.id})
+                                            junior_id.auth.id, {'task_id': task.id})
-                return custom_response(SUCCESS_CODE['3018'], serializer.data, response_status=status.HTTP_200_OK)
+                    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)
+                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)
         except Exception as e:
             return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
 
@@ -302,8 +306,13 @@ class ApproveJuniorAPIView(viewsets.ModelViewSet):
                                             junior_queryset.auth.id)
                     return custom_response(SUCCESS_CODE['3023'], serializer.data, response_status=status.HTTP_200_OK)
             else:
-                junior_queryset.guardian_code = None
+                if junior_queryset.guardian_code and ('-' in junior_queryset.guardian_code):
-                junior_queryset.guardian_code_status = str(NUMBER['one'])
+                    junior_queryset.guardian_code.remove('-')
+                if junior_queryset.guardian_code_status and ('-' in junior_queryset.guardian_code_status):
+                    junior_queryset.guardian_code_status.remove('-')
+                index = junior_queryset.guardian_code.index(guardian.guardian_code)
+                junior_queryset.guardian_code.remove(guardian.guardian_code)
+                junior_queryset.guardian_code_status.pop(index)
                 junior_queryset.save()
                 send_notification.delay(ASSOCIATE_REJECTED, guardian.user.id, GUARDIAN, junior_queryset.auth.id)
                 return custom_response(SUCCESS_CODE['3024'], response_status=status.HTTP_200_OK)
@@ -354,7 +363,7 @@ class ApproveTaskAPIView(viewsets.ModelViewSet):
                 return custom_error_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)
-
+#
 class GuardianListAPIView(viewsets.ModelViewSet):
     """Guardian list of assosicated junior"""
 

junior/migrations/0030_remove_junior_guardian_code_status.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.2 on 2023-08-26 08:59
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('junior', '0029_junior_is_deleted'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='junior',
+            name='guardian_code_status',
+        ),
+    ]

junior/migrations/0031_junior_guardian_code_status.py

@@ -0,0 +1,19 @@
+# Generated by Django 4.2.2 on 2023-08-26 08:59
+
+import django.contrib.postgres.fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('junior', '0030_remove_junior_guardian_code_status'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='junior',
+            name='guardian_code_status',
+            field=django.contrib.postgres.fields.ArrayField(base_field=models.CharField(blank=True, default=None, max_length=10, null=True), null=True, size=None),
+        ),
+    ]

junior/models.py

@@ -76,9 +76,9 @@ class Junior(models.Model):
     is_verified = models.BooleanField(default=False)
     """guardian code is approved or not"""
     guardian_code_approved = models.BooleanField(default=False)
-    # guardian code status"""
+    # # guardian code status"""
-    guardian_code_status = models.CharField(max_length=31, choices=GUARDIAN_CODE_STATUS, default='1',
+    guardian_code_status = ArrayField(models.CharField(max_length=10, null=True, blank=True, default=None), null=True,
-                                            null=True, blank=True)
+                                      )
     # Profile created and updated time"""
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)

junior/serializers.py

@@ -93,15 +93,17 @@ class CreateJuniorSerializer(serializers.ModelSerializer):
             if guardian_code:
                 if not junior.guardian_code:
                     junior.guardian_code = []
+                    junior.guardian_code_status = []
                     junior.guardian_code.extend(guardian_code)
+                    junior.guardian_code_status.extend(str(NUMBER['three']))
                 elif len(junior.guardian_code) < 3 and len(guardian_code) < 3:
                     junior.guardian_code.extend(guardian_code)
+                    junior.guardian_code_status.extend(str(NUMBER['three']))
                 else:
                     raise serializers.ValidationError({"error":ERROR_CODE['2081'],"code":"400", "status":"failed"})
                 guardian_data = Guardian.objects.filter(guardian_code=guardian_code[0]).last()
                 if guardian_data:
                     JuniorGuardianRelationship.objects.get_or_create(guardian=guardian_data, junior=junior)
-                junior.guardian_code_status = str(NUMBER['three'])
                 junior_approval_mail.delay(user.email, user.first_name)
                 send_notification.delay(ASSOCIATE_REQUEST, junior.auth.id, JUNIOR, guardian_data.user.id, {})
 
@@ -296,8 +298,8 @@ class AddJuniorSerializer(serializers.ModelSerializer):
                                                 referral_code=generate_code(ZOD, user_data.id),
                                                 referral_code_used=guardian_data.referral_code,
                                                 is_password_set=False, is_verified=True,
-                                                guardian_code_status=GUARDIAN_CODE_STATUS[1][0])
+                                                guardian_code_status=[str(NUMBER['two'])])
-            JuniorGuardianRelationship.objects.get_or_create(guardian=guardian_data, junior=junior_data,
+            JuniorGuardianRelationship.objects.create(guardian=guardian_data, junior=junior_data,
                                                       relationship=relationship)
             total_junior = Junior.objects.all().count()
             JuniorPoints.objects.create(junior=junior_data, position=total_junior)
@@ -326,9 +328,11 @@ class RemoveJuniorSerializer(serializers.ModelSerializer):
         if instance:
             guardian_code = self.context['guardian_code']
             instance.is_invited = False
+            if instance.guardian_code and ('-' in instance.guardian_code):
+                instance.guardian_code.remove('-')
+            index = instance.guardian_code.index(guardian_code)
             instance.guardian_code.remove(guardian_code)
-            if not instance.guardian_code:
+            instance.guardian_code_status.pop(index)
-                instance.guardian_code_status = str(NUMBER['one'])
             instance.save()
             return instance
 
@@ -447,7 +451,7 @@ class AddGuardianSerializer(serializers.ModelSerializer):
                                             user_type=str(NUMBER['two']), expired_at=expiry_time,
                                             is_verified=True)
                 UserNotification.objects.get_or_create(user=user)
-            JuniorGuardianRelationship.objects.get_or_create(guardian=guardian_data, junior=junior_data,
+            JuniorGuardianRelationship.objects.create(guardian=guardian_data, junior=junior_data,
                                                       relationship=relationship)
 
             """Notification email"""
@@ -506,15 +510,15 @@ class RemoveGuardianCodeSerializer(serializers.ModelSerializer):
     def update(self, instance, validated_data):
         guardian_code = self.context['guardian_code']
         if guardian_code in instance.guardian_code:
+            if instance.guardian_code and ('-' in instance.guardian_code):
+                instance.guardian_code.remove('-')
+            if instance.guardian_code_status and ('-' in instance.guardian_code_status):
+                instance.guardian_code_status.remove('-')
+            index = instance.guardian_code.index(guardian_code)
             instance.guardian_code.remove(guardian_code)
+            instance.guardian_code_status.pop(index)
         else:
             raise serializers.ValidationError({"error":ERROR_CODE['2082'],"code":"400", "status":"failed"})
-        if not instance.guardian_code:
-            instance.guardian_code_status = str(NUMBER['one'])
-        elif instance.guardian_code and (len(instance.guardian_code) == 1 and '-' in instance.guardian_code):
-            instance.guardian_code_status = str(NUMBER['one'])
-        else:
-            instance.guardian_code_status = str(NUMBER['two'])
         instance.save()
         return instance
 

junior/views.py

@@ -99,7 +99,10 @@ class UpdateJuniorProfile(viewsets.ModelViewSet):
                 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:
-            error_detail = e.detail.get('error', None)
+            if e.detail:
+                error_detail = e.detail.get('error', None)
+            else:
+                error_detail = str(e)
             return custom_error_response(error_detail, response_status=status.HTTP_400_BAD_REQUEST)
 
 class ValidateGuardianCode(viewsets.ModelViewSet):
@@ -191,7 +194,7 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
                     return custom_error_response(ERROR_CODE['2077'], response_status=status.HTTP_400_BAD_REQUEST)
                 elif not data:
                     return custom_error_response(ERROR_CODE['2076'], response_status=status.HTTP_400_BAD_REQUEST)
-                if data == "Max":
+                elif data == "Max":
                     return custom_error_response(ERROR_CODE['2081'], response_status=status.HTTP_400_BAD_REQUEST)
                 return custom_response(SUCCESS_CODE['3021'], response_status=status.HTTP_200_OK)
             # use AddJuniorSerializer serializer
@@ -219,10 +222,12 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
             junior.guardian_code.append(guardian.guardian_code)
         else:
             return "Max"
-        junior.guardian_code_status = str(NUMBER['two'])
+        junior.guardian_code_status = [str(NUMBER['two'])]
         junior.save()
-        JuniorGuardianRelationship.objects.get_or_create(guardian=guardian, junior=junior,
+        jun_data, created = JuniorGuardianRelationship.objects.get_or_create(guardian=guardian, junior=junior)
-                                                         relationship=str(self.request.data['relationship']))
+        if jun_data:
+            jun_data.relationship = str(self.request.data['relationship'])
+            jun_data.save()
         return True