def get(self, request, format=None):
subs = FinancialAccountsByProgramActivityObjectClass.objects.all()
fg = FilterGenerator()
filter_arguments = fg.create_from_get(request.GET)
subs = subs.filter(**filter_arguments)
paged_data = ResponsePaginator.get_paged_data(
subs, request_parameters=request.GET)
serializer = FinancialAccountsByProgramActivityObjectClassSerializer(
paged_data, many=True)
response_object = {
"total_metadata": {
"count": subs.count(),
},
"page_metadata": {
"page_number": paged_data.number,
"num_pages": paged_data.paginator.num_pages,
"count": len(paged_data),
},
"results": serializer.data
}
return Response(response_object)
def get(self, request, uri=None, piid=None, fain=None, format=None):
awards = None
if uri:
awards = FinancialAccountsByAwardsTransactionObligations.objects.filter(financial_accounts_by_awards__uri=uri)
elif piid:
awards = FinancialAccountsByAwardsTransactionObligations.objects.filter(financial_accounts_by_awards__piid=piid)
elif fain:
awards = FinancialAccountsByAwardsTransactionObligations.objects.filter(financial_accounts_by_awards__fain=fain)
else:
awards = FinancialAccountsByAwardsTransactionObligations.objects.all()
fg = FilterGenerator()
filter_arguments = fg.create_from_get(request.GET)
awards = awards.filter(**filter_arguments)
paged_data = ResponsePaginator.get_paged_data(awards, request_parameters=request.GET)
serializer = FinancialAccountsByAwardsTransactionObligationsSerializer(paged_data, many=True)
response_object = {
"total_metadata": {
"count": awards.count(),
},
"page_metadata": {
"page_number": paged_data.number,
"num_pages": paged_data.paginator.num_pages,
"count": len(paged_data),
},
"results": serializer.data
}
return Response(response_object)
def get(self, request, format=None):
taa = AppropriationAccountBalances.objects.all()
fg = FilterGenerator()
filter_arguments = fg.create_from_get(request.GET)
taa = taa.filter(**filter_arguments)
paged_data = ResponsePaginator.get_paged_data(
taa, request_parameters=request.GET)
serializer = AppropriationAccountBalancesSerializer(paged_data,
many=True)
response_object = {
"total_metadata": {
"count": taa.count(),
},
"page_metadata": {
"page_number": paged_data.number,
"num_pages": paged_data.paginator.num_pages,
"count": len(paged_data),
},
"results": serializer.data
}
serializer = AppropriationAccountBalancesSerializer(taa, many=True)
response_object = {"count": taa.count(), "results": serializer.data}
return Response(response_object)
def build_response(self, request, *args, **kwargs):
"""Returns total and page metadata that can be attached to a response."""
queryset = kwargs.get('queryset')
# workaround to handle both GET and POST requests
params = self.request.query_params.copy(
) # copy() creates mutable copy of a QueryDict
params.update(self.request.data.copy())
# construct metadata of entire set of data that matches the request specifications
total_metadata = {"count": queryset.count()}
# get paged data for this request
paged_data = ResponsePaginator.get_paged_data(
queryset, request_parameters=params)
# construct page-specific metadata
page_metadata = {
"page_number": paged_data.number,
"num_pages": paged_data.paginator.num_pages,
"count": len(paged_data)
}
# note that generics/viewsets pass request and view info to the
# serializer context automatically. however, we explicitly add it here
# because our common DetailViewSet overrides the 'list' method, which
# somehow prevents the extra info from being added to the serializer
# context. because we can get rid of DetailViewSet and use
# ReadOnlyModelViewSet directly as soon as the pagination changes
# are in, not going spend a lot of time researching this.
context = {'request': request, 'view': self}
# serialize the paged data
serializer = kwargs.get('serializer')(paged_data,
many=True,
context=context)
serialized_data = serializer.data
response_object = OrderedDict({
"total_metadata": total_metadata,
"page_metadata": page_metadata
})
response_object.update({'results': serialized_data})
return response_object
def list(self, request, *args, **kwargs):
"""
Override the parent list method so we can aggregate the data
before constructing a respones.
"""
try:
queryset = self.aggregate(request, *args, **kwargs)
# construct metadata of entire queryset
metadata = {"count": queryset.count()}
# get paged data for this request
paged_data = ResponsePaginator.get_paged_data(
queryset, request_parameters=request.data)
paged_queryset = paged_data.object_list.all()
# construct page-specific metadata
page_metadata = {
"page_number": paged_data.number,
"num_pages": paged_data.paginator.num_pages,
"count": len(paged_data)
}
# serialize the paged data
serializer = self.get_serializer(paged_queryset, many=True)
serialized_data = serializer.data
response_object = {
"total_metadata": metadata,
"page_metadata": page_metadata
}
response_object.update({'results': serialized_data})
status_code = status.HTTP_200_OK
except InvalidParameterException as e:
response_object = {"message": str(e)}
status_code = status.HTTP_400_BAD_REQUEST
self.exception_logger.exception(e)
except Exception as e:
response_object = {"message": str(e)}
status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
self.exception_logger.exception(e)
finally:
return Response(response_object, status=status_code)
def post(self, request, format=None):
fg = FilterGenerator()
try:
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
filters = fg.create_from_post(body)
except Exception as e:
return Response({"message": str(e)}, status=status.HTTP_400_BAD_REQUEST)
awards = Award.objects.all()
if len(fg.search_vectors) > 0:
vector_sum = fg.search_vectors[0]
for vector in fg.search_vectors[1:]:
vector_sum += vector
awards = awards.annotate(search=vector_sum)
awards = awards.filter(filters)
paged_data = ResponsePaginator.get_paged_data(awards, request_parameters=body)
fields = body.get('fields', None)
exclude = body.get('exclude', None)
serializer = AwardSerializer(paged_data, fields=fields, exclude=exclude, many=True)
response_object = {
"total_metadata": {
"count": awards.count(),
"total_obligation_sum": awards.aggregate(Sum('total_obligation'))["total_obligation__sum"],
},
"page_metadata": {
"page_number": paged_data.number,
"num_pages": paged_data.paginator.num_pages,
"count": len(paged_data),
"total_obligation_sum": paged_data.object_list.aggregate(Sum('total_obligation'))["total_obligation__sum"],
},
"results": serializer.data
}
return Response(response_object)
def get(self, request, uri=None, piid=None, fain=None, format=None):
filter_map = {
'awarding_fpds': 'awarding_agency__fpds_code',
'funding_fpds': 'funding_agency__fpds_code',
}
fg = FilterGenerator(filter_map=filter_map, ignored_parameters=['fy'])
filter_arguments = fg.create_from_get(request.GET)
# We need to parse the FY to be the appropriate value
if 'fy' in request.GET:
fy = FiscalYear(request.GET.get('fy'))
fy_arguments = fy.get_filter_object('date_signed', as_dict=True)
filter_arguments = {**filter_arguments, **fy_arguments}
if uri:
filter_arguments['uri'] = uri
elif piid:
filter_arguments['piid'] = piid
elif fain:
filter_arguments['fain'] = fain
awards = Award.objects.all().filter(**filter_arguments)
paged_data = ResponsePaginator.get_paged_data(awards, request_parameters=request.GET)
serializer = AwardSerializer(paged_data, many=True)
response_object = {
"total_metadata": {
"count": awards.count(),
"total_obligation_sum": awards.aggregate(Sum('total_obligation'))["total_obligation__sum"],
},
"page_metadata": {
"page_number": paged_data.number,
"num_pages": paged_data.paginator.num_pages,
"count": len(paged_data),
"total_obligation_sum": paged_data.object_list.aggregate(Sum('total_obligation'))["total_obligation__sum"],
},
"results": serializer.data
}
return Response(response_object)