def get(self, request, *args, **kwargs): parameters = request.GET user = request.user if not user.is_authenticated: return self.err_res.UNAUTHORIZED limit = parameters.get('limit') if limit is not None: if not 10 <= int(limit) <= 100: return self.err_res.BAD_PAGINATION type_id = parameters.get('report_type_id') paginator = LimitOffsetPagination() report_dal = ReportDal() if type_id is None: query_data = paginator.paginate_queryset( self.report_dal.get_all(sorted_by='report_time'), request ) else: query_data = paginator.paginate_queryset( report_dal.get_by_type(type_id, sorted_by='report_time'), request ) reports_data = ReportDeepSerializer(query_data, many=True).data if not reports_data: return self.err_res.REPORT_NOT_FOUND return paginator.get_paginated_response(reports_data)
def streams(self, request, pk=None): streamer = self.get_object() streams = streamer.streams.all() paginator = LimitOffsetPagination() paginator.paginate_queryset(streams, request) serializer = StreamSerializer(streams, many=True) return paginator.get_paginated_response(serializer.data)
def get(self, request): """GET request for the list the history of purchases of the shop.""" purchases = Purchase.objects.annotate(num_orders=Count('orders'))\ .filter(num_orders__gt=0) paginator = LimitOffsetPagination() result_page = paginator.paginate_queryset(purchases, request) return Response(self.serializer_class(result_page, many=True).data)
def leaderboard(request, task_id, cluster): if request.user.is_staff: task = get_object_or_404(Task, pk=task_id) else: task = get_object_or_404(Task.objects.filter(scores_published=True), pk=task_id) paginator = LimitOffsetPagination() paginator.default_limit = paginator.max_limit = 200 if cluster == 'approach': submission_ids = submissions_by_approach(task.id) elif cluster == 'team': submission_ids = submissions_by_team(task.id) else: raise Http404() leaderboard_submissions = (Submission.objects.select_related( 'approach', 'approach__team').filter(id__in=submission_ids).order_by( '-overall_score', 'created')) result_page = paginator.paginate_queryset(leaderboard_submissions, request) serializer = LeaderboardEntrySerializer(result_page, many=True, context={'request': request}) return paginator.get_paginated_response(serializer.data)
def get_object(self): """ Get a all record of the JobCatalog available on the system having status to be active. :return: :rtype: """ try: q_object = self.make_complex_query_set() order_by_list = self.make_order_by_combination() if q_object: obj = JobCatalog.objects.filter(q_object).distinct() else: obj = JobCatalog.objects.all() if order_by_list: obj = obj.order_by(*order_by_list) # Retrieving Data paginator = LimitOffsetPagination() results = paginator.paginate_queryset(obj, self.request) return results except JobCatalog.DoesNotExist: raise Http404
def restaurant_list(request): paginator = LimitOffsetPagination() paginator.page_size = 15 rests = Restaurants.objects.all() result_page = paginator.paginate_queryset(rests, request) serializer = RestaurantModelSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
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 get(self, request, *args, **kwargs): data = request.data paginator = LimitOffsetPagination() if 'user' not in data: return Response({'message': 'Please enter the user name'}, status=HTTP_400_BAD_REQUEST) try: user_obj = User.objects.get(username=data['user']) except: return Response({'message': 'The given user does not exist'}, status=HTTP_400_BAD_REQUEST) queryset = Recipe.objects.filter(user=user_obj.id) if queryset.count() > 0: context = paginator.paginate_queryset(queryset, request) serializer = RecipeRetrieveSerializer(context, many=True) return paginator.get_paginated_response(serializer.data) else: return Response( {'message': 'There are no recipes for the given ' 'user'}, status=HTTP_200_OK)
def productList(request): paginator = LimitOffsetPagination() paginator.page_size = 10 prods = Product.objects.all() result_page = paginator.paginate_queryset(prods, request) serializer = ProductSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def most_active(self, request): """ Returns parliamentarians in votes count order. """ most_active = ParliamentaryVote.objects.filter( Q(option='Y') | Q(option='N') ).values('parliamentary').annotate( votes=Count('option') ).order_by('-votes', 'parliamentary__name') for parliamentary in most_active: parliamentary_obj = Parliamentary.objects.get( id=parliamentary['parliamentary'] ) parliamentary['parliamentary'] = ParliamentarySerializer( parliamentary_obj ).data paginator = LimitOffsetPagination() page = paginator.paginate_queryset(most_active, request) if page is not None: return paginator.get_paginated_response(page) return Response(most_active)
def search(self, request): """This action returns result of a search request using cache""" paginator = LimitOffsetPagination() paginator.page_size = 20 data = request.data search_serializer = SearchSerializer(data=data) if search_serializer.is_valid(raise_exception=True): code = search_serializer.validated_data['code'].lower() if code in cache: result = cache.get(code) return Response(result) else: cities, all_cities = search_cities(code) page = paginator.paginate_queryset(all_cities, request) serializer = CityDetailedSerializer(page, many=True, context={ "code": code, "cities": cities }) result = serializer.data cache.set(code, result, timeout=CACHE_TTL) return paginator.get_paginated_response(result)
def most_compatible(self, request): """ Returns parliamentarians in compatibility order. """ extended_user = ExtendedUser.objects.get(user=request.user) if extended_user.should_update: update_compatibility(self) extended_user.should_update = False extended_user.save() compatibilities = request.user.compatibilities.all().order_by( '-compatibility' ) compatibilities_list = list() for compatibility in compatibilities: compatibility_serialized = CompatibilitySerializer( compatibility ).data del compatibility_serialized['user'] compatibility_serialized['compatibility'] = \ round(compatibility_serialized['compatibility'], 2) compatibilities_list.append(compatibility_serialized) paginator = LimitOffsetPagination() page = paginator.paginate_queryset(compatibilities_list, request) if page is not None: return paginator.get_paginated_response(page) return Response(compatibilities_list)
def get(self, request): paginator = LimitOffsetPagination() transactions = Transaction.objects.all() result_page = paginator.paginate_queryset(transactions, request) serializer = TransactionSerializer(result_page, many=True) return_data = paginator.get_paginated_response(serializer.data) return return_data
def bank_details(request): """ Endpoint to fetch the bank details params: search_query(q) """ try: paginator = LimitOffsetPagination() search_term = request.GET['q'] or '' bank_details_object = BankBranches.objects.filter( ( Q(branch__icontains= search_term) | Q(ifsc__icontains=search_term) | Q(city__icontains=search_term) | Q(district__icontains=search_term) | Q(state__icontains=search_term) | Q(bank_name__icontains=search_term) | Q(ifsc__icontains=search_term) | Q(address__icontains=search_term) ) ).order_by('ifsc') result_page = paginator.paginate_queryset(bank_details_object, request) file_obj = BankSerializer(result_page, many=True) return Response( { 'message': 'Bank details retrieved successfully!', 'data': file_obj.data }, status=status.HTTP_200_OK) except BankBranches.DoesNotExist: return Response({'message': 'No matching data found for the search entries!'}, status=status.HTTP_404_NOT_FOUND) except Exception as e: return Response({'message': str(e)}, status=status.HTTP_404_NOT_FOUND)
def get(self, request, *args, **kwargs): if "owner" in request.GET: get_data = request.query_params image = Image.objects.filter( owner=get_data['owner'], viewable='True').order_by('timestamp').reverse() else: image = Image.objects.filter( viewable='True').all().order_by('timestamp').reverse() if "checked" in request.GET: get_data = request.query_params image = Image.objects.filter( checked='False').all().order_by('timestamp').reverse() pagenator = LimitOffsetPagination() result_page = pagenator.paginate_queryset(image, request) serializer = ImageSerializer(result_page, many=True) response = { 'message': 'get image', 'result': serializer.data, "next": remove_query_param(pagenator.get_next_link(), '') } reset_queries() return Response(response, status=status.HTTP_200_OK)
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 stores(request): """Return list of stores ordered by postcode and name. This uses limitofsetpagination so that it can serve for both backend task and frontend task. Using limit result set can be limited to the any number. Three suggestion can be load as user type in and same result can be used to display first result, and for lazy load there can be another call without specifiying limit. Example Response: [{ 'name': 'St_Albans', 'postcode': 'AL12RJ', 'latitude': '51.741753', 'longitude': '-0.341337', }] """ search = request.GET.get('search') paginator = LimitOffsetPagination() queryset = Store.objects.all() if search: queryset = queryset.filter( Q(name__contains=search) or Q(postcode__contains=search)) queryset = queryset.order_by('postcode', 'name') if request.GET.get('limit'): page = paginator.paginate_queryset(queryset) if page is not None: serializer = StoreSerializer(page, many=True) return paginator.get_paginated_response(serializer.data) else: queryset = queryset.order_by('name') serializer = StoreSerializer(queryset, many=True) return Response(serializer.data)
def get(self, request): def process_data(x): pid = x.get('id') userid = request.user.id statusset = Status.objects.filter(problem=pid, owner=userid) if statusset.count() == 0: x['score'] = -1 else: x['score'] = statusset.aggregate(Max('score'))['score__max'] x.pop('id') # Don't Leak ID in DataBase return x problem_filter = {} data = request.GET if not request.user.has_perm('problem.view_hidden'): problem_filter['enabled'] = True if data.get('title'): problem_filter['title__icontains'] = data.get('title') queryset = Problem.objects.filter(**problem_filter).order_by('pid') pg = LimitOffsetPagination() problems = pg.paginate_queryset(queryset=queryset, request=request, view=self) ps = ProblemListSerializer(problems, many=True) return Response( {'count': queryset.count(), 'res': [process_data(x) for x in ps.data]}, status=status.HTTP_200_OK )
def get(self, request, *args, **kwargs): roles = Role.objects.all() # 分页实例 # 1. # pagination = PageNumberPagination() # page参数:页码,size参数:单页数据量 # pagination = MyPageNumberPagination() # 2. pagination = LimitOffsetPagination() # offset参数:起始数据的索引,limit参数:单页面限定展示的数据量 # pagination = MyLimitOffsetPagination() # 3. # pagination = CursorPagination() # pagination = MyCursorPagination() # 传入 queryset 、 请求 对象 和 视图对象(也就是当前视图对象,self)(可写可不写) pager_roles = pagination.paginate_queryset(queryset=roles, request=request, view=self) # 序列化分页后的数据 # serializer = RoleSerializer(instance=pager_roles, many=True) serializer = RoleSerializer2(instance=pager_roles, many=True) # return Response(data=serializer.data) # 返回分页自动生成的响应,第1、2种可以适用两种返回形式,第3种分页,只适合以下返回形式 return pagination.get_paginated_response(data=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 get(self, request): # Status List def process(x): problem = Problem.objects.get(id=x['problem']) x['problem'] = problem.pid return x status_filter = {} data = request.GET if data.get('problem') is not None: status_filter['problem'] = get_object_or_404( Problem, pid=data['problem']).id if data.get('lang') is not None: status_filter['lang'] = data['lang'] if data.get('owner') is not None: status_filter['owner'] = data['owner'] queryset = Status.objects.filter(**status_filter).order_by('-id') pg = LimitOffsetPagination() statuses = pg.paginate_queryset(queryset=queryset, request=request, view=self) ss = StatusListSerializer(statuses, many=True) return Response( { 'count': queryset.count(), 'res': [process(x) for x in ss.data] }, status=status.HTTP_200_OK)
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 categoryList(request): paginator = LimitOffsetPagination() paginator.page_size = 10 cats = Category.objects.all() result_page = paginator.paginate_queryset(cats, request) serializer = CategorySerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def get(self, request): humans = Human.objects.all().order_by('created_at') paginator = LimitOffsetPagination() result_page = paginator.paginate_queryset(humans, request) serializer = HumanSerializer(result_page, many=True, context={'request':request}) response = Response(serializer.data, status=status.HTTP_200_OK) return response
def get(self, req): items = Item.objects.filter(on_sale=True).order_by('-date_posted') paginator = LimitOffsetPagination() paginated_items = paginator.paginate_queryset(items, req) # serialized = ItemSerializer(paginated_items, many=True).data serialized = [i.to_json() for i in paginated_items] return Response({'items': serialized})
def order_list(request): paginator = LimitOffsetPagination() paginator.page_size = 15 orders = Order.objects.all() result_page = paginator.paginate_queryset(orders, request) serializer = OrderModelSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def most_followed(self, request): """ Returns parliamentarians in followers count order. """ most_followed = Parliamentary.objects.values('id').annotate( followers=Count('followers') ).order_by('-followers', 'name') for parliamentary in most_followed: parliamentary_obj = Parliamentary.objects.get( id=parliamentary['id'] ) del parliamentary['id'] parliamentary['parliamentary'] = ParliamentarySerializer( parliamentary_obj ).data """ Returns the most followed parliamentary. """ paginator = LimitOffsetPagination() page = paginator.paginate_queryset(most_followed, request) if page is not None: return paginator.get_paginated_response(page) return Response(most_followed)
def get_posts_for_stream(request): stream_id = request.data.get('streamId') if not stream_id: return Response({'details': { 'required_fields': ['streamId'] }}, status=status.HTTP_400_BAD_REQUEST) try: stream = Stream.objects.get(pk=stream_id) except Stream.DoesNotExist: raise Http404 except ValidationError: return Response({'details': { 'required field as UUID': ['streamId'] }}, status=status.HTTP_400_BAD_REQUEST) profiles = ProfileFollow.objects.filter(stream=stream.id).values('profile') posts = Post.objects.filter(owner__in=profiles) paginator = LimitOffsetPagination() paginator.default_limit = 12 result_page = paginator.paginate_queryset(posts, request) serializer = PostSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def get(self, request): paginator = LimitOffsetPagination() statement_files = StatementFile.objects.all() result_page = paginator.paginate_queryset(statement_files, request) serializer = StatementFileSerializer(result_page, many=True) return_data = paginator.get_paginated_response(serializer.data) return return_data
def brandList(request): paginator = LimitOffsetPagination() paginator.page_size = 10 brands = Brand.objects.all() result_page = paginator.paginate_queryset(brands, request) serializer = BrandSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
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 get_assets(self, obj): paginator = LimitOffsetPagination() paginator.default_limit = 10 page = paginator.paginate_queryset( queryset=obj.assets.all(), request=self.context.get('request', None) ) serializer = AssetUrlListSerializer( page, many=True, read_only=True, context=self.context) return OrderedDict([ ('count', paginator.count), ('next', paginator.get_next_link()), ('previous', paginator.get_previous_link()), ('results', 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 get_children(self, obj): paginator = LimitOffsetPagination() paginator.default_limit = 10 queryset = CollectionChildrenQuerySet(obj).select_related( 'owner', 'parent' ).prefetch_related( 'permissions', 'permissions__permission', 'permissions__user', 'permissions__content_object', ).all() page = paginator.paginate_queryset( queryset=queryset, request=self.context.get('request', None) ) serializer = CollectionChildrenSerializer( page, read_only=True, many=True, context=self.context) return OrderedDict([ ('count', paginator.count), ('next', paginator.get_next_link()), ('previous', paginator.get_previous_link()), ('results', serializer.data) ])
def get(self, request, institute, format=None): query_set = Post.objects.filter(institute=institute) paginator = LimitOffsetPagination() result_page = paginator.paginate_queryset(query_set, request) serializer = PostSerializer(result_page, many=True) return Response(serializer.data)
def get(self, request, format=None): query_set = Post.objects.filter(user=request.user) paginator = LimitOffsetPagination() result_page = paginator.paginate_queryset(query_set, request) serializer = PostSerializer(result_page, many=True) return Response({'count':paginator.count,'response':serializer.data})