def form_model_change_handler(form_model_doc, dbm, old_form_model_doc=None):
form_model = FormModel.new_from_doc(dbm, form_model_doc)
old_form_model = None
if old_form_model_doc:
old_form_model = FormModel.new_from_doc(dbm, old_form_model_doc)
if form_model.form_code != 'delete':
create_submission_mapping(dbm, form_model, old_form_model)
def test_should_create_a_questionnaire_from_dictionary(self):
#entityQ = UniqueIdField('reporter', name="What are you reporting on?", code="eid",
# label="Entity being reported on", )
ageQ = IntegerField(
name="What is your age?",
code="AGE",
label="",
constraints=[NumericRangeConstraint(min=0, max=10)],
required=False)
placeQ = SelectField(name="Where do you live?",
code="PLC",
label="",
options=[{
"text": "Pune"
}, {
"text": "Bangalore"
}],
single_select_flag=False,
required=False)
questions = [ageQ, placeQ]
document = self.get_form_model_doc()
questionnaire = FormModel.new_from_doc(self.manager, document)
self.maxDiff = None
self.assertListEqual(questionnaire.entity_type, [])
self.assertEqual(questionnaire.name, "New Project")
for i in range(len(questions)):
self.assertEqual(questionnaire.fields[i]._to_json(),
questions[i]._to_json())
def convert_field_code_to_lower_case(db_name):
logger = logging.getLogger(db_name)
try:
dbm = get_db_manager(db_name)
rows = dbm.load_all_rows_in_view('questionnaire', reduce=False)
for row in rows:
form_model = FormModel.new_from_doc(
dbm, FormModelDocument.wrap(row['value']))
is_upper = False
for field in form_model.fields:
if re.match(r".*[A-Z]+.*", field.code):
logger.info("doc id: %s, field code: %s", form_model.id,
field.code)
is_upper = True
field._dict['code'] = field.code.lower()
if is_upper:
form_model.save()
survey_responses = survey_responses_by_form_code(
dbm, form_model.form_code)
for survey_response in survey_responses:
convert_dict_keys_to_lowercase(survey_response.values)
survey_response.save()
logger.info("Modified survey response id: %s" %
survey_response.uuid)
except Exception as e:
logger.exception(e.message)
mark_as_completed(db_name)
def _get_form_models(dbm, form_code):
form_model_docs = _get_form_model_docs(dbm, form_code)
if form_model_docs:
return [
FormModel.new_from_doc(dbm, FormModelDocument.wrap(form_model_doc))
for form_model_doc in form_model_docs
]
return None
def get_subject_form_model_docs_of_questionnaire(dbm, questionnaire_doc):
questionnaire = FormModel.new_from_doc(dbm, questionnaire_doc)
subject_form_model_docs = []
for entity_question in questionnaire.entity_questions:
rows = dbm.view.registration_form_model_by_entity_type(key=[entity_question.unique_id_type], include_docs=True)
for row in rows:
row.update({'value': row["doc"]})
subject_form_model_docs.extend(rows)
return subject_form_model_docs
def form_model_change_handler(form_model_doc, dbm):
form_model = FormModel.new_from_doc(dbm, form_model_doc)
if form_model.is_entity_registration_form():
if form_model.form_code == REGISTRATION_FORM_CODE:
create_ds_mapping(dbm, form_model)
else:
create_subject_mapping(dbm, form_model)
else:
if form_model.form_code != 'delete':
create_submission_mapping(dbm, form_model)
def get_subject_form_models(manager):
form_models = {}
form_model_values = manager.load_all_rows_in_view('questionnaire')
for each in form_model_values:
form_model = FormModel.new_from_doc(
manager, FormModelDocument.wrap(each['value']))
if form_model.is_registration_form(
) and not form_model.entity_defaults_to_reporter():
form_models[form_model.entity_type[0]] = form_model
return form_models
def test_should_return_questions_for_specific_entity(self):
fields = [{
"constraints": [('range', {
"max": 10,
"min": 0
})],
"label": "",
"type": "integer",
"name": "What is your age?",
"code": "AGE",
"required": False
}, {
"unique_id_type": "waterpoint",
"label": "",
"type": "unique_id",
"name": "Which waterpoint is it?",
"code": "q2",
"required": False
}, {
"unique_id_type": "clinic",
"label": "",
"type": "unique_id",
"name": "Give the name of the clinic",
"code": "q4",
"required": False
}, {
"unique_id_type": "waterpoint",
"label": "",
"type": "unique_id",
"name": "Which waterpoint will you visit next?",
"code": "q3",
"required": False
}, {
"choices": [{
"text": "Pune"
}, {
"text": "Bangalore"
}],
"label": "",
"type": "select",
"name": "Where do you live?",
"code": "PLC",
"required": False
}]
document = self.get_form_model_doc(fields)
form_model = FormModel.new_from_doc(self.manager, document)
clinic_fields = form_model.get_questions_for_entity(["clinic"])
waterpoint_fields = form_model.get_questions_for_entity("waterpoint")
all_idrn_fields = form_model.entity_questions
self.assertEqual(["q4"], [field.code for field in clinic_fields])
self.assertEqual(["q2", "q3"],
[field.code for field in waterpoint_fields])
self.assertEqual(['q2', 'q4', 'q3'],
[field.code for field in all_idrn_fields])
def is_mapping_out_of_sync(form_model_doc, dbm):
form_model = FormModel.new_from_doc(dbm, form_model_doc)
if form_model.form_code == 'delete':
return
submission_search_store = SubmissionSearchStore(dbm,
form_model,
old_form_model=None)
current_mapping = submission_search_store.get_mappings()
old_mapping = submission_search_store.get_old_mappings()
return submission_search_store.is_mapping_out_of_sync()
def registration_form_model_codes(dbm):
rows = dbm.view.registration_form_model_by_entity_type(include_docs=True)
# Form code for Data sender registration
form_codes = ['reg']
if len(rows):
for row in rows:
doc = FormModelDocument.wrap(row['doc'])
form_model = FormModel.new_from_doc(dbm, doc)
form_codes.append(form_model.form_code)
return form_codes
def migrate_subject_form_code_to_add_regex_validator_in_short_code(db_name):
logger = logging.getLogger(db_name)
logger.info('Starting Migration')
mark_as_completed(db_name)
manager = get_db_manager(db_name)
for row in manager.database.query(map_subject_form_model):
try:
doc = FormModelDocument.wrap(row['value'])
form_model = FormModel.new_from_doc(manager, doc)
add_regex_constraint_to_short_code(form_model, logger)
except Exception as e:
logger.exception("FAILED to migrate:%s " % row['value']['_id'])
logger.info('Completed Migration')
def delete_language_setting_for_form_models(dbm):
assert isinstance(dbm, DatabaseManager)
rows = dbm.load_all_rows_in_view('questionnaire')
for row in rows:
try:
form_model_row_value = row['value']
form_model_row_value = delete_language_redundant_settings(
form_model_row_value)
doc = FormModelDocument.wrap(form_model_row_value)
form_model = FormModel.new_from_doc(dbm, doc)
form_model.save()
except Exception as e:
print(
"*******************form model error *************************************",
row['key'])
print e
print "*************************************************"
def create_submission_index(database_name, logger):
dbm = get_db_manager(database_name)
for row in dbm.load_all_rows_in_view('questionnaire'):
try:
form_model = FormModel.new_from_doc(
dbm, FormModelDocument.wrap(row["value"]))
except FormModelDoesNotExistsException as e:
logger.exception(e.message)
continue
if form_model.is_entity_registration_form(
) or "delete" == form_model.form_code:
continue
try:
es.delete_all(dbm.database_name, form_model.id)
except Exception as ignore:
logger.info("Error while deleting index %s" % ignore.message)
create_submission_mapping(dbm, form_model)
create_index(dbm, form_model, logger)
def is_authorized_for_questionnaire(dbm, request_user, form_code):
try:
user_profile = request_user.get_profile()
if not user_profile.reporter:
return True
questionnaire = get_form_model_by_code(dbm, form_code)
if isinstance(questionnaire, EntityFormModel):
rows = dbm.view.projects_by_subject_type(include_docs=True)
for row in rows:
fm = FormModel.new_from_doc(dbm,
FormModelDocument.wrap(row['doc']))
if not fm.is_void(
) and user_profile.reporter_id in fm.data_senders:
return True
if questionnaire.is_void(
) or user_profile.reporter_id not in questionnaire.data_senders:
return False
except FormModelDoesNotExistsException as e:
return False
return True
def get_form_model(manager, raw_str):
doc = FormModelDocument.wrap(raw_str)
form_model = FormModel.new_from_doc(manager, doc)
return form_model
def test_should_create_a_questionnaire_from_dictionary(self):
fields = [
{
"name": "What are you reporting on?",
"defaultValue": "",
"label": {
"eng": "Entity being reported on"
},
"entity_question_flag": True,
"type": "text",
"ddtype": self.default_ddtype.to_json(),
"code": "eid",
"length": {"min": 1, "max": 10},
},
{
"range": {
"max": 10,
"min": 0
},
"label": {"eng": ""},
"type": "integer",
"ddtype": self.default_ddtype.to_json(),
"name": "What is your age?",
"code": "AGE"
},
{
"choices": [
{
"text": {"eng": "Pune"}
},
{
"text": {"eng": "Bangalore"}
}
],
"label": {"eng": ""},
"type": "select",
"ddtype": self.default_ddtype.to_json(),
"name": "Where do you live?",
"code": "PLC"
}]
document = FormModelDocument()
document.json_fields = fields
document.entity_type = ["Reporter"]
document.document_type = "FormModel"
document.form_code = "F1"
document.name = "New Project"
document.type = "survey"
document.type = "survey"
entityQ = TextField(name="What are you reporting on?", code="eid",
label="Entity being reported on", entity_question_flag=True,
length=TextConstraint(min=1, max=10), ddtype=self.default_ddtype)
ageQ = IntegerField(name="What is your age?", code="AGE", label="",
range=NumericConstraint(min=0, max=10), ddtype=self.default_ddtype)
placeQ = SelectField(name="Where do you live?", code="PLC", label="",
options=[{"text": {"eng": "Pune"}}, {"text": {"eng": "Bangalore"}}],
single_select_flag=False, ddtype=self.default_ddtype)
questions = [entityQ, ageQ, placeQ]
questionnaire = FormModel.new_from_doc(self.dbm, document)
self.maxDiff = None
self.assertListEqual(questionnaire.entity_type, ["Reporter"])
self.assertEqual(questionnaire.name, "New Project")
self.assertEqual(questionnaire.type, "survey")
for i in range(len(questions)):
self.assertEqual(questionnaire.fields[i]._to_json(), questions[i]._to_json())
def get_form_model(manager, questionnaire):
doc = FormModelDocument.wrap(questionnaire['value'])
form_model = FormModel.new_from_doc(manager, doc)
return form_model
def test_should_create_a_questionnaire_from_dictionary(self):
fields = [{
"name": "What are you reporting on?",
"defaultValue": "",
"label": {
"eng": "Entity being reported on"
},
"entity_question_flag": True,
"type": "text",
"ddtype": self.default_ddtype.to_json(),
"code": "eid",
"length": {
"min": 1,
"max": 10
},
}, {
"range": {
"max": 10,
"min": 0
},
"label": {
"eng": ""
},
"type": "integer",
"ddtype": self.default_ddtype.to_json(),
"name": "What is your age?",
"code": "AGE"
}, {
"choices": [{
"text": {
"eng": "Pune"
}
}, {
"text": {
"eng": "Bangalore"
}
}],
"label": {
"eng": ""
},
"type":
"select",
"ddtype":
self.default_ddtype.to_json(),
"name":
"Where do you live?",
"code":
"PLC"
}]
document = FormModelDocument()
document.json_fields = fields
document.entity_type = ["Reporter"]
document.document_type = "FormModel"
document.form_code = "F1"
document.name = "New Project"
document.type = "survey"
document.type = "survey"
entityQ = TextField(name="What are you reporting on?",
code="eid",
label="Entity being reported on",
entity_question_flag=True,
length=TextConstraint(min=1, max=10),
ddtype=self.default_ddtype)
ageQ = IntegerField(name="What is your age?",
code="AGE",
label="",
range=NumericConstraint(min=0, max=10),
ddtype=self.default_ddtype)
placeQ = SelectField(name="Where do you live?",
code="PLC",
label="",
options=[{
"text": {
"eng": "Pune"
}
}, {
"text": {
"eng": "Bangalore"
}
}],
single_select_flag=False,
ddtype=self.default_ddtype)
questions = [entityQ, ageQ, placeQ]
questionnaire = FormModel.new_from_doc(self.dbm, document)
self.maxDiff = None
self.assertListEqual(questionnaire.entity_type, ["Reporter"])
self.assertEqual(questionnaire.name, "New Project")
self.assertEqual(questionnaire.type, "survey")
for i in range(len(questions)):
self.assertEqual(questionnaire.fields[i]._to_json(),
questions[i]._to_json())
def add_unique_id_and_short_code_field(dbm, logger):
for row in dbm.database.query(list_all_form_models, include_docs=True):
try:
document_data = row.doc
json_data = document_data.get('json_fields')
validator = None
short_code_field = None
short_code_dict = None
index = 0
if document_data.get('is_registration_model') or document_data.get("form_code") == "delete":
for index, f in enumerate(json_data):
if f.get('name') == SHORT_CODE_FIELD:
short_code_field = ShortCodeField(f.get('name'), f.get('code'), f.get('label'),
defaultValue=f.get('defaultValue'),
instruction=f.get('instruction'), required=f.get('required'))
short_code_dict = f
break
else:
for index, f in enumerate(json_data):
if f.get('entity_question_flag'):
start_key = [document_data.get('form_code')]
end_key = [document_data.get('form_code'), {}]
survey_response_rows = dbm.database.iterview("surveyresponse/surveyresponse", 1000, reduce=False, include_docs=False, startkey=start_key, endkey=end_key)
if document_data.get('entity_type') != ['reporter']:
short_code_field = UniqueIdField(document_data.get('entity_type')[0], f.get('name'),
f.get('code'),
f.get('label'), defaultValue=f.get('defaultValue'),
instruction=f.get('instruction'),
required=f.get('required'))
validator = UniqueIdExistsValidator
#Remove test field from survey responses
for row in survey_response_rows:
if row.get('value').get('test'):
row.get('value').pop('test')
else:
for row in survey_response_rows:
try:
row.get('value').get('values').pop(f.get('code'))
if row.get('value').get('test'):
row.get('value').pop('test')
survey_response = SurveyResponseDocument._wrap_row(row)
dbm._save_document(survey_response)
except Exception as e:
logger.error("Survey response update failed for database %s for id %s" %(dbm.database_name,row.get('id')))
logger.error(e)
short_code_dict = f
break
#Remove event_time flag from reporting date question
elif f.get('type') == 'date' and 'event_time_field_flag' in f:
f.pop('event_time_field_flag')
#Remove entity type from questionnaire form models.
if document_data.get('entity_type'):
document_data.pop('entity_type')
if short_code_dict:
json_data.remove(short_code_dict)
form_model = FormModel.new_from_doc(dbm, (FormModelDocument.wrap(document_data)))
if short_code_field:
form_model._form_fields.insert(index, short_code_field)
if validator:
form_model.add_validator(validator)
_save_form_model_doc(dbm, form_model)
except Exception as e:
logger.error('Failed form model for database : %s, doc with id: %s', dbm.database_name,
row.id)
logger.error(e)
def test_should_set_is_open_survey(self):
document = self.get_form_model_doc()
form_model = FormModel.new_from_doc(self.manager, document)
self.assertFalse(form_model.is_open_survey)
document['is_open_survey'] = True
self.assertTrue(form_model.is_open_survey)
