def test_update_preload_case(self):
self.form.requires = 'case'
self.form.actions.update_case = UpdateCaseAction(
update={'question1': '/data/question1'})
self.form.actions.update_case.condition.type = 'always'
self.form.actions.case_preload = PreloadAction(
preload={'/data/question1': 'question1'})
self.form.actions.case_preload.condition.type = 'always'
check_xml_line_by_line(self, self.get_xml('update_preload_case'),
self.form.render_xform())
def test_update_parent_case(self):
self.form.requires = 'case'
self.form.actions.update_case = UpdateCaseAction(
update={
'question1': '/data/question1',
'parent/question1': '/data/question1',
})
self.form.actions.update_case.condition.type = 'always'
self.assertXmlEqual(self.get_xml('update_parent_case'),
self.form.render_xform())
def form_uses_usercase(form, update=None, preload=None):
if form.form_type == 'module_form':
if update:
form.actions.usercase_update = UpdateCaseAction(update=update)
form.actions.usercase_update.condition.type = 'always'
if preload:
form.actions.usercase_preload = PreloadAction(preload=preload)
form.actions.usercase_preload.condition.type = 'always'
else:
AppFactory.advanced_form_autoloads(form, AUTO_SELECT_USERCASE, None)
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')
name = _("Register") if case_action == 'open' else (
_("Followup") if case_action == 'update' else "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 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 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 test_update_attachment(self):
self.form.requires = 'case'
self.form.source = self.get_xml('attachment').decode('utf-8')
self.form.actions.update_case = UpdateCaseAction(
update={
'photo': ConditionalCaseUpdate(
question_path='/data/thepicture')
})
self.form.actions.update_case.condition.type = 'always'
self.assertXmlEqual(self.get_xml('update_attachment_case'),
self.form.render_xform())
def test_update_case(self):
"""Case updates are not permitted"""
self.form.requires = 'case'
self.form.actions.update_case = UpdateCaseAction(
update={
'question1': ConditionalCaseUpdate(
question_path='/data/question1')
})
self.form.actions.update_case.condition.type = 'always'
self.assertXmlEqual(self.get_xml('no_actions'),
self.form.render_xform())
def test_ext_case_update_host_case(self):
"""
A extension case should be able to save host case properties
"""
self.freshwater_form.requires = 'case'
self.freshwater_form.actions.update_case = UpdateCaseAction(update={
'question1': '/data/question1',
'host/question1': '/data/question1',
})
self.freshwater_form.actions.update_case.condition.type = 'always'
self.assertXmlEqual(self.get_xml('update_host_case'), self.freshwater_form.render_xform())
def test_child_module_adjusted_datums_basic_module(self):
"""
Testing that the session variable name for the case_id is correct since
it will have been adjusted in the suite.xml to match the variable name
in the root module.
"""
module = self.app.add_module(Module.new_module('New Module',
lang='en'))
module.case_type = 'guppy'
form = module.new_form(
"Untitled Form", "en",
self.get_xml('original_form',
override_path=('data', )).decode('utf-8'))
form.requires = 'case'
form.actions.update_case = UpdateCaseAction(
update={'question1': '/data/question1'})
form.actions.update_case.condition.type = 'always'
root_module = self.app.add_module(
Module.new_module('root module', None))
root_module.unique_id = 'm_root'
root_module.case_type = 'test_case_type'
root_module_form = root_module.new_form('root module form', None)
root_module_form.requires = 'case'
root_module_form.actions.update_case = UpdateCaseAction(
update={'question1': '/data/question1'})
root_module_form.actions.update_case.condition.type = 'always'
# make module a child module of root_module
module.root_module_id = root_module.unique_id
module.parent_select.active = True
module.parent_select.module_id = root_module.unique_id
self.assertXmlEqual(
self.get_xml('child_module_adjusted_case_id_basic'),
form.render_xform())
def test_usercase_id_added_update(self):
app = Application.new_app('domain', "Untitled Application")
child_module = app.add_module(Module.new_module("Untitled Module", None))
child_module.case_type = 'child'
child_form = app.new_form(0, "Untitled Form", None)
child_form.xmlns = 'http://id_m1-f0'
child_form.requires = 'case'
child_form.actions.usercase_update = UpdateCaseAction(update={'name': '/data/question1'})
child_form.actions.usercase_update.condition.type = 'always'
self.assertXmlPartialEqual(self.get_xml('usercase_entry'), app.create_suite(), "./entry[1]")
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_update_preload_case(self):
self.form.requires = 'case'
self.form.actions.update_case = UpdateCaseAction(
update={
'question1': ConditionalCaseUpdate(
question_path='/data/question1')
})
self.form.actions.update_case.condition.type = 'always'
self.form.actions.case_preload = PreloadAction(
preload={'/data/question1': 'question1'})
self.form.actions.case_preload.condition.type = 'always'
self.assertXmlEqual(self.get_xml('update_preload_case'),
self.form.render_xform())
def test_open_case(self):
self.form.actions.open_case = OpenCaseAction(
name_update=ConditionalCaseUpdate(
question_path="/data/question1"), )
self.form.actions.open_case.condition.type = 'always'
self.form.actions.update_case = UpdateCaseAction(
update={
'question1': ConditionalCaseUpdate(
question_path='/data/question1')
})
self.form.actions.update_case.condition.type = 'always'
self.assertXmlEqual(self.get_xml('multi_open_update_case'),
self.form.render_xform())
def test_open_case(self):
"""Opening cases still works with registry search"""
self.form.actions.open_case = OpenCaseAction(
name_update=ConditionalCaseUpdate(question_path="/data/question1"),
external_id=None)
self.form.actions.open_case.condition.type = 'always'
self.form.actions.update_case = UpdateCaseAction(
update={
'question1': ConditionalCaseUpdate(
question_path='/data/question1')
})
self.form.actions.update_case.condition.type = 'always'
self.assertXmlEqual(self.get_xml('open_update_case'),
self.form.render_xform())
def form_requires_case(form,
case_type=None,
parent_case_type=None,
update=None,
preload=None):
if update:
update = {
name: ConditionalCaseUpdate(question_path=question_path)
for name, question_path in update.items()
}
if form.form_type == 'module_form':
form.requires = 'case'
if update:
form.actions.update_case = UpdateCaseAction(update=update)
form.actions.update_case.condition.type = 'always'
if preload:
form.actions.case_preload = PreloadAction(preload=preload)
form.actions.case_preload.condition.type = 'always'
if parent_case_type:
module = form.get_module()
module.parent_select.active = True
parent_select_module = next(
module for module in module.get_app().get_modules()
if module.case_type == parent_case_type)
module.parent_select.module_id = parent_select_module.unique_id
else:
case_type = case_type or form.get_module().case_type
index = len([
load for load in form.actions.load_update_cases
if load.case_type == case_type
])
kwargs = {
'case_type': case_type,
'case_tag': 'load_{}_{}'.format(case_type, index)
}
if update:
kwargs['case_properties'] = update
if preload:
kwargs['preload'] = preload
action = LoadUpdateAction(**kwargs)
if parent_case_type:
parent_action = form.actions.load_update_cases[-1]
assert parent_action.case_type == parent_case_type
action.case_index = CaseIndex(tag=parent_action.case_tag)
form.actions.load_update_cases.append(action)
def test_child_module_adjust_session_datums(self):
"""
Test that session datum id's in child module match those in parent module
"""
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'
self.module_1.case_type = 'guppy'
m1f0 = self.module_1.get_form(0)
self._load_case(m1f0, 'gold-fish')
self._load_case(m1f0, 'guppy')
self.assertXmlPartialEqual(self.get_xml('child-module-entry-datums'),
self.app.create_suite(), "./entry")
def test_child_module_adjusted_datums_advanced_module(self):
"""
Testing that the session variable name for the case_id is correct since
it will have been adjusted in the suite.xml to match the variable name
in the root module.
"""
module = self.app.add_module(
AdvancedModule.new_module('New Module', lang='en'))
module.case_type = 'test_case_type'
form = module.new_form(
"Untitled Form", "en",
self.get_xml('original_form',
override_path=('data', )).decode('utf-8'))
form.actions.load_update_cases.append(
LoadUpdateAction(
case_type=module.case_type,
case_tag='load_1',
case_properties={
'question1':
ConditionalCaseUpdate(question_path='/data/question1')
}))
root_module = self.app.add_module(
Module.new_module('root module', None))
root_module.unique_id = 'm_root'
root_module.case_type = module.case_type
root_module_form = root_module.new_form('root module form', None)
root_module_form.requires = 'case'
root_module_form.actions.update_case = UpdateCaseAction(
update={
'question1': ConditionalCaseUpdate(
question_path='/data/question1')
})
root_module_form.actions.update_case.condition.type = 'always'
# make module a child module of root_module
module.root_module_id = root_module.unique_id
self.assertXmlEqual(
self.get_xml('child_module_adjusted_case_id_advanced'),
form.render_xform())
def test_update_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.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 test_update_usercase_edit_update_mode(self):
self.form.actions.usercase_update = UpdateCaseAction(
update={
'name':
ConditionalCaseUpdate(question_path='/data/question1',
update_mode='edit')
})
self.form.actions.usercase_update.condition.type = 'always'
expected = """
<partial>
<ns0:bind xmlns:ns0="http://www.w3.org/2002/xforms" nodeset="/data/commcare_usercase/case/update/case_name"
relevant="count(/data/question1) > 0 and instance('casedb')/casedb/case[@case_id=/data/commcare_usercase/case/@case_id]/case_name != /data/question1"
calculate="/data/question1"/>
</partial>
"""
xpath = './{h}head/{w3x}model/{w3x}bind[@nodeset="/data/commcare_usercase/case/update/case_name"]'.format(
h='{http://www.w3.org/1999/xhtml}',
w3x='{http://www.w3.org/2002/xforms}')
self.assertXmlPartialEqual(expected, self.form.render_xform(), xpath)
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 assert_form_datums(self, form, datum_id):
"""Check the datum IDs used in the form XML case preload"""
form.source = self.get_xml('original_form',
override_path=('data', )).decode('utf-8')
form.actions.update_case = UpdateCaseAction(
update={
'question1': ConditionalCaseUpdate(
question_path='/data/question1')
})
form.actions.update_case.condition.type = 'always'
xml = lxml.etree.XML(form.render_xform())
model_children = xml.getchildren()[0].getchildren()[1].getchildren()
calculate_expr = [
child.attrib['calculate'] for child in model_children
if child.attrib.get('nodeset') == '/data/case/@case_id'
][0]
self.assertTrue(
calculate_expr.startswith(
"instance('commcaresession')/session/data/"))
actual_id = calculate_expr.split("/")[-1]
self.assertEqual(datum_id, actual_id)
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 _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 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 test_open_update_case(self):
self.form.actions.open_case = OpenCaseAction(name_path="/data/question1", external_id=None)
self.form.actions.open_case.condition.type = 'always'
self.form.actions.update_case = UpdateCaseAction(update={'question1': '/data/question1'})
self.form.actions.update_case.condition.type = 'always'
self.assertXmlEqual(self.get_xml('open_update_case'), self.form.render_xform())
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)
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 == 'biometrics':
enroll_module, enroll_form_id = _init_biometrics_enroll_module(
app, lang)
_init_biometrics_identify_module(app, lang, enroll_form_id)
app.save()
response = back_to_main(request,
domain,
app_id=app_id,
module_id=enroll_module.id,
form_id=0)
response.set_cookie('suppress_build_errors', 'yes')
return response
elif 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 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 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 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
followup = app.new_form(module_id, _("Followup Form"), lang)
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)
