ammar/zod-backend
1
0
Fork 0
mirror of https://github.com/HamzaSha1/zod-backend.git synced 2025-07-16 02:16:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

list of guardian code status

Browse Source
This commit is contained in:
jain
2023-08-26 17:09:10 +05:30
parent 9891060ee3
commit cf9376663c
8 changed files with 185 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
guardian/serializers.py
View File

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

80
guardian/views.py
View File

@ -179,36 +179,42 @@ 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 (guardian_data.guardian_code not in junior_id.guardian_code or
junior_id.guardian_code_status in guardian_code_tuple):
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')
# use TaskSerializer serializer
serializer = TaskSerializer(context={"user":request.user, "image":image_data}, data=data)
if serializer.is_valid():
# save serializer
task = serializer.save()
if junior_id:
guardian_data = Guardian.objects.filter(user=request.user).last()
index = junior_id.guardian_code.index(guardian_data.guardian_code)
print("index===>", index, '===>', type(index))
status_index = junior_id.guardian_code_status[index]
print("status_index===>", status_index, '===>', type(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')
# use TaskSerializer serializer
serializer = TaskSerializer(context={"user":request.user, "image":image_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'], serializer.data, response_status=status.HTTP_200_OK)
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
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'], 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['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 +308,20 @@ 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
junior_queryset.guardian_code_status = str(NUMBER['one'])
print("#############################################")
if junior_queryset.guardian_code and ('-' in junior_queryset.guardian_code):
print("777777777777777")
junior_queryset.guardian_code.remove('-')
if junior_queryset.guardian_code_status and ('-' in junior_queryset.guardian_code_status):
print("666666666666666666666666")
junior_queryset.guardian_code_status.remove('-')
print("guardian.guardian_code==>", guardian.guardian_code, '==>', type(guardian.guardian_code))
print("junior_queryset.guardian_code==>", junior_queryset.guardian_code, '==>', type(junior_queryset.guardian_code))
index = junior_queryset.guardian_code.index(guardian.guardian_code)
print("index==>", index, '==>', type(index))
junior_queryset.guardian_code.remove(guardian.guardian_code)
data = junior_queryset.guardian_code_status.pop(index)
print("data==>", data, '==>', type(data))
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)

17
junior/migrations/0030_remove_junior_guardian_code_status.py Normal file
View File

@ -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',
),
]

19
junior/migrations/0031_junior_guardian_code_status.py Normal file
View File

@ -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),
),
]

6
junior/models.py
View File

@ -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 = models.CharField(max_length=31, choices=GUARDIAN_CODE_STATUS, default='1',
null=True, blank=True)
# # guardian code status"""
guardian_code_status = ArrayField(models.CharField(max_length=10, null=True, blank=True, default=None), null=True,
)
# Profile created and updated time"""
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)

42
junior/serializers.py
View File

@ -92,16 +92,23 @@ class CreateJuniorSerializer(serializers.ModelSerializer):
# condition for guardian code
if guardian_code:
if not junior.guardian_code:
print("111111111")
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:
print("2222222222")
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'])
# print("junior.guardian_code.index(guardian_code)==>",junior.guardian_code.index(guardian_code),'===>',type(junior.guardian_code.index(guardian_code)))
print("junior.guardian_code==>", junior.guardian_code, '===>', type(junior.guardian_code))
junior_approval_mail.delay(user.email, user.first_name)
send_notification.delay(ASSOCIATE_REQUEST, junior.auth.id, JUNIOR, guardian_data.user.id, {})
@ -296,9 +303,9 @@ 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,
relationship=relationship)
relationship=relationship)
total_junior = Junior.objects.all().count()
JuniorPoints.objects.create(junior=junior_data, position=total_junior)
"""Generate otp"""
@ -326,9 +333,18 @@ 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):
print("1111111111111")
instance.guardian_code.remove('-')
print("instance.guardian_code==>",instance.guardian_code,'==>',type(instance.guardian_code),'===>',
len(instance.guardian_code))
print("instance.guardian_code_status==>", instance.guardian_code_status, '==>', type(instance.guardian_code_status), '===>',
len(instance.guardian_code_status))
index = instance.guardian_code.index(guardian_code)
print("index==>",index,'==>',type(index))
instance.guardian_code.remove(guardian_code)
if not instance.guardian_code:
instance.guardian_code_status = str(NUMBER['one'])
data = instance.guardian_code_status.pop(index)
print("data==>", data, '==>', type(data))
instance.save()
return instance
@ -506,15 +522,19 @@ 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):
print("777777777777777")
instance.guardian_code.remove('-')
if instance.guardian_code_status and ('-' in instance.guardian_code_status):
print("666666666666666666666666")
instance.guardian_code_status.remove('-')
index = instance.guardian_code.index(guardian_code)
print("index===>",index,'===>',type(index))
instance.guardian_code.remove(guardian_code)
data = instance.guardian_code_status.pop(index)
print("data===>", data, '===>', type(data))
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

46
junior/views.py
View File

@ -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
@ -208,6 +211,7 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
junior = Junior.objects.filter(auth__email=self.request.data['email']).first()
guardian = Guardian.objects.filter(user=self.request.user).first()
if junior.guardian_code and ('-' in junior.guardian_code):
print("1111111111111")
junior.guardian_code.remove('-')
if not junior:
return none
@ -219,7 +223,7 @@ 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,
relationship=str(self.request.data['relationship']))
@ -736,24 +740,24 @@ class RemoveGuardianCodeAPIView(views.APIView):
permission_classes = [IsAuthenticated]
def put(self, request, format=None):
try:
guardian_code = self.request.data.get("guardian_code")
junior_queryset = Junior.objects.filter(auth=self.request.user).last()
if junior_queryset:
# use RemoveGuardianCodeSerializer serializer
serializer = RemoveGuardianCodeSerializer(junior_queryset, context = {"guardian_code":guardian_code},
data=request.data, partial=True)
if serializer.is_valid():
# save serializer
serializer.save()
return custom_response(SUCCESS_CODE['3044'], 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['2047'], response_status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
error_detail = e.detail.get('error', None)
return custom_error_response(error_detail, response_status=status.HTTP_400_BAD_REQUEST)
# try:
guardian_code = self.request.data.get("guardian_code")
junior_queryset = Junior.objects.filter(auth=self.request.user).last()
if junior_queryset:
# use RemoveGuardianCodeSerializer serializer
serializer = RemoveGuardianCodeSerializer(junior_queryset, context = {"guardian_code":guardian_code},
data=request.data, partial=True)
if serializer.is_valid():
# save serializer
serializer.save()
return custom_response(SUCCESS_CODE['3044'], 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['2047'], response_status=status.HTTP_400_BAD_REQUEST)
# except Exception as e:
# error_detail = e.detail.get('error', None)
# return custom_error_response(error_detail, response_status=status.HTTP_400_BAD_REQUEST)
class FAQViewSet(GenericViewSet, mixins.CreateModelMixin,

52
zod_bank/settings.py
View File

@ -181,32 +181,32 @@ AUTH_PASSWORD_VALIDATORS = [
# database query logs settings
# Allows us to check db hits
# useful to optimize db query and hit
LOGGING = {
"version": 1,
"filters": {
"require_debug_true": {
"()": "django.utils.log.RequireDebugTrue"
}
},
"handlers": {
"console": {
"level": "DEBUG",
"filters": [
"require_debug_true"
],
"class": "logging.StreamHandler"
}
},
# database logger
"loggers": {
"django.db.backends": {
"level": "DEBUG",
"handlers": [
"console"
]
}
}
}
# LOGGING = {
# "version": 1,
# "filters": {
# "require_debug_true": {
# "()": "django.utils.log.RequireDebugTrue"
# }
# },
# "handlers": {
# "console": {
# "level": "DEBUG",
# "filters": [
# "require_debug_true"
# ],
# "class": "logging.StreamHandler"
# }
# },
# # database logger
# "loggers": {
# "django.db.backends": {
# "level": "DEBUG",
# "handlers": [
# "console"
# ]
# }
# }
# }
# Internationalization
# https://docs.djangoproject.com/en/3.0/topics/i18n/