def process_custom_fields(self, json_blob):
# Internal method to convert custom fields responses into a list of Parsons tables
# Original table & columns
custom_fields = Table(json_blob)
# Available On
available_on = custom_fields.long_table(['id'], 'available_on')
# Options
options = custom_fields.long_table(['id', 'name'], 'options')
return [{'name': 'custom_fields', 'tbl': custom_fields},
{'name': 'custom_fields_available', 'tbl': available_on},
{'name': 'custom_fields_options', 'tbl': options}]
def get_activity_types(self):
"""
Get activity types
`Args:`
`filters: dict`
Optional; pass additional parameters to filter the records returned.
See `Copper documentation <https://developer.copper.com/?version=latest#6bd339f1-f0de-48b4-8c34-5a5e245e036f>`_ for choices
`Returns:`
List of dicts of Parsons Tables:
* activitiy_types
""" # noqa: E501,E261
logger.info("Retrieving activity types.")
response = self.paginate_request('/activity_types/', req_type='GET')
orig_table = Table(response)
at_user = orig_table.long_table([], 'user', prepend=False)
at_sys = orig_table.long_table([], 'system', prepend=False)
Table.concat(at_sys, at_user)
return [{'name': 'activity_types', 'tbl': at_sys}]
def process_json(self, json_blob, obj_type, tidy=False):
# Internal method for converting most types of json responses into a list of Parsons tables
# Output goes here
table_list = []
# Original table & columns
obj_table = Table(json_blob)
cols = obj_table.get_columns_type_stats()
list_cols = [x['name'] for x in cols if 'list' in x['type']]
dict_cols = [x['name'] for x in cols if 'dict' in x['type']]
# Unpack all list columns
if len(list_cols) > 0:
for l in list_cols: # noqa E741
# Check for nested data
list_rows = obj_table.select_rows(
lambda row: isinstance(row[l], list)
and any(isinstance(x, dict) for x in row[l])
)
# Add separate long table for each column with nested data
if list_rows.num_rows > 0:
logger.debug(l, 'is a nested column')
if len([x for x in cols if x['name'] == l]) == 1:
table_list.append({
'name': f'{obj_type}_{l}',
'tbl': obj_table.long_table(['id'], l)
})
else:
# Ignore if column doesn't exist (or has multiples)
continue
else:
if tidy is False:
logger.debug(l, 'is a normal list column')
obj_table.unpack_list(l)
# Unpack all dict columns
if len(dict_cols) > 0 and tidy is False:
for d in dict_cols:
logger.debug(d, 'is a dict column')
obj_table.unpack_dict(d)
if tidy is not False:
packed_cols = list_cols + dict_cols
for p in packed_cols:
if p in obj_table.columns:
logger.debug(p, 'needs to be unpacked into rows')
# Determine whether or not to expand based on tidy
unpacked_tidy = obj_table.unpack_nested_columns_as_rows(p, expand_original=tidy)
# Check if column was removed as sign it was unpacked into separate table
if p not in obj_table.columns:
table_list.append({
'name': f'{obj_type}_{p}',
'tbl': unpacked_tidy
})
else:
obj_table = unpacked_tidy
# Original table will have had all nested columns removed
if len(obj_table.columns) > 1:
table_list.append({'name': obj_type, 'tbl': obj_table})
return table_list
