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)
