def taskscompletedview(request):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
queryset = Tasks.objects.filter(completed=True).order_by('id')
result_page = paginator.paginate_queryset(queryset, request)
serializer = TaskSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.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 get(self, request, *args, **kwargs):
query = self.get_query()
sort = self.get_sort()
pagination = LimitOffsetPagination()
pagination.default_limit = 20
pagination.limit = pagination.get_limit(request)
pagination.offset = pagination.get_offset(request)
pagination.request = request
body = {
'query': query,
'size': pagination.limit,
'from': pagination.offset
}
if sort:
body['sort'] = sort
# execute elasticsearch query
indexer = self.get_indexer()
res = indexer.search(body=body)
# map back to expected format
items = list(indexer.map_results(res['hits']['hits']))
pagination.count = res['hits']['total']
return pagination.get_paginated_response(items)
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 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(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 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 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_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, *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 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, *args, **kwargs):
query = self.get_query()
sort = self.get_sort()
pagination = LimitOffsetPagination()
pagination.default_limit = 20
pagination.limit = pagination.get_limit(request)
pagination.offset = pagination.get_offset(request)
pagination.request = request
body = {
"track_total_hits": True,
"query": query,
"size": pagination.limit,
"from": pagination.offset,
}
if sort:
body["sort"] = sort
# execute elasticsearch query
indexer = self.get_indexer()
res = indexer.search(body=body)
# map back to expected format
items = list(indexer.map_results(res["hits"]["hits"]))
pagination.count = res["hits"]["total"]["value"]
return pagination.get_paginated_response(items)
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(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 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 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):
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 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 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 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 my_favourites(self, request):
fav_offers = Favourite.objects.filter(user=request.user)
serializer = FavouriteSerializer(fav_offers,
many=True,
context={'request': request})
paginator = LimitOffsetPagination()
data = paginator.paginate_queryset(serializer.data, request)
return paginator.get_paginated_response(data=data)
def notifview(request):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
queryset = Notifications.objects.filter(
user=request.user).order_by('-date_created')
result_page = paginator.paginate_queryset(queryset, request)
serializer = NotificationSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
events = Event.objects.all()
paginator = LimitOffsetPagination()
items = paginator.paginate_queryset(events, request)
serializer = EventSerializer(items, many=True)
return paginator.get_paginated_response(serializer.data)
def commentsview(request, task_id):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
queryset = TaskComments.objects.filter(
task_id=task_id).order_by('date_created')
result_page = paginator.paginate_queryset(queryset, request)
serializer = CommentsSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def simple_list(self, request, queryset):
"""
Paginate and return a list of objects from given queryset.
"""
queryset = self.filter_queryset(queryset)
paginator = LimitOffsetPagination()
items = paginator.paginate_queryset(queryset, request)
serializer = self.serializer_class(items, many=True, context={"request": request})
return paginator.get_paginated_response(serializer.data)
def get_explore(request):
posts = Post.objects.all()
paginator = LimitOffsetPagination()
paginator.default_limit = 6
result_page = paginator.paginate_queryset(posts, request)
serializer = PostSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def user_offers(self, request, **kwargs):
user = get_object_or_404(User, id=kwargs.get('user_id'))
offers = Offer.objects.filter(owner=user, owner__active=True)
serializer = self.get_serializer(offers,
many=True,
context={'request': request})
paginator = LimitOffsetPagination()
data = paginator.paginate_queryset(serializer.data, request)
return paginator.get_paginated_response(data=data)
def get_comments(self, request, **kwargs):
offer_comment = Comment.objects.filter(
offer=kwargs.get('offer_id')).order_by('-date')
serializer = CommentSerializer(offer_comment,
many=True,
context={'request': request})
paginator = LimitOffsetPagination()
data = paginator.paginate_queryset(serializer.data, request)
return paginator.get_paginated_response(data=data)
def get(self, request, *args, **kwargs):
if not request.user.is_authenticated:
return self.err_res.UNAUTHORIZED
query_set = self.report_location_dal.get_all()
paginator = LimitOffsetPagination()
paginated_data = paginator.paginate_queryset(query_set, request)
res_data = ReportLocationsSerializer(paginated_data, many=True).data
return paginator.get_paginated_response(res_data)