Pagination - I

apps/jobs/views.py

@@ -1,8 +1,10 @@
 import jwt
 import uuid
 from re import search
+from django.db.models import Count
 import django.core.exceptions
 from django.db.utils import IntegrityError
+from django.core.paginator import Paginator, PageNotAnInteger, EmptyPage
 from django_filters.rest_framework import DjangoFilterBackend
 from rest_framework import status, viewsets
 from rest_framework.decorators import action
@@ -72,13 +74,26 @@ def list(self, request):
         except django.core.exceptions.ValidationError as err:
             return response.create_response(err.messages, status.HTTP_404_NOT_FOUND)
         else:
+            # Use Paginator for the queryset
+            page_number = request.GET.get("page", 1)
+            paginator = Paginator(jobs_data, 5)  # 5 items per page
+
+            try:
+                jobs_data = paginator.page(page_number)
+            except PageNotAnInteger:
+                jobs_data = paginator.page(1)
+            except EmptyPage:
+                return response.create_response([], status.HTTP_200_OK)
+
             serialized_job_data = self.serializer_class(
                 jobs_data, many=True, context={"request": request}
             )
 
             # get number of applicants
             if serialized_job_data:
-                serialized_job_data = JobViewSets.get_number_of_applicants(serialized_job_data)
+                serialized_job_data = JobViewSets.get_number_of_applicants(
+                    serialized_job_data
+                )
 
             return response.create_response(
                 serialized_job_data.data, status.HTTP_200_OK
@@ -129,7 +144,6 @@ def details(self, request, *args, **kwargs):
             )
         return response.create_response(serialized_job_data.data, status.HTTP_200_OK)
 
-
     @staticmethod
     def get_number_of_applicants(serialized_data):
         """
@@ -153,7 +167,7 @@ def get_number_of_applicants(serialized_data):
             jobdata.update({"Number of Applicants": number_of_applicants})
 
         return serialized_data
-    
+
     @staticmethod
     def get_active_jobs_count(serialized_company_data):
         """
@@ -162,10 +176,12 @@ def get_active_jobs_count(serialized_company_data):
         """
 
         for company in serialized_company_data.data:
-                jobs_belong_to_company = Job.objects.filter(company_id=company.get("company_id"))
-                active_jobs = sum(1 for job in jobs_belong_to_company if job.is_active)
-                company.update({"Active Jobs": active_jobs})
-
+            jobs_belong_to_company = Job.objects.filter(
+                company_id=company.get("company_id")
+            )
+            active_jobs = sum(1 for job in jobs_belong_to_company if job.is_active)
+            company.update({"Active Jobs": active_jobs})
+
         return serialized_company_data
 
     @action(detail=True, methods=["get"])
@@ -319,38 +335,148 @@ def featured_jobs(self, request):
         """
 
         # past 3 weeks datetime specified for featured jobs (can be modified as per use)
-        past_3_weeks_datetime = datetime_safe.datetime.now(tz=timezone.utc) - timedelta(days=18)
+        past_3_weeks_datetime = datetime_safe.datetime.now(tz=timezone.utc) - timedelta(
+            days=18
+        )
 
         # get the jobs_data and sort it in DESC order
         # `-` with column name indicates to return the result in DESC order
         try:
             jobs_data = Job.objects.filter(
-                created_at__gt=past_3_weeks_datetime,
-                is_active=True
+                created_at__gt=past_3_weeks_datetime, is_active=True
             ).order_by("-created_at")
 
             jobs_posted_within_3_weeks = JobSerializer(jobs_data, many=True)
 
             # find out how many jobs were posted within past_3_weeks
-            jobs_posted_within_3_weeks = JobViewSets.get_number_of_applicants(jobs_posted_within_3_weeks)
+            jobs_posted_within_3_weeks = JobViewSets.get_number_of_applicants(
+                jobs_posted_within_3_weeks
+            )
 
             # find 5 jobs with maximum number of applicants
             featured_jobs = sorted(
                 jobs_posted_within_3_weeks.data,
-                key=lambda k: (k.get('Number of Applicants')),
-                reverse=True
+                key=lambda k: (k.get("Number of Applicants")),
+                reverse=True,
             )
 
+            return response.create_response(featured_jobs[0:5], status.HTTP_200_OK)
+        except Exception:
             return response.create_response(
-                featured_jobs[0:5],
-                status.HTTP_200_OK
+                response.SOMETHING_WENT_WRONG, status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    @action(detail=False, methods=["get"])
+    def get_posted_jobs(self, request):
+        """
+        API: localhost:8000/jobs/get_posted_jobs/
+        This method returns a list of jobs where is_posted is True.
+        """
+
+        # Get only posted jobs
+        posted_jobs_data = Job.objects.filter(posted=True)
+        page_number = request.GET.get("page", 1)  # used paginator for queryset
+        paginator = Paginator(posted_jobs_data, 2)  # per page 2 items
+
+        try:
+            posted_jobs_data = paginator.page(page_number)
+        except PageNotAnInteger:
+            posted_jobs_data = paginator.page(1)
+        except EmptyPage:
+            return response.create_response([], status.HTTP_200_OK)
+
+        serialized_posted_jobs_data = self.serializer_class(
+            posted_jobs_data, many=True, context={"request": request}
+        )
+
+        # Add number of applicants to the serialized data
+        if serialized_posted_jobs_data:
+            serialized_posted_jobs_data = JobViewSets.get_number_of_applicants(
+                serialized_posted_jobs_data
             )
-        except Exception:
             return response.create_response(
-                response.SOMETHING_WENT_WRONG,
-                status.HTTP_500_INTERNAL_SERVER_ERROR
+                serialized_posted_jobs_data.data, status.HTTP_200_OK
             )
 
+    @action(detail=False, methods=["get"])
+    def get_job_categories(self, request):
+        """
+        API: /api/v1/jobs/get_job_categories/
+        This method returns a list of distinct job categories.
+        If a 'category' parameter is provided in the query string,
+        it filters jobs by the specified category.
+        """
+
+        # Check if 'category' parameter is provided in the query string
+        category = request.query_params.get("category", None)
+
+        if category:
+            # Filter jobs by the specified category
+            jobs_data = Job.objects.filter(category=category)
+            serialized_jobs_data = JobSerializer(
+                jobs_data, many=True, context={"request": request}
+            )
+            return response.create_response(
+                serialized_jobs_data.data, status.HTTP_200_OK
+            )
+        else:
+            # Get distinct job categories
+            job_categories = Job.objects.values_list("category", flat=True).distinct()
+            serialized_job_categories = list(job_categories)
+
+            return response.create_response(
+                serialized_job_categories, status.HTTP_200_OK
+            )
+
+    @action(detail=False, methods=["get"])
+    def get_jobs(self, request):
+        """
+        API: /api/v1/jobs/get_jobs/
+        This method retrieves jobs based on dynamic filters such as
+        category, job type, experience, and qualification provided in the query parameters.
+        It also includes the count of active jobs for each filter.
+        """
+
+        # Extract filters from query parameters
+        filters = {}
+        category = request.query_params.get("category", None)
+        job_type = request.query_params.get("job_type", None)
+        experience = request.query_params.get("experience", None)
+        qualification = request.query_params.get("qualification", None)
+
+        if category:
+            filters["category"] = category
+        if job_type:
+            filters["job_type"] = job_type
+        if experience:
+            filters["experience__gte"] = int(
+                experience
+            )  # Filter jobs with experience greater than or equal to specified value
+        if qualification:
+            filters[
+                "qualifications__icontains"
+            ] = qualification  # Case-insensitive search for qualifications
+
+        # Get the filtered jobs
+        filtered_jobs_data = Job.objects.filter(**filters, is_active=True)
+
+        # If no jobs match the filters, return a specific response
+        if not filtered_jobs_data.exists():
+            return response.create_response(
+                "Sorry, currently no jobs available as per your request",
+                status.HTTP_200_OK,
+            )
+
+        # Serialize the filtered job data
+        serialized_filtered_jobs_data = JobSerializer(
+            filtered_jobs_data, many=True
+        ).data
+
+        return response.create_response(
+            serialized_filtered_jobs_data, status.HTTP_200_OK
+        )
+
+
 class UserViewSets(viewsets.ModelViewSet):
     """
     User object viewsets
@@ -498,16 +624,16 @@ def update(self, request, *args, **kwargs):
                 UserSerializer(user_data).data, status.HTTP_200_OK
             )
 
-    @action(detail=False, methods=['get'])
+    @action(detail=False, methods=["get"])
     def get_profile_details(self, request):
         """
         API: /api/v1/user/myProfile
-        Returns user profile data in the response. 
+        Returns user profile data in the response.
         This method gets the user_id from "access-token".
         """
-        
+
         # Get the value from Access-Token header
-        if access_token:=request.headers.get(response.ACCESS_TOKEN, None):
+        if access_token := request.headers.get(response.ACCESS_TOKEN, None):
             try:
                 # decode JWT Token; for any issues with it, raise an exception
                 decoded_user_access_token = jwt.decode(
@@ -516,29 +642,25 @@ def get_profile_details(self, request):
                 user_id = decoded_user_access_token.get(values.USER_ID, None)
                 if not user_id:
                     raise Exception
-                
+
                 # get user data
                 user_data = self.queryset.filter(user_id=user_id)
                 if user_data:
                     serialized_user_data = self.serializer_class(user_data, many=True)
                     return response.create_response(
-                        serialized_user_data.data,
-                        status.HTTP_200_OK
+                        serialized_user_data.data, status.HTTP_200_OK
                     )
                 else:
                     return response.create_response(
-                        response.USER_DATA_NOT_PRESENT,
-                        status.HTTP_404_NOT_FOUND
+                        response.USER_DATA_NOT_PRESENT, status.HTTP_404_NOT_FOUND
                     )
             except Exception:
                 return response.create_response(
-                    response.ACCESS_TOKEN_NOT_VALID,
-                    status.HTTP_400_BAD_REQUEST
+                    response.ACCESS_TOKEN_NOT_VALID, status.HTTP_400_BAD_REQUEST
                 )
         else:
             return response.create_response(
-                response.ACCESS_TOKEN_NOT_PRESENT,
-                status.HTTP_401_UNAUTHORIZED
+                response.ACCESS_TOKEN_NOT_PRESENT, status.HTTP_401_UNAUTHORIZED
             )
 
     @action(detail=True, methods=["get"])
@@ -619,7 +741,7 @@ class CompanyViewSets(viewsets.ModelViewSet):
 
     def list(self, request):
         """
-        Method to return a list of companies available, 
+        Method to return a list of companies available,
         Along with the count of active jobs present in the company
         """
 
@@ -630,17 +752,18 @@ def list(self, request):
 
             # get number of applicants
             if serialized_company_data:
-                serialized_company_data = JobViewSets.get_active_jobs_count(serialized_company_data)
+                serialized_company_data = JobViewSets.get_active_jobs_count(
+                    serialized_company_data
+                )
 
             return response.create_response(
                 serialized_company_data.data, status.HTTP_200_OK
             )
         except Exception:
             return response.create_response(
-                response.SOMETHING_WENT_WRONG,
-                status.HTTP_500_INTERNAL_SERVER_ERROR
+                response.SOMETHING_WENT_WRONG, status.HTTP_500_INTERNAL_SERVER_ERROR
             )
-    
+
     def retrieve(self, request, pk=None):
         """
         retrieve the data of given company id
@@ -657,12 +780,15 @@ def retrieve(self, request, pk=None):
             company_data = Company.objects.filter(company_id=pk)
             serialized_company_data = self.serializer_class(company_data, many=True)
             if serialized_company_data:
-                serialized_company_data = JobViewSets.get_active_jobs_count(serialized_company_data)
-            return response.create_response(serialized_company_data.data, status.HTTP_200_OK)
+                serialized_company_data = JobViewSets.get_active_jobs_count(
+                    serialized_company_data
+                )
+            return response.create_response(
+                serialized_company_data.data, status.HTTP_200_OK
+            )
         except Exception:
             return response.create_response(
-                response.SOMETHING_WENT_WRONG,
-                status.HTTP_500_INTERNAL_SERVER_ERROR
+                response.SOMETHING_WENT_WRONG, status.HTTP_500_INTERNAL_SERVER_ERROR
             )
 
     @action(detail=False, methods=["get"])
@@ -751,4 +877,4 @@ def list(self, request, *args, **kwargs):
             else:
                 return super().list(request, *args, **kwargs)
         else:
-            return super().list(request, *args, **kwargs)
+            return super().list(request, *args, **kwargs)