コード例 #1
0
def channel_list(request):
    '''
    채널리스트 API
    ---
    전체 채널의 목록을 보여주는 API입니다.
    '''
    youtuber_name = request.query_params.get('youtuber_name')

    if youtuber_name is not None:
        # 유튜버 검색 기능
        paginator = PageNumberPagination()
        paginator.page_size = 10
        channel_querysets = list(
            Channel.objects.prefetch_related('video', 'channelviews').filter(
                channel_name__icontains=youtuber_name).order_by(
                    '-subscriber_num'))

        # 데이터 많을 시 페이지네이션 진행(페이지별로 데이터 끊기)
        result_page = paginator.paginate_queryset(channel_querysets, request)

        # 데이터 직렬화
        serializer = ChannelListSerializer(result_page, many=True)
        result = serializer.data
        additional_data = []
        for channel_queryset in channel_querysets:
            videos = channel_queryset.video.order_by('-upload_time')
            video_counts = len(videos)
            recent_videos = videos[:2]
            recent_video_url = []
            for recent_video in recent_videos:
                recent_video_url.append(recent_video.thumbnail_url)

            max_views_count = list(
                channel_queryset.channelviews.order_by('-check_time')[:1])
            try:
                max_views_count = max_views_count[0].view_count
            except:
                max_views_count = 0
            try:
                popularity = round(
                    max_views_count / channel_queryset.subscriber_num, 1)
            except:
                popularity = 0
            additional_data.append({
                'video_counts': video_counts,
                'recent_videos': recent_video_url,
                'max_views_count': max_views_count,
                'popularity': popularity
            })

        for i in range(len(result)):
            result[i].update(additional_data[i])
        return paginator.get_paginated_response(result)
    else:
        paginator = PageNumberPagination()
        paginator.page_size = 10
        queryset = Channel.objects.all()
        result_page = paginator.paginate_queryset(queryset, request)
        serializer = ChannelListSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)
コード例 #2
0
    def list(self, request, *args, **kwargs):
        paginator = PageNumberPagination()
        paginator.page_size = 12
        if 'no_page' in self.request.query_params:
            paginator.page_size = self.queryset.count()

        queryset = self.queryset.model.query_objects.filter_by_query_params(
            request)
        queryset = queryset.order_by('-id')
        queryset = paginator.paginate_queryset(queryset, request)
        serializer = ProductCategorySerializer(
            queryset, many=True, context={'request': self.request})
        custom_data = {'data': serializer.data}
        return paginator.get_paginated_response(custom_data)
コード例 #3
0
ファイル: views.py プロジェクト: ondev97/lms2
def MyCoursesInTheSubject(request, pk):
    subject = Subject.objects.get(id=pk)
    student = StudentProfile.objects.get(user=request.user)
    enrollments = Enrollment.objects.filter(student=student,
                                            course__subject=subject)
    # courseids = []
    # for e in enrollments:
    #     if e.course.id not in courseids:
    #         courseids.append(e.course.id)
    # courses = Course.objects.filter(id__in=courseids)
    # filterset = CourseFilter(request.GET,queryset=courses)
    # if filterset.is_valid():
    #     queryset = filterset.qs
    # paginator = PageNumberPagination()
    # paginator.page_size = 10
    # result_page = paginator.paginate_queryset(queryset, request)
    # serializer = EnrolledCourseSerializer(result_page, many=True)
    # return paginator.get_paginated_response(serializer.data)
    filterset = EnrollCourseFilter(request.GET, queryset=enrollments)
    if filterset.is_valid():
        queryset = filterset.qs
        paginator = PageNumberPagination()
        paginator.page_size = 10
        result_page = paginator.paginate_queryset(queryset, request)
        serializer = MycoursesSerializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)
コード例 #4
0
ファイル: views.py プロジェクト: sibis/acme-inc
def list_products(request):
    """
	The products lists with info and date time
	"""
    try:
        paginator = PageNumberPagination()
        paginator.page = request.GET.get('page') or 1
        paginator.page_size = 10
        product_status = request.GET.get('status') or [1, 2]
        product_status = json.loads(product_status)
        search_term = request.GET.get('search') or ""
        products_objects = ProductInfo.objects.filter(
            (Q(status__in=product_status))
            & (Q(name__icontains=search_term) | Q(sku__icontains=search_term)
               | Q(description__icontains=search_term)))
        result_page = paginator.paginate_queryset(products_objects, request)
        products = FetchProductsSerializer(result_page, many=True)
        return Response(
            {
                'msg': 'Products information retrived successfully!',
                'data': products.data
            },
            status=status.HTTP_200_OK)
    except Exception as e:
        return Response({'msg': str(e)}, status=status.HTTP_400_BAD_REQUEST)
コード例 #5
0
def chat_api_view(request):
    if request.method == "GET":

        # Set Pagination
        paginator = PageNumberPagination()
        paginator.page_size = 100
        obj = Chat.objects.filter(roomid_id=1).order_by('datetime')
        for i in obj:
            i.time = i.datetime.time()


        if obj:
            result_page = paginator.paginate_queryset(obj, request)
            serializer = ChatSerializer(result_page, many=True)

            return paginator.get_paginated_response(serializer.data)

        else:
            return Response(status=status.HTTP_404_NOT_FOUND)

    else:
        return Response(status=status.HTTP_400_BAD_REQUEST)

        #     data = {}
    #     print(request.data)
    #     serializer = DocumentSerializer(data=request.data)
    #     if serializer.is_valid():
    #         data['response'] = "that was good"
    #     else:
    #         data['response'] = "your file has problem"
    # else:
    #     return Response(status=status.HTTP_400_BAD_REQUEST)
    #     pass
    # return Response(data={'respose':'ok'})
コード例 #6
0
ファイル: views.py プロジェクト: wx139/ConchIOT_Back
    def get(self, request, format="JSON"):
        try:
            per_list = Permission.objects.filter()
            page = PageNumberPagination()  # 生成分页器对象
            page.page_size = 100  # 设置每页的条数
            # page.page_query_param = 'page'  # url中查询第几页的key默认为'page
            # page.page_size_query_param = 'limit'  # url中这一页数据的条数的key, 默认为None
            page.max_page_size = 50  # 每页的最大数据条数

            page_list = page.paginate_queryset(per_list, request,
                                               self)  # 生成这一页的数据列表
            # page_list.
            # 将这一页的数据列表序列化
            # return Response(ret.data)  # 返回查到的数据列表
            ret = PowerSerializer(page_list, many=True)
            for data in ret.data:
                data['children'] = []

            for data in ret.data:
                if data['parent']:
                    for vdata in ret.data:
                        if vdata['id'] == data['parent']:
                            vdata['children'].append((data))
            Per = []
            for data in ret.data:
                if data['parent'] == None:
                    Per.append(data)
            jsondata = {}
            jsondata['code'] = 20000
            jsondata['total'] = page.page.paginator.count
            jsondata['items'] = Per
            return Response(jsondata)
        except:
            return Response({'code': 0, 'msg': '设备列表获取失败'})
コード例 #7
0
def new_arrival_product_list(request, currency_id, lang):
    """
    List the the products ordered from newest arrival to oldest in paginated view
    """
    if request.method == 'GET':
        if not Currency.exists(currency_id):
            return Response(data={"message": "currency doesn't exist"},
                            status=status.HTTP_404_NOT_FOUND)

        paginator = PageNumberPagination()
        paginator.page_size = 10

        # @TODO: fix duplicate products

        recent_products = Product.objects.raw('''
            SELECT product.*
            FROM Products_Product product
            JOIN Orders_Purchase purchase ON product.id = purchase.product_id
            WHERE product.balance > 0
            AND product.active = True
            ORDER BY purchase.id DESC; 
            ''')
        result_page = paginator.paginate_queryset(recent_products, request)
        serializer = ProductSerializer(result_page,
                                       many=True,
                                       context={
                                           'lang': lang,
                                           'curr': currency_id
                                       })
        return paginator.get_paginated_response(serializer.data)
コード例 #8
0
ファイル: views.py プロジェクト: umairkhan987/Job-Boards
def task_detail_view(request, pk, *args, **kwargs):
    try:
        task = PostTask.objects.get(id=pk)

        if task.job_status == "Completed":
            return Response({"detail": "Not Found"}, status=404)
        proposal = task.proposals.all().select_related(
            'user', 'user__profile').order_by('created_at')

        paginator = PageNumberPagination()
        paginator.page_size = 4
        paginator_qs = paginator.paginate_queryset(proposal, request)
        proposal_serializer = ProposalSerializer(paginator_qs, many=True)

        serializer = TasksSerializer(task,
                                     many=False,
                                     context={"request": request})
        context = {
            "task": serializer.data,
            "proposals": proposal_serializer.data,
        }
        return paginator.get_paginated_response(context)
        # return Response(proposals, status=200)
    except PostTask.DoesNotExist:
        return Response({"detail": "Not Found"}, status=404)
コード例 #9
0
ファイル: views.py プロジェクト: wx139/ConchIOT_Back
    def get(self, request, format="JSON"):
        user = request.user
        try:
            dept_id = user.dept.id
            dept_arr = []
            depts = Department.objects.all()
            getDept(dept_id, depts, dept_arr).append(dept_id)
            query_params = list(request.query_params.keys())
            kwargs = {}
            if 'title' in query_params:
                kwargs['title__contains'] = request.query_params['title']
            kwargs['dept_id__in'] = dept_arr
            print(dept_arr)
            type_list = Role.objects.filter(**kwargs)
            page = PageNumberPagination()  # 生成分页器对象
            page.page_size = 20  # 设置每页的条数
            page.page_query_param = 'page'  # url中查询第几页的key默认为'page
            page.page_size_query_param = 'limit'  # url中这一页数据的条数的key, 默认为None
            # page.max_page_size = 5  # 每页的最大数据条数

            page_list = page.paginate_queryset(type_list, request,
                                               self)  # 生成这一页的数据列表
            # page_list.
            # 将这一页的数据列表序列化
            # return Response(ret.data)  # 返回查到的数据列表
            ret = Roleserializer(page_list, many=True)
            jsondata = {}
            jsondata['code'] = 20000
            jsondata['total'] = page.page.paginator.count
            jsondata['items'] = ret.data
            return Response(jsondata)
        except:
            return Response({'code': 0, 'msg': '设备列表获取失败'})
コード例 #10
0
 def list(self, request):
     paginator = PageNumberPagination()
     paginator.page_size = 5
     queryset = Goods.objects.all()
     result_page = paginator.paginate_queryset(queryset, request)
     serializer = GameItemSerializer(result_page, many=True)
     return paginator.get_paginated_response(serializer.data)
コード例 #11
0
def search_person(request):
    """
    This Endpoint is for searching contact 
    details of a person based on their 
    email id or name. 
    We will paginate this for 10 items at a time.

    """

    try:
        persons = None
        paginator = PageNumberPagination()
        paginator.page_size = 10
        name = request.GET.get("name")
        email = request.GET.get("email")
        if name and email:
            persons = Person.objects.filter(name__icontains=name,
                                            email__email__icontains=email)
        elif name:
            persons = Person.objects.filter(name__icontains=name)
        elif email:
            persons = Person.objects.filter(email__email__icontains=email)
        else:
            persons = Person.objects.all()
        paginated_persons = paginator.paginate_queryset(persons, request)
        serializer = PersonDetailSerializer(paginated_persons, many=True)
        return Response(serializer.data, status=status.HTTP_200_OK)
    except:
        print(traceback.format_exc())
        return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
コード例 #12
0
ファイル: views.py プロジェクト: usama2762/recipts-backend
 def list(self, request):
     queryset = Image.objects.all()
     paginator = PageNumberPagination()
     paginator.page_size = 100
     page = paginator.paginate_queryset(queryset, request)
     serializer = ImageSerializer(page, many=True).data
     return Response({"results": serializer})
コード例 #13
0
ファイル: views.py プロジェクト: nonomal/MrDoc
    def get(self, request):
        username = request.query_params.get('username', '')
        page_num = request.query_params.get('page', 1)
        limit = request.query_params.get('limit', 10)
        if username == '':
            user_data = User.objects.all().values('id', 'last_login',
                                                  'is_superuser', 'username',
                                                  'email', 'date_joined',
                                                  'is_active', 'first_name')
        else:
            user_data = User.objects.filter(
                username__icontains=username).values('id', 'last_login',
                                                     'is_superuser',
                                                     'username', 'email',
                                                     'date_joined',
                                                     'is_active', 'first_name')

        page = PageNumberPagination()  # 实例化一个分页器
        page.page_size = limit
        page_users = page.paginate_queryset(user_data, request,
                                            view=self)  # 进行分页查询
        serializer = UserSerializer(page_users, many=True)  # 对分页后的结果进行序列化处理
        resp = {'code': 0, 'data': serializer.data, 'count': user_data.count()}

        return Response(resp)
コード例 #14
0
def CategoryView(request, categoryId=None):
    try:

        if request.method == "GET":
            if categoryId:
                c = Category.objects.get(id=categoryId)
                serializer = CategoryFormSerializer(c)
                return Response(serializer.data, status=status.HTTP_200_OK)
            else:

                if request.query_params.get('limit'):
                    paginator = PageNumberPagination()
                    paginator.page_size = 10
                    m = MenuItem.objects.all().order_by('item_id')
                    result_page = paginator.paginate_queryset(m, request)
                    serializer = MenuItemSerializer(m, many=True)
                    return paginator.get_paginated_response(serializer.data)

                else:
                    c = Category.objects.all()
                    serializer = CategoryFormSerializer(c, many=True)
                    return Response(serializer.data, status=status.HTTP_200_OK)

        else:
            context = {}
            context['method'] = request.method
            return Response({'detail': context},
                            status=status.HTTP_400_BAD_REQUEST)

    except Exception as e:
        context = {}
        context['details'] = str(e)
        return Response(context, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
コード例 #15
0
def get_items_by_filter(request):
    # items = Item.objects.all()
    psize = 10
    data = request.GET
    if data.get('from_date', False) is not False:
        from_date_string = data['from_date'].replace('T', ' ') + ":00"
        to_date_string = data['to_date'].replace('T', ' ') + ":59"
        from_date = datetime.strptime(from_date_string, '%Y-%m-%d %H:%M:%S')
        to_date = datetime.strptime(to_date_string, '%Y-%m-%d %H:%M:%S')
        items = Item.objects.filter(published_date__range=(from_date, to_date))
        ordered = sorted(items,
                         key=lambda item: datetime.strptime(
                             item.published_date, '%Y-%m-%d %H:%M:%S'),
                         reverse=True)
    else:
        items = Item.objects.all()
        ordered = sorted(items,
                         key=lambda item: datetime.strptime(
                             item.published_date, '%Y-%m-%d %H:%M:%S'),
                         reverse=True)
    if data.get('size', False) is not False:
        psize = data['size']
    # print(psize)
    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)
コード例 #16
0
ファイル: views.py プロジェクト: jonathangriguol/pyplan-ide
    def getIndexValues(request, *args, **kargs):
        serialized_rq = DashboardGetIndexValuesSerializer(
            data=request.query_params)
        serialized_rq.is_valid(raise_exception=True)

        service = DashboardManagerService(request)
        query_set = service.getIndexValues(serialized_rq.validated_data)

        if query_set:

            paginator = PageNumberPagination()
            paginator.page_size = 1000

            new_query_set = []
            for item in query_set['results']:
                new_query_set.append(item)
            try:
                context = paginator.paginate_queryset(new_query_set, request)

                paginated_context = paginator.get_paginated_response(context)

                serializer = NodeDimensionValueSerializer(context, many=True)
                # absolute_uri = request.build_absolute_uri()
                return Response({
                    'next': paginated_context.data['next'],
                    'previous': paginated_context.data['previous'],
                    'count': paginated_context.data['count'],
                    'results': serializer.data,
                })
            except Exception as ex:
                pass
        return Response(status=status.HTTP_204_NO_CONTENT)
コード例 #17
0
    def get(self, request, slug, formate=None):
        paginator = PageNumberPagination()
        paginator.page_size = 10
        profile = get_object_or_404(UsersProfile, slug=slug)
        attachment = ActivityAttachment.objects.filter(
            auth_user=profile.auth_user, type='AUDIO')
        # retrieve hidden
        activity_hidden = ActivityControl.objects.filter(
            auth_user=request.user).filter(
                Q(is_hidden=True) | Q(is_reported=True)).values('activity_id')

        activity_data = Activity.objects.filter(pk__in=[activity.activity.pk for activity in attachment]) \
            .exclude(pk__in=[activity_hidden])
        if activity_data:
            result_page = paginator.paginate_queryset(activity_data, request)
            data = ActivitySerializer(instance=result_page,
                                      many=True,
                                      context={
                                          'request': request
                                      }).data
            return paginator.get_paginated_response(data)
        else:
            raise DataNotFoundException

        return Response(status=HTTP_500_INTERNAL_SERVER_ERROR)
コード例 #18
0
def get_team_list(request, format=None):
    paginator = PageNumberPagination()
    paginator.page_size = 25
    teams = Team.objects.filter(active=True).order_by('name')
    result_page = paginator.paginate_queryset(teams, request)
    serializer = TeamShortSerializer(result_page, many=True)
    return paginator.get_paginated_response(serializer.data)
コード例 #19
0
    def get(self, request, format=None):
        paginator = PageNumberPagination()
        paginator.page_size = 10
        # retrieve hidden
        activity_hidden = ActivityControl.objects.filter(
            auth_user=request.user).filter(
                Q(is_hidden=True) | Q(is_reported=True)).values('activity_id')
        # TODO get connection posts Friends or Company
        friends = Friend.objects.friends(request.user)
        friends.append(request.user)
        # Get company post
        profile_session = ProfileSession(request)
        company = profile_session.get_company()
        if company:
            company = company[1]

        if company:
            print("is company")
            activity_data = Activity.objects.filter(company=company, blocked=False) \
                .exclude(pk__in=[activity_hidden]).prefetch_related('activity_attachment')
        else:
            activity_data = Activity.objects.filter(auth_user__in=[user for user in friends], blocked=False) \
                .exclude(pk__in=[activity_hidden]).prefetch_related('activity_attachment')
        if activity_data:
            result_page = paginator.paginate_queryset(activity_data, request)
            data = ActivitySerializer(instance=result_page,
                                      many=True,
                                      context={
                                          'request': request
                                      }).data
            return paginator.get_paginated_response(data)
        else:
            raise DataNotFoundException

        return Response(status=HTTP_500_INTERNAL_SERVER_ERROR)
コード例 #20
0
def search_resultado_api_view(request):
    """
    Vista para buscar y listar todas las ordenes o recepciones de acuerdo a un parametro
    de busqueda.
    """

    param = request.GET.get('param', '')
    terminadas = request.GET.get('terminadas', '')
    pagination = PageNumberPagination()
    pagination.page_size = 10
    querys = (
        Q(orden__paciente__pnombre__icontains=param) | Q(orden__paciente__papellido__icontains=param) |
        Q(orden__paciente__cedula__icontains=param) | Q(orden__id__icontains=param) |
        Q(orden__institucion__razon__icontains=param) | Q(orden__empresa__razon__icontains=param) |
        Q(orden__empresa_cliente__icontains=param)
    )

    # servicios = Laboratorio.objects.all().values_list('servicio_id', flat=True)
    ordenes = Recepcion.objects.filter(querys).select_related('orden').exclude(orden__anulada=True).order_by(
        'orden__paciente__pnombre', 'orden__paciente__papellido')

    if terminadas:
        ordenes = ordenes.filter(estado=Recepcion.RESULTADO_EMITIDO)
    else:
        ordenes = ordenes.filter(estado=Recepcion.EN_CURSO)

    result_pagination = pagination.paginate_queryset(ordenes, request)
    serializer = RecepcionSerializer(result_pagination, many=True)
    return pagination.get_paginated_response(serializer.data)
コード例 #21
0
def get_channel(request):
    chan = Channel.objects.all()
    paginator = PageNumberPagination()
    paginator.page_size = 1
    result_page = paginator.paginate_queryset(chan, request)
    chan_ser = ChannelReadSerializer(result_page, many=True)
    return paginator.get_paginated_response(chan_ser.data)
コード例 #22
0
ファイル: views.py プロジェクト: vocuzi/bank-ifsc-api
def bank_details(request):
    if request.method == "POST":
        if request.data.get("ifsc"):
            """
			Get bank details with IFSC Code
			"""
            banks = Bank.objects.filter(ifsc=request.data["ifsc"])
            if banks.count():
                serializer = BankSerializer(banks[0])
                return Response(serializer.data)
            else:
                return Response(status=status.HTTP_404_NOT_FOUND)
        if request.data.get("name") and request.data.get("city"):
            """
			Get list of banks with Bank name and City in input
			"""
            paginator = PageNumberPagination()
            paginator.page_size = 10
            banks = Bank.objects.filter(bank_name=request.data["name"],
                                        city=request.data.get("city"))
            payload = paginator.paginate_queryset(banks, request)
            serializer = BankSerializer(payload, many=True)
            return paginator.get_paginated_response(serializer.data)
        else:
            return Response(status=status.HTTP_400_BAD_REQUEST)
    return Response(status=status.HTTP_405_METHOD_NOT_ALLOWED)
コード例 #23
0
def get_post_diagnosis(request):
	#get all diagnosis
	if request.method == 'GET':
		paginator = PageNumberPagination()
		paginator.page_size = 20
		diagnosis = DiagnosisCode.objects.get_queryset().order_by('id')
		result_page = paginator.paginate_queryset(diagnosis, request)
		serializer = DiagnosisCodeSerializer(result_page,many=True)
		return paginator.get_paginated_response(serializer.data)
	#insert a new record for a diagnosis
	elif request.method == 'POST':
		data = {
			'category_code' : request.data.get('category_code'),
			'diagnosis_code' : request.data.get('diagnosis_code'),
			'full_code' : request.data.get('full_code'),
			'abbreviated_description' : request.data.get('abbreviated_description'),
			'full_description' : request.data.get('full_description'),
			'category_title' : request.data.get('category_title')
		}

		serializer = DiagnosisCodeSerializer(data=data)
		if serializer.is_valid():
			serializer.save()
			return Response(serializer.data, status=status.HTTP_201_CREATED)
		return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
コード例 #24
0
ファイル: views.py プロジェクト: shivanXI/EvalAI
def get_all_challenges(request, challenge_time):
    """
    Returns the list of all challenges
    """
    try:
        q_params = {'published': True}
        if challenge_time.lower() == "past":
            q_params['end_date__lt'] = timezone.now()

        elif challenge_time.lower() == "present":
            q_params['start_date__lt'] = timezone.now()
            q_params['end_date__gt'] = timezone.now()

        elif challenge_time.lower() == "future":
            q_params['start_date__gt'] = timezone.now()

        challenge = Challenge.objects.filter(**q_params)
        paginator = PageNumberPagination()
        paginator.page_size = settings.REST_FRAMEWORK['PAGE_SIZE']
        result_page = paginator.paginate_queryset(challenge, request)
        serializer = ChallengeSerializer(result_page, many=True)
        response_data = serializer.data
        return paginator.get_paginated_response(response_data)
    except:
        response_data = {'error': 'Wrong url pattern!'}
        return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)
コード例 #25
0
 def get(self, request):
     # get a task
     filters = {"user": request.user}
     for key in request.GET:
         if key != "page":
             filters[key] = request.GET[key]
     try:
         print(filters)
         tasks = Task.objects.filter(**filters).order_by("due_on")
         paginator = PageNumberPagination()
         paginator.page_size = 15
         result_page = paginator.paginate_queryset(tasks, request)
         serializer = TaskSerializer(result_page,
                                     many=True,
                                     context={"request": request})
         return Response({
             "current_page": request.GET['page'],
             "total_pages": math.ceil(len(tasks) / 15),
             "count": len(result_page),
             "data": serializer.data
         })
     except KeyError:
         return Response(data={
             "message":
             "Bad request. The allowed fields are given in this response. You can use standard Django Queryset filters",
             "allowed_fields":
             "created_at, desc, due_on, labels, name, status, subtasks, user, user_id, uuid"
         },
                         status=status.HTTP_400_BAD_REQUEST)
コード例 #26
0
ファイル: views.py プロジェクト: shitalluitel/Django-test-API
 def get(self, request, format=None):
     api = Api.objects.all()
     paginator = PageNumberPagination()
     paginator.page_size = 2
     result_page = paginator.paginate_queryset(api, request)
     serializer = ApiSerializer(result_page, many=True)
     return paginator.get_paginated_response(serializer.data)
コード例 #27
0
ファイル: views.py プロジェクト: pmlynarski/PPS_BACKEND
    def search_for_group(self, request):

        if request.data.get('phrase'):
            phrase = request.data.get('phrase')
            groups = Group.objects.filter(name__contains=phrase)
        else:
            phrase = '  '
            groups = Group.objects.all()

        if len(phrase) < 2:
            return Response(
                data={'message': 'You provided too short search phrase'},
                status=status.HTTP_406_NOT_ACCEPTABLE)

        paginator = PageNumberPagination()
        paginator.page_size = 10
        response_groups = GroupSerializer(groups,
                                          context={
                                              'host': request.get_host()
                                          },
                                          many=True).data
        data = paginator.paginate_queryset(response_groups, request)
        if len(data) == 0:
            return Response(status=status.HTTP_406_NOT_ACCEPTABLE,
                            data={'message': 'No groups were found'})
        return paginator.get_paginated_response(data=data)
コード例 #28
0
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)
    return paginator.get_paginated_response(
        serializer.data)  # Response( serializer.data, status=200)
コード例 #29
0
ファイル: views.py プロジェクト: brooklikeme/tigercnc
    def list(self, request):
        rows = 12
        if request.query_params.has_key('rows'):
            rows = request.query_params.get('rows').strip()

        paginator = PageNumberPagination()
        paginator.page_size = rows
        sort_field = "-update_time"
        if request.query_params.has_key('sort'):
            sort_field = request.query_params.get('sort')
        queryset = Image.objects.all().order_by(sort_field)

        if request.query_params.has_key('imagefolder_id'):
            if request.query_params.get('imagefolder_id') == '-1':
                queryset = queryset
            elif request.query_params.get('imagefolder_id') == '-2':
                queryset = queryset.exclude(is_video=True)
            elif request.query_params.get('imagefolder_id') == '-3':
                queryset = queryset.filter(is_video=True)
            elif request.query_params.get('imagefolder_id') == '-4':
                queryset = queryset.filter(imagefolder_id__isnull=True)
            else:
                queryset = queryset.filter(imagefolder_id=request.query_params.
                                           get('imagefolder_id').strip())

        result_page = paginator.paginate_queryset(queryset, request)
        serializer = ImageSerializer(result_page, many=True)

        return_result = paginator.get_paginated_response(serializer.data)
        if request.query_params.has_key('page'):
            return_result.data['page'] = request.query_params.get('page')
        else:
            return_result.data['page'] = 1

        return return_result
コード例 #30
0
ファイル: views.py プロジェクト: shivanXI/EvalAI
def challenge_list(request, challenge_host_team_pk):
    try:
        challenge_host_team = ChallengeHostTeam.objects.get(
            pk=challenge_host_team_pk)
    except ChallengeHostTeam.DoesNotExist:
        response_data = {'error': 'ChallengeHostTeam does not exist'}
        return Response(response_data, status=status.HTTP_406_NOT_ACCEPTABLE)

    if request.method == 'GET':
        challenge = Challenge.objects.filter(creator=challenge_host_team)
        paginator = PageNumberPagination()
        paginator.page_size = settings.REST_FRAMEWORK['PAGE_SIZE']
        result_page = paginator.paginate_queryset(challenge, request)
        serializer = ChallengeSerializer(result_page, many=True)
        response_data = serializer.data
        return paginator.get_paginated_response(response_data)

    elif request.method == 'POST':
        serializer = ChallengeSerializer(
            data=request.data,
            context={'challenge_host_team': challenge_host_team})
        if serializer.is_valid():
            serializer.save()
            response_data = serializer.data
            return Response(response_data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
コード例 #31
0
ファイル: pagination.py プロジェクト: ncs-jss/HTTP_200
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)
コード例 #32
0
ファイル: views.py プロジェクト: classifaddict/classifactory
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)
コード例 #33
0
ファイル: views.py プロジェクト: msarabi95/easy-internship
    def plans(self, request, pk, *args, **kwargs):
        batch = get_object_or_404(Batch, id=pk)
        plans = Internship.objects.filter(intern__batch=batch).prefetch_related(
            'rotation_requests__requested_department__department__hospital',
            'rotation_requests__requested_department__department__specialty',
            'rotation_requests__response',
            'rotation_requests__forward',
            'rotations__department__specialty',
            'rotations__department__hospital',
            'intern__profile__user__freezes',
            'intern__profile__user__freeze_requests__response',
            'intern__profile__user__freeze_cancel_requests__response',
            'intern__profile__user__leaves',
            'intern__profile__user__leave_requests__response',
            'intern__profile__user__leave_cancel_requests__response',
            'intern__university',
            'intern__batch',
        ).order_by(
            Lower('intern__profile__en_first_name'),
            Lower('intern__profile__en_father_name'),
            Lower('intern__profile__en_grandfather_name'),
            Lower('intern__profile__en_last_name'),
        )

        filtered = InternshipFilter({'intern__profile__en_full_name': request.query_params.get('query')}, plans)

        paginator = PageNumberPagination()
        paginator.page_size = 10
        page = paginator.paginate_queryset(filtered.qs, request)

        if page is not None:
            serialized = FullInternshipSerializer2(page, many=True)
            return paginator.get_paginated_response(serialized.data)

        serialized = FullInternshipSerializer2(filtered.qs, many=True)
        return Response(serialized.data)
コード例 #34
0
ファイル: views.py プロジェクト: classifaddict/classifactory
def element_fancy_search(request, query):
    """
    List all ancestors' pk of the first element found.
    """

    queryset = TreeNode.objects.only('id')

    for param in query.split():
        if '!' in param:
            p = param.split('!')
            if len(p) > 2:
                break
            queryset = queryset.filter(
                dataset__doctype__name=p[0],
                dataset__name=p[1]
            )
        elif '@' in param:
            # Search specified element by attribute
            p = param.split('@')
            if len(p) > 2:
                continue
            if p[0] and p[1]:
                if '=' in p[1]:
                    a = p[1].split('=')
                    if len(a) > 2:
                        continue
                    if a[0] and a[1]:
                        # 'e@a=v' Search specified element by attribute name and value
                        queryset = queryset.filter(
                            element__type__name=p[0],
                            element__attributes__type__name=a[0],
                            element__attributes__value=a[1]
                        )
                    elif a[1]:
                        # 'e@=v' Search specified element by attribute value
                        queryset = queryset.filter(
                            element__type__name=p[0],
                            element__attributes__value=a[1]
                        )
                else:
                    # 'e@a' Search specified element by attribute name
                    queryset = queryset.filter(
                        element__type__name=p[0],
                        element__attributes__type__name=p[1],
                    )
            elif p[1]:
                # Search any element by attribute
                if '=' in p[1]:
                    a = p[1].split('=')
                    if len(a) > 2:
                        continue
                    if a[0] and a[1]:
                        # '@a=v' Search any element by attribute name and value
                        queryset = queryset.filter(
                            element__attributes__type__name=a[0],
                            element__attributes__value=a[1]
                        )
                    elif a[1]:
                        # '@=v' Search any element by attribute value
                        queryset = queryset.filter(
                            element__attributes__value=a[1]
                        )
                else:
                    # '@a' Search any element by attribute name
                    queryset = queryset.filter(
                        element__attributes__type__name=p[1]
                    )
            else:
                # '@' Search any element with attribute
                queryset = queryset.filter(
                    element__attributes__isnull=False
                )
        else:
            # if '=' in p[1]:
                # 'e=t' Search element by content
            # else:
            # 'e' Search specified element by name
            queryset = queryset.filter(
                element__type__name=param
            )

    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)