class ResultCollectionPayload:
"""
Collection of result payloads.
"""
def __init__(self, container=None):
"""
Constructor.
:param container: optional container to populate values from.
"""
self._results = []
if not container:
self._container = Form()
else:
self._container = container
self._unpack_container()
def append(self, *args):
"""
Append a result to the collection.
:param result:
:return:
"""
self._results += args
def _unpack_container(self):
"""
Unpack the container into the internal data structures.
"""
self._results = []
reported_values = self._container.get_reported()
for item in self._container.get_items():
logger.debug('item: %s' % item)
about = None
types = None
flags = dict()
columns = dict()
for key, value in item.iteritems():
if key == str(RDF.about):
about = value
elif key == str(RDF.type):
types = value
else:
reported_item = reported_values[key]
if reported_item['validate']['datatype']:
columns[_ColumnKey(key, reported_item['validate']['datatype'])] = value
else:
flags[Flag(*(key, reported_item['type'], None))] = value
result_payload = ResultPayload(about=about, types=types)
for key, value in flags.iteritems():
result_payload.add_flag(key, value)
for key, value in columns.iteritems():
result_payload.add_column(key.key, value, key.data_type)
self.append(result_payload)
def populate_payload(self):
"""
Populate the data structures into the container for this object, and return it.
:return: transmittable data structure.
"""
self._container.clear()
self._container.add_reported(var=str(RDF.about), ftype='list-multi')
self._container.add_reported(var=str(RDF.type), ftype='list-multi')
additional_flags = set()
additional_columns = set()
for result in self._results:
additional_flags.update(result.flags.keys())
additional_columns.update(result.columns.keys())
for flag_value in additional_flags:
self._container.add_reported(var=flag_value.var, ftype=flag_value.field_type)
for column_value in additional_columns:
reported = self._container.add_reported(var=column_value.key, ftype='list-multi')
validation = FormValidation()
validation['datatype'] = column_value.data_type
reported.append(validation)
for result in self._results:
parameters = {
str(RDF.about): str(result.about),
str(RDF.type): result.types
}
for key, value in result.flags.iteritems():
parameters[key.var] = value
for key, value in result.columns.iteritems():
parameters[key.key] = value
self._container.add_item(parameters)
return self._container
@property
def results(self):
"""
Retrieve the results.
:return: list of result payloads
"""
return self._results
