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_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 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)
