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 get(self, request, *args, **kwargs): if "owner" in request.GET: get_data = request.query_params image = Image.objects.filter( owner=get_data['owner'], viewable='True').order_by('timestamp').reverse() else: image = Image.objects.filter( viewable='True').all().order_by('timestamp').reverse() if "checked" in request.GET: get_data = request.query_params image = Image.objects.filter( checked='False').all().order_by('timestamp').reverse() pagenator = LimitOffsetPagination() result_page = pagenator.paginate_queryset(image, request) serializer = ImageSerializer(result_page, many=True) response = { 'message': 'get image', 'result': serializer.data, "next": remove_query_param(pagenator.get_next_link(), '') } reset_queries() return Response(response, status=status.HTTP_200_OK)
def get(self, request, *args, **kwargs): user = self.request.user profile = user.userAssociated.all().first() blocked_users = BlockedUsers.objects.filter(blocked_by=profile) getblocked_id = "GetBlockedUsersBy_{}".format(user.id) if cache.get(getblocked_id): blocked_users = cache.get(getblocked_id) else: blocked_users = BlockedUsers.objects.filter(blocked_by=profile) cache.set(getblocked_id, blocked_users) if blocked_users: try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset( blocked_users, request) data = BlockedUserSerializer(paginated_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = BlockedUserSerializer(blocked_users, context={ 'request': request }, many=True).data response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'No Users blocked', 'body': [], 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK)
def post(self, request, *args, **kwargs): user = self.request.user profile = user.userAssociated.all().first() friendrequests_id = "GetFriendRequests_{}".format(user.id) if cache.get(friendrequests_id): pending_requests = cache.get(friendrequests_id) else: pending_requests = FriendRequest.objects.filter( receiver=profile).filter(request_status='pending') cache.set(friendrequests_id, pending_requests) if pending_requests: try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset( pending_requests, request) data = FriendRequestSerializer(paginated_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = FriendRequestSerializer(pending_requests, context={ 'request': request }, many=True).data response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'No pending requests', 'body': [], 'status': HTTP_200_OK } return Response(response, 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 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 get(self, request, *args, **kwargs): user = request.user objs = user.notifications.all().order_by("-timestamp") if objs.exists(): try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset(objs, request) data = NotificationsSerializer(paginated_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = NotificationsSerializer(objs, context={ 'request': request }, many=True).data response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'No notifications found', 'body': [], 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK)
def list(self, request, *args, **kwargs): if "empathizer" in request.GET: get_data = request.query_params empathies = Empathy.objects.filter( empathizer=get_data['empathizer']).order_by( 'timestamp').reverse() else: empathies = Empathy.objects.all().order_by('timestamp').reverse() pagenator = LimitOffsetPagination() result_page = pagenator.paginate_queryset(empathies, request) serializer = EmpathySerializer(result_page, many=True) response = { 'message': 'get empathy', 'result': serializer.data, "next": remove_query_param(pagenator.get_next_link(), '') } reset_queries() return Response(response, status=status.HTTP_200_OK)
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_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 post(self, request, *args, **kwargs): userId = request.data.get('userId') try: userId = int(userId) profile = get_object_or_404(Profile, pk=userId) user = profile.user if user.pk == self.request.user.pk: raise Http404 except: response = { 'message': 'Invalid Request !!', 'error': 'Invalid userID', 'status': HTTP_400_BAD_REQUEST } return Response(response, status=HTTP_400_BAD_REQUEST) if user.status != 'Activated': response = { 'message': 'Failed', 'error': 'user is not active', 'status': HTTP_400_BAD_REQUEST } return Response(response, status=HTTP_400_BAD_REQUEST) logged_user = self.request.user logged_user_profile = logged_user.userAssociated.all().first() blocked_status = check_blocked_status(profile, logged_user_profile) if blocked_status: response = { 'message': 'No status Found', 'error': blocked_status[0], 'status': HTTP_400_BAD_REQUEST } return Response(response, status=HTTP_400_BAD_REQUEST) all_status = list( Status.objects.filter(author=profile).filter( Q(current_status='active') | Q(current_status='inactive')).order_by('-created_at')) if all_status: try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset( all_status, request) data = StatusSerializer(paginated_list, context={ 'request': request }, many=True).data print(data) response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = StatusSerializer(all_status, context={ 'request': request }, many=True).data response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'No status Found', 'body': [], 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK)
def post(self, request, *args, **kwargs): searchString = request.data.get('search_phrase') country = request.data.get('country') city = request.data.get('city') user = self.request.user users = Profile.objects.filter( Q(user__status='Activated') | Q(user__status='Deactivated')).prefetch_related("user").exclude( user=user) if country and country != '' and country != 'global': users = users.filter(country=country) if city and city != '' and city != 'global': users = users.filter(city=city) search_keywords = searchString.strip().split(" ") users_filtered_search = {} for key in search_keywords: filtered = users.filter( Q(full_name__icontains=key) | Q(user__username__icontains=key) | Q(country=key) | Q(city=key)) print(filtered, key) for us in filtered: users_filtered_search[us] = users_filtered_search.get(us, 0) + 1 users_sorted_search = OrderedDict( sorted(users_filtered_search.items(), key=lambda kv: kv[1], reverse=True)) users_search_list = list(users_sorted_search) if users_search_list: try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset( users_search_list, request) data = SearchUserSerializer(paginated_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = SearchUserSerializer(users_search_list, context={ 'request': request }, many=True).data print(data) response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'Success', 'body': 'No search result', 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK)
def post(self, request, *args, **kwargs): searchString = request.data.get('search_phrase') country = request.data.get('country') city = request.data.get('city') status1 = Status.objects.filter( Q(current_status='active') | Q(current_status='inactive')) if country and country != '' and country != 'global': status = status1.filter(author__country=country) if city and city != '' and city != 'global': status1 = status1.filter(author__city=city) print(type(status1)) search_keywords = searchString.strip().split(" ") search_keywords = list(filter(None, search_keywords)) for i in range(len(search_keywords)): if search_keywords[i] == " ": del search_keywords[i] else: print(search_keywords[i], 1) print(searchString, search_keywords) status_filtered_search = {} for key in search_keywords: filtered = status1.filter(content__icontains=key) print(filtered, key) for status in filtered: status_filtered_search[status] = status_filtered_search.get( status, 0) + 1 status_sorted_search = OrderedDict( sorted(status_filtered_search.items(), key=lambda kv: kv[1], reverse=True)) status_search_list = list(status_sorted_search) if status_search_list: try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset( status_search_list, request) data = SearchStatusSerializer(paginated_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = SearchStatusSerializer(status_search_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'Success', 'body': 'No search result', 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK)
def ahj_list(request): """ Public API endpoint for AHJ Search. See the API documentation for more information. """ # increment user's # of api calls if (request.user.is_authenticated): update_user_api_call_num(request.user) # Process sent Location object str_location = None try: ob_location = request.data.get('Location', None) if ob_location is not None: str_location = get_str_location(ob_location) except (TypeError, KeyError, ValueError) as e: return Response(str(e), status=status.HTTP_400_BAD_REQUEST) # Process sent Address object if no location provided try: if ob_location is None: ob_address = request.data.get('Address', None) if ob_address is not None: str_address = get_str_address(ob_address) json_location = get_location_gecode_address_str(str_address) str_location = get_str_location(location=json_location) except TypeError: return Response('Invalid Address, all values must be strings', status=status.HTTP_400_BAD_REQUEST) ahjs = filter_ahjs( AHJName=get_ob_value_primitive(request.data, 'AHJName', throw_exception=False), AHJID=get_ob_value_primitive(request.data, 'AHJID', throw_exception=False), AHJCode=get_ob_value_primitive(request.data, 'AHJCode', throw_exception=False), AHJLevelCode=get_ob_value_primitive(request.data, 'AHJLevelCode', throw_exception=False), BuildingCode=get_ob_value_primitive(request.data, 'BuildingCodes', throw_exception=False, exception_return_value=[]), ElectricCode=get_ob_value_primitive(request.data, 'ElectricCodes', throw_exception=False, exception_return_value=[]), FireCode=get_ob_value_primitive(request.data, 'FireCodes', throw_exception=False, exception_return_value=[]), ResidentialCode=get_ob_value_primitive(request.data, 'ResidentialCodes', throw_exception=False, exception_return_value=[]), WindCode=get_ob_value_primitive(request.data, 'WindCodes', throw_exception=False, exception_return_value=[]), StateProvince=get_ob_value_primitive(request.data, 'StateProvince', throw_exception=False), location=str_location) serializer = AHJSerializer paginator = LimitOffsetPagination() context = get_public_api_serializer_context() page = paginator.paginate_queryset(ahjs, request) if str_location is not None: page = order_ahj_list_AHJLevelCode_PolygonLandArea(page) payload = serializer(page, many=True, context=context).data # Mimics implementation of LimitOffsetPagination.get_paginated_response(data) return Response( OrderedDict([ ('count', paginator.count), ('next', paginator.get_next_link()), ('previous', paginator.get_previous_link()), ('AuthorityHavingJurisdictions', payload ) # Match Array name of AuthorityHavingJurisdiction ]))
def post(self, request, *args, **kwargs): user = self.request.user profile = user.userAssociated.all().first() search_field = request.data.get('searchString') if user.status == 'Activated' or user.status == 'Deactivated': matched_sender = list( FriendRequest.objects.filter(request_status='accepted').filter( sender=profile).filter( Q(receiver__full_name__icontains=search_field) | Q(receiver__user__username__icontains=search_field))) matched_receiver = list( FriendRequest.objects.filter(request_status='accepted').filter( receiver=profile).filter( Q(sender__full_name__icontains=search_field) | Q(sender__user__username__icontains=search_field))) friends_list = [] friends_list.extend(matched_receiver) friends_list.extend(matched_sender) if friends_list: try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset( friends_list, request) data = FriendModelSerializer(paginated_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = FriendModelSerializer(friends_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'Success', 'error': 'No Users Found', 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'failed', 'error': 'You are blocked from searching anything', 'status': HTTP_400_BAD_REQUEST } return Response(response, status=HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs): user = self.request.user profile = user.userAssociated.all().first() getfriends_id = "GetFriendList_{}".format(user.id) if cache.get(getfriends_id): friends_list = cache.get(getfriends_id) print("GetFriendlist from Cache") else: requests_sent_accepted = list( FriendRequest.objects.filter(sender=profile).filter( request_status='accepted')) requests_received_accepted = list( FriendRequest.objects.filter(receiver=profile).filter( request_status='accepted')) friends_list = [] friends_list.extend(requests_sent_accepted) friends_list.extend(requests_received_accepted) cache.set(getfriends_id, friends_list) print("GetFriendlist from DB") if friends_list: try: paginator = LimitOffsetPagination() paginated_list = paginator.paginate_queryset( friends_list, request) data = FriendModelSerializer(paginated_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'links': { 'next': paginator.get_next_link(), 'previous': paginator.get_previous_link() }, 'count': paginator.count, 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) except: data = FriendModelSerializer(friends_list, context={ 'request': request }, many=True).data response = { 'message': 'success', 'body': data, 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK) response = { 'message': 'No Friends yet', 'body': [], 'status': HTTP_200_OK } return Response(response, status=HTTP_200_OK)