def test_limit(self):
paginator = Paginator({}, self.data_set, limit=20, offset=0)
paginator.limit = '10'
self.assertEqual(paginator.get_limit(), 10)
paginator.limit = None
self.assertEqual(paginator.get_limit(), 20)
paginator.limit = 10
self.assertEqual(paginator.get_limit(), 10)
paginator.limit = -10
raised = False
try:
paginator.get_limit()
except BadRequest as e:
raised = e
self.assertTrue(raised)
self.assertEqual(
str(raised),
"Invalid limit '-10' provided. Please provide a positive integer >= 0."
)
paginator.limit = 'hAI!'
raised = False
try:
paginator.get_limit()
except BadRequest as e:
raised = e
self.assertTrue(raised)
self.assertEqual(
str(raised),
"Invalid limit 'hAI!' provided. Please provide a positive integer."
)
# Test the max_limit.
paginator.limit = 1000
self.assertEqual(paginator.get_limit(), 1000)
paginator.limit = 1001
self.assertEqual(paginator.get_limit(), 1000)
paginator = Paginator({},
self.data_set,
limit=20,
offset=0,
max_limit=10)
self.assertEqual(paginator.get_limit(), 10)
def get_list(self, request, **kwargs):
query = request.GET.get('q', None)
results = self.obj_get_list(request, **{'query': query})
if not results:
results = EmptySearchQuerySet()
paginator = Paginator(request.GET,
results,
resource_uri='/api/v1/search/',
max_limit=10)
bundles = []
for result in paginator.page()['objects']:
result_obj = ResultObject(result)
bundle = self.build_bundle(obj=result_obj, request=request)
bundles.append(self.full_dehydrate(bundle))
object_list = {'meta': paginator.page()['meta'], 'objects': bundles}
object_list['meta']['search_query'] = query
return self.create_response(request, object_list)
def test_max_limit_none(self):
paginator = Paginator({'limit': 0},
self.data_set,
max_limit=None,
resource_uri='/api/v1/notes/')
meta = paginator.page()['meta']
self.assertEqual(meta['limit'], 0)
def test_page1(self):
reset_queries()
self.assertEqual(len(self._get_query_count()), 0)
paginator = Paginator({},
self.data_set,
resource_uri='/api/v1/notes/',
limit=2,
offset=0)
# REGRESSION: Check to make sure only part of the cache is full.
# We used to run ``len()`` on the ``QuerySet``, which would populate
# the entire result set. Owwie.
paginator.get_count()
self.assertEqual(len(self._get_query_count()), 1)
# Should be nothing in the cache.
self.assertEqual(paginator.objects._result_cache, None)
meta = paginator.page()['meta']
self.assertEqual(meta['limit'], 2)
self.assertEqual(meta['offset'], 0)
self.assertEqual(meta['previous'], None)
self.assertTrue('limit=2' in meta['next'])
self.assertTrue('offset=2' in meta['next'])
self.assertEqual(meta['total_count'], 6)
def test_offset(self):
paginator = Paginator({}, self.data_set, limit=20, offset=0)
paginator.offset = '10'
self.assertEqual(paginator.get_offset(), 10)
paginator.offset = 0
self.assertEqual(paginator.get_offset(), 0)
paginator.offset = 10
self.assertEqual(paginator.get_offset(), 10)
paginator.offset = -10
raised = False
try:
paginator.get_offset()
except BadRequest as e:
raised = e
self.assertTrue(raised)
self.assertEqual(
str(raised),
"Invalid offset '-10' provided. Please provide a positive integer >= 0."
)
paginator.offset = 'hAI!'
raised = False
try:
paginator.get_offset()
except BadRequest as e:
raised = e
self.assertTrue(raised)
self.assertEqual(
str(raised),
"Invalid offset 'hAI!' provided. Please provide an integer.")
def get_refresh(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
if 'marked_at__gt' not in request.GET:
results = UserStars.objects.filter(
user_id=request.user.id).order_by('-marked_at').exclude(star=1)
else:
results = UserStars.objects.filter(user_id=request.user.id,
marked_at__gt=request.GET['marked_at__gt'])\
.order_by('-marked_at').exclude(star=1)
paginator = Paginator(request.GET,
results,
resource_uri='/api/v1/account/star/refresh/')
bundles = []
for result in paginator.page()['objects']:
bundle = self.build_bundle(obj=result, request=request)
bundle.data['refresh'] = True
bundle.data['id'] = bundle.obj.article_id
bundles.append(self.full_dehydrate(bundle))
object_list = {'meta': paginator.page()['meta'], 'objects': bundles}
self.log_throttled_access(request)
return self.create_response(request, object_list)
def get_search(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
self.log_throttled_access(request)
query = request.GET.get('q', None)
if not query:
raise BadRequest(
'Please supply the search parameter (e.g. "/api/v1/feeds/search/?q=query")'
)
results = SearchQuerySet().filter(content__contains=query).filter_or(
keywords__contains=query).models(Feed)
paginator = Paginator(request.GET,
results,
resource_uri='/api/v1/feeds/search/')
bundles = []
for result in paginator.page()['objects']:
bundle = self.build_bundle(obj=result.object, request=request)
bundles.append(self.full_dehydrate(bundle))
object_list = {'meta': paginator.page()['meta'], 'objects': bundles}
object_list['meta']['search_query'] = query
self.log_throttled_access(request)
return self.create_response(request, object_list)
def get_populars(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
time_frame = datetime.utcnow() - timedelta(days=1)
most_read = UserReads.objects.filter(marked_at__gte=time_frame)\
.annotate(occ=Count('article')).order_by('-occ')
if not most_read or len(most_read) < 1000:
results = Article.objects.filter(Q(id__in=most_read.values('article')) |
Q(feed_id__in=CategoryFeeds.objects.all().values('feed_id')))\
.order_by('-date_parsed')
else:
results = Article.objects.filter(
id__in=most_read.values('article')).order_by('-date_parsed')
paginator = Paginator(request.GET,
results,
resource_uri='/api/v1/articles/populars/')
bundles = []
for result in paginator.page()['objects']:
bundle = self.build_bundle(obj=result, request=request)
bundles.append(self.full_dehydrate(bundle))
object_list = {'meta': paginator.page()['meta'], 'objects': bundles}
self.log_throttled_access(request)
return self.create_response(request, object_list)
def get_search(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
query = request.GET.get('q', None)
if not query:
raise BadRequest(
'Please supply the search parameter (e.g. "/api/v1/articles/search/?q=query")'
)
results = SearchQuerySet().models(Article).filter(
feed_id__in=[x['id'] for x in request.user.feeds.values('id')])\
.filter(content=query).filter_or(title=query).order_by('-date_parsed')
if not results:
results = EmptySearchQuerySet()
paginator = Paginator(request.GET,
results,
resource_uri='/api/v1/articles/search/')
bundles = []
for result in paginator.page()['objects']:
bundle = self.build_bundle(obj=result.object, request=request)
bundles.append(self.full_dehydrate(bundle))
object_list = {'meta': paginator.page()['meta'], 'objects': bundles}
object_list['meta']['search_query'] = query
self.log_throttled_access(request)
return self.create_response(request, object_list)
def get_search(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.throttle_check(request)
# Do the query.
ret = []
for field in self._meta.object_class.haystack_index:
kwargs = {field: request.GET.get('q', '')}
sqs = SearchQuerySet().models(
self._meta.object_class).autocomplete(**kwargs)
ret.extend(sqs)
paginator = Paginator(request.GET, ret)
try:
page = paginator.page()
except InvalidPage:
raise Http404("Sorry, no results on that page.")
objects = []
for result in page['objects']:
bundle = self.build_bundle(obj=result.object, request=request)
bundle = self.full_dehydrate(bundle)
objects.append(bundle)
object_list = {
'objects': objects,
}
self.log_throttled_access(request)
return self.create_response(request, object_list)
def get_search(self, request, **kwargs):
self.method_check(request, allowed=['get'])
self.is_authenticated(request)
self.dispatch_list(request)
self.throttle_check(request)
# Do the query.
sqs = SearchQuerySet()
query = request.GET.getlist("q")
OR = request.GET.getlist("or")
if query:
for q in query:
query_dict = {}
encoded_q = encode_filter(q.split(':')[0], q.split(':')[1])
try:
key = "{}Filter_exact".format(encoded_q.get('filter'))
value = encoded_q.get('value')
if ' ' in value:
key = key.replace('_', '__')
query_dict[key] = value
if OR:
sqs = sqs.filter_or(**query_dict)
else:
sqs = sqs.filter(**query_dict)
except IndexError:
sqs = sqs.filter(content=q)
# Apply tastypie filters if any whatsoever
sqs_objects = [sq.object for sq in sqs]
filtered = self.apply_filters(request, applicable_filters={})
final_list = list(set(sqs_objects) & set(filtered))
ids = [fl.id for fl in final_list]
final_list = lr.resourceInfoType_model.objects.filter(id__in=ids)
if 'latest' in request.GET.get('sort', ''):
final_list = self.apply_sorting(final_list,
options={'sort': [u'latest']})
elif 'earliest' in request.GET.get('sort', ''):
final_list = self.apply_sorting(final_list,
options={'sort': [u'earliest']})
paginator = Paginator(request.GET,
final_list,
resource_uri='/api/v1/lr/search/')
to_be_serialized = paginator.page()
bundles = [
self.build_bundle(obj=result, request=request)
for result in to_be_serialized['objects']
]
to_be_serialized['objects'] = [
self.full_dehydrate(bundle) for bundle in bundles
]
to_be_serialized = self.alter_list_data_to_serialize(
request, to_be_serialized)
return self.create_response(request, to_be_serialized)
def test_page2(self):
paginator = Paginator({},
self.data_set,
resource_uri='/api/v1/notes/',
limit=2,
offset=2)
meta = paginator.page()['meta']
self.assertEqual(meta['limit'], 2)
self.assertEqual(meta['offset'], 2)
self.assertTrue('limit=2' in meta['previous'])
self.assertTrue('offset=0' in meta['previous'])
self.assertTrue('limit=2' in meta['next'])
self.assertTrue('offset=4' in meta['next'])
self.assertEqual(meta['total_count'], 6)
def prepare_result(self, request, sqs, limit):
uri = reverse('api_ms_search',
kwargs={
'api_name': self.api_name,
'resource_name': self._meta.resource_name
})
paginator = Paginator(request.GET, sqs, resource_uri=uri, limit=limit)
objects = []
for result in paginator.page()['objects']:
if result:
try:
bundle = self.build_bundle(obj=result.object,
request=request)
bundle = self.full_dehydrate(bundle)
objects.append(bundle)
except:
pass
return {
'meta': paginator.page()['meta'],
'objects': objects,
}
