def get_page_num(self, request):
"""
获取页码
:param request:
:return:
"""
if self.other_page_query_param:
for param_name in self.other_page_query_param:
if param_name in request.query_params:
return _positive_int(request.query_params[param_name], strict=True)
page_num = request.query_params.get(self.page_query_param, 1)
return _positive_int(page_num, strict=True)
def _validate_limit(self, request):
value = _positive_int(request.query_params[self.limit_query_param],
strict=True)
if value > self.max_limit:
raise ValueError
return value
def get_offset(self, query_params):
try:
return pagination._positive_int(
query_params[self.offset_query_param],
)
except (KeyError, ValueError):
return 0
def get_offset(self, request):
try:
return _positive_int(
((int(request.query_params[self.offset_query_param]) - 1) *
int(request.query_params[self.limit_query_param])), )
except (KeyError, ValueError):
return 0
def get_offset(self, *args):
if self._rql_offset is not None:
try:
return _positive_int(self._rql_offset)
except ValueError:
pass
return 0
def decode_cursor(self, request):
"""
Given a request with a cursor, return a `Cursor` instance.
"""
# Determine if we have a cursor, and if so then decode it.
encoded = request.query_params.get(self.cursor_query_param)
if encoded is None:
return None
# The offset in the cursor is used in situations where we have a
# nearly-unique index. (Eg millisecond precision creation timestamps)
# We guard against malicious users attempting to cause expensive database
# queries, by having a hard cap on the maximum possible size of the offset.
OFFSET_CUTOFF = getattr(settings, 'CURSOR_PAGINATION_OFFSET_CUTOFF',
1000)
try:
querystring = b64decode(encoded.encode('ascii')).decode('ascii')
tokens = parse_qs(querystring, keep_blank_values=True)
offset = tokens.get('o', ['0'])[0]
offset = _positive_int(offset, cutoff=OFFSET_CUTOFF)
reverse = tokens.get('r', ['0'])[0]
reverse = bool(int(reverse))
position = tokens.get('p', [None])[0]
except (TypeError, ValueError):
raise NotFound(self.invalid_cursor_message)
return Cursor(offset=offset, reverse=reverse, position=position)
def get_page_size(self, request):
page_size = request.query_params.get(self.paginate_by_param,
self.page_size)
try:
return _positive_int(page_size, cutoff=self.max_page_size)
except ValueError:
raise MalformedPageParameter()
def decode_cursor(self, request):
"""
Given a request with a cursor, return a `Cursor` instance.
"""
# Determine if we have a cursor, and if so then decode it.
encoded = request.query_params.get(self.cursor_query_param)
if encoded is None:
return None
# The offset in the cursor is used in situations where we have a
# nearly-unique index. (Eg millisecond precision creation timestamps)
# We guard against malicious users attempting to cause expensive database
# queries, by having a hard cap on the maximum possible size of the offset.
offset_cutoff = getattr(settings, 'CURSOR_PAGINATION_OFFSET_CUTOFF', 1000)
try:
querystring = b64decode(encoded.encode('ascii')).decode('ascii')
tokens = parse_qs(querystring, keep_blank_values=True)
offset = tokens.get('o', ['0'])[0]
offset = _positive_int(offset, cutoff=offset_cutoff)
reverse = tokens.get('r', ['0'])[0]
reverse = bool(int(reverse))
position = tokens.get('p', [None])[0]
except (TypeError, ValueError):
raise NotFound(self.invalid_cursor_message)
return Cursor(offset=offset, reverse=reverse, position=position)
def decode_cursor(self, request):
"""
Given a request with a cursor, return a `Cursor` instance.
Differs from the standard CursorPagination to handle a tuple in the
position field.
"""
# Determine if we have a cursor, and if so then decode it.
encoded = request.query_params.get(self.cursor_query_param)
if encoded is None:
return None
try:
querystring = b64decode(encoded.encode('ascii')).decode('ascii')
tokens = parse.parse_qs(querystring, keep_blank_values=True)
offset = tokens.get('o', ['0'])[0]
offset = _positive_int(offset, cutoff=self.offset_cutoff)
reverse = tokens.get('r', ['0'])[0]
reverse = bool(int(reverse))
# The difference. Don't get just the 0th entry: get all entries.
position = tokens.get('p', None)
except (TypeError, ValueError):
raise NotFound(self.invalid_cursor_message)
return Cursor(offset=offset, reverse=reverse, position=position)
def decode_cursor(self, request):
"""
Given a request with a cursor, return a `Cursor` instance.
Differs from the standard CursorPagination to handle a tuple in the
position field.
"""
# Determine if we have a cursor, and if so then decode it.
encoded = request.query_params.get(self.cursor_query_param)
if encoded is None:
return None
try:
querystring = b64decode(encoded.encode('ascii')).decode('ascii')
tokens = urlparse.parse_qs(querystring, keep_blank_values=True)
offset = tokens.get('o', ['0'])[0]
# This was hard-coded until Django REST Framework 3.4.0.
try:
offset_cutoff = self.offset_cutoff
except AttributeError:
offset_cutoff = 1000
offset = _positive_int(offset, cutoff=offset_cutoff)
reverse = tokens.get('r', ['0'])[0]
reverse = bool(int(reverse))
# The difference. Don't get just the 0th entry: get all entries.
position = tokens.get('p', None)
except (TypeError, ValueError):
raise NotFound(self.invalid_cursor_message)
return Cursor(offset=offset, reverse=reverse, position=position)
def get_offset(self, request):
"""Return offset parameter."""
try:
return _positive_int(
get_query_param(request, self.offset_query_param), )
except (KeyError, ValueError):
return 0
def decode_cursor(self, request):
"""
Given a request with a cursor, return a `Cursor` instance.
"""
# Determine if we have a cursor, and if so then decode it.
encoded = request.query_params.get(self.cursor_query_param)
if encoded is None:
return None
try:
reverse = False
if encoded.startswith('-'):
encoded = encoded[1:]
reverse = True
offset = 0
parts = encoded.split('+', 1)
if '-' in parts[0]:
position = parts[0]
else:
position = None
if len(parts) > 1:
offset = _positive_int(parts[1], cutoff=self.offset_cutoff)
except (TypeError, ValueError):
raise NotFound(self.invalid_cursor_message)
return Cursor(offset=offset, reverse=reverse, position=position)
def paginate_queryset(self, queryset, request, view=None):
"""
Paginate a queryset according to start/end values (zero-indexed) in
`range` header, or `None` if pagination is not properly configured.
"""
self.count = self.get_count(queryset)
self.start_index = 0
self.end_index = self.start_index + self.page_size - 1
# TODO: this logic is repeated below...
if self.end_index > self.count - 1:
self.end_index = self.count - 1 if self.count else 0
range_string = request.GET.get(self.range_query_param)
if range_string:
try:
page_range = json.loads(range_string)
except json.JSONDecodeError:
return None
if len(page_range) != 2:
return None
self.start_index, self.end_index = [
pagination._positive_int(x) for x in page_range
]
if self.end_index > self.count - 1:
self.end_index = self.count - 1 if self.count else 0
if self.start_index > self.end_index:
self.start_index = self.end_index
return list(queryset[self.start_index:self.end_index + 1])
def get_offset(self, request):
try:
return _positive_int(
request.query_params[self.offset_query_param],
)
except (KeyError, ValueError):
return 0
def get_page_size(self, request):
if self.page_size_query_param:
try:
return _positive_int(
request.query_params[self.page_size_query_param], strict=False, cutoff=self.max_page_size)
except (KeyError, ValueError):
pass
return self.page_size
def get_offset(self, request):
try:
return _positive_int(request.query_params[self.offset_query_param])
except KeyError:
return 0
except ValueError:
raise ValidationError({'detail': f'Offset parameter must be >= 0'},
code=status.HTTP_400_BAD_REQUEST)
def get_page_size(self, request):
if self.header_page_size_param in request.META.keys():
return pagination._positive_int(
request.META[self.header_page_size_param],
strict=True,
cutoff=self.max_page_size)
elif self.page_size_query_param:
try:
return pagination._positive_int(
request.query_params[self.page_size_query_param],
strict=True,
cutoff=self.max_page_size)
except (KeyError, ValueError):
pass
return self.page_size
def get_limit(self, request):
if self.limit_query_param:
try:
return drf_pagination._positive_int(
request.query_params[self.limit_query_param])
except (KeyError, ValueError):
pass
return self.default_limit
def get_offset(self, request):
try:
return _positive_int(
request.query_params[self.offset_query_param]
if self.offset_query_param in request.query_params else
request.data[self.offset_query_param], )
except (KeyError, ValueError):
return 0
def get_page_size(self, request):
try:
return _positive_int(
request.query_params[self.page_size_query_param],
strict=True,
)
except (KeyError, ValueError):
return self.page_size
def get_offset(self, request):
try:
return _positive_int(
request.query_params[self.offset_query_param],
cutoff=((self.limit * self.max_pages) - self.limit)
)
except (KeyError, ValueError):
return 0
def get_offset(self, request):
try:
return pagination._positive_int(
request.query_params[self.offset_query_param], )
except KeyError:
return 0
except ValueError:
raise BadRequest()
def get_offset(self, request):
"""Return offset parameter."""
try:
return _positive_int(
get_query_param(request, self.offset_query_param),
)
except (KeyError, ValueError):
return 0
def get_limit(self, *args):
if self._rql_limit is not None:
try:
return _positive_int(self._rql_limit,
strict=False,
cutoff=self.max_limit)
except ValueError:
pass
return self.default_limit
def get_limit(self, request):
ret = pagination._positive_int(
request.query_params.get(self.limit_query_param, self.default_limit),
strict=False,
cutoff=self.max_limit,
)
if ret == 0:
return self.max_limit
return ret
def get_page_size_2(self, request):
try:
return _positive_int(
request.query_params[self.page_size_query_param],
strict=True,
cutoff=self.max_page_size
)
except (KeyError, ValueError):
return None
def _get_offset_from_request(self, request):
try:
offset = _positive_int(
request.query_params[self.offset_query_param])
except (KeyError, ValueError):
offset = 0
if offset < 1:
offset = 1
return offset
def get_page_number(self, request, view=None):
"""获取页码
:param request: 请求对象
:param view: viewset实例
:return: 页码
"""
return pagination._positive_int(request.query_params.get(
self.page_query_param, 1),
strict=True)
def get_limit(self, request):
ret = pagination._positive_int(
request.query_params.get(self.limit_query_param,
self.default_limit),
strict=False,
cutoff=self.max_limit,
)
if ret == 0:
return self.max_limit
return ret
def get_limit(self):
if self.limit_query_param:
try:
return _positive_int(
self.request.query_params[self.limit_query_param],
strict=True,
cutoff=self.max_limit)
except (KeyError, ValueError):
return None
return None
def get_limit(self, query_params):
if self.limit_query_param:
try:
return pagination._positive_int(
query_params[self.limit_query_param],
cutoff=self.max_limit)
except (KeyError, ValueError):
pass
return self.default_limit
def get_limit(self, request):
if self.limit_query_param:
try:
return _positive_int(
request.query_params[self.limit_query_param],
cutoff=self.max_limit)
except (KeyError, ValueError):
pass
return self.default_limit
def get_page_number(self, request, view=None):
try:
page_query = pagination._positive_int(
request.query_params.get(self.page_query_param, 1),
strict=True
)
if page_query > unlimit_number:
raise exceptions.ValidationError('Field Invalid')
return page_query
except Exception:
raise exceptions.ValidationError('Field Invalid')
def get_offset(self, request):
try:
offset = _positive_int(
request.query_params[self.offset_query_param], )
if offset == 0:
offset = 1
if offset > 1:
offset = (offset - 1) * self.default_limit + 1
return offset - 1
except (KeyError, ValueError):
return 0
def get_limit(self, query_params):
if self.limit_query_param:
try:
return pagination._positive_int(
query_params[self.limit_query_param],
cutoff=self.max_limit
)
except (KeyError, ValueError):
pass
return self.default_limit
def get_limit(self, request):
if self.limit_query_param:
try:
return pagination._positive_int(
request.query_params[self.limit_query_param],
strict=True,
cutoff=self.max_limit)
except (KeyError, ValueError) as e:
pass
return self.default_limit
def get_limit(self, request):
if self.limit_query_param:
try:
return _positive_int(
request.query_params[self.limit_query_param],
cutoff=self.max_limit
)
except (KeyError, ValueError):
pass
return self.default_limit
def get_limit(self, request):
"""Return limit parameter."""
if self.limit_query_param:
try:
return _positive_int(get_query_param(request,
self.limit_query_param),
strict=True,
cutoff=self.max_limit)
except (KeyError, ValueError):
pass
return self.default_limit
def get_page_size(self, request):
if self.page_size_query_param:
try:
page_size = pagination._positive_int(
request.query_params[self.page_size_query_param],
strict=True,
cutoff=self.max_page_size)
self.page_size = page_size
return self.page_size
except (KeyError, ValueError):
pass
return self.page_size
def get_page_size(self, request):
if self.page_size_query_param:
try:
return _positive_int(
request.query_params[self.page_size_query_param],
strict=True,
cutoff=self.max_page_size
)
except (KeyError, ValueError):
pass
return self.page_size
def get_limit(self, request):
"""Return limit parameter."""
if self.limit_query_param:
try:
return _positive_int(
get_query_param(request, self.limit_query_param),
strict=True,
cutoff=self.max_limit
)
except (KeyError, ValueError):
pass
return self.default_limit
def get_page_size(self, request):
if self.page_size_query_param:
cutoff = self.max_page_size
if request.query_params.get('format', '').lower() == 'xlsx':
cutoff = 50000
try:
return _positive_int(
request.query_params[self.page_size_query_param],
strict=True, cutoff=cutoff
)
except (KeyError, ValueError):
pass
return self.page_size
def adjust_offset(self, url, page_offset):
if url is None:
return
(scheme, netloc, path, query, fragment) = urlparse.urlsplit(force_str(url))
query_dict = QueryDict(query)
try:
offset = pagination._positive_int(
query_dict[self.offset_query_param],
)
except (KeyError, ValueError):
pass
else:
if offset > page_offset:
url = replace_query_param(url, self.offset_query_param, max(0, offset - self.overlapping))
elif offset < page_offset:
url = replace_query_param(url, self.offset_query_param, offset + self.overlapping)
return url
def get_page_size(self, request):
"""
this is overrided to allow 0 as a page_size.
if page_size=0, we will set page_size as max_page_size.
"""
page_size = self.page_size
if self.page_size_query_param:
try:
page_size = _positive_int(
request.query_params[self.page_size_query_param],
strict=False,
cutoff=self.max_page_size
)
except (KeyError, ValueError):
pass
if page_size == 0:
page_size = self.max_page_size
return page_size
