jira-16 filter, invite and remove API

account/serializers.py

@@ -26,7 +26,7 @@ class UpdateJuniorProfileImageSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = Junior
-        fields = ['image']
+        fields = ['id', 'image']
 
     def update(self, instance, validated_data):
         """update image """
@@ -41,7 +41,7 @@ class UpdateGuardianImageSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = Guardian
-        fields = ['image']
+        fields = ['id','image']
 
     def update(self, instance, validated_data):
         """update image """
@@ -192,7 +192,7 @@ class JuniorSerializer(serializers.ModelSerializer):
         model = Junior
         fields = ['id', 'auth_token', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'gender', 'dob',
                   'guardian_code', 'referral_code','is_active', 'is_complete_profile', 'created_at', 'image',
-                  'updated_at', 'user_type', 'country_name']
+                  'updated_at', 'user_type', 'country_name','is_invited']
 
 class EmailVerificationSerializer(serializers.ModelSerializer):
     """Email verification serializer"""
@@ -208,7 +208,7 @@ class DefaultTaskImagesSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = DefaultTaskImages
-        fields = ['task_name', 'image_url']
+        fields = ['id', 'task_name', 'image_url']
     def create(self, validated_data):
         data = DefaultTaskImages.objects.create(**validated_data)
         return data
@@ -225,7 +225,7 @@ class UserDeleteSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta Information"""
         model = UserDelete
-        fields = ['reason']
+        fields = ['id','reason']
     def create(self, validated_data):
         user = self.context['user']
         user_type = str(self.context['user_type'])

account/views.py

@@ -86,11 +86,21 @@ class GoogleLoginMixin:
             user_obj = User.objects.create(username=email, email=email, first_name=first_name, last_name=last_name)
             if str(user_type) == '1':
                 junior_query = Junior.objects.create(auth=user_obj, is_verified=True, is_active=True,
-                                                     image=profile_picture, signup_method='2')
+                                                     image=profile_picture, signup_method='2',
+                                                     junior_code=''.join(
+                                                         [str(random.randrange(9)) for _ in range(6)]),
+                                                     referral_code=''.join(
+                                                         [str(random.randrange(9)) for _ in range(6)])
+                                                     )
                 serializer = JuniorSerializer(junior_query)
             if str(user_type) == '2':
                 guardian_query = Guardian.objects.create(user=user_obj, is_verified=True, is_active=True,
-                                                         image=profile_picture,signup_method='2')
+                                                         image=profile_picture,signup_method='2',
+                                                         guardian_code=''.join(
+                                                             [str(random.randrange(9)) for _ in range(6)]),
+                                                         referral_code=''.join(
+                                                             [str(random.randrange(9)) for _ in range(6)])
+                                                         )
                 serializer = GuardianSerializer(guardian_query)
         # Return a JSON response with the user's email and name
         return custom_response(SUCCESS_CODE['3003'], serializer.data,
@@ -131,11 +141,18 @@ class SigninWithApple(views.APIView):
                     user = User.objects.create(**user_data)
                     if str(user_type) == '1':
                         junior_query = Junior.objects.create(auth=user, is_verified=True, is_active=True,
-                                                             signup_method='3')
+                                                             signup_method='3',junior_code=''.join(
+                                                             [str(random.randrange(9)) for _ in range(6)]),
+                                                         referral_code=''.join(
+                                                             [str(random.randrange(9)) for _ in range(6)]))
                         serializer = JuniorSerializer(junior_query)
                     if str(user_type) == '2':
                         guardian_query = Guardian.objects.create(user=user, is_verified=True, is_active=True,
-                                                                 signup_method='3')
+                                                                 signup_method='3',
+                                                                 guardian_code=''.join(
+                                                                     [str(random.randrange(9)) for _ in range(6)]),
+                                                                 referral_code=''.join(
+                                                                     [str(random.randrange(9)) for _ in range(6)]))
                         serializer = GuardianSerializer(guardian_query)
                     return custom_response(SUCCESS_CODE['3003'], serializer.data,
                                            response_status=status.HTTP_200_OK)
@@ -442,7 +459,6 @@ class DeleteUserProfileAPIViewSet(viewsets.GenericViewSet):
         user_type = str(request.data['user_type'])
         password = request.data.get('password')
         signup_method = str(request.data.get('signup_method'))
-        print("signup_method===>",signup_method,'==>',type(signup_method))
         serializer = self.get_serializer(data=request.data, context={'request': request, 'user': request.user,
                                                                      'user_type': user_type,
                                                                      'password': password,

base/messages.py

@@ -56,7 +56,8 @@ ERROR_CODE = {
     "2030": "Use correct user type and token",
     "2031": "Invalid password",
     "2032": "Failed to send email",
-    "2033": "Missing required fields"
+    "2033": "Missing required fields",
+    "2034": "Junior is not associated"
 }
 SUCCESS_CODE = {
     # Success code for password
@@ -89,7 +90,8 @@ SUCCESS_CODE = {
     "3018": "Task created successfully",
     "3019": "Support Email sent successfully",
     "3020": "Logged out successfully.",
-    "3021": "Add junior successfully"
+    "3021": "Add junior successfully",
+    "3022": "Remove junior successfully"
 }
 
 STATUS_CODE_ERROR = {

guardian/serializers.py

@@ -21,7 +21,7 @@ class UserSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = User
-        fields = ['email', 'password', 'auth_token']
+        fields = ['id', 'email', 'password', 'auth_token']
 
     def get_auth_token(self, obj):
         """generate auth token"""
@@ -72,7 +72,7 @@ class CreateGuardianSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = Guardian
-        fields = ['first_name', 'last_name', 'email', 'phone', 'family_name', 'gender', 'country_code',
+        fields = ['id', 'first_name', 'last_name', 'email', 'phone', 'family_name', 'gender', 'country_code',
                   'dob', 'referral_code', 'passcode', 'is_complete_profile', 'referral_code_used',
                   'country_name', 'image']
 
@@ -119,7 +119,7 @@ class CreateGuardianSerializer(serializers.ModelSerializer):
             """Complete profile of the junior if below all data are filled"""
             complete_profile_field = all([guardian.phone, guardian.gender, guardian.country_name,
                                           guardian.dob, guardian.country_code, user.first_name, user.last_name,
-                                          user.email, guardian.image, guardian.passcode])
+                                          user.email, guardian.image])
             guardian.is_complete_profile = False
             if complete_profile_field:
                 guardian.is_complete_profile = True
@@ -139,7 +139,7 @@ class TaskSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = JuniorTask
-        fields = ['task_name','task_description','points', 'due_date', 'junior', 'default_image']
+        fields = ['id', 'task_name','task_description','points', 'due_date', 'junior', 'default_image']
     def create(self, validated_data):
         """create default task image data"""
         validated_data['guardian'] = Guardian.objects.filter(user=self.context['user']).last()
@@ -229,7 +229,7 @@ class GuardianProfileSerializer(serializers.ModelSerializer):
     def get_complete_field_count(self, obj):
         """total filled fields count"""
         total_field_list = [obj.user.first_name, obj.user.last_name, obj.user.email, obj.country_name, obj.country_code,
-                            obj.phone, obj.gender, obj.dob, obj.image, obj.passcode]
+                            obj.phone, obj.gender, obj.dob, obj.image]
         total_complete_field = [data for data in total_field_list if data != '' and  data is not None]
         return len(total_complete_field)
 

guardian/views.py

@@ -169,6 +169,6 @@ class TopJuniorListAPIView(viewsets.ModelViewSet):
             junior.save()
 
         serializer = self.get_serializer(junior_total_points, many=True)
-        return custom_response(serializer.data, response_status=status.HTTP_200_OK)
+        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
 
 

junior/serializers.py

@@ -48,9 +48,9 @@ class CreateJuniorSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = Junior
-        fields = ['first_name', 'last_name', 'email', 'phone', 'gender', 'country_code', 'dob', 'referral_code',
+        fields = ['id', 'first_name', 'last_name', 'email', 'phone', 'gender', 'country_code', 'dob', 'referral_code',
                   'passcode', 'is_complete_profile', 'guardian_code', 'referral_code_used',
-                  'country_name', 'image']
+                  'country_name', 'image', 'is_invited']
 
     def get_first_name(self,obj):
         """first name of junior"""
@@ -100,7 +100,7 @@ class CreateJuniorSerializer(serializers.ModelSerializer):
             """Complete profile of the junior if below all data are filled"""
             complete_profile_field = all([junior.phone, junior.gender, junior.country_name, junior.image,
                                           junior.dob, junior.country_code, user.first_name, user.last_name,
-                                          user.email, junior.passcode])
+                                          user.email])
             junior.is_complete_profile = False
             if complete_profile_field:
                 junior.is_complete_profile = True
@@ -135,7 +135,7 @@ class JuniorDetailSerializer(serializers.ModelSerializer):
         """Meta info"""
         model = Junior
         fields = ['id', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'gender', 'dob',
-                  'guardian_code', 'referral_code','is_active', 'is_complete_profile', 'created_at', 'image',
+                  'guardian_code', 'is_invited', 'referral_code','is_active', 'is_complete_profile', 'created_at', 'image',
                   'updated_at']
 
 class JuniorDetailListSerializer(serializers.ModelSerializer):
@@ -202,7 +202,7 @@ class JuniorDetailListSerializer(serializers.ModelSerializer):
         fields = ['id', 'email', 'first_name', 'last_name', 'country_code', 'phone', 'gender', 'dob',
                   'guardian_code', 'referral_code','is_active', 'is_complete_profile', 'created_at', 'image',
                   'updated_at', 'assigned_task','points', 'pending_task', 'in_progress_task', 'completed_task',
-                  'requested_task', 'rejected_task', 'position']
+                  'requested_task', 'rejected_task', 'position', 'is_invited']
 
 class JuniorProfileSerializer(serializers.ModelSerializer):
     """junior serializer"""
@@ -231,12 +231,12 @@ class JuniorProfileSerializer(serializers.ModelSerializer):
 
     def get_total_count(self, obj):
         """total fields count"""
-        return 10
+        return 9
 
     def get_complete_field_count(self, obj):
         """total filled fields count"""
         field_list = [obj.auth.first_name, obj.auth.last_name, obj.auth.email, obj.country_name, obj.country_code,
-                      obj.phone, obj.gender, obj.dob, obj.image, obj.passcode]
+                      obj.phone, obj.gender, obj.dob, obj.image]
         complete_field = [data for data in field_list if data is not None and data != '']
         return len(complete_field)
     class Meta(object):
@@ -244,7 +244,8 @@ class JuniorProfileSerializer(serializers.ModelSerializer):
         model = Junior
         fields = ['id', 'email', 'first_name', 'last_name', 'country_name', 'country_code', 'phone', 'gender', 'dob',
                   'guardian_code', 'referral_code','is_active', 'is_complete_profile', 'created_at', 'image',
-                  'updated_at', 'notification_count', 'total_count', 'complete_field_count', 'signup_method']
+                  'updated_at', 'notification_count', 'total_count', 'complete_field_count', 'signup_method',
+                  'is_invited']
 
 class AddJuniorSerializer(serializers.ModelSerializer):
     """Add junior serializer"""
@@ -259,7 +260,7 @@ class AddJuniorSerializer(serializers.ModelSerializer):
     class Meta(object):
         """Meta info"""
         model = Junior
-        fields = ['gender','dob', 'relationship', 'auth_token']
+        fields = ['id', 'gender','dob', 'relationship', 'auth_token', 'is_invited']
 
 
     def create(self, validated_data):
@@ -296,3 +297,15 @@ class AddJuniorSerializer(serializers.ModelSerializer):
 
 
 
+class RemoveJuniorSerializer(serializers.ModelSerializer):
+    """User Update Serializer"""
+    class Meta(object):
+        """Meta class"""
+        model = Junior
+        fields = ('id', 'is_invited')
+    def update(self, instance, validated_data):
+        if instance:
+            instance.is_invited = False
+            instance.guardian_code = '{}'
+            instance.save()
+            return instance

junior/urls.py

@@ -1,7 +1,8 @@
 """ Urls files"""
 """Django import"""
 from django.urls import path, include
-from .views import UpdateJuniorProfile, ValidateGuardianCode, JuniorListAPIView, AddJuniorAPIView
+from .views import (UpdateJuniorProfile, ValidateGuardianCode, JuniorListAPIView, AddJuniorAPIView,
+                    InvitedJuniorAPIView, FilterJuniorAPIView, RemoveJuniorAPIView)
 """Third party import"""
 from rest_framework import routers
 
@@ -17,7 +18,12 @@ router.register('validate-guardian-code', ValidateGuardianCode, basename='valida
 router.register('junior-list', JuniorListAPIView, basename='junior-list')
 """Add junior list API"""
 router.register('add-junior', AddJuniorAPIView, basename='add-junior')
+"""Invited junior list API"""
+router.register('invited-junior', InvitedJuniorAPIView, basename='invited-junior')
+"""Filter junior list API"""
+router.register('filter-junior', FilterJuniorAPIView, basename='filter-junior')
 """Define url pattern"""
 urlpatterns = [
     path('api/v1/', include(router.urls)),
+    path('api/v1/remove-junior/', RemoveJuniorAPIView.as_view())
 ]

junior/views.py

@@ -1,9 +1,12 @@
 """Junior view file"""
-from rest_framework import viewsets, status
+from rest_framework import viewsets, status, generics,views
 from rest_framework.permissions import IsAuthenticated
+from rest_framework.pagination import PageNumberPagination
+from rest_framework.response import Response
 """Django app import"""
 from junior.models import Junior
-from .serializers import CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer
+from .serializers import (CreateJuniorSerializer, JuniorDetailListSerializer, AddJuniorSerializer,\
+                          RemoveJuniorSerializer)
 from guardian.models import Guardian
 from base.messages import ERROR_CODE, SUCCESS_CODE
 from account.utils import custom_response, custom_error_response
@@ -76,3 +79,70 @@ class AddJuniorAPIView(viewsets.ModelViewSet):
             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)
+
+class InvitedJuniorAPIView(viewsets.ModelViewSet):
+    """Junior list of assosicated guardian"""
+
+    serializer_class = JuniorDetailListSerializer
+    queryset = Junior.objects.all()
+    permission_classes = [IsAuthenticated]
+    pagination_class = PageNumberPagination
+
+    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"""
+        queryset = self.get_queryset()
+        paginator = self.pagination_class()
+        paginated_queryset = paginator.paginate_queryset(queryset, request)
+        serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
+        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+
+
+class FilterJuniorAPIView(viewsets.ModelViewSet):
+    """Update guardian profile"""
+    serializer_class = JuniorDetailListSerializer
+    permission_classes = [IsAuthenticated]
+    pagination_class = PageNumberPagination
+    queryset = Junior.objects.all()
+
+    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()
+        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"""
+        queryset = self.get_queryset()
+        paginator = self.pagination_class()
+        paginated_queryset = paginator.paginate_queryset(queryset, request)
+        serializer = JuniorDetailListSerializer(paginated_queryset, many=True)
+        return custom_response(None, serializer.data, response_status=status.HTTP_200_OK)
+
+
+class RemoveJuniorAPIView(views.APIView):
+    """Eater Update API"""
+    serializer_class = RemoveJuniorSerializer
+    model = Junior
+    permission_classes = [IsAuthenticated]
+
+    def put(self, request, format=None):
+        junior_id = self.request.GET.get('id')
+        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),
+                                                is_invited=True).last()
+        if junior_queryset:
+            serializer = RemoveJuniorSerializer(junior_queryset, data=request.data, partial=True)
+            if serializer.is_valid():
+                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)

zod_bank/settings.py

@@ -154,10 +154,6 @@ AUTH_PASSWORD_VALIDATORS = [
     },
 ]
 
-JWT_AUTH = {
-    # Other JWT authentication settings
-    'JWT_AUTHENTICATION': 'your_app.authentication.CustomJWTAuthentication',
-}
 
 # Internationalization
 # https://docs.djangoproject.com/en/3.0/topics/i18n/