def test_subcase_repeat_mixed_form(self):
app = Application.new_app(None, "Untitled Application")
module_0 = app.add_module(Module.new_module('parent', None))
module_0.unique_id = 'm0'
module_0.case_type = 'parent'
form = app.new_form(0, "Form", None, attachment=self.get_xml('subcase_repeat_mixed_form_pre'))
module_1 = app.add_module(Module.new_module('subcase', None))
module_1.unique_id = 'm1'
module_1.case_type = 'subcase'
form.actions.open_case = OpenCaseAction(name_path="/data/parent_name")
form.actions.open_case.condition.type = 'always'
form.actions.subcases.append(OpenSubCaseAction(
case_type=module_1.case_type,
case_name="/data/first_child_name",
condition=FormActionCondition(type='always')
))
# subcase in the middle that has a repeat context
form.actions.subcases.append(OpenSubCaseAction(
case_type=module_1.case_type,
case_name="/data/repeat_child/repeat_child_name",
repeat_context='/data/repeat_child',
condition=FormActionCondition(type='always')
))
form.actions.subcases.append(OpenSubCaseAction(
case_type=module_1.case_type,
case_name="/data/last_child_name",
condition=FormActionCondition(type='always')
))
self.assertXmlEqual(self.get_xml('subcase_repeat_mixed_form_post'),
app.get_module(0).get_form(0).render_xform())
def new_module(request, domain, app_id):
"Adds a module to an app"
app = get_app(domain, app_id)
from corehq.apps.app_manager.views.utils import get_default_followup_form_xml
lang = request.COOKIES.get('lang', app.langs[0])
name = request.POST.get('name')
module_type = request.POST.get('module_type', 'case')
if module_type == 'case' or module_type == 'survey': # survey option added for V2
if module_type == 'case':
name = name or 'Case List'
else:
name = name or 'Surveys'
module = app.add_module(Module.new_module(name, lang))
module_id = module.id
form_id = None
unstructured = add_ons.show("empty_case_lists", request, app)
if module_type == 'case':
if not unstructured:
form_id = 0
# registration form
register = app.new_form(module_id, _("Registration Form"), lang)
register.actions.open_case = OpenCaseAction(condition=FormActionCondition(type='always'))
register.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
# one followup form
msg = _("This is your follow up form. "
"Delete this label and add questions for any follow up visits.")
attachment = get_default_followup_form_xml(context={'lang': lang, 'default_label': msg})
followup = app.new_form(module_id, _("Followup Form"), lang, attachment=attachment)
followup.requires = "case"
followup.actions.update_case = UpdateCaseAction(condition=FormActionCondition(type='always'))
_init_module_case_type(module)
else:
form_id = 0
app.new_form(module_id, _("Survey"), lang)
app.save()
response = back_to_main(request, domain, app_id=app_id,
module_id=module_id, form_id=form_id)
response.set_cookie('suppress_build_errors', 'yes')
return response
elif module_type in MODULE_TYPE_MAP:
fn = MODULE_TYPE_MAP[module_type][FN]
validations = MODULE_TYPE_MAP[module_type][VALIDATIONS]
error = next((v[1] for v in validations if v[0](app)), None)
if error:
messages.warning(request, error)
return back_to_main(request, domain, app_id=app.id)
else:
return fn(request, domain, app, name, lang)
else:
logger.error('Unexpected module type for new module: "%s"' % module_type)
return back_to_main(request, domain, app_id=app_id)
def add_edit_form_to_module(module_):
edit_form = module_.new_form('Edit Subject', None)
edit_form.get_unique_id()
edit_form.source = self.get_subject_form_source('Edit Subject')
edit_form.requires = 'case'
update = dict(self.case_update, name='/data/' + CC_SUBJECT_KEY)
preload = {v: k for k, v in update.items()}
edit_form.actions.case_preload = PreloadAction(
preload=preload, condition=FormActionCondition(type='always'))
edit_form.actions.update_case = UpdateCaseAction(
update=update, condition=FormActionCondition(type='always'))
def add_reg_form_to_module(module_):
reg_form = module_.new_form('Register Subject', None)
reg_form.get_unique_id()
reg_form.source = self.get_subject_form_source('Register Subject')
reg_form.actions.open_case = OpenCaseAction(
name_path='/data/' + CC_SUBJECT_KEY,
external_id=None,
condition=FormActionCondition(type='always'))
reg_form.actions.update_case = UpdateCaseAction(
update=self.case_update,
condition=FormActionCondition(type='always'))
def new_form(request, domain, app_id, module_unique_id):
"""
Adds a form to an app (under a module)
"""
app = get_app(domain, app_id)
try:
module = app.get_module_by_unique_id(module_unique_id)
except ModuleNotFoundException:
raise HttpResponseBadRequest
lang = request.COOKIES.get('lang', app.langs[0])
form_type = request.POST.get('form_type', 'form')
case_action = request.POST.get('case_action', 'none')
if case_action == 'open':
name = _('Register')
elif case_action == 'update':
name = _('Followup')
elif module.is_training_module:
name = _('Lesson')
else:
name = _('Survey')
if form_type == "shadow":
if module.module_type == "advanced":
form = module.new_shadow_form(name, lang)
else:
raise Exception("Shadow forms may only be created under shadow modules")
else:
form = module.new_form(name, lang)
if form_type != "shadow":
if case_action == 'update':
form.requires = 'case'
form.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
elif case_action == 'open':
form.actions.open_case = OpenCaseAction(
condition=FormActionCondition(type='always'))
form.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
app.save()
return back_to_main(
request, domain,
app_id=app.id,
module_unique_id=module.unique_id,
form_unique_id=form.unique_id
)
def form_opens_case(form, case_type=None, is_subcase=False, parent_tag=None, is_extension=False):
if form.form_type == 'module_form':
if is_subcase:
form.actions.subcases.append(OpenSubCaseAction(
case_type=case_type,
case_name="/data/name",
condition=FormActionCondition(type='always')
))
else:
form.actions.open_case = OpenCaseAction(name_path="/data/name", external_id=None)
form.actions.open_case.condition.type = 'always'
else:
case_type = case_type or form.get_module().case_type
action = AdvancedOpenCaseAction(
case_type=case_type,
case_tag='open_{}'.format(case_type),
name_path='/data/name'
)
if is_subcase:
if not parent_tag:
parent_tag = form.actions.load_update_cases[-1].case_tag
action.case_indices = [CaseIndex(tag=parent_tag, relationship='extension' if is_extension else 'child')]
form.actions.open_cases.append(action)
def test_child_module_with_parent_select_entry_datums(self):
"""
m0 - opens 'gold-fish' case.
m1 - has m0 as root-module, has parent-select, updates 'guppy' case, creates
'pregnancy' subcases to guppy
"""
self.module_1.root_module_id = self.module_0.unique_id
# m0f0 registers gold-fish case
self.module_0.case_type = 'gold-fish'
m0f0 = self.module_0.get_form(0)
m0f0.requires = 'case'
m0f0.actions.update_case = UpdateCaseAction(
update={'question2': '/data/question2'})
m0f0.actions.update_case.condition.type = 'always'
# m1f0 has parent-select, updates `guppy` case, and opens sub-subcase 'pregnancy'
self.module_1.case_type = 'guppy'
self.module_1.parent_select = ParentSelect(
active=True, module_id=self.module_0.unique_id)
m1f0 = self.module_1.get_form(0)
m1f0.requires = 'case'
m1f0.actions.update_case = UpdateCaseAction(
update={'question2': '/data/question2'})
m1f0.actions.update_case.condition.type = 'always'
m1f0.actions.subcases.append(
OpenSubCaseAction(case_type='pregnancy',
case_name="/data/question1",
condition=FormActionCondition(type='always')))
self.assertXmlPartialEqual(
self.get_xml('child-module-with-parent-select-entry-datums-added'),
self.app.create_suite(), "./entry")
def setUp(self):
self.is_usercase_in_use_patch = patch('corehq.apps.app_manager.models.is_usercase_in_use')
self.is_usercase_in_use_mock = self.is_usercase_in_use_patch.start()
self.is_usercase_in_use_mock.return_value = True
self.app = Application.new_app('domain', 'New App')
self.module = self.app.add_module(AdvancedModule.new_module('Fish Module', None))
self.module.case_type = 'fish'
self.form = self.module.new_form('Form', 'en', self.get_xml('original').decode('utf-8'))
self.other_module = self.app.add_module(AdvancedModule.new_module('Freshwater Module', lang='en'))
self.other_module.case_type = 'freshwater'
self.other_form = self.module.new_form('Other Form', 'en', self.get_xml('original').decode('utf-8'))
self.case_index = CaseIndex(
reference_id='host',
relationship='extension',
)
self.subcase = AdvancedOpenCaseAction(
case_tag='open_freshwater_0',
case_type='freshwater',
case_name='Wanda',
name_update=ConditionalCaseUpdate(question_path='/data/question1'),
open_condition=FormActionCondition(type='always'),
case_properties={'name': ConditionalCaseUpdate(question_path='/data/question1')},
case_indices=[self.case_index],
)
self.form.actions.open_cases.append(self.subcase)
self.xform = XForm(self.get_xml('original'))
path = 'subcase_0/'
self.subcase_block = XFormCaseBlock(self.xform, path)
def new_form(request, domain, app_id, module_id):
"Adds a form to an app (under a module)"
app = get_app(domain, app_id)
lang = request.COOKIES.get('lang', app.langs[0])
name = request.POST.get('name')
form_type = request.POST.get('form_type', 'form')
if form_type == "shadow":
app = get_app(domain, app_id)
module = app.get_module(module_id)
if module.module_type == "advanced":
form = module.new_shadow_form(name, lang)
else:
raise Exception(
"Shadow forms may only be created under shadow modules")
else:
form = app.new_form(module_id, name, lang)
if toggles.APP_MANAGER_V2.enabled(
request.user.username) and form_type != "shadow":
case_action = request.POST.get('case_action', 'none')
if case_action == 'update':
form.requires = 'case'
form.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
app.save()
# add form_id to locals()
form_id = form.id
response = back_to_main(request,
domain,
app_id=app_id,
module_id=module_id,
form_id=form_id)
return response
def get_open_subcase_action():
props = {
'start_date': '/data/start_date',
'start_time': '/data/start_time',
'end_date': '/data/end_date',
'end_time': '/data/end_time',
'event_type': '/data/event_type',
'event_repeats': '/data/event_repeats',
}
# Save all properties to the case. We will use them to pre-populate the event's update forms (see
# StudyForm.add_form_to_module) ... but we won't use them for the export. We will use all the form
# submissions instead, so we can get an audit trail of all value changes for the ODM.
for study_form in self.iter_forms():
for item_group in study_form.iter_item_groups():
for item in item_group.iter_items():
props[item.question_name] = '/data/{}/{}'.format(
item_group.question_name,
item.question_name
)
return OpenSubCaseAction(
case_type='event',
case_name='/data/name',
case_properties=props,
condition=FormActionCondition(type='always')
)
def new_form(request, domain, app_id, module_id):
"Adds a form to an app (under a module)"
app = get_app(domain, app_id)
lang = request.COOKIES.get('lang', app.langs[0])
name = request.POST.get('name')
form = app.new_form(module_id, name, lang)
blank_form = render_to_string("app_manager/blank_form.xml", context={
'xmlns': str(uuid.uuid4()).upper(),
'name': form.name[lang],
'lang': lang,
})
form.source = blank_form
if toggles.APP_MANAGER_V2.enabled(domain):
case_action = request.POST.get('case_action', 'none')
if case_action == 'update':
form.requires = 'case'
form.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
app.save()
# add form_id to locals()
form_id = form.id
response = back_to_main(request, domain, app_id=app_id, module_id=module_id,
form_id=form_id)
return response
def condition_case(expected, type=None, question=None, answer=None, operator=None):
condition = FormActionCondition(
type=type,
question=question,
answer=answer,
operator=operator
)
return condition, expected
def test_current_schedule_phase(self):
""" Current Schedule Phase is set depending on transition and termination conditions """
self._fetch_sources()
current_schedule_phase_partial = """
<partial>
<bind type="xs:integer"
nodeset="/data/case_case_clinic/case/update/current_schedule_phase"
calculate="{value}"
{xmlns}/>
</partial>
"""
transition_question = '/data/successful_birth'
transition_answer = 'yes'
self.form_1.schedule.transition_condition = FormActionCondition(
type='if',
question=transition_question,
answer=transition_answer,
)
termination_question = '/data/passed_away'
termination_answer = 'yes'
self.form_1.schedule.termination_condition = FormActionCondition(
type='if',
question=termination_question,
answer=termination_answer,
)
self._apply_schedule_phases()
xform_1 = self.form_1.wrapped_xform()
self.form_1.add_stuff_to_xform(xform_1)
value = "if({termination_condition}, -1, if({transition_condition}, 2, 1))".format(
termination_condition="{} = '{}'".format(termination_question,
termination_answer),
transition_condition="{} = '{}'".format(transition_question,
transition_answer),
)
self.assertXmlPartialEqual(
current_schedule_phase_partial.format(value=value,
xmlns=self.xmlns),
(xform_1.model_node.find(
'./bind[@nodeset="/data/case_case_clinic/case/update/current_schedule_phase"]'
).render()), '.')
def _add_save_to_case_questions(self):
# The information for save to case questions comes directly from Vellum
form_id = self.form.unique_id
for property_info in self.form.case_references_data.get_save_references(
):
if not property_info.case_type:
# If there is no case type given by the user, we can't really
# infer what this save to case question refers to
continue
for property_name in property_info.properties:
question = FormQuestionResponse.wrap({
"label":
property_info.path,
"tag":
property_info.path,
"value":
property_info.path,
"repeat":
None,
"group":
None,
"type":
'SaveToCase',
"relevant":
None,
"required":
None,
"comment":
None,
"hashtagValue":
property_info.path,
})
self.meta.add_property_save(property_info.case_type,
property_name, form_id, question)
type_meta = self.meta.get_type(property_info.case_type)
if property_info.create:
type_meta.add_opener(form_id,
FormActionCondition(type='always'))
if property_info.close:
type_meta.add_closer(form_id,
FormActionCondition(type='always'))
def test_subcase_repeat_mixed(self, *args):
app = Application.new_app(None, "Untitled Application")
module_0 = app.add_module(Module.new_module('parent', None))
module_0.unique_id = 'm0'
module_0.case_type = 'parent'
form = app.new_form(0, "Form", None)
form.actions.open_case = OpenCaseAction(
name_update=ConditionalCaseUpdate(question_path="/data/question1"))
form.actions.open_case.condition.type = 'always'
child_case_type = 'child'
form.actions.subcases.append(
OpenSubCaseAction(case_type=child_case_type,
name_update=ConditionalCaseUpdate(
question_path="/data/question1"),
condition=FormActionCondition(type='always')))
# subcase in the middle that has a repeat context
form.actions.subcases.append(
OpenSubCaseAction(case_type=child_case_type,
name_update=ConditionalCaseUpdate(
question_path="/data/repeat/question1"),
repeat_context='/data/repeat',
condition=FormActionCondition(type='always')))
form.actions.subcases.append(
OpenSubCaseAction(case_type=child_case_type,
name_update=ConditionalCaseUpdate(
question_path="/data/question1"),
condition=FormActionCondition(type='always')))
expected = """
<partial>
<session>
<datum id="case_id_new_parent_0" function="uuid()"/>
<datum id="case_id_new_child_1" function="uuid()"/>
<datum id="case_id_new_child_3" function="uuid()"/>
</session>
</partial>
"""
self.assertXmlPartialEqual(expected, app.create_suite(),
'./entry[1]/session')
def get_update_case_action():
update = {
'start_date': '/data/start_date',
'start_time': '/data/start_time',
'end_date': '/data/end_date',
'end_time': '/data/end_time',
}
for item_group in self.iter_item_groups():
for item in item_group.iter_items():
update[item.question_name] = '/data/{}/{}'.format(
item_group.question_name, item.question_name)
return UpdateCaseAction(
update=update, condition=FormActionCondition(type='always'))
def test_grandparent_as_child_module(self):
"""
Module 0 case_type = gold-fish
Module 1 case_type = guppy (child of gold-fish)
Module 2 case_type = tadpole (child of guppy, grandchild of gold-fish)
Module 2's parent module = Module 1
"""
self.module_0.case_type = 'gold-fish'
m0f0 = self.module_0.get_form(0)
self._load_case(m0f0, 'gold-fish')
m0f0.actions.subcases.append(
OpenSubCaseAction(case_type='guppy',
case_name="/data/question1",
condition=FormActionCondition(type='always')))
self.module_1.case_type = 'guppy'
m1f0 = self.module_1.get_form(0)
self._load_case(m1f0, 'guppy', parent_module=self.module_0)
m1f0.actions.subcases.append(
OpenSubCaseAction(case_type='tadpole',
case_name="/data/question1",
condition=FormActionCondition(type='always')))
self.module_2 = self.app.add_module(
self.child_module_class.new_module("grandchild", None))
self.module_2.unique_id = 'm2'
self.app.new_form(2, 'grandchild form', None)
self.module_2.case_type = 'tadpole'
m2f0 = self.module_2.get_form(0)
self._load_case(m2f0, 'tadpole', parent_module=self.module_1)
self.module_2.root_module_id = self.module_1.unique_id
self.assertXmlPartialEqual(
self.get_xml('child-module-grandchild-case'),
self.app.create_suite(), "./entry")
def _init_biometrics_enroll_module(app, lang):
"""
Creates Enrolment Module for Biometrics
"""
module = app.add_module(Module.new_module(_("Registration"), lang))
form_name = _("Enroll New Person")
context = {
'xmlns_uuid': str(uuid.uuid4()).upper(),
'form_name': form_name,
'name_label': _("What is your name?"),
'simprints_enrol_label': _("Scan Fingerprints"),
'lang': lang,
}
context.update(app.biometric_context)
attachment = render_to_string("app_manager/simprints_enrolment_form.xml",
context=context)
enroll = app.new_form(module.id, form_name, lang, attachment=attachment)
enroll.actions.open_case = OpenCaseAction(
name_path="/data/name",
condition=FormActionCondition(type='always'),
)
enroll.actions.update_case = UpdateCaseAction(
update={
'simprintsId': '/data/simprintsId',
'rightIndex': '/data/rightIndex',
'rightThumb': '/data/rightThumb',
'leftIndex': '/data/leftIndex',
'leftThumb': '/data/leftThumb',
},
condition=FormActionCondition(type='always'),
)
module.case_type = 'person'
return module, enroll.get_unique_id()
def get_preload_action():
preload = {
'/data/start_date': 'start_date',
'/data/start_time': 'start_time',
'/data/end_date': 'end_date',
'/data/end_time': 'end_time',
}
for item_group in self.iter_item_groups():
for item in item_group.iter_items():
preload['/data/{}/{}'.format(
item_group.question_name,
item.question_name)] = item.question_name
return PreloadAction(preload=preload,
condition=FormActionCondition(type='always'))
def test_open_case_and_subcase(self):
app = Application.new_app('domain', "Untitled Application")
module = app.add_module(Module.new_module('parent', None))
module.case_type = 'phone'
module.unique_id = 'm0'
form = app.new_form(0, "Untitled Form", None)
form.xmlns = 'http://m0-f0'
form.actions.open_case = OpenCaseAction(name_path="/data/question1")
form.actions.open_case.condition.type = 'always'
form.actions.subcases.append(
OpenSubCaseAction(case_type='tablet',
case_name="/data/question1",
condition=FormActionCondition(type='always')))
self.assertXmlPartialEqual(self.get_xml('open_case_and_subcase'),
app.create_suite(), "./entry[1]")
def test_child_module_session_datums_added(self):
self.module_1.root_module_id = self.module_0.unique_id
self.module_0.case_type = 'gold-fish'
m0f0 = self.module_0.get_form(0)
m0f0.requires = 'case'
m0f0.actions.update_case = UpdateCaseAction(
update={'question1': '/data/question1'})
m0f0.actions.update_case.condition.type = 'always'
m0f0.actions.subcases.append(
OpenSubCaseAction(case_type='guppy',
case_name="/data/question1",
condition=FormActionCondition(type='always')))
self.module_1.case_type = 'guppy'
m1f0 = self.module_1.get_form(0)
self._load_case(m1f0, 'gold-fish')
self._load_case(m1f0, 'guppy', parent_module=self.module_0)
self.assertXmlPartialEqual(
self.get_xml('child-module-entry-datums-added'),
self.app.create_suite(), "./entry")
def test_update_and_subcase(self):
app = Application.new_app('domain',
"Untitled Application",
application_version=APP_V2)
module = app.add_module(Module.new_module('parent', None))
module.case_type = 'phone'
module.unique_id = 'm0'
form = app.new_form(0, "Untitled Form", None)
form.xmlns = 'http://m0-f0'
form.requires = 'case'
form.actions.update_case = UpdateCaseAction(
update={'question1': '/data/question1'})
form.actions.update_case.condition.type = 'always'
form.actions.subcases.append(
OpenSubCaseAction(case_type=module.case_type,
case_name="/data/question1",
condition=FormActionCondition(type='always')))
self.assertXmlPartialEqual(self.get_xml('update_case_and_subcase'),
app.create_suite(), "./entry[1]")
def form_opens_case(form, case_type=None, is_subcase=False):
if form.form_type == 'module_form':
if is_subcase:
form.actions.subcases.append(
OpenSubCaseAction(
case_type=case_type,
case_name="/data/name",
condition=FormActionCondition(type='always')))
else:
form.actions.open_case = OpenCaseAction(name_path="/data/name",
external_id=None)
form.actions.open_case.condition.type = 'always'
else:
case_type = case_type or form.get_module().case_type
action = AdvancedOpenCaseAction(
case_type=case_type,
case_tag='open_{}'.format(case_type),
name_path='/data/name')
if is_subcase:
action.parent_tag = form.actions.load_update_cases[-1].case_tag
form.actions.open_cases.append(action)
def test_child_module_session_datums_added(self):
self.module_1.root_module_id = self.module_0.unique_id
self.module_0.case_type = 'gold-fish'
m0f0 = self.module_0.get_form(0)
# m0 is a user-case-only module. m0f0 does not update a normal case, only the user case.
m0f0.actions.usercase_preload = PreloadAction(
preload={'/data/question1': 'question1'})
m0f0.actions.usercase_preload.condition.type = 'always'
m0f0.actions.subcases.append(
OpenSubCaseAction(case_type='guppy',
case_name="/data/question1",
condition=FormActionCondition(type='always')))
self.module_1.case_type = 'guppy'
m1f0 = self.module_1.get_form(0)
self._load_case(m1f0, 'gold-fish')
self._load_case(m1f0, 'guppy', parent_module=self.module_0)
self.assertXmlPartialEqual(
self.get_xml('child-module-entry-datums-added-usercase'),
self.app.create_suite(), "./entry")
def _init_biometrics_identify_module(app, lang, enroll_form_id):
"""
Creates Identification Module for Biometrics
"""
module = app.add_module(
Module.new_module(_("Identify Registered Person"), lang))
# make sure app has Register From Case List Add-On enabled
app.add_ons["register_from_case_list"] = True
# turn on Register from Case List with Simprints Enrolment form
module.case_list_form = CaseListForm(
form_id=enroll_form_id,
label=dict([(lang, _("Enroll New Person"))]),
)
case_list = module.case_details.short
case_list.lookup_enabled = True
case_list.lookup_action = "com.simprints.id.IDENTIFY"
case_list.lookup_name = _("Scan Fingerprint")
case_list.lookup_extras = list([
dict(key=key, value="'{}'".format(value))
for key, value in app.biometric_context.items()
])
case_list.lookup_responses = [
{
'key': 'fake'
},
]
case_list.lookup_display_results = True
case_list.lookup_field_header[lang] = _("Confidence")
case_list.lookup_field_template = 'simprintsId'
identify = app.new_form(module.id, _("Followup with Person"), lang)
identify.requires = 'case'
identify.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
module.case_type = 'person'
def new_form(request, domain, app_id, module_id):
"Adds a form to an app (under a module)"
app = get_app(domain, app_id)
lang = request.COOKIES.get('lang', app.langs[0])
name = request.POST.get('name')
form = app.new_form(module_id, name, lang)
if toggles.APP_MANAGER_V2.enabled(domain):
case_action = request.POST.get('case_action', 'none')
if case_action == 'update':
form.requires = 'case'
form.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
app.save()
# add form_id to locals()
form_id = form.id
response = back_to_main(request,
domain,
app_id=app_id,
module_id=module_id,
form_id=form_id)
return response
def _ucla_form_modifier(form, question_ids):
message = ""
xform = form.wrapped_xform()
# Get the questions specified in question_ids
question_dict = {
q["value"].split("/")[-1]: FormQuestion.wrap(q)
for q in form.get_questions(["en"])
}
question_ids = {q for q in question_ids}.intersection(question_dict.keys())
questions = [question_dict[k] for k in question_ids]
# Get the existing subcases
existing_subcases = {c.case_name: c for c in form.actions.subcases}
message += "Found %s questions.\n" % len(questions)
for question in questions:
for option in question.options:
hidden_value_tag = question.value.split(
"/")[-1] + "-" + option.value
hidden_value_path = "/data/" + hidden_value_tag
hidden_value_text = option.label
# Create new hidden values for each question option if they don't already exist:
if hidden_value_tag not in question_dict:
# Add data element
tag = "{x}%s" % hidden_value_tag
element = etree.Element(tag.format(**namespaces))
xform.data_node.append(element)
# Add bind
xform.itext_node.addprevious(
_make_elem(
"bind", {
"nodeset": xform.resolve_path(hidden_value_path),
"calculate": '"' + hidden_value_text + '"'
}))
message += "Node " + hidden_value_path + " created!\n"
else:
message += "Node " + hidden_value_path + " already exists, skipping.\n"
# Create FormActions for opening subcases
if hidden_value_path not in existing_subcases:
action = OpenSubCaseAction(
condition=FormActionCondition(
type='if',
question=question.value,
operator='selected',
answer=option.value,
),
case_name=hidden_value_path,
case_type='task',
# Note, the case properties will not necessarily be created in the order given.
case_properties={
'task_responsible': '/data/task_responsible',
'task_due': '/data/task_due',
'owner_id': '/data/owner_id',
'task_risk_factor': '/data/task_risk_factor',
'study_id': '/data/study_id',
'patient_name': '/data/patient_name'
},
close_condition=FormActionCondition(answer=None,
operator=None,
question=None,
type='never'))
form.actions.subcases.append(action)
message += "OpenSubCaseAction " + hidden_value_path + " created!\n"
else:
message += "OpenSubCaseAction " + hidden_value_path + " already exists, skipping.\n"
app = form.get_app()
# Save the xform modifications
save_xform(app, form, etree.tostring(xform.xml, encoding="unicode"))
# save the action modifications
app.save()
message += "Form saved.\n"
return message
def new_module(request, domain, app_id):
"Adds a module to an app"
app = get_app(domain, app_id)
lang = request.COOKIES.get('lang', app.langs[0])
name = request.POST.get('name')
module_type = request.POST.get('module_type', 'case')
if module_type == 'case' or module_type == 'survey': # survey option added for V2
if toggles.APP_MANAGER_V2.enabled(domain):
if module_type == 'case':
name = name or 'Case List'
else:
name = name or 'Surveys'
module = app.add_module(Module.new_module(name, lang))
module_id = module.id
form_id = None
if toggles.APP_MANAGER_V2.enabled(domain):
if module_type == 'case':
# registration form
register = app.new_form(module_id, "Register", lang)
with open(
os.path.join(os.path.dirname(__file__), '..', 'static',
'app_manager', 'xml',
'registration_form.xml')) as f:
register.source = f.read()
register.actions.open_case = OpenCaseAction(
condition=FormActionCondition(type='always'),
name_path=u'/data/name')
register.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
# make case type unique across app
app_case_types = set([
module.case_type for module in app.modules
if module.case_type
])
module.case_type = 'case'
suffix = 0
while module.case_type in app_case_types:
suffix = suffix + 1
module.case_type = 'case-{}'.format(suffix)
else:
form = app.new_form(module_id, "Survey", lang)
form_id = 0
else:
app.new_form(module_id, "Untitled Form", lang)
app.save()
response = back_to_main(request,
domain,
app_id=app_id,
module_id=module_id,
form_id=form_id)
response.set_cookie('suppress_build_errors', 'yes')
return response
elif module_type in MODULE_TYPE_MAP:
fn = MODULE_TYPE_MAP[module_type][FN]
validations = MODULE_TYPE_MAP[module_type][VALIDATIONS]
error = next((v[1] for v in validations if v[0](app)), None)
if error:
messages.warning(request, error)
return back_to_main(request, domain, app_id=app.id)
else:
return fn(request, domain, app, name, lang)
else:
logger.error('Unexpected module type for new module: "%s"' %
module_type)
return back_to_main(request, domain, app_id=app_id)
def new_module(request, domain, app_id):
"Adds a module to an app"
app = get_app(domain, app_id)
lang = request.COOKIES.get('lang', app.langs[0])
name = request.POST.get('name')
module_type = request.POST.get('module_type', 'case')
if module_type == 'case' or module_type == 'survey': # survey option added for V2
if toggles.APP_MANAGER_V2.enabled(domain):
if module_type == 'case':
name = name or 'Case List'
else:
name = name or 'Surveys'
module = app.add_module(Module.new_module(name, lang))
module_id = module.id
form_id = None
if toggles.APP_MANAGER_V2.enabled(domain):
if module_type == 'case':
# registration form
register = app.new_form(module_id, "Register", lang)
register.actions.open_case = OpenCaseAction(
condition=FormActionCondition(type='always'))
register.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
# set up reg from case list
module.case_list_form.form_id = register.unique_id
module.case_list_form.label = register.name
register.form_filter = "false()"
# one followup form
followup = app.new_form(module_id, "Followup", lang)
followup.requires = "case"
followup.actions.update_case = UpdateCaseAction(
condition=FormActionCondition(type='always'))
# make case type unique across app
app_case_types = set([
module.case_type for module in app.modules
if module.case_type
])
module.case_type = 'case'
suffix = 0
while module.case_type in app_case_types:
suffix = suffix + 1
module.case_type = 'case-{}'.format(suffix)
else:
app.new_form(module_id, "Survey", lang)
form_id = 0
else:
app.new_form(module_id, "Untitled Form", lang)
app.save()
response = back_to_main(request,
domain,
app_id=app_id,
module_id=module_id,
form_id=form_id)
response.set_cookie('suppress_build_errors', 'yes')
return response
elif module_type in MODULE_TYPE_MAP:
fn = MODULE_TYPE_MAP[module_type][FN]
validations = MODULE_TYPE_MAP[module_type][VALIDATIONS]
error = next((v[1] for v in validations if v[0](app)), None)
if error:
messages.warning(request, error)
return back_to_main(request, domain, app_id=app.id)
else:
return fn(request, domain, app, name, lang)
else:
logger.error('Unexpected module type for new module: "%s"' %
module_type)
return back_to_main(request, domain, app_id=app_id)
def get_preload_action():
return PreloadAction(preload={'/data/subject_name': 'name'},
condition=FormActionCondition(type='always'))
