def get_page_index(self, qs):
page_size = self.max_paginate_by or 9999
if self.paginate_by_param:
try:
page_size = strict_positive_int(
self.request.QUERY_PARAMS[self.paginate_by_param],
cutoff=self.max_paginate_by)
except (KeyError, ValueError):
pass
paginator = self.paginator_class(qs,
page_size,
allow_empty_first_page=True)
page_kwarg = self.kwargs.get(self.page_kwarg)
page_query_param = self.request.QUERY_PARAMS.get(self.page_kwarg)
page = page_kwarg or page_query_param or 1
try:
page_number = strict_positive_int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404(
_("Page is not 'last', nor can it be converted to an int.")
)
try:
page = paginator.page(page_number)
return page
except InvalidPage as e:
raise Http404(
_('Invalid page (%(page_number)s): %(message)s') % {
'page_number': page_number,
'message': str(e)
})
def get_page_index(self, qs):
page_size=self.max_paginate_by or 9999
if self.paginate_by_param:
try:
page_size= strict_positive_int(
self.request.QUERY_PARAMS[self.paginate_by_param],
cutoff=self.max_paginate_by
)
except (KeyError, ValueError):
pass
paginator = self.paginator_class(qs, page_size,
allow_empty_first_page=True)
page_kwarg = self.kwargs.get(self.page_kwarg)
page_query_param = self.request.QUERY_PARAMS.get(self.page_kwarg)
page = page_kwarg or page_query_param or 1
try:
page_number = strict_positive_int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404(_("Page is not 'last', nor can it be converted to an int."))
try:
page = paginator.page(page_number)
return page
except InvalidPage as e:
raise Http404(_('Invalid page (%(page_number)s): %(message)s') % {
'page_number': page_number,
'message': str(e)
})
def paginate_queryset(self, queryset, page_size=None):
"""
Paginate a queryset if required, either returning a page object,
or `None` if pagination is not configured for this view.
"""
deprecated_style = False
if page_size is not None:
warnings.warn('The `page_size` parameter to `paginate_queryset()` '
'is due to be deprecated. '
'Note that the return style of this method is also '
'changed, and will simply return a page object '
'when called without a `page_size` argument.',
PendingDeprecationWarning, stacklevel=2)
deprecated_style = True
else:
# Determine the required page size.
# If pagination is not configured, simply return None.
page_size = self.get_paginate_by()
if not page_size:
return None
# if not self.allow_empty:
# warnings.warn(
# 'The `allow_empty` parameter is due to be deprecated. '
# 'To use `allow_empty=False` style behavior, You should override '
# '`get_queryset()` and explicitly raise a 404 on empty querysets.',
# PendingDeprecationWarning, stacklevel=2
# )
paginator = self.paginator_class(queryset, page_size,
allow_empty_first_page=True)
page_kwarg = self.kwargs.get(self.page_kwarg)
page_query_param = self.request.QUERY_PARAMS.get(self.page_kwarg)
page = page_kwarg or page_query_param or 1
try:
page_number = generics.strict_positive_int(page)
except ValueError:
if page == 'last':
page_number = paginator.num_pages
else:
raise Http404("Page is not 'last', nor can it be converted to an int.")
try:
page = paginator.page(page_number)
except InvalidPage as e:
# here is where we override the default paginator behavior
# rather than fail, try and return a valid page
try:
if page_number > paginator.num_pages:
page = paginator.page(paginator.num_pages)
else:
page = paginator.page(1)
except:
raise Http404('Invalid page (%(page_number)s): %(message)s' % {
'page_number': page_number,
'message': str(e)
})
if deprecated_style:
return (paginator, page, page.object_list, page.has_other_pages())
return page
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all HE InVisualizations
queryset = HistoricalEventsInVisualizations.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(self.request,
queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(self.request,
queryset, self)
# Filter the set by potential filters
queryset = VisualizationsLinkedByEventFilter(request.GET,
queryset=queryset)
# Set the pagination
# set defaul
page_size = 10
# get url param
request_page_size = request.QUERY_PARAMS.get('page_size')
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
# Set the pagination
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get('page')
try:
eventsinvisualizations = paginator.page(page)
except PageNotAnInteger:
eventsinvisualizations = paginator.page(1)
except EmptyPage:
eventsinvisualizations = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListVisualizationLinkedByEventSerializer(
eventsinvisualizations)
# log.info(paginator.page_range)
# return set_jsonschema_link_header(Response(serializer.data), 'visualization_collection', request)
return Response(serializer.data)
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all HE InVisualizations
queryset = HistoricalEventsInVisualizations.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(
self.request, queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(
self.request, queryset, self)
# Filter the set by potential filters
queryset = VisualizationsLinkedByEventFilter(request.GET,
queryset=queryset)
# Set the pagination
# set defaul
page_size = 10
# get url param
request_page_size = request.QUERY_PARAMS.get('page_size')
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
# Set the pagination
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get('page')
try:
eventsinvisualizations = paginator.page(page)
except PageNotAnInteger:
eventsinvisualizations = paginator.page(1)
except EmptyPage:
eventsinvisualizations = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListVisualizationLinkedByEventSerializer(
eventsinvisualizations)
# log.info(paginator.page_range)
# return set_jsonschema_link_header(Response(serializer.data), 'visualization_collection', request)
return Response(serializer.data)
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all Datasets In Visualizations
# queryset = MetricsInVisualizations.objects.all()
queryset = DatasetsInVisualizations.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(self.request,
queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(self.request,
queryset, self)
# Filter the set by potential filters
queryset = VisualizationsLinkedByDatasetFilter(request.GET,
queryset=queryset)
# Set the pagination
page_size = 10
request_page_size = request.QUERY_PARAMS.get('page_size')
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
# Set the pagination
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get('page')
try:
datasetsinvisualizations = paginator.page(page)
except PageNotAnInteger:
datasetsinvisualizations = paginator.page(1)
except EmptyPage:
datasetsinvisualizations = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListVisualizationLinkedByDatasetSerializer(
datasetsinvisualizations)
return Response(serializer.data)
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all Datasets In Visualizations
# queryset = MetricsInVisualizations.objects.all()
queryset = DatasetsInVisualizations.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(
self.request, queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(
self.request, queryset, self)
# Filter the set by potential filters
queryset = VisualizationsLinkedByDatasetFilter(request.GET,
queryset=queryset)
# Set the pagination
page_size = 10
request_page_size = request.QUERY_PARAMS.get('page_size')
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
# Set the pagination
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get('page')
try:
datasetsinvisualizations = paginator.page(page)
except PageNotAnInteger:
datasetsinvisualizations = paginator.page(1)
except EmptyPage:
datasetsinvisualizations = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListVisualizationLinkedByDatasetSerializer(
datasetsinvisualizations)
return Response(serializer.data)
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all visualizations
queryset = Visualization.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(self.request, queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(self.request, queryset, self)
# Filter the set by potential filters
queryset = VisualizationFilter(request.GET, queryset=queryset)
# Set the pagination
# set defaul
page_size = 10
# get url param
request_page_size = request.QUERY_PARAMS.get("page_size")
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
# Set the pagination
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get("page")
try:
visualizations = paginator.page(page)
except PageNotAnInteger:
visualizations = paginator.page(1)
except EmptyPage:
visualizations = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListDatasetSerializer(visualizations)
# log.info(paginator.page_range)
return Response(serializer.data)
def get(self, request):
"""
Builds the representation for the GET method.
"""
# Get all metrics
queryset = Metric.objects.all()
# Perform a search
queryset = filters.SearchFilter().filter_queryset(self.request, queryset, self)
# Order the set accordingly to query parameters
queryset = filters.OrderingFilter().filter_queryset(self.request, queryset, self)
# Filter the set by potential filters
queryset = MetricFilter(request.GET, queryset=queryset)
# Set the pagination
page_size = 10
request_page_size = request.QUERY_PARAMS.get('page_size')
if request_page_size:
try:
page_size = strict_positive_int(request_page_size)
except (KeyError, ValueError):
pass
paginator = Paginator(queryset, page_size)
page = request.QUERY_PARAMS.get('page')
try:
metrics = paginator.page(page)
except PageNotAnInteger:
metrics = paginator.page(1)
except EmptyPage:
metrics = paginator.page(paginator.num_pages)
# Serialize the data
serializer = PaginatedListMetricSerializer(metrics)
return set_jsonschema_link_header(Response(serializer.data), 'metric_collection', request)
