def get_paginated(queryset, request, to_dict, limit=10): paginator = LimitOffsetPagination() paginator.max_limit = 50 paginator.default_limit = limit paginator.offset = 0 obj_list = paginator.paginate_queryset( queryset, request ) results = to_dict(obj_list) next_link = paginator.get_next_link() prev_link = paginator.get_previous_link() if next_link: next_link = next_link.split('?')[1] if prev_link: prev_link = prev_link.split('?')[1] data = { 'results': results, 'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'next': next_link, 'prev': prev_link, } # print(json.dumps(data)) return data
def list(self, request, username=None): """Lists all addresses the user has. Arguments: request: the request data sent by the user, it is used to check the user's permissions and in Pagination username: the username of the user profile whose addresses will be returned Returns: HTTP 403 Response if the user is not authorized to see that user's addresses, HTTP 404 if user profile is not found, HTTP 200 Response with all addresses in the user's profile in JSON. """ user = get_object_or_404(UserProfileModel, account__username=username) self.check_object_permissions(request, user) queryset = user.addresses.all() paginator = LimitOffsetPagination() paginator.default_limit = 10 paginator.max_limit = 100 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = self.serializer_class(paginated_queryset, many=True) return Response(data={'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'addresses': serializer.data})
def list(self, request, username=None): """Lists all reviews the driver has. Arguments: request: the request data sent by the user, it is used for Pagination username: the username of the driver profile whose reviews will be returned Returns: HTTP 404 if driver profile is not found, HTTP 200 Response with all reviews in the driver's profile in JSON. """ driver = get_object_or_404(DriverProfileModel, account__username=username) queryset = driver.reviews.all() paginator = LimitOffsetPagination() paginator.default_limit = 25 paginator.max_limit = 100 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = DriverReviewSerializer(paginated_queryset, many=True) return Response( data={ 'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'reviews': serializer.data })
def list(self, request, shop_slug=None): queryset = ProductGroupModel.objects.filter(shop__slug=shop_slug) best_selling_queryset = ProductModel.objects.filter( shop__slug=shop_slug, is_available=True, num_sold__gt=0).order_by('num_sold') best_selling_serializer = ProductSerializer(best_selling_queryset[:5], many=True) offers_queryset = ProductModel.objects.filter(shop__slug=shop_slug, is_offer=True, is_available=True) offers_serializer = ProductSerializer(offers_queryset, many=True) paginator = LimitOffsetPagination() paginator.default_limit = 5 paginator.max_limit = 10 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = ProductGroupSerializer(paginated_queryset, many=True) return Response( data={ 'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'offers': offers_serializer.data, 'best_selling': best_selling_serializer.data, 'groups': serializer.data })
def list(self, request): """Lists all orders the user has. Arguments: request: the request data sent by the user, it is used for Pagination Returns: HTTP 403 if user is not authenticated HTTP 200 Response with all orders in JSON. """ queryset = None if hasattr(request.user, 'profile'): queryset = request.user.profile.orders.all() # this is a regular user if hasattr(request.user, 'driver_profile'): queryset = request.user.driver_profile.served_orders.all() # this is a driver if hasattr(request.user, 'shop_profile'): queryset = request.user.shop_profile.served_orders.all() # this is a shop paginator = LimitOffsetPagination() paginator.default_limit = 15 paginator.max_limit = 100 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = OrderSerializer(paginated_queryset, many=True) return Response(data={'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'orders': serializer.data})
def list(self, request): """get users list Args: request ([type]): [description] Returns: [type]: [description] """ if self.request.user.is_superuser: search = request.query_params.get('search', None) if search is not None: query = Q(first_name__icontains=search) | Q( last_name__icontains=search) | Q( email__icontains=search) | Q(phone__icontains=search) if search.lower() == "yes": search = True query = query | Q(is_verified__icontains=search) | Q( is_active__icontains=search) elif search.lower() == "no": search = False query = query | Q(is_verified__icontains=search) | Q( is_active__icontains=search) elif search.lower() == "admin": search = True query = query | Q(is_staff__icontains=search) elif search.lower() == "staff": search = False query = query | Q(is_staff__icontains=search) queryset = User.objects.filter(query).order_by( 'id').reverse().values() else: queryset = User.objects.all().order_by('id').reverse().values() if request is not None: paginator = LimitOffsetPagination() paginator.max_limit = 100 paginator.default_limit = 20 user = paginator.paginate_queryset(queryset, request) limit = paginator.limit if isinstance(limit, list): limit = limit[0] offset = paginator.offset count = paginator.count res = { "Success": True, "ExceptionString": "Record Found.", "results": user, "count": count, "limit": limit, "offset": offset } return Response(res, status.HTTP_200_OK) else: res = {"Success": False, "results": []} return Response(res, status.HTTP_401_UNAUTHORIZED)
def list(request): """List transactions for all users :param request: Request send from the client :return: Response """ paginator = LimitOffsetPagination() paginator.max_limit = 250 paginator.default_limit = 100 transactions = paginator.paginate_queryset(Transaction.objects.all(), request) return Response(data={'entries': [x.to_dict() for x in transactions], 'limit': paginator.limit, 'offset': paginator.offset, 'overall_count': paginator.count}, status=status.HTTP_200_OK)
def list(request) -> Response: """List users :param request: HTTP Request :return: Response """ paginator = LimitOffsetPagination() paginator.max_limit = 250 paginator.default_limit = 100 users = paginator.paginate_queryset(User.objects.filter(active=True), request) return Response( data={'entries': [x.to_dict() for x in users], 'limit': paginator.limit, 'offset': paginator.offset, 'overall_count': paginator.count}, status=status.HTTP_200_OK)
def list(self, request, shop_slug=None, product_slug=None): queryset = ProductReviewModel.objects.filter( product__shop__slug=shop_slug, product__slug=product_slug).all() paginator = LimitOffsetPagination() paginator.default_limit = 25 paginator.max_limit = 100 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = ProductReviewSerializer(paginated_queryset, many=True) return Response( data={ 'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'reviews': serializer.data })
def list(request, user_pk=None) -> Response: """List transactions for a single user :param request: Request send from the client :param user_pk: Primary key to identify a user :return: Response """ try: user = User.objects.get(id=user_pk) except User.DoesNotExist: return Response(data={'msg': 'user {} not found'.format(user_pk)}, status=status.HTTP_404_NOT_FOUND) paginator = LimitOffsetPagination() paginator.max_limit = 250 paginator.default_limit = 100 transactions = paginator.paginate_queryset(Transaction.objects.filter(user=user), request) return Response(data={'entries': [x.to_dict() for x in transactions], 'limit': paginator.limit, 'offset': paginator.offset, 'overall_count': paginator.count}, status=status.HTTP_200_OK)
def list(self, request): """Lists all available driver profiles near a certain location Arguments: request: the request data sent by the user, it is used to get the queries entered by user, and for Pagination Returns: returns HTTP 200 Response with the drivers' JSON data. if there are no coordinates given will return 400 Response. """ try: user_longitude = float(request.GET.get('longitude')) user_latitude = float(request.GET.get('latitude')) except Exception: return Response("invalid coordinates", status=status.HTTP_400_BAD_REQUEST) min_active_time = timezone.now() - timezone.timedelta(seconds=10) queryset = DriverProfileModel.objects.annotate(distance=haversine( user_latitude, user_longitude, F('live_location_latitude'), F('live_location_longitude'))).filter( distance__lte=2.5, is_busy=False, last_time_online__gte=min_active_time, is_active=True, is_available=True).order_by('distance') paginator = LimitOffsetPagination() paginator.default_limit = 10 paginator.max_limit = 100 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = DriverProfileSerializer(paginated_queryset, many=True) return Response( data={ 'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'drivers': serializer.data })
def list(self, request): try: user_longitude = float(request.GET.get('longitude')) user_latitude = float(request.GET.get('latitude')) shop_type = request.GET.get('type') search = request.GET.get('search') except Exception: return Response("invalid coordinates", status=status.HTTP_400_BAD_REQUEST) queryset = ShopProfileModel.objects.annotate(distance=haversine( user_latitude, user_longitude, F('address__location_latitude'), F('address__location_longitude'))).filter( distance__lte=2.5, is_open=True, is_active=True, opens_at__lte=timezone.now(), closes_at__gt=timezone.now()).order_by('distance') if shop_type: queryset = queryset.filter(shop_type__iexact=shop_type) if search: queryset_temp1 = queryset.filter(name__icontains=search) queryset_temp2 = queryset.filter( tags__tag__icontains=search).exclude(name__icontains=search) queryset = list(chain(queryset_temp1, queryset_temp2)) paginator = LimitOffsetPagination() paginator.default_limit = 25 paginator.max_limit = 100 paginated_queryset = paginator.paginate_queryset(queryset, request) serializer = ShopProfileSerializer(paginated_queryset, many=True) return Response( data={ 'limit': paginator.limit, 'offset': paginator.offset, 'count': paginator.count, 'shops': serializer.data })