def __init__(self,
channel=None,
destination=None,
values=None,
id=None,
status=None,
error_message=None,
form_model_id=None,
form_model_revision=None,
data_record_id=None,
event_time=None,
modified_by_id=None,
owner_uid=None):
DocumentBase.__init__(self, id, 'SurveyResponse')
self.submitted_on = utcnow()
self.channel = channel
self.destination = destination
self.created_by = self.modified_by = modified_by_id
self.form_model_id = form_model_id
self.form_model_revision = form_model_revision
self.values = values
self.status = status
self.error_message = error_message
self.data_record_id = data_record_id
self.event_time = event_time if event_time is not None else self.created
self.data_record_history = []
self.owner_uid = owner_uid
def __init__(self, id=None, document_type=None, **values):
if id is None:
id = uuid1().hex
Document.__init__(self, id=id, **values)
self.created = utcnow()
self.document_type = document_type
self.void = False
def add_data(self, entity=None, data=(), event_time=None, submission=None, multiple_records=False):
"""
Add a new datarecord to this Entity and return a UUID for the datarecord.
Arguments:
data: a sequence of ordered tuples, (label, value, type)
event_time: the time at which the event occured rather than
when it was reported
submission_id: an id to a 'submission' document in the
submission log from which this data came
"""
assert is_sequence(data)
assert event_time is None or isinstance(event_time, datetime)
assert self.id is not None, u"id should never be none, even if haven't been saved,an entity should have a UUID."
if event_time is None:
event_time = utcnow()
for (label, value) in data:
if is_empty(label):
raise ValueError(u'Empty label')
if multiple_records:
data_list = []
for (label, value) in data:
data_record = DataRecordDocument(
event_time=event_time,
data=[(label, value)],
submission=submission
)
data_list.append(data_record)
return self._dbm._save_documents(data_list)
else:
data_record_doc = DataRecordDocument(
event_time=event_time,
data=data,
submission=submission
)
return self._dbm._save_document(data_record_doc)
def __init__(self, source, channel=None, destination=None, message=None, id=None):
assert is_string(source)
DocumentBase.__init__(self, id, 'RawSubmissionLog')
self.source = source
self.submitted_on = utcnow()
self.channel = channel
self.destination = destination
self.message = message
def __init__(self, source=None, channel=None, destination=None, values=None, id=None, status=None,
error_message=None, form_code=None, data_record_id=None, voided=None, test=None):
DocumentBase.__init__(self, id, 'SubmissionLog')
self.source = source
self.submitted_on = utcnow()
self.channel = channel
self.destination = destination
self.form_code = form_code
self.values = values
self.status = status
self.error_message = error_message
self.data_record_id = data_record_id
self.voided = voided
self.test = test
def add_data(self,
data=(),
event_time=None,
submission=None,
multiple_records=False):
"""
Add a new datarecord to this Entity and return a UUID for the datarecord.
Arguments:
data: a sequence of ordered tuples, (label, value, type)
where type is a DataDictType
event_time: the time at which the event occured rather than
when it was reported
submission_id: an id to a 'submission' document in the
submission log from which this data came
"""
assert is_sequence(data)
assert event_time is None or isinstance(event_time, datetime)
assert self.id is not None, u"id should never be none, even if haven't been saved,an entity should have a UUID."
# TODO: should we have a flag that says that this has been
# saved at least once to avoid adding data records for an
# Entity that may never be saved? Should docs just be saved on
# init?
if event_time is None:
event_time = utcnow()
for (label, value, dd_type) in data:
if not isinstance(dd_type, DataDictType) or is_empty(label):
raise ValueError(
u'Data must be of the form (label, value, DataDictType).')
self.update_latest_data(data=data)
if multiple_records:
data_list = []
for (label, value, dd_type) in data:
data_record = DataRecordDocument(entity_doc=self._doc,
event_time=event_time,
data=[(label, value, dd_type)
],
submission=submission)
data_list.append(data_record)
return self._dbm._save_documents(data_list)
else:
data_record_doc = DataRecordDocument(entity_doc=self._doc,
event_time=event_time,
data=data,
submission=submission)
return self._dbm._save_document(data_record_doc)
def values(self, aggregation_rules, asof=None):
"""
Return a dictionary of aggregated values. The keys are the
attribute label, each value is the aggregated value for the
given fields using the aggregation function specified for data
collected till a point in time.
Eg: aggregation_rules={'arv':'latest', 'num_patients':'sum'}
will return latest value for arv and sum the number of
patients.
"""
# todo: I think we need to simplify this method a bit and
# expose some of the ViewResults goodness.
asof = asof or utcnow()
result = {}
for field, aggregate_fn in aggregation_rules.items():
view_name = self._translate(aggregate_fn)
result[field] = self._get_aggregate_value(field, view_name, asof)
return result
def values(self, aggregation_rules, asof=None):
"""
Return a dictionary of aggregated values. The keys are the
attribute label, each value is the aggregated value for the
given fields using the aggregation function specified for data
collected till a point in time.
Eg: aggregation_rules={'arv':'latest', 'num_patients':'sum'}
will return latest value for arv and sum the number of
patients.
"""
# todo: I think we need to simplify this method a bit and
# expose some of the ViewResults goodness.
asof = asof or utcnow()
result = {}
for field, aggregate_fn in aggregation_rules.items():
view_name = self._translate(aggregate_fn)
result[field] = self._get_aggregate_value(field, view_name, asof)
return result
def add_data(self, data=(), event_time=None, submission=None, multiple_records=False):
"""
Add a new datarecord to this Entity and return a UUID for the datarecord.
Arguments:
data: a sequence of ordered tuples, (label, value, type)
where type is a DataDictType
event_time: the time at which the event occured rather than
when it was reported
submission_id: an id to a 'submission' document in the
submission log from which this data came
"""
assert is_sequence(data)
assert event_time is None or isinstance(event_time, datetime)
assert self.id is not None, u"id should never be none, even if haven't been saved,an entity should have a UUID."
# TODO: should we have a flag that says that this has been
# saved at least once to avoid adding data records for an
# Entity that may never be saved? Should docs just be saved on
# init?
if event_time is None:
event_time = utcnow()
for (label, value, dd_type) in data:
if not isinstance(dd_type, DataDictType) or is_empty(label):
raise ValueError(u'Data must be of the form (label, value, DataDictType).')
self.update_latest_data(data=data)
if multiple_records:
data_list = []
for (label, value, dd_type) in data:
data_record = DataRecordDocument(
entity_doc=self._doc,
event_time=event_time,
data=[(label, value, dd_type)],
submission=submission
)
data_list.append(data_record)
return self._dbm._save_documents(data_list)
else:
data_record_doc = DataRecordDocument(
entity_doc=self._doc,
event_time=event_time,
data=data,
submission=submission
)
return self._dbm._save_document(data_record_doc)
def _save_documents(self, documents, modified=None):
assert is_sequence(documents)
assert modified is None or isinstance(modified, datetime)
for doc in documents:
assert isinstance(doc, DocumentBase)
doc.modified = modified if modified is not None else dates.utcnow()
# TODO: what should we return here? this is what is available from db.update()...
# The return value of this method is a list containing a tuple for every
# element in the `documents` sequence. Each tuple is of the form
# ``(success, docid, rev_or_exc)``, where ``success`` is a boolean
# indicating whether the update succeeded, ``docid`` is the ID of the
# document, and ``rev_or_exc`` is either the new document revision, or
# an exception instance (e.g. `ResourceConflict`) if the update failed.
# Fix up rev, 'cause bulk update seems not to do that
results = self.database.update(documents)
for x in range(len(results)):
if results[x][0]:
documents[x]._data["_rev"] = results[x][2]
return results
def _save_documents(self, documents, modified=None):
assert is_sequence(documents)
assert modified is None or isinstance(modified, datetime)
for doc in documents:
assert isinstance(doc, DocumentBase)
doc.modified = (modified
if modified is not None else dates.utcnow())
# TODO: what should we return here? this is what is available from db.update()...
# The return value of this method is a list containing a tuple for every
# element in the `documents` sequence. Each tuple is of the form
# ``(success, docid, rev_or_exc)``, where ``success`` is a boolean
# indicating whether the update succeeded, ``docid`` is the ID of the
# document, and ``rev_or_exc`` is either the new document revision, or
# an exception instance (e.g. `ResourceConflict`) if the update failed.
# Fix up rev, 'cause bulk update seems not to do that
results = self.database.update(documents)
for x in range(len(results)):
if results[x][0]:
documents[x]._data['_rev'] = results[x][2]
return results