Esempio n. 1
0
 def paginate_query(self, query, page_size):
     """
     Paginate the query, if needed.
     """
     paginator = self.get_paginator(
         query, page_size, orphans=self.get_paginate_orphans(),
         allow_empty_first_page=self.get_allow_empty())
     page_kwarg = self.page_kwarg
     page = self.kwargs.get(page_kwarg) or self.request.GET.get(page_kwarg) or 1
     try:
         page_number = int(page)
     except ValueError:
         if page == 'last':
             page_number = paginator.num_pages
         else:
             raise httpexceptions.HTTPNotFound(_("Page is not 'last', nor can it be converted to an int."))
     try:
         page = paginator.page(page_number)
         return (paginator, page, page.object_list, page.has_other_pages())
     except InvalidPage as e:
         raise httpexceptions.HTTPNotFound(_('Invalid page (%(page_number)s): %(message)s') % {
             'page_number': page_number,
             'message': str(e)
         })
Esempio n. 2
0
 def get(self, request, *args, **kwargs):
     self.object_list = self.get_query()
     allow_empty = self.get_allow_empty()
     if not allow_empty:
         # When pagination is enabled and object_list is a query,
         # it's better to do a cheap query than to load the unpaginated
         # query in memory.
         if (self.get_paginate_by(self.object_list) is not None
                 and hasattr(self.object_list, 'exists')):
             is_empty = not self.object_list.session.query(self.object_list.exists()).scalar()
         else:
             is_empty = self.object_list.count() == 0
         if is_empty:
             raise httpexceptions.HTTPNotFound(_("Empty list and '%(class_name)s.allow_empty' is False.")
                     % {'class_name': self.__class__.__name__})
     context = self.get_context_data()
     return self.render_to_response(context)
Esempio n. 3
0
    def get_object(self, query=None):
        """
        Returns the object the view is displaying.

        By default this requires `self.query` and a `pk` or `slug` argument
        in the URLconf, but subclasses can override this to return any object.
        """
        # Use a custom query if provided; this is required for subclasses
        # like DateDetailView
        if query is None:
            query = self.get_query()

        # Next, try looking up by primary key.
        pk = self.kwargs.get(self.pk_url_kwarg, None)
        slug = self.kwargs.get(self.slug_url_kwarg, None)
        if pk is not None:
            pk_field = utils.get_pk_field(query)
            query = query.filter(pk_field==pk)

        # Next, try looking up by slug.
        elif slug is not None:
            slug_field = utils.get_field(query, self.get_slug_field())
            query = query.filter(slug_field==slug)

        # If none of those are defined, it's an error.
        else:
            raise AttributeError("Generic detail view %s must be called with "
                                 "either an object pk or a slug."
                                 % self.__class__.__name__)

        try:
            # Get the single item from the filtered query
            obj = query.one()
        except NoResultFound:
            raise httpexceptions.HTTPNotFound(_("No %(verbose_name)s found matching the query") %
                                            {'verbose_name': utils.model_from_query(query).__name__})
        return obj