mirror of
https://github.com/HamzaSha1/zod-backend.git
synced 2025-07-16 18:36:18 +00:00
400 lines
19 KiB
Python
400 lines
19 KiB
Python
"""Junior view file"""
|
|
import os
|
|
|
|
from rest_framework import viewsets, status, generics,views
|
|
from rest_framework.permissions import IsAuthenticated
|
|
from rest_framework.pagination import PageNumberPagination
|
|
from django.contrib.auth.models import User
|
|
import requests
|
|
"""Django app import"""
|
|
|
|
# Import guardian's model,
|
|
# Import junior's model,
|
|
# Import account's model,
|
|
# Import constant from
|
|
# base package,
|
|
# Import messages from
|
|
# base package,
|
|
# Import some functions
|
|
# from utils file
|
|
# Import account's serializer
|
|
# Import account's task
|
|
# import junior serializer
|
|
from junior.models import Junior, JuniorPoints
|
|
from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,\
|
|
RemoveJuniorSerializer, CompleteTaskSerializer, JuniorPointsSerializer,
|
|
AddGuardianSerializer, StartTaskSerializer)
|
|
from guardian.models import Guardian, JuniorTask
|
|
from guardian.serializers import TaskDetailsSerializer
|
|
from base.messages import ERROR_CODE, SUCCESS_CODE
|
|
from base.constants import NUMBER
|
|
from account.utils import custom_response, custom_error_response
|
|
from guardian.utils import upload_image_to_alibaba
|
|
from .utils import update_positions_based_on_points
|
|
|
|
""" Define APIs """
|
|
# Define validate guardian code API,
|
|
# update junior profile,
|
|
# list of all assosicated junior
|
|
# Add junior API
|
|
# invite junior API
|
|
# search junior API
|
|
# remove junior API,
|
|
# approve junior API
|
|
# create referral code
|
|
# validation API
|
|
|
|
# Create your views here.
|
|
class UpdateJuniorProfile(viewsets.ViewSet):
|
|
"""Update junior profile"""
|
|
queryset = Junior.objects.all()
|
|
serializer_class = CreateJuniorSerializer
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def create(self, request, *args, **kwargs):
|
|
"""Use CreateJuniorSerializer"""
|
|
try:
|
|
request_data = request.data
|
|
image = request.data.get('image')
|
|
image_url = ''
|
|
if image:
|
|
if image.size == NUMBER['zero']:
|
|
return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
|
|
# convert into file
|
|
filename = f"images/{image.name}"
|
|
# upload image on ali baba
|
|
image_url = upload_image_to_alibaba(image, filename)
|
|
request_data = {"image": image_url}
|
|
serializer = CreateJuniorSerializer(context={"user":request.user, "image":image_url,
|
|
"first_name": request.data.get('first_name'),
|
|
"last_name": request.data.get('last_name')
|
|
},
|
|
data=request_data)
|
|
if serializer.is_valid():
|
|
"""save serializer"""
|
|
serializer.save()
|
|
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):
|
|
"""Check guardian code exist or not"""
|
|
queryset = Guardian.objects.all()
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
"""check guardian code"""
|
|
try:
|
|
guardian_code = self.request.GET.get('guardian_code').split(',')
|
|
for code in guardian_code:
|
|
# fetch guardian object
|
|
guardian_data = Guardian.objects.filter(guardian_code=code).exists()
|
|
if guardian_data:
|
|
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)
|
|
except Exception as e:
|
|
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
class JuniorListAPIView(viewsets.ModelViewSet):
|
|
"""Junior list of assosicated guardian"""
|
|
|
|
serializer_class = JuniorDetailListSerializer
|
|
queryset = Junior.objects.all()
|
|
permission_classes = [IsAuthenticated]
|
|
http_method_names = ('get',)
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
""" junior list"""
|
|
try:
|
|
update_positions_based_on_points()
|
|
guardian_data = Guardian.objects.filter(user__email=request.user).last()
|
|
# fetch junior object
|
|
if guardian_data:
|
|
queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code))
|
|
# use JuniorDetailListSerializer serializer
|
|
serializer = JuniorDetailListSerializer(queryset, many=True)
|
|
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):
|
|
"""Add Junior by guardian"""
|
|
queryset = Junior.objects.all()
|
|
serializer_class = AddJuniorSerializer
|
|
permission_classes = [IsAuthenticated]
|
|
http_method_names = ('post',)
|
|
def create(self, request, *args, **kwargs):
|
|
""" junior list"""
|
|
try:
|
|
info = {'user': request.user, '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)
|
|
if serializer.is_valid():
|
|
# save serializer
|
|
serializer.save()
|
|
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)
|
|
except Exception as e:
|
|
return custom_error_response(str(e), response_status=status.HTTP_400_BAD_REQUEST)
|
|
|
|
class InvitedJuniorAPIView(viewsets.ModelViewSet):
|
|
"""Junior list of assosicated guardian"""
|
|
|
|
serializer_class = JuniorDetailListSerializer
|
|
queryset = Junior.objects.all()
|
|
permission_classes = [IsAuthenticated]
|
|
pagination_class = PageNumberPagination
|
|
http_method_names = ('get',)
|
|
|
|
def get_queryset(self):
|
|
"""Get the queryset for the view"""
|
|
guardian = Guardian.objects.filter(user__email=self.request.user).last()
|
|
junior_queryset = Junior.objects.filter(guardian_code__icontains=str(guardian.guardian_code),
|
|
is_invited=True)
|
|
return junior_queryset
|
|
def list(self, request, *args, **kwargs):
|
|
""" junior list"""
|
|
try:
|
|
queryset = self.get_queryset()
|
|
paginator = self.pagination_class()
|
|
# pagination
|
|
paginated_queryset = paginator.paginate_queryset(queryset, request)
|
|
# use JuniorDetailListSerializer serializer
|
|
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):
|
|
"""Update guardian profile"""
|
|
serializer_class = JuniorDetailListSerializer
|
|
permission_classes = [IsAuthenticated]
|
|
pagination_class = PageNumberPagination
|
|
queryset = Junior.objects.all()
|
|
http_method_names = ('get',)
|
|
|
|
def get_queryset(self):
|
|
"""Get the queryset for the view"""
|
|
title = self.request.GET.get('title')
|
|
guardian_data = Guardian.objects.filter(user__email=self.request.user).last()
|
|
# fetch junior query
|
|
queryset = Junior.objects.filter(guardian_code__icontains=str(guardian_data.guardian_code),
|
|
is_invited=True, auth__first_name=title)
|
|
return queryset
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
"""Create guardian profile"""
|
|
try:
|
|
queryset = self.get_queryset()
|
|
paginator = self.pagination_class()
|
|
# use Pagination
|
|
paginated_queryset = paginator.paginate_queryset(queryset, request)
|
|
# use JuniorDetailListSerializer serializer
|
|
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):
|
|
"""Remove junior API"""
|
|
serializer_class = RemoveJuniorSerializer
|
|
model = Junior
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def put(self, request, format=None):
|
|
try:
|
|
junior_id = self.request.GET.get('id')
|
|
guardian = Guardian.objects.filter(user__email=self.request.user).last()
|
|
# fetch junior query
|
|
junior_queryset = Junior.objects.filter(id=junior_id, guardian_code__icontains=str(guardian.guardian_code),
|
|
is_invited=True).last()
|
|
if junior_queryset:
|
|
# use RemoveJuniorSerializer serializer
|
|
serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
|
|
if serializer.is_valid():
|
|
# save serializer
|
|
serializer.save()
|
|
return custom_response(SUCCESS_CODE['3022'], 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['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):
|
|
"""Update guardian profile"""
|
|
serializer_class = TaskDetailsSerializer
|
|
permission_classes = [IsAuthenticated]
|
|
pagination_class = PageNumberPagination
|
|
queryset = JuniorTask.objects.all()
|
|
http_method_names = ('get',)
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
"""Create guardian profile"""
|
|
try:
|
|
status_value = self.request.GET.get('status')
|
|
search = self.request.GET.get('search')
|
|
if search and str(status_value) == '0':
|
|
# search with title and for all task list
|
|
queryset = JuniorTask.objects.filter(junior__auth=request.user,
|
|
task_name__icontains=search).order_by('due_date', 'created_at')
|
|
elif search and str(status_value) != '0':
|
|
# search with title and fetch task list with status wise
|
|
queryset = JuniorTask.objects.filter(junior__auth=request.user, task_name__icontains=search,
|
|
task_status=status_value).order_by('due_date', 'created_at')
|
|
if search is None and str(status_value) == '0':
|
|
# fetch all task list
|
|
queryset = JuniorTask.objects.filter(junior__auth=request.user).order_by('due_date', 'created_at')
|
|
elif search is None and str(status_value) != '0':
|
|
# fetch task list with status wise
|
|
queryset = JuniorTask.objects.filter(junior__auth=request.user,
|
|
task_status=status_value).order_by('due_date','created_at')
|
|
paginator = self.pagination_class()
|
|
# use Pagination
|
|
paginated_queryset = paginator.paginate_queryset(queryset, request)
|
|
# use TaskDetailsSerializer serializer
|
|
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):
|
|
"""Update junior task API"""
|
|
serializer_class = CompleteTaskSerializer
|
|
model = JuniorTask
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def put(self, request, format=None):
|
|
try:
|
|
task_id = self.request.data.get('task_id')
|
|
image = request.data['image']
|
|
if image and image.size == NUMBER['zero']:
|
|
return custom_error_response(ERROR_CODE['2035'], response_status=status.HTTP_400_BAD_REQUEST)
|
|
# create file
|
|
filename = f"images/{image.name}"
|
|
# upload image
|
|
filename = f"images/{image.name}"
|
|
|
|
image_url = upload_image_to_alibaba(image, filename)
|
|
# fetch junior query
|
|
task_queryset = JuniorTask.objects.filter(id=task_id, junior__auth__email=self.request.user).last()
|
|
if task_queryset:
|
|
# use CompleteTaskSerializer serializer
|
|
if task_queryset.task_status in [str(NUMBER['four']), str(NUMBER['five'])]:
|
|
"""Already request send """
|
|
return custom_error_response(ERROR_CODE['2049'], response_status=status.HTTP_400_BAD_REQUEST)
|
|
serializer = CompleteTaskSerializer(task_queryset, data={'image': image_url}, partial=True)
|
|
if serializer.is_valid():
|
|
# save serializer
|
|
serializer.save()
|
|
return custom_response(SUCCESS_CODE['3032'], 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['2044'], 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 JuniorPointsListAPIView(viewsets.ModelViewSet):
|
|
"""Junior Points viewset"""
|
|
serializer_class = JuniorPointsSerializer
|
|
permission_classes = [IsAuthenticated]
|
|
http_method_names = ('get',)
|
|
|
|
def get_queryset(self):
|
|
"""get queryset"""
|
|
return JuniorTask.objects.filter(junior__auth__email=self.request.user).last()
|
|
def list(self, request, *args, **kwargs):
|
|
"""profile view"""
|
|
try:
|
|
queryset = self.get_queryset()
|
|
# update position of junior
|
|
update_positions_based_on_points()
|
|
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):
|
|
"""Check guardian code exist or not"""
|
|
permission_classes = [IsAuthenticated]
|
|
http_method_names = ('get',)
|
|
|
|
def get_queryset(self):
|
|
"""Get queryset based on referral_code."""
|
|
referral_code = self.request.GET.get('referral_code')
|
|
if referral_code:
|
|
# search referral code in guardian model
|
|
guardian_queryset = Guardian.objects.filter(referral_code=referral_code).last()
|
|
if guardian_queryset:
|
|
return guardian_queryset
|
|
else:
|
|
# search referral code in junior model
|
|
junior_queryset = Junior.objects.filter(referral_code=referral_code).last()
|
|
if junior_queryset:
|
|
return junior_queryset
|
|
return None
|
|
|
|
def list(self, request, *args, **kwargs):
|
|
"""check guardian code"""
|
|
try:
|
|
if self.get_queryset():
|
|
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):
|
|
"""Invite guardian by junior"""
|
|
serializer_class = AddGuardianSerializer
|
|
permission_classes = [IsAuthenticated]
|
|
http_method_names = ('post',)
|
|
def create(self, request, *args, **kwargs):
|
|
""" junior list"""
|
|
try:
|
|
info = {'user': request.user, 'email': request.data['email'], 'first_name': request.data['first_name'],
|
|
'last_name': request.data['last_name']}
|
|
# use AddJuniorSerializer serializer
|
|
serializer = AddGuardianSerializer(data=request.data, context=info)
|
|
if serializer.is_valid():
|
|
# save serializer
|
|
serializer.save()
|
|
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):
|
|
"""Update junior task API"""
|
|
serializer_class = StartTaskSerializer
|
|
model = JuniorTask
|
|
permission_classes = [IsAuthenticated]
|
|
|
|
def put(self, request, format=None):
|
|
try:
|
|
task_id = self.request.data.get('task_id')
|
|
task_queryset = JuniorTask.objects.filter(id=task_id, junior__auth__email=self.request.user).last()
|
|
if task_queryset and task_queryset.task_status == str(NUMBER['one']):
|
|
# use StartTaskSerializer serializer
|
|
serializer = StartTaskSerializer(task_queryset, data=request.data, partial=True)
|
|
if serializer.is_valid():
|
|
# save serializer
|
|
serializer.save()
|
|
return custom_response(SUCCESS_CODE['3035'], None, 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['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)
|