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

try and except in api

Browse Source
This commit is contained in:
jain
2023-07-25 12:53:56 +05:30
parent e6d45f3bf2
commit bb56fc7a33
4 changed files with 333 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
base/constants.py
View File

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

282
guardian/views.py
View File

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

28
junior/models.py
View File

@ -7,6 +7,7 @@ from django.contrib.auth import get_user_model
from django.contrib.postgres.fields import ArrayField from django.contrib.postgres.fields import ArrayField
"""Import django app""" """Import django app"""
from base.constants import GENDERS, SIGNUP_METHODS, RELATIONSHIP from base.constants import GENDERS, SIGNUP_METHODS, RELATIONSHIP
"""Define User model""" """Define User model"""
User = get_user_model() User = get_user_model()
# Create your models here. # Create your models here.
@ -31,7 +32,7 @@ User = get_user_model()
"""Define junior points model""" """Define junior points model"""
# points of the junior # points of the junior
# position of the junior # position of the junior
# define junior guardian relation model
class Junior(models.Model): class Junior(models.Model):
"""Junior model""" """Junior model"""
auth = models.ForeignKey(User, on_delete=models.CASCADE, related_name='junior_profile', verbose_name='Email') auth = models.ForeignKey(User, on_delete=models.CASCADE, related_name='junior_profile', verbose_name='Email')
@ -109,3 +110,28 @@ class JuniorPoints(models.Model):
def __str__(self): def __str__(self):
"""Return email id""" """Return email id"""
return f'{self.junior.auth}' return f'{self.junior.auth}'
class JuniorGuardianRelationship(models.Model):
"""Junior Guardian relationship model"""
guardian = models.ForeignKey(Guardian, on_delete=models.CASCADE, related_name='guardian', verbose_name='Guardian')
# associated junior with the task
junior = models.ForeignKey(Junior, on_delete=models.CASCADE, related_name='junior', 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}'

269
junior/views.py
View File

@ -53,27 +53,30 @@ class UpdateJuniorProfile(viewsets.ViewSet):
def create(self, request, *args, **kwargs): def create(self, request, *args, **kwargs):
"""Use CreateJuniorSerializer""" """Use CreateJuniorSerializer"""
request_data = request.data try:
image = request.data.get('image') request_data = request.data
image_url = '' image = request.data.get('image')
if image: image_url = ''
if image.size == NUMBER['zero']: if image:
return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST) if image.size == NUMBER['zero']:
# convert into file return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
filename = f"images/{image.name}" # convert into file
# upload image on ali baba filename = f"images/{image.name}"
image_url = upload_image_to_alibaba(image, filename) # upload image on ali baba
request_data = {"image": image_url} image_url = upload_image_to_alibaba(image, filename)
serializer = CreateJuniorSerializer(context={"user":request.user, "image":image_url, request_data = {"image": image_url}
"first_name": request.data.get('first_name'), serializer = CreateJuniorSerializer(context={"user":request.user, "image":image_url,
"last_name": request.data.get('last_name') "first_name": request.data.get('first_name'),
}, "last_name": request.data.get('last_name')
data=request_data) },
if serializer.is_valid(): data=request_data)
"""save serializer""" if serializer.is_valid():
serializer.save() """save serializer"""
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK) serializer.save()
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST) 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): class ValidateGuardianCode(viewsets.ViewSet):
"""Check guardian code exist or not""" """Check guardian code exist or not"""
@ -82,14 +85,17 @@ class ValidateGuardianCode(viewsets.ViewSet):
def list(self, request, *args, **kwargs): def list(self, request, *args, **kwargs):
"""check guardian code""" """check guardian code"""
guardian_code = self.request.GET.get('guardian_code').split(',') try:
for code in guardian_code: guardian_code = self.request.GET.get('guardian_code').split(',')
# fetch guardian object for code in guardian_code:
guardian_data = Guardian.objects.filter(guardian_code=code).exists() # fetch guardian object
if guardian_data: guardian_data = Guardian.objects.filter(guardian_code=code).exists()
return custom_response(SUCCESS_CODE['3013'], response_status=status.HTTP_200_OK) if guardian_data:
else: return custom_response(SUCCESS_CODE['3013'], response_status=status.HTTP_200_OK)
return custom_error_response(ERROR_CODE["2022"], response_status=status.HTTP_400_BAD_REQUEST) 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): class JuniorListAPIView(viewsets.ModelViewSet):
"""Junior list of assosicated guardian""" """Junior list of assosicated guardian"""
@ -101,15 +107,18 @@ class JuniorListAPIView(viewsets.ModelViewSet):
def list(self, request, *args, **kwargs): def list(self, request, *args, **kwargs):
""" junior list""" """ junior list"""
update_positions_based_on_points() try:
guardian_data = Guardian.objects.filter(user__email=request.user).last() update_positions_based_on_points()
# fetch junior object guardian_data = Guardian.objects.filter(user__email=request.user).last()
if guardian_data: # fetch junior object
queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code)) if guardian_data:
# use JuniorDetailListSerializer serializer queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code))
serializer = JuniorDetailListSerializer(queryset, many=True) # use JuniorDetailListSerializer serializer
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK) serializer = JuniorDetailListSerializer(queryset, many=True)
return custom_error_response(ERROR_CODE['2045'], response_status=status.HTTP_200_OK) 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): class AddJuniorAPIView(viewsets.ModelViewSet):
"""Add Junior by guardian""" """Add Junior by guardian"""
@ -119,18 +128,21 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
http_method_names = ('post',) http_method_names = ('post',)
def create(self, request, *args, **kwargs): def create(self, request, *args, **kwargs):
""" junior list""" """ junior list"""
info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'], try:
'last_name': request.data['last_name']} info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
if User.objects.filter(username=request.data['email']): 'last_name': request.data['last_name']}
return custom_error_response(ERROR_CODE['2059'], response_status=status.HTTP_400_BAD_REQUEST) 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 # use AddJuniorSerializer serializer
serializer = AddJuniorSerializer(data=request.data, context=info) serializer = AddJuniorSerializer(data=request.data, context=info)
if serializer.is_valid(): if serializer.is_valid():
# save serializer # save serializer
serializer.save() serializer.save()
return custom_response(SUCCESS_CODE['3021'], serializer.data, response_status=status.HTTP_200_OK) 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) 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): class InvitedJuniorAPIView(viewsets.ModelViewSet):
"""Junior list of assosicated guardian""" """Junior list of assosicated guardian"""
@ -149,13 +161,16 @@ class InvitedJuniorAPIView(viewsets.ModelViewSet):
return junior_queryset return junior_queryset
def list(self, request, *args, **kwargs): def list(self, request, *args, **kwargs):
""" junior list""" """ junior list"""
queryset = self.get_queryset() try:
paginator = self.pagination_class() queryset = self.get_queryset()
# pagination paginator = self.pagination_class()
paginated_queryset = paginator.paginate_queryset(queryset, request) # pagination
# use JuniorDetailListSerializer serializer paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = JuniorDetailListSerializer(paginated_queryset, many=True) # use JuniorDetailListSerializer serializer
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK) 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): class FilterJuniorAPIView(viewsets.ModelViewSet):
@ -177,13 +192,16 @@ class FilterJuniorAPIView(viewsets.ModelViewSet):
def list(self, request, *args, **kwargs): def list(self, request, *args, **kwargs):
"""Create guardian profile""" """Create guardian profile"""
queryset = self.get_queryset() try:
paginator = self.pagination_class() queryset = self.get_queryset()
# use Pagination paginator = self.pagination_class()
paginated_queryset = paginator.paginate_queryset(queryset, request) # use Pagination
# use JuniorDetailListSerializer serializer paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = JuniorDetailListSerializer(paginated_queryset, many=True) # use JuniorDetailListSerializer serializer
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK) 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): class RemoveJuniorAPIView(views.APIView):
@ -193,21 +211,24 @@ class RemoveJuniorAPIView(views.APIView):
permission_classes = [IsAuthenticated] permission_classes = [IsAuthenticated]
def put(self, request, format=None): def put(self, request, format=None):
junior_id = self.request.GET.get('id') try:
guardian = Guardian.objects.filter(user__email=self.request.user).last() junior_id = self.request.GET.get('id')
# fetch junior query guardian = Guardian.objects.filter(user__email=self.request.user).last()
junior_queryset = Junior.objects.filter(id=junior_id, guardian_code__icontains=str(guardian.guardian_code), # fetch junior query
is_invited=True).last() junior_queryset = Junior.objects.filter(id=junior_id, guardian_code__icontains=str(guardian.guardian_code),
if junior_queryset: is_invited=True).last()
# use RemoveJuniorSerializer serializer if junior_queryset:
serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True) # use RemoveJuniorSerializer serializer
if serializer.is_valid(): serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
# save serializer if serializer.is_valid():
serializer.save() # save serializer
return custom_response(SUCCESS_CODE['3022'], serializer.data, response_status=status.HTTP_200_OK) serializer.save()
return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST) return custom_response(SUCCESS_CODE['3022'], serializer.data, response_status=status.HTTP_200_OK)
else: return custom_error_response(serializer.errors, response_status=status.HTTP_400_BAD_REQUEST)
return custom_error_response(ERROR_CODE['2034'], 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): class JuniorTaskListAPIView(viewsets.ModelViewSet):
@ -220,29 +241,32 @@ class JuniorTaskListAPIView(viewsets.ModelViewSet):
def list(self, request, *args, **kwargs): def list(self, request, *args, **kwargs):
"""Create guardian profile""" """Create guardian profile"""
status_value = self.request.GET.get('status') try:
search = self.request.GET.get('search') status_value = self.request.GET.get('status')
if search and str(status_value) == '0': search = self.request.GET.get('search')
# search with title and for all task list if search and str(status_value) == '0':
queryset = JuniorTask.objects.filter(junior__auth=request.user, # search with title and for all task list
task_name__icontains=search).order_by('due_date', 'created_at') queryset = JuniorTask.objects.filter(junior__auth=request.user,
elif search and str(status_value) != '0': task_name__icontains=search).order_by('due_date', 'created_at')
# search with title and fetch task list with status wise elif search and str(status_value) != '0':
queryset = JuniorTask.objects.filter(junior__auth=request.user, task_name__icontains=search, # search with title and fetch task list with status wise
task_status=status_value).order_by('due_date', 'created_at') queryset = JuniorTask.objects.filter(junior__auth=request.user, task_name__icontains=search,
if search is None and str(status_value) == '0': task_status=status_value).order_by('due_date', 'created_at')
# fetch all task list if search is None and str(status_value) == '0':
queryset = JuniorTask.objects.filter(junior__auth=request.user).order_by('due_date', 'created_at') # fetch all task list
elif search is None and str(status_value) != '0': queryset = JuniorTask.objects.filter(junior__auth=request.user).order_by('due_date', 'created_at')
# fetch task list with status wise elif search is None and str(status_value) != '0':
queryset = JuniorTask.objects.filter(junior__auth=request.user, # fetch task list with status wise
task_status=status_value).order_by('due_date','created_at') queryset = JuniorTask.objects.filter(junior__auth=request.user,
paginator = self.pagination_class() task_status=status_value).order_by('due_date','created_at')
# use Pagination paginator = self.pagination_class()
paginated_queryset = paginator.paginate_queryset(queryset, request) # use Pagination
# use TaskDetailsSerializer serializer paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = TaskDetailsSerializer(paginated_queryset, many=True) # use TaskDetailsSerializer serializer
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK) 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): class CompleteJuniorTaskAPIView(views.APIView):
@ -292,11 +316,14 @@ class JuniorPointsListAPIView(viewsets.ModelViewSet):
return JuniorTask.objects.filter(junior__auth__email=self.request.user).last() return JuniorTask.objects.filter(junior__auth__email=self.request.user).last()
def list(self, request, *args, **kwargs): def list(self, request, *args, **kwargs):
"""profile view""" """profile view"""
queryset = self.get_queryset() try:
# update position of junior queryset = self.get_queryset()
update_positions_based_on_points() # update position of junior
serializer = JuniorPointsSerializer(queryset) update_positions_based_on_points()
return custom_response(None, serializer.data, response_status=status.HTTP_200_OK) 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): class ValidateReferralCode(viewsets.ViewSet):
"""Check guardian code exist or not""" """Check guardian code exist or not"""
@ -320,9 +347,12 @@ class ValidateReferralCode(viewsets.ViewSet):
def list(self, request, *args, **kwargs): def list(self, request, *args, **kwargs):
"""check guardian code""" """check guardian code"""
if self.get_queryset(): try:
return custom_response(SUCCESS_CODE['3033'], response_status=status.HTTP_200_OK) if self.get_queryset():
return custom_error_response(ERROR_CODE["2019"], response_status=status.HTTP_400_BAD_REQUEST) 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): class InviteGuardianAPIView(viewsets.ModelViewSet):
"""Invite guardian by junior""" """Invite guardian by junior"""
@ -331,15 +361,18 @@ class InviteGuardianAPIView(viewsets.ModelViewSet):
http_method_names = ('post',) http_method_names = ('post',)
def create(self, request, *args, **kwargs): def create(self, request, *args, **kwargs):
""" junior list""" """ junior list"""
info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'], try:
'last_name': request.data['last_name']} info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
# use AddJuniorSerializer serializer 'last_name': request.data['last_name']}
serializer = AddGuardianSerializer(data=request.data, context=info) # use AddJuniorSerializer serializer
if serializer.is_valid(): serializer = AddGuardianSerializer(data=request.data, context=info)
# save serializer if serializer.is_valid():
serializer.save() # save serializer
return custom_response(SUCCESS_CODE['3034'], serializer.data, response_status=status.HTTP_200_OK) serializer.save()
return custom_error_response(serializer.error, response_status=status.HTTP_400_BAD_REQUEST) 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): class StartTaskAPIView(views.APIView):