Merge branch 'sprint4' of github.com:KiwiTechLLC/ZODBank-Backend into sprint4

account/views.py

@@ -327,24 +327,17 @@ class UserLogin(viewsets.ViewSet):
 
     @action(methods=['post'], detail=False)
     def admin_login(self, request):
-        username = request.data.get('username')
+        email = request.data.get('email')
         password = request.data.get('password')
-        user = authenticate(request, username=username, password=password)
+        user = User.objects.filter(email__iexact=email, is_superuser=True
-        try:
+                                   ).only('id', 'first_name', 'last_name', 'email', 'is_superuser').first()
-            if user is not None:
+
-                login(request, user)
+        if not user:
-                if user.is_superuser:
+            return custom_error_response(ERROR_CODE["2063"], response_status=status.HTTP_400_BAD_REQUEST)
-                    serializer = SuperUserSerializer(user)
+        elif not user.check_password(password):
-                return custom_response(SUCCESS_CODE['3003'], serializer.data, response_status=status.HTTP_200_OK)
+            return custom_error_response(ERROR_CODE["2031"], response_status=status.HTTP_400_BAD_REQUEST)
-            else:
+        serializer = SuperUserSerializer(user)
-                return custom_error_response(ERROR_CODE["2002"], response_status=status.HTTP_401_UNAUTHORIZED)
+        return custom_response(SUCCESS_CODE['3003'], serializer.data, response_status=status.HTTP_200_OK)
-        except Exception as e:
-            logging.error(e)
-            refresh = RefreshToken.for_user(user)
-            access_token = str(refresh.access_token)
-            refresh_token = str(refresh)
-            data = {"auth_token": access_token, "refresh_token":refresh_token, "user_type": '3'}
-            return custom_response(None, data, response_status=status.HTTP_200_OK)
 
 
 class AdminLoginViewSet(viewsets.GenericViewSet):

guardian/serializers.py

@@ -1,5 +1,5 @@
 """Serializer of Guardian"""
-"""Third party Django app"""
+# third party imports
 import logging
 from rest_framework import serializers
 # Import Refresh token of jwt
@@ -7,7 +7,8 @@ from rest_framework_simplejwt.tokens import RefreshToken
 from django.db import transaction
 from django.contrib.auth.models import User
 from datetime import datetime, time
-"""Import Django app"""
+import pytz
+from django.utils import timezone
 # Import guardian's model,
 # Import junior's model,
 # Import account's model,
@@ -16,7 +17,7 @@ from datetime import datetime, time
 # Import messages from
 # base package,
 # Import some functions
-# from utils file"""
+# local imports
 from .models import Guardian, JuniorTask
 from account.models import UserProfile, UserEmailOtp, UserNotification
 from account.utils import generate_code
@@ -226,7 +227,10 @@ class TaskDetailsSerializer(serializers.ModelSerializer):
         """ remaining time to complete task"""
         due_date_datetime = datetime.combine(obj.due_date, datetime.max.time())
         # fetch real time
-        current_datetime = real_time()
+        # current_datetime = real_time()
+        # new code
+        due_date_datetime = due_date_datetime.astimezone(pytz.utc)
+        current_datetime = timezone.now().astimezone(pytz.utc)
         # Perform the subtraction
         if due_date_datetime > current_datetime:
             time_difference = due_date_datetime - current_datetime
@@ -256,7 +260,10 @@ class TaskDetailsjuniorSerializer(serializers.ModelSerializer):
         """ remaining time to complete task"""
         due_date_datetime = datetime.combine(obj.due_date, datetime.max.time())
         # fetch real time
-        current_datetime = real_time()
+        # current_datetime = real_time()
+        # new code
+        due_date_datetime = due_date_datetime.astimezone(pytz.utc)
+        current_datetime = timezone.now().astimezone(pytz.utc)
         # Perform the subtraction
         if due_date_datetime > current_datetime:
             time_difference = due_date_datetime - current_datetime
@@ -373,7 +380,8 @@ class ApproveTaskSerializer(serializers.ModelSerializer):
                 # update total task point
                 junior_data.total_points = junior_data.total_points + instance.points
                 # update complete time of task
-                instance.completed_on = real_time()
+                # instance.completed_on = real_time()
+                instance.completed_on = timezone.now().astimezone(pytz.utc)
                 send_notification.delay(TASK_POINTS, None, junior_details.auth.id, {})
             else:
                 # reject the task
@@ -382,7 +390,8 @@ class ApproveTaskSerializer(serializers.ModelSerializer):
                 # update total task point
                 junior_data.total_points = junior_data.total_points - instance.points
                 # update reject time of task
-                instance.rejected_on = real_time()
+                # instance.rejected_on = real_time()
+                instance.rejected_on = timezone.now().astimezone(pytz.utc)
                 send_notification.delay(TASK_REJECTED, None, junior_details.auth.id, {})
             instance.save()
             junior_data.save()

guardian/views.py

@@ -11,6 +11,9 @@ from rest_framework import viewsets, status
 from rest_framework.pagination import PageNumberPagination
 from django.contrib.auth.models import User
 
+from rest_framework.filters import SearchFilter
+from django.utils import timezone
+
 # Import guardian's model,
 # Import junior's model,
 # Import account's model,
@@ -121,37 +124,69 @@ class AllTaskListAPIView(viewsets.ModelViewSet):
         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
+#     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':
+#                 queryset = JuniorTask.objects.filter(guardian__user=request.user,
+#                                                      task_name__icontains=search).order_by('due_date', 'created_at')
+#             elif search and str(status_value) != '0':
+#                 queryset = JuniorTask.objects.filter(guardian__user=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':
+#                 queryset = JuniorTask.objects.filter(guardian__user=request.user).order_by('due_date', 'created_at')
+#             elif search is None and str(status_value) != '0':
+#                 queryset = JuniorTask.objects.filter(guardian__user=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 TaskListAPIView(viewsets.ModelViewSet):
     """Update guardian profile"""
     serializer_class = TaskDetailsSerializer
     permission_classes = [IsAuthenticated]
+    filter_backends = (SearchFilter,)
+    search_fields = ['task_name', ]
     pagination_class = PageNumberPagination
     http_method_names = ('get',)
 
+    def get_queryset(self):
+        queryset = JuniorTask.objects.filter(guardian__user=self.request.user
+                                             ).prefetch_related('junior', 'junior__auth'
+                                                                ).order_by('due_date', 'created_at')
+
+        queryset = self.filter_queryset(queryset)
+        return queryset
+
     def list(self, request, *args, **kwargs):
         """Create guardian profile"""
-        try:
+        status_value = self.request.GET.get('status')
-            status_value = self.request.GET.get('status')
+        queryset = self.get_queryset()
-            search = self.request.GET.get('search')
+        if status_value and status_value != '0':
-            if search and str(status_value) == '0':
+            queryset = queryset.filter(task_status=status_value)
-                queryset = JuniorTask.objects.filter(guardian__user=request.user,
+        paginator = self.pagination_class()
-                                                     task_name__icontains=search).order_by('due_date', 'created_at')
+        # use Pagination
-            elif search and str(status_value) != '0':
+        paginated_queryset = paginator.paginate_queryset(queryset, request)
-                queryset = JuniorTask.objects.filter(guardian__user=request.user,task_name__icontains=search,
+        # use TaskDetailsSerializer serializer
-                                                     task_status=status_value).order_by('due_date', 'created_at')
+        serializer = self.serializer_class(paginated_queryset, many=True)
-            if search is None and str(status_value) == '0':
+        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
-                queryset = JuniorTask.objects.filter(guardian__user=request.user).order_by('due_date', 'created_at')
+
-            elif search is None and str(status_value) != '0':
-                queryset = JuniorTask.objects.filter(guardian__user=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 CreateTaskAPIView(viewsets.ModelViewSet):
     """create task for junior"""

junior/serializers.py

@@ -1,5 +1,8 @@
 """Serializer file for junior"""
-"""Import Django 3rd party app"""
+# third party imports
+import pytz
+
+# django imports
 from rest_framework import serializers
 from django.contrib.auth.models import User
 from django.db import transaction
@@ -7,7 +10,7 @@ from datetime import datetime
 from django.utils import timezone
 from rest_framework_simplejwt.tokens import RefreshToken
 
-"""Import django app"""
+# local imports
 from account.utils import send_otp_email, generate_code
 from junior.models import Junior, JuniorPoints, JuniorGuardianRelationship
 from guardian.tasks import generate_otp
@@ -325,7 +328,8 @@ class CompleteTaskSerializer(serializers.ModelSerializer):
         fields = ('id', 'image')
     def update(self, instance, validated_data):
         instance.image = validated_data.get('image', instance.image)
-        instance.requested_on = real_time()
+        # instance.requested_on = real_time()
+        instance.requested_on = timezone.now().astimezone(pytz.utc)
         instance.task_status = str(NUMBER['four'])
         instance.is_approved = False
         instance.save()
@@ -452,7 +456,10 @@ class StartTaskSerializer(serializers.ModelSerializer):
         """ remaining time to complete task"""
         due_date = datetime.combine(obj.due_date, datetime.max.time())
         # fetch real time
-        real_datetime = real_time()
+        # real_datetime = real_time()
+        # new code
+        due_date = due_date.astimezone(pytz.utc)
+        real_datetime = timezone.now().astimezone(pytz.utc)
         # Perform the subtraction
         if due_date > real_datetime:
             time_difference = due_date - real_datetime

notifications/serializers.py

@@ -8,6 +8,7 @@ from rest_framework import serializers
 from notifications.utils import register_fcm_token
 from notifications.models import Notification
 
+
 class RegisterDevice(serializers.Serializer):
     """
     used to create and validate register device token
@@ -27,7 +28,8 @@ class RegisterDevice(serializers.Serializer):
         return register_fcm_token(self.context['user_id'], registration_id,
                                   validated_data['device_id'], device_type)
 
-class NotificationListSerailizer(serializers.ModelSerializer):
+
+class NotificationListSerializer(serializers.ModelSerializer):
     """List of notification"""
 
     class Meta(object):

notifications/views.py

@@ -11,15 +11,32 @@ from rest_framework import viewsets, status, views
 from account.utils import custom_response, custom_error_response
 from base.messages import SUCCESS_CODE, ERROR_CODE
 from notifications.constants import TEST_NOTIFICATION
-from notifications.serializers import RegisterDevice, NotificationListSerailizer, ReadNotificationSerializer
+from notifications.serializers import RegisterDevice, NotificationListSerializer, ReadNotificationSerializer
 from notifications.utils import send_notification
 from notifications.models import Notification
 
+
 class NotificationViewSet(viewsets.GenericViewSet):
     """ used to do the notification actions """
-    serializer_class = RegisterDevice
+    serializer_class = NotificationListSerializer
     permission_classes = [IsAuthenticated, ]
 
+    def list(self, request, *args, **kwargs) -> Response:
+        """ list the notifications """
+        queryset = Notification.objects.filter(notification_to_id=request.auth.payload['user_id']
+                                               ).select_related('notification_to').order_by('-id')
+        paginator = self.pagination_class()
+        paginated_queryset = paginator.paginate_queryset(queryset, request)
+        serializer = self.serializer_class(paginated_queryset, many=True)
+        self.mark_notifications_as_read(serializer.data)
+        return custom_response(None, serializer.data)
+
+    @staticmethod
+    def mark_notifications_as_read(data):
+        """ used to mark notification queryset as read """
+        ids = [obj['id'] for obj in data]
+        Notification.objects.filter(id__in=ids).update(is_read=True)
+
     @action(methods=['post'], detail=False, url_path='device', url_name='device', serializer_class=RegisterDevice)
     def fcm_registration(self, request):
         """
@@ -41,14 +58,14 @@ class NotificationViewSet(viewsets.GenericViewSet):
         return custom_response(SUCCESS_CODE["3000"])
 
     @action(methods=['get'], detail=False, url_path='list', url_name='list',
-            serializer_class=NotificationListSerailizer)
+            serializer_class=NotificationListSerializer)
     def notification_list(self, request):
         """
         notification list
         """
         try:
             queryset = Notification.objects.filter(notification_to=request.user)
-            serializer = NotificationListSerailizer(queryset, many=True)
+            serializer = NotificationListSerializer(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)