def get(self, request, **kwargs):
task_id = kwargs['task_id']
paginator = PageNumberPagination()
paginator.page_size = 10
comments = Comments.objects.filter(
task_id=task_id).order_by('-created_at')
result_page = paginator.paginate_queryset(comments, request)
serializer = CommentSerializer(result_page, many=True)
return paginator.get_paginated_response(data=serializer.data)
def get_paginated_queryset_response(qs, request):
paginator = PageNumberPagination()
paginator.page_size = 20
paginated_qs = paginator.paginate_queryset(qs, request)
serializer = TweetSerializer(paginated_qs,
many=True,
context={"request": request})
return paginator.get_paginated_response(
serializer.data) # Response(serializer.data, status=200)
def messages_list(self, request, *args):
thread_id = request.query_params.get('threadId')
messages = Message.objects.filter(
thread_id=thread_id).order_by('-date_send')
serializer = MessageSerializer(messages, many=True)
paginator = PageNumberPagination()
paginator.page_size = 20
data = paginator.paginate_queryset(serializer.data, request)
return paginator.get_paginated_response(data=data)
def get_admin_associação(request):
paginator = PageNumberPagination()
paginator.page_size = 10
ass = Associação.objects.all().order_by('-created_date')
result = paginator.paginate_queryset(ass, request)
serializer = AssociaçãoSerializer(result, many=True)
return paginator.get_paginated_response(serializer.data)
def financeiro(request):
paginator = PageNumberPagination()
paginator.page_size = 5
financeiro = Financeiro.objects.all().order_by('-data_da_movimentação')
result = paginator.paginate_queryset(financeiro, request)
serializer = FinanceiroSerializer(result, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request):
state = request.query_params.get('choose')
todos = Todo.objects.filter(state=state).order_by('-todo_id')
page = PageNumberPagination()
page.page_size = 7
page.page_query_param = 'page'
page_list = page.paginate_queryset(todos, request, self)
serializer = TaskSerializer(instance=page_list, many=True)
return page.get_paginated_response(serializer.data)
def tests(self, request, **kwargs):
tests = TestCase.objects.filter(
suite__job=self.get_object()).order_by("id")
paginator = PageNumberPagination()
page = paginator.paginate_queryset(tests, request)
serializer = TestCaseSerializer(page,
many=True,
context={"request": request})
return paginator.get_paginated_response(serializer.data)
def get(self, request, *args, **kwargs):
roles = models.Role.objects.all()
pg = PageNumberPagination()
page_roles = pg.paginate_queryset(queryset=roles,
request=request,
view=self)
print(page_roles)
ser = PageSerializer(instance=page_roles, many=True)
return Response(ser.data)
def get(self, request, *args, **kwargs):
query = request.query_params.get("q")
paginator = PageNumberPagination()
paginator.page_size = 10
result_page = paginator.paginate_queryset(self.queryset, request)
serializer = MemberSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request):
paginator = PageNumberPagination()
paginator.page_size = 10
rooms = Room.objects.all()
paginated_rooms = paginator.paginate_queryset(rooms, request)
serialized_paginated_rooms = RoomModelSerializer(
paginated_rooms, many=True, context={"request": request}
)
return paginator.get_paginated_response(serialized_paginated_rooms.data)
def tutorial_tag(request, tags):
"""returns tutorials with {tags}"""
paginator = PageNumberPagination()
tags = tags.split(',')
custom_tutorial = Tutorial.objects.filter(
tags__name__in=tags).order_by('id').distinct().filter(publish=True)
context = paginator.paginate_queryset(custom_tutorial, request)
serializer = TutorialSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, name, format=None):
genre = get_object_or_404(Genre, name=name)
pagination = PageNumberPagination()
mangas = Manga.objects.filter(genres__id=genre.id)
result = pagination.paginate_queryset(mangas, request)
serializer = MangaSerializer(result, many=True)
return pagination.get_paginated_response(serializer.data)
def metrics(self, request, pk=None):
testrun = self.get_object()
metrics = testrun.metrics.prefetch_related('suite').order_by('id')
paginator = PageNumberPagination()
page = paginator.paginate_queryset(metrics, request)
serializer = MetricSerializer(page,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializer.data)
def get(self, request):
users = User.objects.all()
paginator = PageNumberPagination()
# paginamos el queryset
paginated_users = paginator.paginate_queryset(users, request)
serializer = BlogsListSerializer(paginated_users,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializer.data)
def ListUsers(request):
users = list(User.objects.all())
paginator = PageNumberPagination()
paginator.page_size = 10
paginated_users = paginator.paginate_queryset(users, request)
serializer = UserSerializer(paginated_users, many=True)
return paginator.get_paginated_response(serializer.data)
def SubjectListIndex(request):
subjects = Subject.objects.all()
paginator = PageNumberPagination()
paginator.page_size = 10
result_page = paginator.paginate_queryset(subjects, request)
serializer = SubjectSerializer(result_page, many=True)
for i in range(len(serializer.data)):
serializer.data[i]['author']['user'].pop('password')
return paginator.get_paginated_response(serializer.data)
def get_possible_values(self, request, pk=None):
queryset = models.UserData.objects.filter(
attribute_id=pk).values('data_value').distinct()
pagination = PageNumberPagination()
pagination.page_size = 10
pagination.page_query_param = 'pagenumber'
qs = pagination.paginate_queryset(queryset, request)
serializer = serializers.UserDataFilterPosibleVal(qs, many=True)
return pagination.get_paginated_response(serializer.data)
def list(self, request):
user = request.user.id
productos = Producto.objects.filter(usuario=user, activo=True)
#paginando el resultado
paginador = PageNumberPagination()
resultado_pagina = paginador.paginate_queryset(productos, request)
serializer = ProductoSerializer(resultado_pagina, many=True)
return paginador.get_paginated_response(serializer.data)
def get(self, request):
queryset = self.request.user.cards.all().order_by('-updated_date')
paginator = PageNumberPagination()
page = paginator.paginate_queryset(queryset, request, view=self)
serializer = CardSerializer(page,
many=True,
context={'request': request})
return paginator.get_paginated_response(serializer.data)
def get(self, request, **kwargs):
flat_id = kwargs['flat_id']
paginator = PageNumberPagination()
paginator.page_size = 10
plans = FlatPlans.objects.filter(flat_id=flat_id)
result_page = paginator.paginate_queryset(plans, request)
serializer = FlatPlanSerializer(result_page, many=True)
ActivityView.change_active_flat(request, flat_id)
return paginator.get_paginated_response(data=serializer.data)
def list(self, request):
# https://stackoverflow.com/questions/44048156/django-filter-use-paginations
paginator = PageNumberPagination()
filtered_set = UserFilter(request.GET, queryset=User.objects.all()).qs
filtered_set = filtered_set.order_by("username").exclude(pk=1)
context = paginator.paginate_queryset(filtered_set, request)
serializer = UserSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request):
public_key = get_header(self.request)
queryset = MySeller.objects.filter(
public_key=public_key).order_by('-id')
page_set = PageNumberPagination().paginate_queryset(queryset=queryset,
request=request,
view=self)
serializer = MySellerSerializer(page_set, many=True)
return create_success_data_response(serializer.data)
def pedidos_admin(request):
paginator = PageNumberPagination()
paginator.page_size = 10
orders = Order.objects.filter(ordered=True).order_by('-ordered_date')
result = paginator.paginate_queryset(orders, request)
serializer = OrderSerializer(result, many=True)
return paginator.get_paginated_response(serializer.data)
def threads_list(self, request, **kwargs):
user_id = request.user.id
threads = Thread.objects.filter(user1_id=user_id).union(
Thread.objects.filter(user2_id=user_id))
serializer = ThreadSerializer(threads, many=True)
paginator = PageNumberPagination()
paginator.page_size = 20
data = paginator.paginate_queryset(serializer.data, request)
return paginator.get_paginated_response(data=data)
def curso_detalle(self, request):
id = request.query_params.get("id")
curso = AsignacionCurso.objects.filter(pk=id)
#paginando el resultado
paginador = PageNumberPagination()
resultado_pagina = paginador.paginate_queryset(curso, request)
serializer = AsignacionEstudianteSerializer(resultado_pagina,
many=True)
return paginador.get_paginated_response(serializer.data)
def state_types(self, request, pk):
paginator = PageNumberPagination()
team = self.get_object()
query_set = team.state_types.all()
context = paginator.paginate_queryset(query_set, request)
serializer = CaseStateTypeSerializer(context, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None):
best_buys = BestBuy.objects.all()
page_number_pagination = PageNumberPagination()
best_buys = page_number_pagination.paginate_queryset(queryset=best_buys, request=request)
serializer = BestBuySerializer(best_buys, context={'request': request}, many=True)
serializer_data = serializer.data
return page_number_pagination.get_paginated_response(serializer_data)
def get(self, request, pk, formate=None):
paginator = PageNumberPagination()
paginator.page_size = 10
activity = get_object_or_404(Activity, pk=pk)
comments = Comments.objects.filter(
activity=activity, thread=None).prefetch_related('comment_mention')
result_page = paginator.paginate_queryset(comments, request)
data = ActivityCommentSerializer(instance=result_page, many=True).data
return paginator.get_paginated_response(data)
def SubjectList(request):
subjects = Subject.objects.all()
filterset = SubjectFilter(request.GET, queryset=subjects)
if filterset.is_valid():
queryset = filterset.qs
paginator = PageNumberPagination()
paginator.page_size = 5
result_page = paginator.paginate_queryset(queryset, request)
serializer = SubjectViewSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def blog_list(request, ):
""" this return all the blogs, per page = 10
"""
paginator = PageNumberPagination()
paginator.page_size = 10
blog_posts = Post.objects.all()
paginated_results = paginator.paginate_queryset(blog_posts, request)
serializer = BlogPostSerializer(paginated_results, many=True)
return paginator.get_paginated_response(serializer.data)