def get_shop_products(request, slug, cat):
"""
Gets the necessary products needed to show the customer for the shop.
Arguments:
request {[request object]} -- [just for request]
slug {[ string ]} -- [to get the needed information about the shop]
cat {[ string ]} -- [to get the category for the shop]
Returns:
[JSON] -- [Gives the user back a json response of the shop products needed]
"""
try:
shop = Shop.objects.get(slug=slug)
products = Products.objects.filter(shop_rel=shop).order_by('?')
shop_slugs = list(map(lambda x: x["slug"], shop.categories))
if not shop.categories:
products = []
elif cat in shop_slugs:
products = products.filter(genre__slug=cat)
paginator = pagination.PageNumberPagination()
paginator.page_size = 12
result_page = paginator.paginate_queryset(products, request=request)
serializer = ProductSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
except shop.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
def paginated_item(self, obj):
print(f'self: \n{self},\n context: {self.context},')
item = Item.objects.filter(category=obj)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(item, self.context.get("request"))
serializer = ItemSerializer(page, many=True, context={'request': self.context.get("request")})
return serializer.data
def paginated_trips(self, obj):
trips = Trip.objects.filter(set=obj)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(trips, self.context['request'])
serializer = TripSerializer(
page, many=True, context={'request': self.context['request']})
return serializer.data
def get_queryset(self):
"""
Determine queryset for different object type.
"""
object_type = self.kwargs.get('object_type', 'posts')
username = self.kwargs.get('username', None)
User = get_user_model()
if not User.objects.filter(username=username).exists():
raise Http404
user = User.objects.get(username=username)
paginator = pagination.PageNumberPagination()
paginator.page_size = 5
if user.id == self.request.user.id:
objects_status = (0, 1)
else:
objects_status = (1, )
if object_type == 'posts':
query = Post.objects.all().filter(author=user,
status__in=objects_status)
elif object_type == 'comments':
query = Comment.objects.filter(author=user,
status__in=objects_status)
else:
raise ParseError(detail="Invalid object type")
result_page = paginator.paginate_queryset(query, self.request)
return result_page
def paginated_opportunities(self, obj):
opportunities = Opportunity.objects.filter(category=obj)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(opportunities,
self.context['request'])
serializer = OpportunitySerializer(
page, many=True, context={'request': self.context['request']})
return paginator.get_paginated_response(serializer.data).data
def get_comments(self, obj):
comments = obj.comments.get_grand_parents()
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(comments, self.context['request'])
serializer = CommentListSerializer(page,
many=True,
context=self.context)
return serializer.data
def list_user_reports(request, user_id):
queryset = Report.objects.filter(author_id=user_id)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(queryset, request)
serializer = ReportInfoSerializer(page,
many=True,
context={'user': request.user})
return paginator.get_paginated_response(serializer.data)
def get_comments(self, obj):
#c_qs = Comment.objects.filter(post=obj.pk)
#comments = CommentSerializer(c_qs, many=True).data
#return comments
c_qs = Comment.objects.filter(post=obj)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(c_qs, self.context['request'])
serializer = CommentSerializer(
page, many=True, context={'request': self.context['request']})
return serializer.data
def paginated_reviews(self, obj):
print(obj)
reviews = Review.objects.filter(profile=obj).order_by('-updated_at')
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(reviews, self.context['request'])
print('UserProfileSerializer Stage 1: ')
print(type(page))
print(page)
serializer = ReviewSerializer(page, many=True, context={'__request': self.context['request']})
print(serializer)
return serializer.data
def paginated_posts(self, obj):
posts = Post.objects.filter(tag=obj)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(posts, self.context["request"])
serializer = PostSerializer(page, many=True, context={"request": self.context["request"]})
return {
"count": posts.count(),
"results": serializer.data,
"previous": paginator.get_previous_link(),
"next": paginator.get_next_link(),
}
def paginated_posts(self, obj):
posts = obj.post_set.filter(status = Post.STATUS_NORMAL)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(posts, self.context['request'])
serializer = PostSerializer(page, many = True, context = {'request': self.context['request']})
return {
'count': posts.count(),
'results': serializer.data,
'previous': paginator.get_previous_link(),
'next': paginator.get_next_link(),
}
def get_user_popular_reports(request, user_id):
try:
user = User.objects.get(id=user_id)
except User.DoesNotExist:
return Response(
{'response': 'User id %s does not exist' % str(user_id)},
status=404)
paginator = pagination.PageNumberPagination()
queryset = Report.get_user_popular(user)
page = paginator.paginate_queryset(queryset, request)
serializer = PopularReportSerializer(page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_popular_reports(request):
paginator = pagination.PageNumberPagination()
queryset = Report.get_popular()
page = paginator.paginate_queryset(queryset, request)
if request.user and request.user.is_authenticated:
user = request.user
else:
user = None
serializer = ReportInfoSerializer(page,
many=True,
context={'user': user})
return paginator.get_paginated_response(serializer.data)
def quiz_list(request, page):
# Set up pagination for quizzes
paginator = pagination.PageNumberPagination()
paginator.page_size = 10
paginator.page = page
# Create paginated quiz list
queryset = Quiz.objects.all().order_by('-created_at')
paginated_quizzes = paginator.paginate_queryset(queryset, request)
serializer = QuizDetailSerializer(paginated_quizzes, many=True)
if serializer is not None:
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(status=status.HTTP_404_NOT_FOUND)
def paginated_posts(self, obj):
# posts = obj.posts.published()
posts = Post.objects.list_by_category(obj)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(posts, self.context['request'])
serializer = PostSerializer(
page, many=True, context={'request': self.context['request']})
return {
'count': posts.count(),
'results': serializer.data,
'previous': paginator.get_previous_link(),
'next': paginator.get_next_link(),
}
def paginated_posts(self, obj):
posts = obj.post_set.filter(status=Post.STATUS_NORMAL)
paginator = pagination.PageNumberPagination()
# paginate_queryset要从request的查询字符串中获取page_size的值。
page = paginator.paginate_queryset(posts, self.context["request"])
# 由于序列化的是分页page数据，每一页的数据不同，所以需要从request的查询字符串中获取page_size的值。
serializer = PostSerializer(page, many=True, context={"request": self.context["request"]})
return {
"count": posts.count(),
"results": serializer.data,
"previous": paginator.get_previous_link(),
"next": paginator.get_next_link()
}
def paginated_products(self, obj):
products = obj.products.all()
paginator = pagination.PageNumberPagination()
paginator.page_size_query_param = 'page_size'
paginator.max_page_size = 100
page = paginator.paginate_queryset(products, self.context['request'])
page_size = int(self.context['request'].query_params.get('page_size')
or 10)
serializer = ProductSerializer(
page, many=True, context={'request': self.context['request']})
ret = paginator.get_paginated_response(serializer.data).data
ret['num_pages'] = (obj.products.all().count() // page_size) + 1
return ret
def paginated_articles(self, obj):
articles = obj.article_set.filter(
status=Article.STATUS_NORMAL) # 外键反向查询
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(articles, self.context['request'])
serializer = ArticleSerializer(
page, many=True, context={'request': self.context['request']})
return {
'count': articles.count(),
'results': serializer.data,
'previous': paginator.get_previous_link(),
'next': paginator.get_next_link(),
}
def shop_products(request):
"""Get the products assiociated with this user shop.
Arguments:
request {[request object]} -- [Used as a form of verification of a user authencity]
"""
shop = Shop.objects.get(user=request.user)
products = Products.objects.filter(shop_rel=shop)
paginator = pagination.PageNumberPagination()
paginator.page_size = 7
result_page = paginator.paginate_queryset(products, request=request)
serializer = ProductSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_allies_obj(request):
"""
This function get all allies objects.
Arguments:
request { request object } -- this is django request object
Returns:
JSON -- returns json reponse with the needed crendentials
"""
allies = Allies.objects.filter(user=request.user).order_by("-created")
paginator = pagination.PageNumberPagination()
paginator.page_size = 8
result_page = paginator.paginate_queryset(allies, request=request)
allies_obj = AlliesSerializer(result_page, many=True)
return paginator.get_paginated_response(allies_obj.data)
def get(request):
category_data = request.GET.get('category')
tag_data = request.GET.get('tag')
user = request.user
# print(category_data, tag_data, user)
if category_data is not None:
category_id = models.Category.objects.get(category=category_data)
articles = models.Article.objects.filter(
article_category=category_id).order_by('id')
article_list_data = fun.article_list(articles, user)
page = pagination.PageNumberPagination()
page.page_size = 7
page.max_page_size = 7
page_roles = page.paginate_queryset(queryset=article_list_data,
request=request)
return page.get_paginated_response(page_roles)
if tag_data is not None:
tag_id = models.Tag.objects.get(tag=tag_data)
articles = models.Article.objects.filter(
article_tag=tag_id).order_by('id')
article_list_data = fun.article_list(articles, user)
page = pagination.PageNumberPagination()
page.page_size = 7
page.max_page_size = 7
page_roles = page.paginate_queryset(queryset=article_list_data,
request=request)
return page.get_paginated_response(page_roles)
else:
articles = models.Article.objects.all().order_by('id')
article_list_data = fun.article_list(articles, user)
# 实例化分页器对象
page = pagination.PageNumberPagination()
page.page_size = 7
page.max_page_size = 7
page_roles = page.paginate_queryset(queryset=article_list_data,
request=request)
return page.get_paginated_response(page_roles)
def ShopProduct(request, slug, cat):
## Allows me to filter dynamically
## it's filters both catergory
## and the shop so its a 2 in 1
## Through the shops without
## Having to write multiple code
if cat == 'all':
products = Products.objects.filter(shop=slug)
else:
products = Products.objects.filter(shop=slug, genre=cat)
paginator = pagination.PageNumberPagination()
paginator.page_size = 10
result_page = paginator.paginate_queryset(products, request=request)
serializer = ProductSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def paginated_posts(self, obj):
posts = obj.post_set.all()
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(posts, self.context['request'])
serializer = PostSerializer(
page,
many=True,
read_only=True,
context={'request': self.context['request']})
return {
'results': serializer.data,
'previous': paginator.get_previous_link(),
'next': paginator.get_next_link(),
}
def paginated_posts(self,obj):
request = self.context['request']
posts = obj.post_set.filter(status=Post.STATUS_NORMAL)
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(posts,request)
print('=============page============')
print(page)
print(posts)
serializer = PostSerializer(posts, many=True, context={'request': request})
return {
'count': posts.count(),
'post_list': serializer.data,
# 'previous': paginator.get_previous_link(),
# 'next': paginator.get_next_link(),
}
def get_shop_trending_products(request, slug, cat):
try:
shop = Shop.objects.get(slug=slug)
products = Products.objects.filter(
shop_rel=shop).order_by("-num_of_clicks")
shop_slugs = list(map(lambda x: x["slug"], shop.categories))
if not shop.categories:
products = []
elif cat in shop_slugs:
products = products.filter(genre__slug=cat)
paginator = pagination.PageNumberPagination()
paginator.page_size = 6
result_page = paginator.paginate_queryset(products, request=request)
serializer = ProductSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
except shop.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
def list(self, request, *args, **kwargs):
search_form = SearchForm(request.GET)
if search_form.is_valid():
cd = search_form.cleaned_data
if cd["q"] == "":
cd["q"] = "*" # Get everything
paginator = pagination.PageNumberPagination()
sl = api_utils.get_object_list(request, cd=cd, paginator=paginator)
result_page = paginator.paginate_queryset(sl, request)
serializer = SearchResultSerializer(
result_page, many=True, context={"schema": sl.conn.schema})
return paginator.get_paginated_response(serializer.data)
# Invalid search.
return response.Response(search_form.errors,
status=status.HTTP_400_BAD_REQUEST)
class ProductsListAPI(ListAPIView):
paginator = pagination.PageNumberPagination()
paginator.page_size = 6
model = Product
template_name = 'products.html'
context_object_name = 'products'
queryset = Product.objects.all()
serializer_class = ProductSerializer
paginate_by = 6
product_adding_form = ProductAddingForm()
def get_serializer_context(self):
context = dict()
context['auth'] = self.request.user.is_authenticated
context['user'] = self.request.user
context['product_adding_form'] = self.product_adding_form
return context
def user_list(request, page):
try:
queryset = CustomUser.objects.all()
except CustomUser.DoesNotExist:
return Response({'error': 'No profiles found'},
status=status.HTTP_404_NOT_FOUND)
# Set up pagination for users
paginator = pagination.PageNumberPagination()
paginator.page_size = 10
paginator.page = page
# Create paginated user list
paginated_users = paginator.paginate_queryset(queryset, request)
serializer = UserSerializer(paginated_users, many=True)
if serializer is not None:
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(status=status.HTTP_404_NOT_FOUND)
def paginated_posts(self, obj):
# posts对应的数据需要通过paginated_posts获取
posts = obj.post_set.filter(status=Post.STATUS_NORMAL)
# 分页,指定分页方式：当前几页，每页多少条
paginator = pagination.PageNumberPagination()
page = paginator.paginate_queryset(posts, self.context['request'])
serializer = PostSerializer(page, many=True, context={'request':
self.context['request']})
return {
# 数字
'count': posts.count(),
# 详细信息
'results': serializer.data,
# 上一个分类
'previous': paginator.get_previous_link(),
# 下一个分类
'next': paginator.get_next_link(),
}
def paginated_results(self, queryObj):
"""
The results are serialized/de-serialized using a method.
"""
querySet = QueryResultsIteratorWithAutoInsertion(queryObj)
paginationObj = pagination.PageNumberPagination()
paginationObj.page_size_query_param = "page_size"
paginationObj.page_size = 10
paginationObj.paginate_queryset(querySet, self.context['request'])
serializer = PaginatedSearchResultSerializer(
paginationObj.page,
many=True,
context={
'request': self.context['request'],
'paginationObj': paginationObj
})
return serializer.data
