def go(self, endpoint_name, endpoint_vars = {}, local_vars = {}):
if isinstance(local_vars, dict):
self.local_vars = local_vars
# must set endpoint name before checking for bypass_prerequisites
self.config.custom_endpoint_name = endpoint_name
self.config.set_actual_endpoint_name()
self.config.apply_custom_endpoint_params()
if not Utilities.dict_lookup(self.config.settings, 'endpoints', self.config.custom_endpoint_name, 'bypass_prerequisites'):
self._process_prerequisites()
# must set endpoint name after processing prerequisites to setup requested endpoint
self.config.custom_endpoint_name = endpoint_name
self.config.set_actual_endpoint_name()
self.config.apply_custom_endpoint_params()
if self.config.actual_endpoint_name not in self.config.settings['endpoints']:
raise Exception('specified endpoint does not exist in config: {}'.format(self.config['actual_endpoint_name']))
if isinstance(endpoint_vars, dict):
self.endpoint_vars = endpoint_vars
else:
self.endpoint_vars = {}
array_set = endpoint_vars.get('array_set')
if array_set:
self.config.apply_endpoint_array_set_vars(array_set)
self.config.apply_endpoint_vars(endpoint_vars)
self.config.set_method()
self._auth.setup_oauth_header(self.global_vars)
self._time_limit = self.local_vars.get('time_limit') or self.config.get_custom_endpoint_setting('time_limit')
output = self.request.get_response(self._time_limit)
output_config = self.config.get_endpoint_setting('output')
# filter output
if output_config and 'filter' in output_config and Utilities.is_structure(output):
unfiltered_output = list(output)
output = []
if not Utilities.is_structure(output_config['filter']):
raise Exception('onfig endpoint output filter must be a structure')
for filter in output_config['filter']:
match_found = False
if 'search_key' not in filter or 'search_value' not in filter:
raise Exception('search_key and search_value are required for output filtering')
for item in unfiltered_output:
item_value = item.get(filter['search_key'])
if item_value == None:
continue
if item_value == filter['search_value']:
match_found = True
if filter['return_key']:
return item.get(filter['return_key'])
output.append(item)
if filter.get('return_type'):
if filter['return_type'] == 'boolean':
return match_found
elif filter['return_type'] == '!boolean':
return not match_found
self.config.reset_to_unmerged()
return output
def populate(self, config, response, output):
self._config = config
response_count = 0
output_config = config.get_endpoint_setting('output')
paging = config.get_endpoint_setting('paging')
ret = {}
if output == None:
output = []
if not output_config:
if paging:
if isinstance(response, list):
return len(response), output + response
else:
output.append(response)
return 1, output
else:
return 1, response
data = self._get_data(response)
if not data:
return 0, output
output_format = Utilities.dict_lookup(output_config, 'data', 'format')
if output_format == 'iterable': # like an array of contact records
if not Utilities.is_structure(data):
raise Exception('output config specifies structure data format but response is not a structure');
# put in specified output format, if applicable
if Utilities.dict_lookup(output_config, 'data', 'items', 'locations'):
if isinstance(data, dict):
for data_key, data_value in data.items():
key_filter = Utilities.dict_lookup(output_config, 'data', 'key_filter')
if key_filter:
if (key_filter == 'numeric') and not isinstance(data_key, int):
continue
# if output_config.data.items is specified, we are expecting the data structure to contain child structures
if not Utilities.is_structure(data_value):
raise Exception('output config specifies data items but response children are not structures')
output_item = self._get_item(data_value);
output.append(output_item)
response_count += 1
elif isinstance(data, list):
for data_value in data:
# if output_config.data.items is specified, we are expecting the data structure to contain child structures
if not Utilities.is_structure(data_value):
raise Exception('output config specifies data items but response children are not structures')
output_item = self._get_item(data_value);
output.append(output_item)
response_count += 1
else:
output = output + data
response_count = len(data)
else: # non-iterable (like scalar value or single contact record)
if isinstance(data, dict) and Utilities.dict_lookup(output_config, 'data', 'items', 'locations'):
return_output = self._get_item(data)
else:
return_output = data # leave data as is
if paging:
output.append(return_output)
else:
output = return_output
response_count = 1
return response_count, output
