def list(self, request, shop_slug=None):
queryset = ProductGroupModel.objects.filter(shop__slug=shop_slug)
best_selling_queryset = ProductModel.objects.filter(
shop__slug=shop_slug, is_available=True,
num_sold__gt=0).order_by('num_sold')
best_selling_serializer = ProductSerializer(best_selling_queryset[:5],
many=True)
offers_queryset = ProductModel.objects.filter(shop__slug=shop_slug,
is_offer=True,
is_available=True)
offers_serializer = ProductSerializer(offers_queryset, many=True)
paginator = LimitOffsetPagination()
paginator.default_limit = 5
paginator.max_limit = 10
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = ProductGroupSerializer(paginated_queryset, many=True)
return Response(
data={
'limit': paginator.limit,
'offset': paginator.offset,
'count': paginator.count,
'offers': offers_serializer.data,
'best_selling': best_selling_serializer.data,
'groups': serializer.data
})
def get_posts_for_stream(request):
stream_id = request.data.get('streamId')
if not stream_id:
return Response({'details': {
'required_fields': ['streamId']
}},
status=status.HTTP_400_BAD_REQUEST)
try:
stream = Stream.objects.get(pk=stream_id)
except Stream.DoesNotExist:
raise Http404
except ValidationError:
return Response({'details': {
'required field as UUID': ['streamId']
}},
status=status.HTTP_400_BAD_REQUEST)
profiles = ProfileFollow.objects.filter(stream=stream.id).values('profile')
posts = Post.objects.filter(owner__in=profiles)
paginator = LimitOffsetPagination()
paginator.default_limit = 12
result_page = paginator.paginate_queryset(posts, request)
serializer = PostSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def geographic_crs(self, request):
pinboard = self._pinboard
crids = pinboard.crids if pinboard else []
geographic_data_query = GeographyCrsDataQuery(
crids, officers=self._data(False)['officers'])
paginator = LimitOffsetPagination()
paginator.default_limit = DEFAULT_LIMIT
cr_data = geographic_data_query.data()
if self._detail:
cr_data = cr_data.prefetch_related(
'officerallegation_set',
'officerallegation_set__officer',
'officerallegation_set__allegation_category',
'victims',
)
paginated_cr_data = paginator.paginate_queryset(cr_data,
request,
view=self)
serializer_klass = CRDetailSerializer if self._detail else CRSerializer
serializer = serializer_klass(paginated_cr_data, many=True)
return Response({
'count': paginator.count,
'limit': paginator.default_limit,
'results': serializer.data
})
def get(self, request, *args, **kwargs):
query = self.get_query()
sort = self.get_sort()
pagination = LimitOffsetPagination()
pagination.default_limit = 20
pagination.limit = pagination.get_limit(request)
pagination.offset = pagination.get_offset(request)
pagination.request = request
body = {
"track_total_hits": True,
"query": query,
"size": pagination.limit,
"from": pagination.offset,
}
if sort:
body["sort"] = sort
# execute elasticsearch query
indexer = self.get_indexer()
res = indexer.search(body=body)
# map back to expected format
items = list(indexer.map_results(res["hits"]["hits"]))
pagination.count = res["hits"]["total"]["value"]
return pagination.get_paginated_response(items)
def list(self, request):
"""Lists all orders the user has.
Arguments:
request: the request data sent by the user, it is used
for Pagination
Returns:
HTTP 403 if user is not authenticated
HTTP 200 Response with all orders in JSON.
"""
queryset = None
if hasattr(request.user, 'profile'):
queryset = request.user.profile.orders.all() # this is a regular user
if hasattr(request.user, 'driver_profile'):
queryset = request.user.driver_profile.served_orders.all() # this is a driver
if hasattr(request.user, 'shop_profile'):
queryset = request.user.shop_profile.served_orders.all() # this is a shop
paginator = LimitOffsetPagination()
paginator.default_limit = 15
paginator.max_limit = 100
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = OrderSerializer(paginated_queryset, many=True)
return Response(data={'limit': paginator.limit, 'offset': paginator.offset,
'count': paginator.count, 'orders': serializer.data})
def list(self, request, username=None):
"""Lists all reviews the driver has.
Arguments:
request: the request data sent by the user, it is
used for Pagination
username: the username of the driver profile
whose reviews will be returned
Returns:
HTTP 404 if driver profile is not found,
HTTP 200 Response with all reviews in
the driver's profile in JSON.
"""
driver = get_object_or_404(DriverProfileModel,
account__username=username)
queryset = driver.reviews.all()
paginator = LimitOffsetPagination()
paginator.default_limit = 25
paginator.max_limit = 100
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = DriverReviewSerializer(paginated_queryset, many=True)
return Response(
data={
'limit': paginator.limit,
'offset': paginator.offset,
'count': paginator.count,
'reviews': serializer.data
})
def get(self, request, *args, **kwargs):
query = self.get_query()
sort = self.get_sort()
pagination = LimitOffsetPagination()
pagination.default_limit = 20
pagination.limit = pagination.get_limit(request)
pagination.offset = pagination.get_offset(request)
pagination.request = request
body = {
'query': query,
'size': pagination.limit,
'from': pagination.offset
}
if sort:
body['sort'] = sort
# execute elasticsearch query
indexer = self.get_indexer()
res = indexer.search(body=body)
# map back to expected format
items = list(indexer.map_results(res['hits']['hits']))
pagination.count = res['hits']['total']
return pagination.get_paginated_response(items)
def list(self, request, username=None):
"""Lists all addresses the user has.
Arguments:
request: the request data sent by the user, it is used
to check the user's permissions and in Pagination
username: the username of the user profile
whose addresses will be returned
Returns:
HTTP 403 Response if the user is
not authorized to see that user's addresses,
HTTP 404 if user profile is not found,
HTTP 200 Response with all addresses in
the user's profile in JSON.
"""
user = get_object_or_404(UserProfileModel, account__username=username)
self.check_object_permissions(request, user)
queryset = user.addresses.all()
paginator = LimitOffsetPagination()
paginator.default_limit = 10
paginator.max_limit = 100
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = self.serializer_class(paginated_queryset, many=True)
return Response(data={'limit': paginator.limit, 'offset': paginator.offset,
'count': paginator.count, 'addresses': serializer.data})
def geographic_trrs(self, request):
pinboard = self._pinboard
trr_ids = pinboard.trr_ids if pinboard else []
geographic_data_query = GeographyTrrsDataQuery(
trr_ids, officers=self._data(False)['officers'])
paginator = LimitOffsetPagination()
paginator.default_limit = DEFAULT_LIMIT
trr_data = geographic_data_query.data()
if self._detail:
trr_data = trr_data.select_related('officer')
paginated_trr_data = paginator.paginate_queryset(trr_data,
request,
view=self)
serializer_klass = TRRDetailSerializer if self._detail else TRRSerializer
serializer = serializer_klass(paginated_trr_data, many=True)
return Response({
'count': paginator.count,
'limit': paginator.default_limit,
'results': serializer.data
})
def taskscompletedview(request):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
queryset = Tasks.objects.filter(completed=True).order_by('id')
result_page = paginator.paginate_queryset(queryset, request)
serializer = TaskSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_paginated(queryset, request, to_dict, limit=10):
paginator = LimitOffsetPagination()
paginator.max_limit = 50
paginator.default_limit = limit
paginator.offset = 0
obj_list = paginator.paginate_queryset(
queryset,
request
)
results = to_dict(obj_list)
next_link = paginator.get_next_link()
prev_link = paginator.get_previous_link()
if next_link:
next_link = next_link.split('?')[1]
if prev_link:
prev_link = prev_link.split('?')[1]
data = {
'results': results,
'limit': paginator.limit,
'offset': paginator.offset,
'count': paginator.count,
'next': next_link,
'prev': prev_link,
}
# print(json.dumps(data))
return data
def notifview(request):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
queryset = Notifications.objects.filter(
user=request.user).order_by('-date_created')
result_page = paginator.paginate_queryset(queryset, request)
serializer = NotificationSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def commentsview(request, task_id):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
queryset = TaskComments.objects.filter(
task_id=task_id).order_by('date_created')
result_page = paginator.paginate_queryset(queryset, request)
serializer = CommentsSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_explore(request):
posts = Post.objects.all()
paginator = LimitOffsetPagination()
paginator.default_limit = 6
result_page = paginator.paginate_queryset(posts, request)
serializer = PostSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def list(self, request):
"""get users list
Args:
request ([type]): [description]
Returns:
[type]: [description]
"""
if self.request.user.is_superuser:
search = request.query_params.get('search', None)
if search is not None:
query = Q(first_name__icontains=search) | Q(
last_name__icontains=search) | Q(
email__icontains=search) | Q(phone__icontains=search)
if search.lower() == "yes":
search = True
query = query | Q(is_verified__icontains=search) | Q(
is_active__icontains=search)
elif search.lower() == "no":
search = False
query = query | Q(is_verified__icontains=search) | Q(
is_active__icontains=search)
elif search.lower() == "admin":
search = True
query = query | Q(is_staff__icontains=search)
elif search.lower() == "staff":
search = False
query = query | Q(is_staff__icontains=search)
queryset = User.objects.filter(query).order_by(
'id').reverse().values()
else:
queryset = User.objects.all().order_by('id').reverse().values()
if request is not None:
paginator = LimitOffsetPagination()
paginator.max_limit = 100
paginator.default_limit = 20
user = paginator.paginate_queryset(queryset, request)
limit = paginator.limit
if isinstance(limit, list):
limit = limit[0]
offset = paginator.offset
count = paginator.count
res = {
"Success": True,
"ExceptionString": "Record Found.",
"results": user,
"count": count,
"limit": limit,
"offset": offset
}
return Response(res, status.HTTP_200_OK)
else:
res = {"Success": False, "results": []}
return Response(res, status.HTTP_401_UNAUTHORIZED)
def get(self, request: Request) -> Response:
self.info(request)
user_s = CustomUser.objects.all()
paginator = LimitOffsetPagination()
paginator.default_limit = DEFAULT_PAGE_LIMIT
paged_user_s = paginator.paginate_queryset(user_s, request)
serializer = CustomUserSerializer(paged_user_s, many=True)
return Response(data=serializer.data, )
def list(request):
"""List transactions for all users
:param request: Request send from the client
:return: Response
"""
paginator = LimitOffsetPagination()
paginator.max_limit = 250
paginator.default_limit = 100
transactions = paginator.paginate_queryset(Transaction.objects.all(), request)
return Response(data={'entries': [x.to_dict() for x in transactions], 'limit': paginator.limit,
'offset': paginator.offset, 'overall_count': paginator.count},
status=status.HTTP_200_OK)
def loglastmonth(request):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
last_month = timezone.now() - timedelta(days=30)
queryset = TaskLogs.objects.filter(date_finish__gte=last_month). \
order_by('-date_finish')
result_page = paginator.paginate_queryset(queryset, request)
serializer = TaskLogSerializer(result_page, many=True)
total_time = 0
for timelogs in queryset:
total_time += timelogs.time_active
response1 = {'list': serializer.data, 'total_time': total_time}
return paginator.get_paginated_response(response1)
def tasktimelogview(request, task_id):
paginator = LimitOffsetPagination()
paginator.default_limit = 50
queryset = TaskLogs.objects.filter(
task_id=task_id).order_by('-date_finish')
result_page = paginator.paginate_queryset(queryset, request)
serializer = TaskLogSerializer(result_page, many=True)
timelog = TaskLogs.objects.filter(task_id=task_id)
total_time = 0
for timelogs in timelog:
total_time += timelogs.time_active
response1 = {'list': serializer.data, 'total_time': total_time}
return paginator.get_paginated_response(response1)
def get_assets(self, obj):
paginator = LimitOffsetPagination()
paginator.default_limit = 10
page = paginator.paginate_queryset(queryset=obj.assets.all(),
request=self.context.get(
'request', None))
serializer = AssetUrlListSerializer(page,
many=True,
read_only=True,
context=self.context)
return OrderedDict([('count', paginator.count),
('next', paginator.get_next_link()),
('previous', paginator.get_previous_link()),
('results', serializer.data)])
def list(request) -> Response:
"""List users
:param request: HTTP Request
:return: Response
"""
paginator = LimitOffsetPagination()
paginator.max_limit = 250
paginator.default_limit = 100
users = paginator.paginate_queryset(User.objects.filter(active=True), request)
return Response(
data={'entries': [x.to_dict() for x in users], 'limit': paginator.limit,
'offset': paginator.offset, 'overall_count': paginator.count},
status=status.HTTP_200_OK)
def get_assets(self, obj):
paginator = LimitOffsetPagination()
paginator.default_limit = 10
page = paginator.paginate_queryset(
queryset=obj.assets.all(),
request=self.context.get('request', None)
)
serializer = AssetUrlListSerializer(
page, many=True, read_only=True, context=self.context)
return OrderedDict([
('count', paginator.count),
('next', paginator.get_next_link()),
('previous', paginator.get_previous_link()),
('results', serializer.data)
])
def list(self, request, shop_slug=None, product_slug=None):
queryset = ProductReviewModel.objects.filter(
product__shop__slug=shop_slug, product__slug=product_slug).all()
paginator = LimitOffsetPagination()
paginator.default_limit = 25
paginator.max_limit = 100
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = ProductReviewSerializer(paginated_queryset, many=True)
return Response(
data={
'limit': paginator.limit,
'offset': paginator.offset,
'count': paginator.count,
'reviews': serializer.data
})
def get_posts_for_profile(request):
handle = request.data.get('handle')
if not handle:
return Response({'details': {
'required_fields': ['handle']
}},
status=status.HTTP_400_BAD_REQUEST)
posts = Post.objects.filter(owner__account__handle=handle)
paginator = LimitOffsetPagination()
paginator.default_limit = 6
result_page = paginator.paginate_queryset(posts, request)
serializer = PostSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def list(request, user_pk=None) -> Response:
"""List transactions for a single user
:param request: Request send from the client
:param user_pk: Primary key to identify a user
:return: Response
"""
try:
user = User.objects.get(id=user_pk)
except User.DoesNotExist:
return Response(data={'msg': 'user {} not found'.format(user_pk)}, status=status.HTTP_404_NOT_FOUND)
paginator = LimitOffsetPagination()
paginator.max_limit = 250
paginator.default_limit = 100
transactions = paginator.paginate_queryset(Transaction.objects.filter(user=user), request)
return Response(data={'entries': [x.to_dict() for x in transactions], 'limit': paginator.limit,
'offset': paginator.offset, 'overall_count': paginator.count},
status=status.HTTP_200_OK)
def search_profiles(request):
try:
query = request.data['query']
except KeyError:
return Response({'details': {
'required fields': ['query']
}},
status=status.HTTP_400_BAD_REQUEST)
profiles = Profile.objects.filter(
Q(account__handle__icontains=query) | Q(full_name__icontains=query))
paginator = LimitOffsetPagination()
paginator.default_limit = 40
result_page = paginator.paginate_queryset(profiles, request)
serializer = ProfileSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def list(self, request):
"""Lists all available driver profiles near a certain location
Arguments:
request: the request data sent by the user,
it is used to get the queries entered by user,
and for Pagination
Returns:
returns HTTP 200 Response with the drivers' JSON data.
if there are no coordinates given will return 400 Response.
"""
try:
user_longitude = float(request.GET.get('longitude'))
user_latitude = float(request.GET.get('latitude'))
except Exception:
return Response("invalid coordinates",
status=status.HTTP_400_BAD_REQUEST)
min_active_time = timezone.now() - timezone.timedelta(seconds=10)
queryset = DriverProfileModel.objects.annotate(distance=haversine(
user_latitude, user_longitude, F('live_location_latitude'),
F('live_location_longitude'))).filter(
distance__lte=2.5,
is_busy=False,
last_time_online__gte=min_active_time,
is_active=True,
is_available=True).order_by('distance')
paginator = LimitOffsetPagination()
paginator.default_limit = 10
paginator.max_limit = 100
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = DriverProfileSerializer(paginated_queryset, many=True)
return Response(
data={
'limit': paginator.limit,
'offset': paginator.offset,
'count': paginator.count,
'drivers': serializer.data
})
def get(self, request: Request) -> Response:
self.info(request)
params = self.__clear_request_params(request)
try:
publisher_s = Publisher.objects.filter(**params)
except FieldError as error:
self.exception(request, f'{error}')
return Response(data={'errors': str(error)},
status=status.HTTP_400_BAD_REQUEST)
paginator = LimitOffsetPagination()
paginator.default_limit = DEFAULT_PAGE_LIMIT
paged_publisher_s = paginator.paginate_queryset(publisher_s, request)
serializer = PublisherSerializer(paged_publisher_s, many=True)
return Response(data=serializer.data, )
def get_children(self, obj):
paginator = LimitOffsetPagination()
paginator.default_limit = 10
queryset = CollectionChildrenQuerySet(obj).select_related(
'owner', 'parent').prefetch_related(
'permissions',
'permissions__permission',
'permissions__user',
'permissions__content_object',
).all()
page = paginator.paginate_queryset(queryset=queryset,
request=self.context.get(
'request', None))
serializer = CollectionChildrenSerializer(page,
read_only=True,
many=True,
context=self.context)
return OrderedDict([('count', paginator.count),
('next', paginator.get_next_link()),
('previous', paginator.get_previous_link()),
('results', serializer.data)])
def get_following_for_stream(request):
stream_id = request.data.get('streamId')
if not stream_id:
return Response({'details': {
'required_fields': ['streamId']
}},
status=status.HTTP_400_BAD_REQUEST)
profile_ids = ProfileFollow.objects.filter(
stream=stream_id).values('profile')
profiles = Profile.objects.filter(pk__in=profile_ids)
# paginator = PageNumberPagination()
# paginator.page_size = 20
# result_page = paginator.paginate_queryset(profiles, request)
paginator = LimitOffsetPagination()
paginator.default_limit = 40
result_page = paginator.paginate_queryset(profiles, request)
serializer = ProfileSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def list(self, request):
try:
user_longitude = float(request.GET.get('longitude'))
user_latitude = float(request.GET.get('latitude'))
shop_type = request.GET.get('type')
search = request.GET.get('search')
except Exception:
return Response("invalid coordinates",
status=status.HTTP_400_BAD_REQUEST)
queryset = ShopProfileModel.objects.annotate(distance=haversine(
user_latitude, user_longitude, F('address__location_latitude'),
F('address__location_longitude'))).filter(
distance__lte=2.5,
is_open=True,
is_active=True,
opens_at__lte=timezone.now(),
closes_at__gt=timezone.now()).order_by('distance')
if shop_type:
queryset = queryset.filter(shop_type__iexact=shop_type)
if search:
queryset_temp1 = queryset.filter(name__icontains=search)
queryset_temp2 = queryset.filter(
tags__tag__icontains=search).exclude(name__icontains=search)
queryset = list(chain(queryset_temp1, queryset_temp2))
paginator = LimitOffsetPagination()
paginator.default_limit = 25
paginator.max_limit = 100
paginated_queryset = paginator.paginate_queryset(queryset, request)
serializer = ShopProfileSerializer(paginated_queryset, many=True)
return Response(
data={
'limit': paginator.limit,
'offset': paginator.offset,
'count': paginator.count,
'shops': serializer.data
})
def get_children(self, obj):
paginator = LimitOffsetPagination()
paginator.default_limit = 10
queryset = CollectionChildrenQuerySet(obj).select_related(
'owner', 'parent'
).prefetch_related(
'permissions',
'permissions__permission',
'permissions__user',
'permissions__content_object',
).all()
page = paginator.paginate_queryset(
queryset=queryset,
request=self.context.get('request', None)
)
serializer = CollectionChildrenSerializer(
page, read_only=True, many=True, context=self.context)
return OrderedDict([
('count', paginator.count),
('next', paginator.get_next_link()),
('previous', paginator.get_previous_link()),
('results', serializer.data)
])
def get_following_for_profile_helper(handle, request):
stream_ids = Stream.objects.filter(owner__account__handle=handle)
profiles_ids = ProfileFollow.objects.filter(
stream__in=stream_ids).values('profile').distinct()
stream_follow_ids = StreamFollow.objects.filter(
profile__account__handle=handle).values('stream')
followed_streams = Stream.objects.filter(pk__in=stream_follow_ids)
followed_stream_profiles_followed_ids = ProfileFollow.objects\
.filter(stream__in=followed_streams).values('profile').distinct()
profiles = Profile.objects\
.filter(Q(pk__in=profiles_ids) | Q(pk__in=followed_stream_profiles_followed_ids)).distinct()
# paginator = PageNumberPagination()
# paginator.page_size = 3
# result_page = paginator.paginate_queryset(profiles, request)
paginator = LimitOffsetPagination()
paginator.default_limit = 40
result_page = paginator.paginate_queryset(profiles, request)
serializer = ProfileSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get_followers_for_profile_helper(handle, request):
# get the streams that follow this profile, then get their owners.
streams_following = ProfileFollow.objects.filter(
profile__account__handle=handle).values('stream')
profile_owners_of_streams_following = Stream.objects.filter(
pk__in=streams_following).values('owner')
# get all the people following any one of these streams that is following this profile.
profiles_following_streams_following = StreamFollow.objects.filter(stream__in=streams_following)\
.values('profile')
profiles = Profile.objects\
.filter(Q(pk__in=profile_owners_of_streams_following) | Q(pk__in=profiles_following_streams_following)).distinct()
# paginator = PageNumberPagination()
# paginator.page_size = 20
# result_page = paginator.paginate_queryset(profiles, request)
paginator = LimitOffsetPagination()
paginator.default_limit = 40
result_page = paginator.paginate_queryset(profiles, request)
serializer = ProfileSerializer(result_page, many=True)
return paginator.get_paginated_response(serializer.data)
def get(self, request: Request) -> Response:
self.info(request)
params = self.__clear_request_params(request)
author = ''
if 'author' in params:
author = params.pop('author')
article_s = Article.objects.all()
if author:
try:
author_id = Author.objects.get(author_uuid=author)
except Author.DoesNotExist:
return Response(data={'errors': 'author not found'},
status=status.HTTP_404_NOT_FOUND)
article_s = article_s.filter(authors__in=[author_id.id])
try:
article_s = article_s.filter(**params)
except FieldError as error:
self.exception(request, f'{error}')
return Response(data={'errors': str(error)},
status=status.HTTP_400_BAD_REQUEST)
paginator = LimitOffsetPagination()
paginator.default_limit = DEFAULT_PAGE_LIMIT
paged_article_s = paginator.paginate_queryset(article_s, request)
serializer = ArticleSerializer(paged_article_s, many=True)
return Response(data=serializer.data, )
