def employee_list_group_by_badges_detail(request, badge_id): """ Returns employee list grouped by badge, you should provide badge_id --- response_serializer: stars.serializers.EmployeeGroupedListSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden, authentication credentials were not provided - code: 404 message: Not found """ if request.method == 'GET': badge = get_object_or_404(Badge, pk=badge_id) employee_list = EmployeeBadge.objects.filter(badge=badge).values( 'to_user__pk', 'to_user__username', 'to_user__first_name', 'to_user__last_name', 'to_user__level', 'to_user__avatar') paginator = PageNumberPagination() results = paginator.paginate_queryset(employee_list, request) serializer = EmployeeGroupedListSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def stars_keyword_list_detail(request, keyword_id): """ Returns stars list detail for keyword id. --- response_serializer: stars.serializers.StarTopEmployeeLists responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden, authentication credentials were not provided - code: 404 message: Not found """ if request.method == 'GET': keyword = get_object_or_404(Keyword, pk=keyword_id) stars = Star.objects.filter(keyword=keyword).values( 'to_user__pk', 'to_user__username', 'to_user__first_name', 'to_user__last_name', 'to_user__level', 'to_user__avatar').annotate(num_stars=Count('keyword')).order_by('-num_stars') paginator = PageNumberPagination() results = paginator.paginate_queryset(stars, request) serializer = StarTopEmployeeLists(results, many=True) return paginator.get_paginated_response(serializer.data)
def other_location_events(request, employee_id): """ Returns the full upcoming events list for employee location --- serializer: events.serializers.EventSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found """ events = [] if request.method == 'GET': employee = get_object_or_404(Employee, pk=employee_id) events_list = Event.objects.filter(is_active=True) for event in events_list: if event.location != employee.location: events.append(event) paginator = PageNumberPagination() results = paginator.paginate_queryset(events, request) serializer = EventSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def employee_skill_remove(request, employee_id): """ Remove employee skill --- response_serializer: employees.serializers.EmployeeSkillsSerializer parameters: - name: skill type: string required: true responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found - code: 500 message: Internal Server Error """ if request.method == 'PATCH': if 'skill' in request.data: skill = request.data['skill'].upper() keyword = get_object_or_404(Keyword, name=skill) employee = get_object_or_404(Employee, pk=employee_id) employee.skills.remove(keyword) employee.save() skills = employee.skills.all() paginator = PageNumberPagination() results = paginator.paginate_queryset(skills, request) serializer = EmployeeSkillsSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def stars_keyword_list(request): """ Returns stars list grouped by keyword or result list if you use ?search= --- serializer: stars.serializers.StarKeywordList responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden, authentication credentials were not provided - code: 404 message: Not found """ if request.method == 'GET': if request.GET.get('search'): search_term = request.GET.get('search') star_list = Star.objects.filter( Q(keyword__name__icontains=search_term)).values('keyword__pk', 'keyword__name').annotate(num_stars=Count('keyword')).order_by('-num_stars') else: star_list = Star.objects.all().values('keyword__pk', 'keyword__name').annotate(num_stars=Count('keyword')).order_by('-num_stars') paginator = PageNumberPagination() results = paginator.paginate_queryset(star_list, request) serializer = StarKeywordList(results, many=True) return paginator.get_paginated_response(serializer.data)
def get_notifications(request, employee_id): """ Get all notifications for employee id --- response_serializer: activities.serializers.NotificationSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found - code: 500 message: Internal Server Error """ if request.method == 'GET': employee = get_object_or_404(Employee, pk=employee_id) activities = Activity.objects.annotate( profile=F('to_user')).values('datetime', 'text', 'profile').filter(to_user=employee) messages = Message.objects.annotate( profile=F('from_user')).values('datetime', 'text', 'profile').filter(Q(to_user='******') | Q(to_user=employee.location.name) | Q(to_user=employee.username)) notifications = list(chain(activities, messages)) notifications = sorted(notifications, reverse=True) paginator = PageNumberPagination() results = paginator.paginate_queryset(notifications, request) serializer = NotificationSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def get_messages(request, employee_id): """ Get all messages for employee id --- response_serializer: activities.serializers.MessageSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found - code: 500 message: Internal Server Error """ if request.method == 'GET': employee = get_object_or_404(Employee, pk=employee_id) messages = Message.objects.filter( Q(to_user='******') | Q(to_user=employee.location.name) | Q(to_user=employee.username)) paginator = PageNumberPagination() results = paginator.paginate_queryset(messages, request) serializer = MessageSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def employee_skills_search(request, terms): """ Returns the full employee list or result list from search skill terms --- serializer: employees.serializers.EmployeeListSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found - code: 500 message: Internal server error. """ if request.method == 'GET': search_terms_array = terms.split() initial_term = search_terms_array[0] employee_list = Employee.objects.filter(skills__name__icontains=initial_term).annotate(Count('id')) if len(search_terms_array) > 1: for term in range(1, len(search_terms_array)): employee_list = employee_list.filter(search_terms_array[term]) paginator = PageNumberPagination() results = paginator.paginate_queryset(employee_list, request) serializer = EmployeeListSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def employee_list_group_by_badges(request): """ Returns badge list with employee counter or result list if you use ?search= --- response_serializer: stars.serializers.EmployeeBadgeListSerializer parameters: - name: search required: false type: string paramType: query responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden, authentication credentials were not provided - code: 404 message: Not found """ if request.method == 'GET': if request.GET.get('search'): search_term = request.GET.get('search') badge_list = EmployeeBadge.objects.filter( Q(badge__name__icontains=search_term)).values( 'badge__pk', 'badge__name').annotate(num_employees=Count('to_user')).order_by('-num_employees') else: badge_list = EmployeeBadge.objects.all().values( 'badge__pk', 'badge__name').annotate(num_employees=Count('to_user')).order_by('-num_employees') paginator = PageNumberPagination() results = paginator.paginate_queryset(badge_list, request) serializer = EmployeeBadgeListSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def keyword_list(request): """ Returns full keyword list ordered by name --- serializer: categories.serializers.KeywordSerializer parameters: - name: pagination required: false type: string paramType: query responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found """ if request.method == 'GET': keywords = get_list_or_404(Keyword, is_active=True) if request.GET.get('pagination'): pagination = request.GET.get('pagination') if pagination == 'true': paginator = PageNumberPagination() results = paginator.paginate_queryset(keywords, request) serializer = KeywordSerializer(results, many=True) return paginator.get_paginated_response(serializer.data) else: return Response(status=status.HTTP_400_BAD_REQUEST) else: serializer = KeywordSerializer(keywords, many=True) return Response(serializer.data, status=status.HTTP_200_OK)
def person(request, pk=None, search=None, order=None): if request.method == 'GET' and pk==None: """ Returns a JSON response with a listing of person objects """ search = request.query_params.get('search') order = request.query_params.get('order') if (search==None): search = ''; if (order == None or order == ''): order = 'name' people = Person.objects.filter(name__istartswith=search).order_by(order).all() paginator = PageNumberPagination() # From the docs: # The paginate_queryset method is passed the initial queryset # and should return an iterable object that contains only the # data in the requested page. result_page = paginator.paginate_queryset(people, request) # Now we just have to serialize the data serializer = PersonSerializer(result_page, many=True) # From the docs: # The get_paginated_response method is passed the serialized page # data and should return a Response instance. return paginator.get_paginated_response(serializer.data) elif request.method == 'POST': serializer = PersonSerializer(data=request.data) if serializer.is_valid(): serializer.save(photo = get_gravatar_url(serializer.data['email'], size=150)) return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) try: person = Person.objects.get(pk=pk) except Person.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': serializer = PersonSerializer(person) return Response(serializer.data) elif request.method == 'PUT': serializer = PersonSerializer(person, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) else: return Response(serilizer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.method == 'DELETE': person.delete() serializer = PersonSerializer(person) return Response(serializer.data)
def get_paginated_response(self): paginator = PageNumberPagination() page = paginator.paginate_queryset(self.queryset, self.request) model_serializer = self.serializer_class(page, many=True, context={"request": self.request}) return paginator.get_paginated_response(model_serializer.data)
def list(self, request): self.check_permissions(request) paginator = PageNumberPagination() users = User.objects.all() paginator.paginate_queryset(users, request) serializer = UserSerializer(users, many=True) serializer_users = serializer.data return paginator.get_paginated_response(serializer_users)
def paginated_queryset(queryset, request): """ Return a paginated queryset. """ paginator = PageNumberPagination() paginator.page_size = settings.REST_FRAMEWORK['PAGE_SIZE'] result_page = paginator.paginate_queryset(queryset, request) return (paginator, result_page)
def list(self, request): self.check_permissions(request) paginator = PageNumberPagination() #instanciar paginador users = User.objects.all( ) # En users estará el queryset, no los objetos paginator.paginate_queryset(users, request) #paginar el queryset serializer = UserSerializer( users, many=True) #many es necesario para cuando pasas más de un objeto serialized_users = serializer.data #lista de diccionarios #devolver respuesta paginada return paginator.get_paginated_response(serialized_users)
def get(self, request, format=None): """ get PeriodicTask list """ queryset = models.PeriodicTask.objects.filter(~Q( name='celery.backend_cleanup')) p = PageNumberPagination() page = p.paginate_queryset(queryset=queryset, request=request, view=self) s = serializers.PeriodicTaskSerializers(page, many=True) return p.get_paginated_response(s.data)
def get(self, request, *args, **kwargs): ret = BaseResponse() try: queryset = models.DegreeCourse.objects.all() page = PageNumberPagination() course_list = page.paginate_queryset(queryset, request, self) ser = DegreeCourseModelSerializer(instance=course_list, many=True) ret.data = ser.data except Exception as e: ret.code = 500 ret.error = '获取数据失败' return Response(ret.dict)
def discussions(request): query = request.query_params.get('q') if query == None: query = '' # Q objects is used to make complex query to search in discussion content and headline discussions = Discussion.objects.filter( Q(content__icontains=query) | Q(headline__icontains=query)) paginator = PageNumberPagination() paginator.page_size = 10 result_page = paginator.paginate_queryset(discussions, request) serializer = DiscussionSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def curso(self, request, *args, **kwargs): user = request.user perfil = Profile.objects.get(user=user) catedratico = Catedratico.objects.get(perfil=perfil.id) cursos = AsignacionCatedraticoCurso.objects.filter( catedratico=catedratico.id, activo=True) #paginando el resultado paginador = PageNumberPagination() resultado_pagina = paginador.paginate_queryset(cursos, request) serializer = AsignacionCatedraticoSerializer(resultado_pagina, many=True) return paginador.get_paginated_response(serializer.data)
def product_home(request): paginator = PageNumberPagination() paginator.page_size = 15 try: product = Product.objects.all().order_by('-id') product = paginator.paginate_queryset(product, request) serializer = ProductSerializer(product, many=True) return paginator.get_paginated_response(serializer.data) except: return Response(status=status.HTTP_400_BAD_REQUEST) # bad request
def question_answers(request, uid): """Question answers by question id""" answers = Answer.objects.filter(question__id=uid).select_related('author', 'author__profile')\ .order_by('-is_solution', 'created') if not answers: return HttpResponse(status=404) if request.method == 'GET': paginator = PageNumberPagination() result_page = paginator.paginate_queryset(answers, request) serializer = AnswerSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def get_interview(self, request, slug, job_slug, formate=None): profile_in_session = ProfileSession( request=request).is_authorized_company() if not profile_in_session.user_profile.auth_user.username == request.user.username and \ profile_in_session.slug == slug: raise exceptions.PermissionDenied('You are not authorize') paginator = PageNumberPagination() paginator.page_size = 10 applicants_list = get_list_or_404(JobSchedules, job__slug=job_slug) result_page = paginator.paginate_queryset(applicants_list, request) interview_serializer = InterviewSerializer(instance=result_page, many=True) return paginator.get_paginated_response(interview_serializer.data)
def StudentPagiantedData(request, page_size): if request.method == 'GET': if school_id: student = Student.objects.filter(user=school_id) serializer = StudentSerializer(student, many=True) return Response(serializer.data) paginator = PageNumberPagination() paginator.page_size = page_size person_objects = Person.objects.all() result_page = paginator.paginate_queryset(person_objects, request) serializer = PersonSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def list(self, request): self.check_permissions(request) # Instancio paginador paginator = PageNumberPagination() users = User.objects.all() # paginamos el queryset paginator.paginate_queryset(users, request) serializer = UserSerializer(users, many=True) serialized_users = serializer.data # lista de diccionarios # Devolvemos respuesta paginada return paginator.get_paginated_response(serialized_users)
def search(self, search_term): photos = Photo.objects.filter( Q(picture_id=search_term) | Q(author__contains=search_term) | Q(camera__contains=search_term) | Q(tags__contains=search_term) | Q(cropped_picture__contains=search_term) | Q(full_picture__contains=search_term)) paginator = PageNumberPagination() page = paginator.paginate_queryset(photos, self) if page: serializer = PhotoSerializer(page, many=True) else: serializer = PhotoSerializer(photos, many=True) return paginator.get_paginated_response(serializer.data)
def get(self, request, format=None): if request.is_ajax(): apartments = self.get_queryset() paginator = PageNumberPagination() result_page = paginator.paginate_queryset(apartments, request) apartments_serialized = ApartmentSerializer(result_page, many=True) time.sleep(3) return paginator.get_paginated_response(apartments_serialized.data) else: context = {} context['username'] = username_generate(request)['username'] context['title'] = 'apartments' return render(request, 'apartments.html', context)
def total_ventas(self, request): user = request.user.id ventas = Detalle_orden.objects.values( 'producto__descripcionCorta').annotate(total=Sum( ExpressionWrapper(F('precio') * F('cantidad'), output_field=DecimalField()))).filter( producto__usuario=user) #paginando el resultado paginador = PageNumberPagination() resultado_pagina = paginador.paginate_queryset(ventas, request) serializer = resultado_pagina return paginador.get_paginated_response(serializer)
def get(self, request, id, seachstring, format=None): #id = request.data['id'] usuario = self.get_object(id) try: messages = WallMessages.objects.filter( destination=usuario, message__contains=seachstring) paginator = PageNumberPagination() result_page = paginator.paginate_queryset(messages, request) serializer = WallMessagesSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data) except Exception as e: print(e) return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): ret = BaseResponse() try: queryset = Course.objects.filter(id=1) page = PageNumberPagination() course_list = page.paginate_queryset(queryset, request, self) ser = CourseSerializer6(instance=course_list, many=True) ret.data = ser.data except Exception as e: ret.code = 1001 ret.error = '获取数据失败' return Response(ret.dict)
def get(self, request, pk=False): paginator = PageNumberPagination() if pk: try: author = Author.objects.get(pk=pk) except Author.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) serializer = AuthorSerializer(author) else: author = Author.objects.all() result_page = paginator.paginate_queryset(author, request) serializer = AuthorSerializer(result_page, many=True) return Response(serializer.data, status=status.HTTP_200_OK)
def list(self, request, **kwargs): queryset = CustomUser.objects.none() name = self.request.query_params.get('name', None) if name is not None: queryset = CustomUser.objects.all() queryset = queryset.filter( Q(username__contains=name) | Q(email__contains=name) | Q(nickname__contains=name)).distinct() paginator = PageNumberPagination() paginator.page_size = 10 result_page = paginator.paginate_queryset(queryset, request) serializer = UserSerializer(result_page, many=True) return Response(serializer.data)
def category_product(request, slug): paginator = PageNumberPagination() paginator.page_size = 15 try: category_product = Product.objects.filter(product_type=slug) category_product = paginator.paginate_queryset(category_product, request) serializer = ProductSerializer(category_product, many=True) return paginator.get_paginated_response(serializer.data) except: return Response(status=status.HTTP_400_BAD_REQUEST) # bad request
def get(self, request, *args, **kwargs): category_pk = request.GET.get('category') category_queryset = models.Category.objects.all() article_queryset = models.Article.objects.filter(category=category_pk) page_object = PageNumberPagination() article_result = page_object.paginate_queryset(article_queryset, request, self) ser_category = HomePageCategory(instance=category_queryset, many=True) ser_article = HomePageArticle(instance=article_result, many=True) return Response({ "category": ser_category.data, "article": ser_article.data })
def tweet_feed_view(request, *args, **kwargs): panigator = PageNumberPagination() panigator.page_size = 20 user = request.user profiles = user.following.all() followed_users_id = [] if profiles.exists(): followed_users_id = [x.user.id for x in profiles] followed_users_id.append(user.id) qs = Tweet.objects.filter(user__id__in=followed_users_id) panigator_qs = panigator.paginate_queryset(qs, request) serializer = TweetSerializer(panigator_qs, many=True) return panigator.get_paginated_response(serializer.data)
def get_page_response(self, query_set, request, serializer_class): """ simple function to convert query set to rest framework paginated response, :param query_set: query set :param request: wsgi request :param serializer_class: serialzer for query set :return: paginated response. """ paginator = PageNumberPagination() result_page = paginator.paginate_queryset(query_set, request) serializer = serializer_class(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def get_items(request): psize = -1 items = Item.objects.all() ordered = sorted(items, key=lambda item: datetime.strptime( item.published_date, '%Y-%m-%d %H:%M:%S'), reverse=True) # ordered = sorted(items, key=operator.attrgetter('last_name'), reverse=True) paginator = PageNumberPagination() paginator.page_size = psize result_page = paginator.paginate_queryset(ordered, request) item_ser = ItemReadSerializer(result_page, many=True) return paginator.get_paginated_response(item_ser.data)
def get(self, request): queryset = Product.objects.all() # 分页查询,需要在settings.py设置REST_FRAMEWORK属性 pg = PageNumberPagination() page_roles = pg.paginate_queryset(queryset=queryset, request=request, view=self) serializer = ProductSerializer(instance=page_roles, many=True) # serializer = ProductSerializer(instance=queryset, many=True) # 全表查询 # 还可以使用MySerializer加载模型Product # serializer = MySerializer(instance=page_roles, many=True) # 返回对象Response由Django Rest Framework实现 return Response(serializer.data)
def order_details(request): paginator = PageNumberPagination() paginator.page_size = 4 try: order_details = OrderItem.objects.filter( order__customer=request.user).order_by('-id') order_details = paginator.paginate_queryset(order_details, request) serializer = orderitemSerializer(order_details, many=True) return paginator.get_paginated_response(serializer.data) except: return Response(status=status.HTTP_400_BAD_REQUEST) # bad request
def users(request): query = request.query_params.get('q') if query == None: query = '' users = User.objects.filter( Q(userprofile__name__icontains=query) | Q(userprofile__username__icontains=query) ).order_by('-userprofile__followers_count') paginator = PageNumberPagination() paginator.page_size = 10 result_page = paginator.paginate_queryset(users,request) serializer = UserSerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def get_page_response(self, query_set, request, serializer_class): """ simple function to convert query set to rest framework paginated response, :param query_set: query set :param request: wsgi request :param serializer_class: serialzer for query set :return: paginated response. """ paginator = PageNumberPagination() result_page = paginator.paginate_queryset(query_set, request) serializer = serializer_class(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def api_division_post(request, slug): paginator = PageNumberPagination() paginator.page_size = 7 try: division_post = blogPost.objects.filter(division=slug).order_by('-id') post = paginator.paginate_queryset(division_post, request) serializer = blogPostSerializer(post, many=True) return paginator.get_paginated_response(serializer.data) except: return Response(status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): # url 最後面加入?page=1 or 2 ...就可以換分頁資料。 pg_obj = PageNumberPagination() # 實例化分頁類。 # 取得分頁資料,參數1 分頁的資料,Queryset類型,請求request,分頁的視圖,self代表自己 pg_res = pg_obj.paginate_queryset(queryset=self.queryset, request=request, view=self) # 報錯訊息提示要加入 context={'request': request},好像因為有關連的關係所以要加。 res = UserSerializer(instance=pg_res, many=True, context={'request': request}) # return Response(res.data) return pg_obj.get_paginated_response(res.data)
def list(self, request): if request.GET: query = request.GET.get('q') page = request.GET.get('page') if query: queryset = App.objects.filter( Q(name__icontains=query) | Q(abstract__icontains=query)) app_release = Release.objects.filter( app__in=queryset).order_by('-version') if page is not None: paginator = PageNumberPagination() context = paginator.paginate_queryset(app_release, request) serializer = AppReleaseSerializer(context, many=True) return paginator.get_paginated_response(serializer.data) else: serializer = AppReleaseSerializer(app_release, many=True) if len(serializer.data): return Response(serializer.data, 200) else: return Response(serializer.data, 404) elif query is None and page is not None: queryset = App.objects.all() paginator = PageNumberPagination() context = paginator.paginate_queryset(queryset, request) serializer = AppSearchSerializer(context, many=True) return paginator.get_paginated_response(serializer.data) else: return Response([], 404) else: queryset = App.objects.all() serializer = AppSearchSerializer(queryset, many=True) return Response(serializer.data, 200)
def list(self, request): self.check_permissions(request) # Instanciar el paginador paginator = PageNumberPagination() users = User.objects.all() # Pagina el Queryset paginator.paginate_queryset(users, request) serializer = UserSerializer(users, many=True) serialized_users = serializer.data #Lista de diccionarios #renderer = JSONRenderer() #json_users = renderer.render(serialized_users) # Lista de diccionarios --> JSON # Devolver respuesta paginada return paginator.get_paginated_response(serialized_users)
def car_list_view(request, *args, **kwargs): search_str = request.GET.get('search') or '' qs = Car.objects.filter( Q(car_model__name__icontains=search_str) | Q(car_model__brand__name__icontains=search_str)).order_by('-id') paginator = PageNumberPagination() paginator.page_size = 20 paginated_qs = paginator.paginate_queryset(qs, request) serializer = CarSerializer(paginated_qs, many=True) return paginator.get_paginated_response(serializer.data)
def TeacherSubject(request): teacher = TeacherProfile.objects.get(user_id=request.user.id) subject = Subject.objects.filter(author=teacher).order_by('-id') print(subject) filterset = SubjectFilter(request.GET, queryset=subject) if filterset.is_valid(): queryset = filterset.qs paginator = PageNumberPagination() paginator.page_size = 5 result_page = paginator.paginate_queryset(queryset, 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(self, request, format=None): """ Returns a JSON response with a listing of course objects """ paginator = PageNumberPagination() # From the docs: # The paginate_queryset method is passed the initial queryset # and should return an iterable object that contains only the # data in the requested page. result_page = paginator.paginate_queryset(self.get_queryset(), request) # Now we just have to serialize the data. serializer = CommunityPostSerializer(result_page, many=True, context={'request': request}) # From the docs: # The get_paginated_response method is passed the serialized page # data and should return a Response instance. return paginator.get_paginated_response(serializer.data)
def diffs(request, doctype_name, dataset_name): queryset = TreeNode.objects.select_related( 'dataset', 'tree2_diffs' ).filter( dataset__doctype__name=doctype_name, dataset__name=dataset_name, tree2_diffs__isnull=False ) paginator = PageNumberPagination() paginator.page_size = 1 result_page = paginator.paginate_queryset(queryset, request) serializer = KeySerializer(result_page, many=True) return paginator.get_paginated_response(serializer.data)
def blogs_list(request): "GET: displays all the blogs POST: take a new blog as I/P (or) modified text" if request.method == 'GET': blogs = Blog.objects.all() pages = PageNumberPagination() page_data = pages.paginate_queryset(blogs, request) serializer = BlogSerializer(page_data, many=True) return pages.get_paginated_response(serializer.data) elif request.method == 'POST': data = request.data title = data.pop('title') text = data.pop('text') try: blog_exists = Blog.objects.filter(title=title) if blog_exists: para_list = text.split('\n\n') para_text = Paragraph.objects.filter(blog=blog_exists) dummy = json.loads(blog_exists[0].seq) para_delete = para_text.exclude(text__in = para_list) if para_delete: comm_delete = Comment.objects.filter(paragraph__in=para_delete).delete() for i in para_delete: dummy.remove(i.id) para_delete.delete() para_text = para_text.filter().values_list('text', flat=True) for i in range(0, len(para_list)): if para_list[i] not in para_text: para_save = Paragraph(blog=blog_exists[0], text=para_list[i]) para_save.save() dummy = dummy[:i] + [para_save.id] + dummy[i:] blog_exists[0].seq = json.dumps(dummy) blog_exists[0].save() return Response({"status":"success", "message":"Text is updated"}, status=status.HTTP_201_CREATED) else: blog_save = Blog(title=title) blog_save.save() paragraphs = text.split('\n\n') para_list = [Paragraph(blog=blog_save, text=t) for t in paragraphs] Paragraph.objects.bulk_create(para_list) if para_list: blog_save.seq = json.dumps(list(Paragraph.objects.filter(blog=blog_save).order_by('id').values_list('id', flat=True)), cls=DjangoJSONEncoder) else: blog_save.seq = json.dumps(list()) blog_save.save() return Response({"status":"success", "message":"New Blog created"}, status=status.HTTP_201_CREATED) except Exception as ex: return Response({"status":"fail", 'message':str(ex)}, status=status.HTTP_400_BAD_REQUEST)
def search(request, query): """ Lista resultados de búsqueda de palabra clave. Usa paginación y muestra hasta 20 resultados por página. Además muestra links para páginas previas y siguientes. # Puedes obtener los resultados en archivo TSV Este archivo contiene la información en campos separados por tabs (fácil de importar a MS Excel) Solo es necesario usar la dirección `search.tsv`: * <http://manolo.rocks/api/search.tsv/romulo/> --- type: query: required: true type: string parameters: - name: query description: nombre o palabra clave a busar, por ejemplo Romulo type: string paramType: path required: true """ query_request = QueryDict('q={}'.format(query)) form = ApiForm(query_request) if request.user.is_authenticated(): all_items = form.search(premium=True) else: all_items = form.search(premium=False) pagination = PageNumberPagination() paginated_results = pagination.paginate_queryset(all_items, request) paginated_results = [i.object for i in paginated_results] serializer = ManoloSerializer(paginated_results, many=True) data = { 'count': pagination.page.paginator.count, 'next': pagination.get_next_link(), 'previous': pagination.get_previous_link(), 'results': serializer.data, } return JSONResponse(data)
def get_nearest(self, request, *args, **kwargs): #-82.1013183593750000 40.1766586303710014 logger.error('NearestUserViewSet: ' +kwargs['latitude']+' '+kwargs['longitude']) current_user = request.user pref_qs = Preferences.objects.all() preferences = get_object_or_404(pref_qs, user=current_user) # Get the current date now = date.today() min_date = now - relativedelta(years=preferences.max_age) max_date = now - relativedelta(years=preferences.min_age) logger.error('min_date ' + str(min_date)) logger.error('max_date ' + str(max_date)) distance_pref = preferences.distance gender_pref = preferences.gender_pref logger.error('Preferences: Gender ' + gender_pref + ' distance ' + str(distance_pref)) # Filter for all prospects already processed by user match_set = Match.objects.filter(Q(source=current_user) | Q(target=current_user)).all() #for prospect in match_set: email_set = set() for x in match_set: logger.error('Matched emails ' + x.source.email +' and ' + x.target.email) email_set.add(x.source.email) email_set.add(x.target.email) #email_set = {y.email for x in match_set for y in x.users.all()} #set() # Exclude login user '''email_set.add(current_user.email) for match in match_set: email_set.add(match.)''' gps_reading = fromstr('POINT('+kwargs['latitude']+' '+kwargs['longitude']+')', srid=4326) nearest_users = User.geo.exclude(email__in=email_set).exclude(preferences__hidden=True).filter(Q(date_of_birth__gte=min_date) & Q(date_of_birth__lte=max_date)) nearest_users = nearest_users.filter(gender=gender_pref).filter(location__distance_lte=(gps_reading, D(mi=distance_pref))).distance(gps_reading).order_by('distance') paginator = PageNumberPagination() result_page = paginator.paginate_queryset(nearest_users.all(), request) serializer = UserSerializer(result_page , many=True) return paginator.get_paginated_response(serializer.data)
def _get(self,request,*args,**kwargs): """ 自己重写get() ,以上定义的Name些 xxx_class全部失效,完全自己处理数据返回 自定义的 {status,errcode,errmsg,result} 就在这里自行添加了 所以基本上从APIView继承就可以了,如果需要分页处理,看看ListViewAPI """ # if request.user.is_authenticated: # return Response({'status':0}) #这里直接拒绝掉了 ser = SerializerDBTable( self.get_queryset(),many=True) data = ser.data return Response(data) #手动控制分页 page = PageNumberPagination() page.paginate_queryset(self.queryset.all()[:200],request) return page.get_paginated_response(ser.data) return Response({'result':data})
def employee_deactivated_list(request): """ Returns the full employee deactivated list --- serializer: employees.serializers.EmployeeListSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found """ if request.method == 'GET': employee_list = get_list_or_404(Employee, is_active=False) paginator = PageNumberPagination() results = paginator.paginate_queryset(employee_list, request) serializer = EmployeeListSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def comment_list(request): response = {} result = {} if request.method == "POST": member_id = request.data["memberId"] board_id = request.data["boardId"] comment = request.data["comment"] if member_id is None or comment is None: response["STS"] = ERR_USER_PARAM response["MSG"] = MSG[ERR_USER_PARAM] return Response(response) comment = Comment(board_id=board_id, member_id=member_id, comment=comment) comment.save() result["id"] = comment.id result["comment"] = comment.comment result["regdt"] = comment.regdt response["STS"] = SUCCESS response["MSG"] = MSG[SUCCESS] response["DAT"] = result return Response(response) if request.method == "GET": paginator = PageNumberPagination() board_list = Comment.objects.order_by("-id").all() result_page = paginator.paginate_queryset(board_list, request) comment_list_serializer = CommentListSerializer(result_page, many=True) result["comment_list"] = comment_list_serializer.data result["total_cnt"] = len(board_list) response["STS"] = SUCCESS response["MSG"] = MSG[SUCCESS] response["DAT"] = result return Response(response)
def event_list(request): """ Returns the full events list or result list if you use ?search= --- serializer: events.serializers.EventSerializer parameters: - name: search required: false type: string paramType: query responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found - code: 500 message: Internal Server Error """ if request.method == 'GET': if request.GET.get('search'): request_terms = request.GET.get('search') search_terms_array = request_terms.split() initial_term = search_terms_array[0] event_list = Event.objects.annotate( num_participants=Count('participants', distinct=True), num_collaborators=Count('collaborators', distinct=True)).filter( Q(title__icontains=initial_term) | Q(description__icontains=initial_term)) if len(search_terms_array) > 1: for term in range(1, len(search_terms_array)): event_list = event_list.filter(Q(title__icontains=search_terms_array[term]) | Q(description__icontains=search_terms_array[term])) else: event_list = Event.objects.annotate( num_participants=Count('participants', distinct=True), num_collaborators=Count('collaborators', distinct=True)).all() paginator = PageNumberPagination() results = paginator.paginate_queryset(event_list, request) serializer = EventSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def feeds_to_user(request): # load = json.loads(request.body) # device = load.get('device_id') device = request.GET['device_id'] print"===========DEvice Id====",device if not device: return HttpBadRequest("Enter device id") user_obj=UserProfile.objects.get(device_id = device) user_interests = user_obj.interests_category.all() user_languages = user_obj.user_languages.all() paginator = PageNumberPagination() interest_list=[] language_list=[] for interest in user_interests: interest_list.append(interest) for language in user_languages: language_list.append(language) newsfeeds_objs1 = NewsFeedItems.objects.filter(category__in=interest_list)\ .filter(language__in=language_list)\ .order_by('-pubdate') newsfeeds_objs = paginator.paginate_queryset(newsfeeds_objs1, request) feed_item=[] for newsfeeds_obj in newsfeeds_objs: user_feeds={} user_feeds['title']=newsfeeds_obj.title user_feeds['descrption']=newsfeeds_obj.content user_feeds['image_url']=newsfeeds_obj.image_url news_pubdate = datetime.datetime.strftime(newsfeeds_obj.pubdate,'%a, %d %b %Y %I:%M:%S') user_feeds['pubdate']=str(news_pubdate) user_feeds['link']=newsfeeds_obj.link user_feeds['category']=newsfeeds_obj.category user_feeds['language']=newsfeeds_obj.language user_feeds['source']=newsfeeds_obj.source feed_item.append(user_feeds) data = {'status_code':200,'feeds_details': feed_item} return Response(data, status=status.HTTP_200_OK)
def employee_list(request, format=None): """ Returns the full employee list or result list if you use ?search= --- serializer: employees.serializers.EmployeeListSerializer parameters: - name: search required: false type: string paramType: query responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found """ if request.method == 'GET': if request.GET.get('search'): request_terms = request.GET.get('search') search_terms_array = request_terms.split() initial_term = search_terms_array[0] employee_list = Employee.objects.filter( Q(first_name__icontains=initial_term) | Q(last_name__icontains=initial_term) | Q(username__icontains=initial_term)).filter(is_active=True, is_base_profile_complete=True) if len(search_terms_array) > 1: for term in range(1, len(search_terms_array)): employee_list = employee_list.filter( Q(first_name__icontains=search_terms_array[term]) | Q(last_name__icontains=search_terms_array[term]) | Q(username__icontains=search_terms_array[term])).filter( is_active=True, is_base_profile_complete=True) else: employee_list = get_list_or_404(Employee, is_active=True, is_base_profile_complete=True) paginator = PageNumberPagination() results = paginator.paginate_queryset(employee_list, request) serializer = EmployeeListSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def stars_employee_list(request, employee_id): """ Returns stars list from employee --- serializer: stars.serializers.StarSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden, authentication credentials were not provided - code: 404 message: Not found """ if request.method == 'GET': employee = get_object_or_404(Employee, pk=employee_id) employee_stars = Star.objects.filter(to_user=employee) paginator = PageNumberPagination() results = paginator.paginate_queryset(employee_stars, request) serializer = StarSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def stars_employee_subcategory_list(request, employee_id): """ Returns stars list from employee grouped by subcategories --- serializer: stars.serializers.StarEmployeesSubcategoriesSerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden, authentication credentials were not provided - code: 404 message: Not found """ if request.method == 'GET': employee = get_object_or_404(Employee, pk=employee_id) employee_stars = Star.objects.filter(to_user=employee).values('subcategory__pk', 'subcategory__name').annotate(num_stars=Count('subcategory')).order_by('-num_stars', 'subcategory__name') paginator = PageNumberPagination() results = paginator.paginate_queryset(employee_stars, request) serializer = StarEmployeesSubcategoriesSerializer(results, many=True) return paginator.get_paginated_response(serializer.data)
def event_activities(request, event_id): """ Returns activity list for event --- serializer: events.serializers.EventActivitySerializer responseMessages: - code: 401 message: Unauthorized. Authentication credentials were not provided. Invalid token. - code: 403 message: Forbidden. - code: 404 message: Not found """ if request.method == 'GET': event = get_object_or_404(Event, pk=event_id) activities = EventActivity.objects.filter(event=event) paginator = PageNumberPagination() results = paginator.paginate_queryset(activities, request) serializer = EventActivitySerializer(results, many=True) return paginator.get_paginated_response(serializer.data)