示例#1
0
  def list_shelves(self, request):
    """List enabled or all shelves based on any shelf attribute."""
    self.check_xsrf_token(self.request_state)
    if request.page_size <= 0:
      raise endpoints.BadRequestException(
          'The value for page_size must be greater than 0.')
    query, sort_options, returned_fields = (
        search_utils.set_search_query_options(request.query))
    if not query:
      query = search_utils.to_query(request, shelf_model.Shelf)

    offset = search_utils.calculate_page_offset(
        page_size=request.page_size, page_number=request.page_number)

    search_results = shelf_model.Shelf.search(
        query_string=query, query_limit=request.page_size,
        offset=offset, sort_options=sort_options,
        returned_fields=returned_fields)
    total_pages = search_utils.calculate_total_pages(
        page_size=request.page_size, total_results=search_results.number_found)

    shelves_messages = []
    for document in search_results.results:
      message = search_utils.document_to_message(
          document, shelf_messages.Shelf())
      message.shelf_request = shelf_messages.ShelfRequest()
      message.shelf_request.urlsafe_key = document.doc_id
      message.shelf_request.location = message.location
      shelves_messages.append(message)

    return shelf_messages.ListShelfResponse(
        shelves=shelves_messages,
        total_results=search_results.number_found,
        total_pages=total_pages)
示例#2
0
    def list_shelves(self, request):
        """List enabled or all shelves based on any shelf attribute."""
        self.check_xsrf_token(self.request_state)
        query, sort_options, returned_fields = (
            search_utils.set_search_query_options(request.query))
        if not query:
            query = search_utils.to_query(request, shelf_model.Shelf)

        cursor = search_utils.get_search_cursor(request.page_token)
        search_results = shelf_model.Shelf.search(
            query_string=query,
            query_limit=request.page_size,
            cursor=cursor,
            sort_options=sort_options,
            returned_fields=returned_fields)
        new_search_cursor = None
        if search_results.cursor:
            new_search_cursor = search_results.cursor.web_safe_string

        shelves_messages = []
        for document in search_results.results:
            message = search_utils.document_to_message(document,
                                                       shelf_messages.Shelf())
            message.shelf_request = shelf_messages.ShelfRequest()
            message.shelf_request.urlsafe_key = document.doc_id
            message.shelf_request.location = message.location
            shelves_messages.append(message)

        return shelf_messages.ListShelfResponse(
            shelves=shelves_messages,
            additional_results=bool(new_search_cursor),
            page_token=new_search_cursor)
示例#3
0
    def testListShelfResponse(self):
        list_shelf_resp = shelf_messages.ListShelfResponse(
            shelves=[],
            has_additional_results=True,
            page_token='FAKE-PAGE-TOKEN')

        self.assertListEqual(list_shelf_resp.shelves, [])
        self.assertTrue(list_shelf_resp.has_additional_results)
        self.assertEqual(list_shelf_resp.page_token, 'FAKE-PAGE-TOKEN')
示例#4
0
 def test_list_shelves_with_search_constraints(self):
     expressions = shared_messages.SearchExpression(expression='location')
     expected_response = shelf_messages.ListShelfResponse(shelves=[
         shelf_messages.Shelf(location=self.shelf.location,
                              shelf_request=shelf_messages.ShelfRequest(
                                  location=self.shelf.location,
                                  urlsafe_key=self.shelf.key.urlsafe()))
     ],
                                                          total_results=1,
                                                          total_pages=1)
     request = shelf_messages.Shelf(
         query=shared_messages.SearchRequest(query_string='location:NYC',
                                             expressions=[expressions],
                                             returned_fields=['location']))
     response = self.service.list_shelves(request)
     self.assertEqual(response, expected_response)