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

conflict resolved

Browse Source
This commit is contained in:
abutalib-kiwi
2023-07-25 19:45:53 +05:30
parent 7bf0e62604 3b31d08996
commit d0ef4391cc
11 changed files with 90 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
account/templates/templated_email/junior_approval_mail.email
View File

@ -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>

3
account/utils.py
View File

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

6
account/views.py
View File

@ -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

3
base/messages.py
View File

@ -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.",
}

9
guardian/serializers.py
View File

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

17
guardian/views.py
View File

@ -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
from account.utils import custom_response, custom_error_response, OTP_EXPIRY, send_otp_email
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)

8
junior/admin.py
View File

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

6
junior/models.py
View File

@ -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"""

60
junior/serializers.py
View File

@ -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(APPROVED_JUNIOR, None, email, {})
return instance
send_notification.delay(INVITED_GUARDIAN, None, junior_data.auth.id, {})
send_notification.delay(APPROVED_JUNIOR, None, guardian_data.user.id, {})
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()

20
junior/views.py
View File

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

0
web_admin/messages.py
View File