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 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 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 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 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):
"""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 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 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 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 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 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 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
})
