def location_fixture_instances(domain, instance_name):
if toggles.FLAT_LOCATION_FIXTURE.enabled(domain):
return Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name))
else:
return Instance(id=instance_name,
src='jr://fixture/commtrack:{}'.format(instance_name))
def _add_custom_referenced_instances(self, instances,
unknown_instance_ids):
def _add_custom_instance(instance_name):
if instance_name in unknown_instance_ids:
instances.add(
Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name)))
unknown_instance_ids.remove(instance_name)
if toggles.CUSTOM_CALENDAR_FIXTURE.enabled(self.app.domain):
_add_custom_instance('enikshay:calendar')
if toggles.MOBILE_UCR.enabled(self.app.domain):
_add_custom_instance('commcare:reports')
instance_name = 'locations'
if instance_name in unknown_instance_ids:
if toggles.FLAT_LOCATION_FIXTURE.enabled(self.app.domain):
instances.add(
Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name)))
else:
instances.add(
Instance(
id=instance_name,
src='jr://fixture/commtrack:{}'.format(instance_name)))
unknown_instance_ids.remove(instance_name)
return instances, unknown_instance_ids
def location_fixture_instances(domain, instance_name):
from corehq.apps.locations.models import LocationFixtureConfiguration
if (toggles.HIERARCHICAL_LOCATION_FIXTURE.enabled(domain)
and not LocationFixtureConfiguration.for_domain(
domain).sync_flat_fixture):
return Instance(id=instance_name,
src='jr://fixture/commtrack:{}'.format(instance_name))
return Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name))
def build_instances(self):
prompt_select_instances = [
Instance(id=prop.itemset.instance_id,
src=prop.itemset.instance_uri)
for prop in self.module.search_config.properties
if prop.itemset.instance_id
]
xpaths = {QuerySessionXPath(self.case_session_var).instance()}
xpaths.update(datum.ref for datum in self._remote_request_query_datums)
xpaths.add(self.get_post_relevant())
xpaths = xpaths.union(self._get_multi_select_xpaths())
xpaths.add(self.module.search_config.search_filter)
xpaths.update(prop.default_value
for prop in self.module.search_config.properties)
xpaths.update(prop.required
for prop in self.module.search_config.properties)
# we use the module's case list/details view to select the datum so also
# need these instances to be available
xpaths.update(self._get_xpaths_for_module())
instances, unknown_instances = get_all_instances_referenced_in_xpaths(
self.app, xpaths)
# exclude remote instances
instances = [
instance for instance in instances if 'remote' not in instance.src
]
# sorted list to prevent intermittent test failures
return sorted(set(list(instances) + prompt_select_instances),
key=lambda i: i.id)
def _build_instances(self):
prompt_select_instances = [
Instance(id=prop.itemset.instance_id,
src=prop.itemset.instance_uri)
for prop in self.module.search_config.properties
if prop.itemset.instance_id
]
query_xpaths = [
QuerySessionXPath(
self.module.search_config.case_session_var).instance()
]
query_xpaths.extend(
[datum.ref for datum in self._get_remote_request_query_datums()])
query_xpaths.extend([
self.module.search_config.get_relevant(),
self.module.search_config.search_filter
])
query_xpaths.extend([
prop.default_value for prop in self.module.search_config.properties
])
instances, unknown_instances = get_all_instances_referenced_in_xpaths(
self.app, query_xpaths)
# we use the module's case list/details view to select the datum so also
# need these instances to be available
instances |= get_instances_for_module(self.app, self.module,
self.detail_section_elements)
# sorted list to prevent intermittent test failures
return sorted(set(list(instances) + prompt_select_instances),
key=lambda i: i.id)
def _commcare_reports_instances(app, instance_name, prefix):
from corehq.apps.app_manager.suite_xml.features.mobile_ucr import get_uuids_by_instance_id
if instance_name.startswith(prefix) and toggles.MOBILE_UCR.enabled(
app.domain):
instance_id = instance_name[len(prefix):]
uuid = get_uuids_by_instance_id(app).get(instance_id, [instance_id])[0]
return Instance(id=instance_name,
src='jr://fixture/{}{}'.format(prefix, uuid))
def _get_custom_instances(self, entry, known_instances, required_instances):
known_instance_ids = [instance.id for instance in known_instances]
try:
custom_instances = self._custom_instances_by_xmlns()[entry.form]
except KeyError:
custom_instances = []
for instance in custom_instances:
if instance.instance_id in known_instance_ids:
raise DuplicateInstanceIdError(instance.instance_id)
# Remove custom instances from required instances, but add them even if they aren't referenced anywhere
required_instances.discard(instance.instance_id)
return {
Instance(id=instance.instance_id, src=instance.instance_path) for instance in custom_instances
}, required_instances
def add_referenced_instances(self, entry, details_by_id, relevance_by_menu,
menu_by_command):
detail_ids = set()
xpaths = set()
for datum in entry.datums:
detail_ids.add(datum.detail_confirm)
detail_ids.add(datum.detail_select)
xpaths.add(datum.nodeset)
xpaths.add(datum.function)
details = [
details_by_id[detail_id] for detail_id in detail_ids if detail_id
]
entry_id = entry.command.id
menu_id = menu_by_command[entry_id]
relevances = relevance_by_menu[menu_id]
xpaths.update(relevances)
for detail in details:
xpaths.update(detail.get_all_xpaths())
for assertion in entry.assertions:
xpaths.add(assertion.test)
if entry.stack:
for frame in entry.stack.frames:
xpaths.add(frame.if_clause)
if hasattr(frame, 'datums'):
for datum in frame.datums:
xpaths.add(datum.value)
xpaths.discard(None)
instances, unknown_instance_ids = EntryInstances.get_required_instances(
xpaths)
if toggles.CUSTOM_CALENDAR_FIXTURE.enabled(self.app.domain):
instance_name = 'enikshay:calendar'
if instance_name in unknown_instance_ids:
instances.add(
Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name)))
unknown_instance_ids.remove(instance_name)
entry.require_instances(instances=instances,
instance_ids=unknown_instance_ids)
def _build_instances(self):
query_xpaths = [datum.ref for datum in self._get_remote_request_query_datums()]
claim_relevant_xpaths = [self.module.search_config.relevant]
prompt_select_instances = [
Instance(id=prop.itemset.instance_id, src=prop.itemset.instance_uri)
for prop in self.module.search_config.properties
if prop.itemset.instance_id
]
instances, unknown_instances = get_all_instances_referenced_in_xpaths(
self.app,
query_xpaths + claim_relevant_xpaths
)
# we use the module's case list/details view to select the datum so also
# need these instances to be available
instances |= get_instances_for_module(self.app, self.module)
# sorted list to prevent intermittent test failures
return sorted(list(instances) + prompt_select_instances, key=lambda i: i.id)
def commcare_reports_filters_instances(domain, instance_name):
if instance_name.startswith('commcare-reports-filters:'
) and toggles.MOBILE_UCR.enabled(domain):
return Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name))
def commcare_fixture_instances(domain, instance_name):
if instance_name == 'commcare:reports' and toggles.MOBILE_UCR.enabled(
domain):
return Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name))
def enikshay_fixture_instances(domain, instance_name):
if instance_name == 'enikshay:calendar' and toggles.CUSTOM_CALENDAR_FIXTURE.enabled(
domain):
return Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name))
def generic_fixture_instances(domain, instance_name):
return Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name))
def preset_instances(domain, instance_name):
kwargs = INSTANCE_KWARGS_BY_ID.get(instance_name, None)
if kwargs:
return Instance(**kwargs)
def get_module_contributions(self, module):
if module_offers_search(module):
domain = self.app.domain
details_helper = DetailsHelper(self.app)
remote_request = RemoteRequest(
post=RemoteRequestPost(
url=absolute_reverse('claim_case', args=[domain]),
relevant=module.search_config.relevant,
data=[
QueryData(
key='case_id',
ref=QuerySessionXPath('case_id').instance(),
# e.g. instance('querysession')/session/data/case_id
),
]),
command=Command(
id=id_strings.search_command(module),
display=Display(text=Text(
locale_id=id_strings.case_search_locale(module)), ),
),
instances=[
Instance(id=SESSION_INSTANCE, src='jr://instance/session'),
Instance(id='casedb', src='jr://instance/casedb'),
],
session=RemoteRequestSession(
queries=[
RemoteRequestQuery(
url=absolute_reverse('remote_search',
args=[domain]),
storage_instance=RESULTS_INSTANCE,
data=[
QueryData(key='case_type',
ref="'{}'".format(module.case_type)),
],
prompts=[
QueryPrompt(
key=p.name,
display=Display(
text=Text(locale_id=id_strings.
search_property_locale(
module, p.name)), ),
) for p in module.search_config.properties
])
],
data=[
SessionDatum(
id='case_id',
nodeset=(CaseTypeXpath(module.case_type).case(
instance_name=RESULTS_INSTANCE).select(
u'@status', u'open', quote=True)),
value='./@case_id',
detail_select=details_helper.get_detail_id_safe(
module, 'case_short'),
detail_confirm=details_helper.get_detail_id_safe(
module, 'case_long'),
)
],
),
stack=Stack(),
)
frame = CreateFrame()
# Open first form in module
frame.add_command(XPath.string(id_strings.menu_id(module)))
frame.add_datum(
StackDatum(id='case_id',
value=QuerySessionXPath('case_id').instance()))
remote_request.stack.add_frame(frame)
return [remote_request]
return []
def related_locations_fixture_instances(app, instance_name):
if instance_name == 'related_locations' and toggles.RELATED_LOCATIONS.enabled(
app.domain):
return Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name))
def _add_custom_instance(instance_name):
if instance_name in unknown_instance_ids:
instances.add(
Instance(id=instance_name,
src='jr://fixture/{}'.format(instance_name)))
unknown_instance_ids.remove(instance_name)
get_instance_factory._factory_map = {}
class register_factory(object):
def __init__(self, *schemes):
self.schemes = schemes
def __call__(self, fn):
for scheme in self.schemes:
get_instance_factory._factory_map[scheme] = fn
return fn
INSTANCE_BY_ID = {
'groups': Instance(id='groups', src='jr://fixture/user-groups'),
'reports': Instance(id='reports', src='jr://fixture/commcare:reports'),
'ledgerdb': Instance(id='ledgerdb', src='jr://instance/ledgerdb'),
'casedb': Instance(id='casedb', src='jr://instance/casedb'),
'commcaresession': Instance(id='commcaresession',
src='jr://instance/session'),
}
@register_factory(*INSTANCE_BY_ID.keys())
def preset_instances(domain, instance_name):
return INSTANCE_BY_ID.get(instance_name, None)
@register_factory('item-list', 'schedule', 'indicators', 'commtrack')
@memoized