zod-backend/guardian/views.py

"""Views of Guardian"""
"""Third party Django app"""
from rest_framework.permissions import IsAuthenticated
from rest_framework import viewsets, status
from rest_framework.pagination import PageNumberPagination
from django.contrib.auth.models import User
from django.utils import timezone
from datetime import datetime, timedelta
"""Import Django app"""
from .serializers import (UserSerializer, CreateGuardianSerializer, TaskSerializer, TaskDetailsSerializer,
                          TopJuniorSerializer)
from .models import Guardian, JuniorTask
from junior.models import Junior
from junior.serializers import JuniorDetailSerializer
from account.models import UserEmailOtp
from .tasks import generate_otp
from account.utils import send_otp_email
from account.utils import custom_response, custom_error_response
from base.messages import ERROR_CODE, SUCCESS_CODE
from .utils import upload_image_to_alibaba
from django.db.models import Sum
# Create your views here.
class SignupViewset(viewsets.ModelViewSet):
    """Signup view set"""
    serializer_class = UserSerializer
    def create(self, request, *args, **kwargs):
        """Create user profile"""
        if request.data['user_type'] in ['1', '2']:
            serializer = UserSerializer(context=request.data['user_type'], data=request.data)
            if serializer.is_valid():
                serializer.save()
                """Generate otp"""
                otp = generate_otp()
                expiry = timezone.now() + timezone.timedelta(days=1)
                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)
                return custom_response(SUCCESS_CODE['3001'], {"email_otp": otp},
                                       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['2028'], response_status=status.HTTP_400_BAD_REQUEST)

class UpdateGuardianProfile(viewsets.ViewSet):
    """Update guardian profile"""
    serializer_class = CreateGuardianSerializer
    permission_classes = [IsAuthenticated]

    def create(self, request, *args, **kwargs):
        """Create guardian profile"""
        serializer = CreateGuardianSerializer(context={"user":request.user,
                                                       "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)


class AllTaskListAPIView(viewsets.ModelViewSet):
    """Update guardian profile"""
    serializer_class = TaskDetailsSerializer
    permission_classes = [IsAuthenticated]

    def list(self, request, *args, **kwargs):
        """Create guardian profile"""
        queryset = JuniorTask.objects.filter(guardian__user=request.user)
        serializer = TaskDetailsSerializer(queryset, many=True)
        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)

class TaskListAPIView(viewsets.ModelViewSet):
    """Update guardian profile"""
    serializer_class = TaskDetailsSerializer
    permission_classes = [IsAuthenticated]
    pagination_class = PageNumberPagination

    def list(self, request, *args, **kwargs):
        """Create guardian profile"""
        status_value = self.request.GET.get('status')
        if status_value == 0:
            queryset = JuniorTask.objects.filter(guardian__user=request.user).order_by('created_at')
        else:
            queryset = JuniorTask.objects.filter(guardian__user=request.user,
                                                 task_status=status_value).order_by('due_date','created_at')
        paginator = self.pagination_class()
        paginated_queryset = paginator.paginate_queryset(queryset, request)
        serializer = TaskDetailsSerializer(paginated_queryset, many=True)
        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)

class CreateTaskAPIView(viewsets.ModelViewSet):
    """create task for junior"""
    serializer_class = TaskSerializer

    def create(self, request, *args, **kwargs):
        image = request.data['default_image']
        data = request.data
        if 'https' in str(image):
            image_data = image
        else:
            filename = f"images/{image}"
            image_url = upload_image_to_alibaba(image, filename)
            image_data = image_url
        data.pop('default_image')
        serializer = TaskSerializer(context={"user":request.user, "image":image_data}, data=data)
        if serializer.is_valid():
            serializer.save()
            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)

class SearchTaskListAPIView(viewsets.ModelViewSet):
    """Update guardian profile"""
    serializer_class = TaskDetailsSerializer
    permission_classes = [IsAuthenticated]
    pagination_class = PageNumberPagination

    def get_queryset(self):
        """Get the queryset for the view"""
        title = self.request.GET.get('title')
        junior_queryset = JuniorTask.objects.filter(guardian__user=self.request.user, task_name__icontains=title)\
            .order_by('due_date', 'created_at')
        return junior_queryset

    def list(self, request, *args, **kwargs):
        """Create guardian profile"""
        queryset = self.get_queryset()

        paginator = self.pagination_class()
        paginated_queryset = paginator.paginate_queryset(queryset, request)

        serializer = TaskDetailsSerializer(paginated_queryset, many=True)
        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)

class TopJuniorListAPIView(viewsets.ModelViewSet):
    """Top juniors list"""
    serializer_class = TopJuniorSerializer
    # permission_classes = [IsAuthenticated]

    def list(self, request, *args, **kwargs):
        """fetch junior list those complete their task"""
        junior_ids_with_total_points = JuniorTask.objects.filter(task_status=1) \
            .values('junior') \
            .annotate(total_points=Sum('points')) \
            .order_by('-total_points')

        junior_ids = [item['junior'] for item in junior_ids_with_total_points]

        juniors = Junior.objects.filter(id__in=junior_ids)

        serializer = self.get_serializer(juniors, many=True, context={'junior_ids_with_total_points':
                                                                      junior_ids_with_total_points})
        return custom_response(serializer.data, response_status=status.HTTP_200_OK)