def api_build_request(self, resource_obj, request_object, owners=None):
""" """
#
# initialize vars
#
obj_list = []
if owners is None or not owners:
owners = [self._api_org] # set owners to default org
else:
owners = list(owners) # get copy of owners list for pop
count = len(owners)
modified_since = None
request_payload = {}
result_start = 0
result_remaining = 0
#
# resource object values
#
body = request_object.body
content_type = request_object.content_type
http_method = request_object.http_method
owner_allowed = request_object.owner_allowed
resource_pagination = request_object.resource_pagination
resource_type = request_object.resource_type
request_uri = request_object.request_uri
#
# ReportEntry (create a report entry for this request)
#
report_entry = ReportEntry()
report_entry.set_action(request_object.name)
report_entry.set_resource_type(resource_obj.resource_type)
report_entry.add_data({'HTTP Method': http_method})
report_entry.add_data({'Max Results': self._api_max_results})
report_entry.add_data({'Owners': str(owners)})
report_entry.add_data({'Owner Allowed': owner_allowed})
report_entry.add_data({'Request URI': request_uri})
report_entry.add_data({'Request Body': body})
report_entry.add_data({'Resource Pagination': resource_pagination})
report_entry.add_data({'Resource Type': resource_type})
#
# debug
#
self.tcl.debug('Action: {0}'.format(request_object.name))
self.tcl.debug('Resource Type: {0}'.format(resource_obj.resource_type))
self.tcl.debug('HTTP Method: {0}'.format(http_method))
self.tcl.debug('Max Results: {0}'.format(self._api_max_results))
self.tcl.debug('Owners: {0}'.format(str(owners)))
self.tcl.debug('Owner Allowed: {0}'.format(owner_allowed))
self.tcl.debug('Request URI: {0}'.format(request_uri))
self.tcl.debug('Request Body: {0}'.format(body))
self.tcl.debug('Resource Pagination: {0}'.format(resource_pagination))
self.tcl.debug('Resource Type: {0}'.format(resource_type))
# TODO: what would happen if this was always set to request object value?
if resource_type.name in [
'INDICATORS', 'ADDRESSES', 'EMAIL_ADDRESSES', 'FILES', 'HOSTS', 'URLS']:
# TODO: find a cleaner way
if not re.findall('bulk', request_uri):
modified_since = resource_obj.get_modified_since()
# update resource object with max results
# ???moved to report resource_obj.set_max_results(self._api_max_results)
# append uri to resource object
# ???moved to report resource_obj.add_uris(request_uri)
# iterate through all owners and results
if owner_allowed or resource_pagination:
# DEBUG
if modified_since is not None:
request_payload['modifiedSince'] = modified_since
# ReportEntry
report_entry.add_data({'Modified Since': modified_since})
# if request_object.owner_allowed:
# # if len(list(request_object.owners)) > 0:
# # owners = list(request_object.owners)
# count = len(owners)
for x in xrange(count):
retrieve_data = True
# only add_obj owner parameter if owners is allowed
if owner_allowed:
owner = owners.pop(0)
request_payload['owner'] = owner
# DEBUG
self.tcl.debug('owner: %s', owner)
self.tcl.debug('request_payload: %s', request_payload)
# only add_obj result parameters if resource_pagination is allowed
if resource_pagination:
result_limit = int(self._api_max_results)
result_remaining = result_limit
result_start = 0
while retrieve_data:
# set retrieve data to False to prevent loop for non paginating request
retrieve_data = False
# only add_obj result parameters if resource_pagination is allowed
if request_object.resource_pagination:
request_payload['resultLimit'] = result_limit
request_payload['resultStart'] = result_start
# DEBUG
self.tcl.debug('result_limit: %s', result_limit)
self.tcl.debug('result_start: %s', result_start)
#
# api request
#
api_response = self._api_request(
request_uri, request_payload=request_payload, http_method=http_method, body=body)
api_response.encoding = 'utf-8'
# ReportEntry
report_entry.set_status_code(api_response.status_code)
report_entry.add_request_url(api_response.url)
# break is status is not valid
if api_response.status_code not in [200, 201, 202]:
# ReportEntry
report_entry.set_status('Failure')
report_entry.set_status_code(api_response.status_code)
report_entry.add_data({'Failure Message': api_response.content})
# Logging
resource_obj.add_error_message(ErrorCodes.e80000.value.format(api_response.content))
break
#
# CSV Special Case
#
if re.findall('bulk/csv$', request_object.request_uri):
obj_list.extend(
self._api_process_response_csv(resource_obj, api_response.content))
break
#
# parse response
#
api_response_dict = api_response.json()
resource_obj.current_url = api_response.url
# update group object with api response data
resource_obj.add_api_response(api_response.content)
resource_obj.add_status_code(api_response.status_code)
# resource_obj.add_error_message(api_response.content)
#
# bulk indicators
#
# indicator response has no status so it must come first
if 'indicator' in api_response_dict:
#
# process response
#
obj_list.extend(self._api_process_response(
resource_obj, api_response, request_object))
#
# non Success status
#
elif api_response_dict['status'] != 'Success':
# ReportEntry
report_entry.set_status(api_response_dict['status'])
report_entry.add_data(
{'Failure Message': api_response_dict['message']})
#
# normal response
#
elif 'data' in api_response_dict:
# ReportEntry
report_entry.set_status(api_response_dict['status'])
# update resource object
resource_obj.add_status(ApiStatus[api_response_dict['status'].upper()])
#
# process response
#
obj_list.extend(self._api_process_response(
resource_obj, api_response, request_object))
# add_obj resource_pagination if required
if request_object.resource_pagination:
# get the number of results returned by the api
if result_start == 0:
result_remaining = api_response_dict['data']['resultCount']
result_remaining -= result_limit
# flip retrieve data flag if there are more results to pull
if result_remaining > 0:
retrieve_data = True
# increment the start position
result_start += result_limit
else:
resource_obj.add_error_message(api_response.content)
elif content_type == 'application/octet-stream':
#
# api request
#
api_response = self._api_request(
request_uri, request_payload={}, http_method=http_method,
body=body, content_type=content_type)
# ReportEntry
report_entry.set_status_code(api_response.status_code)
report_entry.add_request_url(api_response.url)
if api_response.status_code not in [200, 201, 202]:
# ReportEntry
report_entry.set_status('Failure')
report_entry.add_data({'Failure Message': api_response.content})
# Logging
self.tcl.critical(ErrorCodes.e80000.value.format(api_response.content))
raise RuntimeError(ErrorCodes.e90001.value)
else:
report_entry.set_status('Success')
return api_response.content
else:
#
# api request
#
api_response = self._api_request(
request_uri, request_payload={}, http_method=http_method, body=body)
api_response.encoding = 'utf-8'
if 'content-type' in api_response.headers:
content_type = api_response.headers['content-type']
# ReportData
report_entry.set_status_code(api_response.status_code)
report_entry.add_request_url(api_response.url)
# break is status is not valid
if api_response.status_code not in [200, 201, 202]:
if api_response.status_code == 404:
# failure_message = api_response.json()['message']
failure_message = api_response.content
else:
failure_message = api_response.content
# ReportEntry
report_entry.set_status('Failure')
report_entry.add_data({'Failure Message': failure_message})
# Logging
self.tcl.critical(ErrorCodes.e80000.value.format(api_response.content))
raise RuntimeError(ErrorCodes.e90001.value)
elif content_type == "text/plain":
# signature download
return api_response.content
else:
api_response_dict = api_response.json()
resource_obj.current_url = api_response.url
# ReportEntry
report_entry.set_status(api_response_dict['status'])
# update group object with api response data
resource_obj.add_api_response(api_response.content)
resource_obj.add_status_code(api_response.status_code)
resource_obj.add_status(ApiStatus[api_response_dict['status'].upper()])
# no need to process data for deletes or if no data exists
if http_method != 'DELETE' and 'data' in api_response_dict:
#
# process response
#
processed_data = self._api_process_response(
resource_obj, api_response, request_object)
obj_list.extend(processed_data)
# ReportData
report_entry.add_data({'Result Count': len(obj_list)})
# Report
self.report.add_unfiltered_results(len(obj_list))
self.report.add(report_entry)
return obj_list
