def get_form_data_schema(request, domain, app_id, form_unique_id):
"""Get data schema
:returns: A list of data source schema definitions. A data source schema
definition is a dictionary. For details on the content of the dictionary,
see https://github.com/dimagi/Vellum/blob/master/src/datasources.js
"""
data = []
app = get_app(domain, app_id)
form = app.get_form(form_unique_id)
try:
data.append(get_session_schema(form))
if form.requires_case() or is_usercase_in_use(domain):
data.append(get_casedb_schema(form))
except AppManagerException as e:
notify_exception(request, message=str(e))
return HttpResponseBadRequest(
str(e) or
_("There is an error in the case management of your application. "
"Please fix the error to see case properties in this tree"))
except Exception as e:
notify_exception(request, message=str(e))
return HttpResponseBadRequest("schema error, see log for details")
data.extend(item_lists_by_domain(domain))
kw = {}
if "pretty" in request.GET:
kw["indent"] = 2
return HttpResponse(json.dumps(data, **kw))
def test_get_session_schema_for_child_module(self):
# m0 - opens 'gold-fish' case.
# m1 - has m0 as root-module, has parent-select, updates 'guppy' case
self.module_0, _ = self.factory.new_basic_module('parent', 'gold-fish')
self.module_1, _ = self.factory.new_basic_module(
'child', 'guppy', parent_module=self.module_0)
# m0f0 registers gold-fish case and a child case ('guppy')
m0f0 = self.module_0.get_form(0)
self.factory.form_requires_case(m0f0, update={'name': 'goldilocks'})
self.factory.form_opens_case(m0f0, 'guppy', is_subcase=True)
# m1f0 has parent-select, updates `guppy` case
m1f0 = self.module_1.get_form(0)
self.factory.form_requires_case(m1f0, parent_case_type='gold-fish')
session_schema = get_session_schema(m1f0)
expected_session_schema_structure = {
"data": {
"merge": True,
"structure": {
"case_id_guppy": {
"reference": {
"hashtag": "#case",
"subset": "case",
"source": "casedb",
"key": "@case_id"
}
}
}
}
}
self.assertEqual(session_schema['structure'],
expected_session_schema_structure)
def test_get_session_schema_with_advanced_form(self):
module_id = len(self.factory.app.modules)
module, form = self.factory.new_advanced_module(module_id, "village")
self.factory.form_opens_case(form, "village")
self.factory.form_requires_case(
form,
case_type=self.factory.app.get_module(0).case_type,
update={'foo': '/data/question1'})
schema = get_session_schema(form)
expected_schema = {
'id': 'commcaresession',
'uri': 'jr://instance/session',
'name': 'Session',
'path': '/session',
'structure': {
'data': {
'merge': True,
'structure': {
'case_id_load_village_0': {
'reference': {
'hashtag': '#case',
'source': 'casedb',
'subset': 'case',
'key': '@case_id'
}
}
}
}
}
}
self.assertEqual(schema, expected_schema)
def test_session_schema(self):
# Session schema should not contain case
self.assertEqual(
get_session_schema(self.form), {
'id': 'commcaresession',
'name': 'Session',
'path': '/session',
'structure': {},
'uri': 'jr://instance/session'
})
def test_get_session_schema_for_module_with_no_case_type(self):
form = self.add_form()
schema = get_session_schema(form)
self.assert_has_kv_pairs(
schema, {
"id": "commcaresession",
"uri": "jr://instance/session",
"name": "Session",
"path": "/session",
})
assert "data" not in schema["structure"], schema["structure"]
def test_get_session_schema_for_child_module_not_parent_case_type(self):
# m0 - opens 'goldfish' case.
# m1 - has m0 as root-module, has parent-select, updates 'guppy' case
self.module_0, m0f0 = self.factory.new_basic_module(
'parent', 'goldfish')
self.factory.form_requires_case(m0f0)
self.module_1, m1f0 = self.factory.new_basic_module(
'child', 'guppy', parent_module=self.module_0)
self.factory.form_requires_case(m1f0)
self.module_1.parent_select.active = True
self.module_1.parent_select.relationship = None
self.module_1.parent_select.module_id = self.module_0.unique_id
session_schema = get_session_schema(m1f0)
expected_session_schema_structure = {
"data": {
"merge": True,
"structure": {
"case_id_guppy": {
"reference": {
"hashtag": "#case",
"subset": "case",
"source": "casedb",
"key": "@case_id"
}
},
"case_id": {
"reference": {
"hashtag": "#case:parent-module",
"subset": "case:parent-module",
"source": "casedb",
"key": "@case_id"
}
}
}
}
}
self.assertEqual(session_schema['structure'],
expected_session_schema_structure)
def test_get_session_schema_for_simple_module_with_case(self):
module, form = self.factory.new_basic_module('village', 'village')
self.factory.form_requires_case(form)
schema = get_session_schema(form)
self.assertDictEqual(
schema["structure"], {
"data": {
"merge": True,
"structure": {
"case_id": {
"reference": {
"hashtag": "#case",
"source": "casedb",
"subset": "case",
"key": "@case_id",
},
},
},
},
})
def get_form_data_schema(request, domain, form_unique_id):
"""Get data schema
One of `app_id` or `form_unique_id` is required. `app_id` is ignored
if `form_unique_id` is provided.
:returns: A list of data source schema definitions. A data source schema
definition is a dictionary. For details on the content of the dictionary,
see https://github.com/dimagi/Vellum/blob/master/src/datasources.js
"""
data = []
try:
form, app = Form.get_form(form_unique_id, and_app=True)
except ResourceConflict:
raise Http404()
if app.domain != domain:
raise Http404()
try:
data.append(get_session_schema(form))
if form.requires_case() or is_usercase_in_use(domain):
data.append(get_casedb_schema(form))
except AppManagerException as e:
notify_exception(request, message=str(e))
return HttpResponseBadRequest(
str(e) or _("There is an error in the case management of your application. "
"Please fix the error to see case properties in this tree")
)
except Exception as e:
notify_exception(request, message=six.text_type(e))
return HttpResponseBadRequest("schema error, see log for details")
data.extend(
sorted(item_lists_by_domain(domain), key=lambda x: x['name'].lower())
)
kw = {}
if "pretty" in request.GET:
kw["indent"] = 2
return HttpResponse(json.dumps(data, **kw))
def get_form_data_schema(request, domain, form_unique_id):
"""Get data schema
One of `app_id` or `form_unique_id` is required. `app_id` is ignored
if `form_unique_id` is provided.
:returns: A list of data source schema definitions. A data source schema
definition is a dictionary. For details on the content of the dictionary,
see https://github.com/dimagi/Vellum/blob/master/src/datasources.js
"""
data = []
try:
form, app = Form.get_form(form_unique_id, and_app=True)
except ResourceConflict:
raise Http404()
if app.domain != domain:
raise Http404()
try:
data.append(get_session_schema(form))
if form.requires_case() or is_usercase_in_use(domain):
data.append(get_casedb_schema(form))
except AppManagerException as e:
notify_exception(request, message=str(e))
return HttpResponseBadRequest(
str(e) or _("There is an error in the case management of your application. "
"Please fix the error to see case properties in this tree")
)
except Exception as e:
notify_exception(request, message=six.text_type(e))
return HttpResponseBadRequest("schema error, see log for details")
data.extend(
sorted(item_lists_by_domain(domain), key=lambda x: x['name'].lower())
)
kw = {}
if "pretty" in request.GET:
kw["indent"] = 2
return HttpResponse(json.dumps(data, **kw))
def test_get_session_schema_with_user_case(self):
module, form = self.factory.new_basic_module('village', 'village')
with patch('corehq.apps.app_manager.app_schemas.casedb_schema.is_usercase_in_use') as mock1, \
patch('corehq.apps.app_manager.app_schemas.session_schema.is_usercase_in_use') as mock2:
mock1.return_value = True
mock2.return_value = True
schema = get_session_schema(form)
self.assertDictEqual(
schema["structure"]["context"], {
"merge": True,
"structure": {
"userid": {
"reference": {
"hashtag": "#user",
"source": "casedb",
"subset": util.USERCASE_TYPE,
"subset_key": "@case_type",
"subset_filter": True,
"key": "hq_user_id",
},
},
},
})
def test_get_session_schema(self):
module, form = self.factory.new_basic_module('village', 'village')
schema = get_session_schema(form)
self.assertNotIn("context", schema["structure"], repr(schema))
def test_get_session_schema_for_child_module_with_registry(self):
"""Child module loads a case with the same case type as the parent module.
Child module is using data registry search"""
self.module_0, m0f0 = self.factory.new_basic_module(
'parent', 'patient')
self.factory.form_requires_case(m0f0)
self.module_1, m1f0 = self.factory.new_basic_module(
'child', 'patient', parent_module=self.module_0)
self.factory.form_requires_case(m1f0)
self.module_1.search_config.data_registry = "reg1"
self.module_1.parent_select.active = True
self.module_1.parent_select.relationship = None
self.module_1.parent_select.module_id = self.module_0.unique_id
session_schema = get_session_schema(m1f0)
casedb_schema = get_casedb_schema(m1f0)
registry_schema = get_registry_schema(m1f0)
expected_session_schema_structure = {
"data": {
"merge": True,
"structure": {
"case_id_patient": {
"reference": {
"hashtag": "#registry_case",
"source": "registry",
"subset": "case",
"key": "@case_id",
}
},
"case_id": {
"reference": {
"hashtag": "#case:parent-module",
"subset": "case:parent-module",
"source": "casedb",
"key": "@case_id"
}
}
}
}
}
expected_casedb_schema_subsets = [{
"structure": {
"case_name": {
"description": "",
}
},
"related": None,
"id": "case:parent-module",
"name": "patient - parent module",
}]
expected_registry_schema_subsets = [{
"structure": {
"case_name": {
"description": "",
}
},
"related": None,
"id": "case",
"name": "patient",
}]
self.assertEqual(session_schema['structure'],
expected_session_schema_structure)
self.assertEqual(casedb_schema['subsets'],
expected_casedb_schema_subsets)
self.assertEqual(registry_schema['subsets'],
expected_registry_schema_subsets)
