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, JuniorPoints
from junior.serializers import JuniorDetailSerializer
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 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"""
    queryset = User.objects.all()
    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"""
    queryset = Guardian.objects.all()
    serializer_class = CreateGuardianSerializer
    permission_classes = [IsAuthenticated]

    def create(self, request, *args, **kwargs):
        """Create guardian profile"""
        data = request.data
        image = request.data.get('image')
        image_url = ''
        if image:
            filename = f"images/{image.name}"
            image_url = upload_image_to_alibaba(image, filename)
            data = {"image":image_url}
        serializer = CreateGuardianSerializer(context={"user":request.user,
                                                       "first_name":request.data.get('first_name'),
                                                       "last_name": request.data.get('last_name'),
                                                       "image":image_url},
                                              data=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
    queryset = JuniorTask.objects.all()
    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
    queryset = JuniorTask.objects.all()

    def list(self, request, *args, **kwargs):
        """Create guardian profile"""
        status_value = self.request.GET.get('status')
        if str(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
    queryset = JuniorTask.objects.all()

    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
    queryset = JuniorTask.objects.all()

    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]
    queryset = JuniorPoints.objects.all()

    def get_serializer_context(self):
        context = super().get_serializer_context()
        context.update({'view': self})
        return context

    def list(self, request, *args, **kwargs):
        """Fetch junior list of those who complete their tasks"""
        junior_total_points = self.get_queryset().order_by('-total_task_points')

        # Update the position field for each JuniorPoints object
        for index, junior in enumerate(junior_total_points):
            junior.position = index + 1
            junior.save()

        serializer = self.get_serializer(junior_total_points, many=True)
        return custom_response(serializer.data, response_status=status.HTTP_200_OK)