def test_invalid_eval_expression(self, source_doc, statement, context):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec({
"type": "evaluator",
"statement": statement,
"context_variables": context
})
def test_diff_days_expression(self, source_doc, to_date_expression, expected_value):
from_date_expression = {
'type': 'property_name',
'property_name': 'dob',
}
expression = ExpressionFactory.from_spec({
'type': 'diff_days',
'from_date_expression': from_date_expression,
'to_date_expression': to_date_expression
})
self.assertEqual(expected_value, expression(source_doc))
# test named_expression for 'from_date_expression'
context = FactoryContext(
{"from_date_name": ExpressionFactory.from_spec(from_date_expression)},
{}
)
named_expression = ExpressionFactory.from_spec({
'type': 'diff_days',
'from_date_expression': {
"type": "named",
"name": "from_date_name"
},
'to_date_expression': to_date_expression
}, context)
self.assertEqual(expected_value, named_expression(source_doc))
def _build_boolean_expression_filter(spec, context):
wrapped = BooleanExpressionFilterSpec.wrap(spec)
return SinglePropertyValueFilter(
expression=ExpressionFactory.from_spec(wrapped.expression, context),
operator=get_operator(wrapped.operator),
reference_expression=ExpressionFactory.from_spec(wrapped.property_value, context),
)
def diff_calendar_months(spec, context):
wrapped = DiffCalendarMonthsExpressionSpec.wrap(spec)
wrapped.configure(
from_date_expression=ExpressionFactory.from_spec(wrapped.from_date_expression, context),
to_date_expression=ExpressionFactory.from_spec(wrapped.to_date_expression, context),
)
return wrapped
def test_property_path_empty_path(self):
for empty_path in ([], None):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec({
'type': 'property_path',
'property_path': empty_path,
})
def setUp(self):
# we have to set the fake database before any other calls
self.orig_db = CommCareCase.get_db()
self.database = FakeCouchDb()
CommCareCase.set_db(self.database)
self.spec = {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {"type": "property_name", "property_name": "parent_id"},
"value_expression": {"type": "property_name", "property_name": "related_property"},
}
self.expression = ExpressionFactory.from_spec(self.spec)
self.nested_expression = ExpressionFactory.from_spec(
{
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {"type": "property_name", "property_name": "parent_id"},
"value_expression": {
"type": "related_doc",
"related_doc_type": "CommCareCase",
"doc_id_expression": {"type": "property_name", "property_name": "parent_id"},
"value_expression": {"type": "property_name", "property_name": "related_property"},
},
}
)
def ancestor_location(spec, context):
wrapped = AncestorLocationExpression.wrap(spec)
wrapped.configure(
ExpressionFactory.from_spec(wrapped.location_id, context),
ExpressionFactory.from_spec(wrapped.location_type, context),
)
return wrapped
def test_non_string_keys(self):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec({
"type": "dict",
"properties": {
(1, 2): 2
},
})
def test_datatype(self):
spec = {
"type": "evaluator",
"statement": '1.0 + a',
"context_variables": {'a': 1.0}
}
self.assertEqual(type(ExpressionFactory.from_spec(spec)({})), float)
spec['datatype'] = 'integer'
self.assertEqual(type(ExpressionFactory.from_spec(spec)({})), int)
def test_bad_order_raises_badspec(self):
expression = {
'type': 'sort_items',
'items_expression': [1, 6, 2, 3],
'sort_expression': {'type': 'identity'},
'order': 'complex'
}
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(expression)
def test_fail_on_bad_doc_type(self):
spec = {
"type": "related_doc",
"related_doc_type": "BadDocument",
"doc_id_expression": {"type": "property_name", "property_name": "parent_id"},
"value_expression": {"type": "property_name", "property_name": "related_property"},
}
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(spec)
def get_case_history(spec, context):
wrapped = GetCaseHistorySpec.wrap(spec)
wrapped.configure(
case_id_expression=ExpressionFactory.from_spec(wrapped.case_id_expression, context),
case_forms_expression=ExpressionFactory.from_spec({
'type': 'get_case_forms',
'case_id_expression': wrapped.case_id_expression
}, context)
)
return wrapped
def test_reduce_items_bad_spec(self, items_ex, reduce_ex):
expression = {
'type': 'reduce_items',
}
if items_ex is not None:
expression['items_expression'] = items_ex
if reduce_ex is not None:
expression['aggregation_fn'] = reduce_ex
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(expression)(items_ex, reduce_ex)
def test_filter_items_bad_spec(self, items_ex, filter_ex):
expression = {
'type': 'filter_items',
}
if items_ex is not None:
expression['items_expression'] = items_ex
if filter_ex is not None:
expression['filter_expression'] = filter_ex
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(expression)
def test_sort_items_bad_spec(self, items_ex, sort_ex):
expression = {
'type': 'sort_items',
}
if items_ex is not None:
expression['items_expression'] = items_ex
if sort_ex is not None:
expression['sort_expression'] = sort_ex
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(expression)(items_ex, sort_ex)
def test_name_in_value(self):
expression = ExpressionFactory.from_spec(
{
"type": "nested",
"argument_expression": {
"type": "identity",
},
"value_expression": {
"type": "named",
"name": "three"
}
},
context=FactoryContext({'three': ExpressionFactory.from_spec(3)}, {})
)
self.assertEqual(3, expression({}))
def test_property_path_expression(self):
getter = ExpressionFactory.from_spec({
'type': 'property_path',
'property_path': ['path', 'to', 'foo'],
})
self.assertEqual(PropertyPathGetterSpec, type(getter))
self.assertEqual(['path', 'to', 'foo'], getter.property_path)
def test_reduce_items_basic(self, doc, items_ex, reduce_ex, expected):
expression = ExpressionFactory.from_spec({
'type': 'reduce_items',
'items_expression': items_ex,
'aggregation_fn': reduce_ex
})
self.assertEqual(expression(doc), expected)
def setUp(self):
# this expression is the equivalent to:
# doc.true_value if doc.test == 'match' else doc.false_value
spec = {
'type': 'conditional',
'test': {
# any valid filter can go here
'type': 'boolean_expression',
'expression': {
'type': 'property_name',
'property_name': 'test',
},
'operator': 'eq',
'property_value': 'match',
},
'expression_if_true': {
'type': 'property_name',
'property_name': 'true_value',
},
'expression_if_false': {
'type': 'property_name',
'property_name': 'false_value',
},
}
self.expression = ExpressionFactory.from_spec(spec)
def test_end(self):
context = EvaluationContext(
{"domain": self.domain, "end_date": "2015-02-28"},
0)
expression = ExpressionFactory.from_spec({
"type": "reduce_items",
"aggregation_fn": "count",
"items_expression": {
"type": "ext_get_case_history_by_date",
"case_id_expression": {
"type": "constant",
"constant": self.test_case_id
},
"end_date": {
"type": "ext_root_property_name",
"property_name": "end_date",
"datatype": "date",
},
}
})
self.assertEqual(
5,
expression(
{"some_item": "item_value"},
context=context,
)
)
def test_property_name_expression(self):
getter = ExpressionFactory.from_spec({
'type': 'property_name',
'property_name': 'foo',
})
self.assertEqual(PropertyNameGetterSpec, type(getter))
self.assertEqual('foo', getter.property_name)
def setUpClass(cls):
cls.domain_name = "test-domain"
cls.domain_obj = create_domain(cls.domain_name)
cls.location_type = LocationType(
domain=cls.domain_name,
name="state",
code="state",
)
cls.location_type.save()
cls.location = SQLLocation(
domain="test-domain",
name="Braavos",
location_type=cls.location_type
)
cls.location.save()
cls.unique_id = cls.location.location_id
cls.spec = {
"type": "location_type_name",
"location_id_expression": {
"type": "property_name",
"property_name": "_id"
}
}
cls.expression = ExpressionFactory.from_spec(cls.spec)
def test_parent_case_id(self):
expression = ExpressionFactory.from_spec({
"type": "nested",
"argument_expression": {
"type": "array_index",
"array_expression": {
"type": "property_name",
"property_name": "indices"
},
"index_expression": {
"type": "constant",
"constant": 0
}
},
"value_expression": {
"type": "property_name",
"property_name": "referenced_id"
}
})
self.assertEqual(
'my_parent_id',
expression({
"indices": [
{
"doc_type": "CommCareCaseIndex",
"identifier": "parent",
"referenced_type": "pregnancy",
"referenced_id": "my_parent_id"
}
],
})
)
def test_filter(self):
expression = ExpressionFactory.from_spec({
"type": "reduce_items",
"aggregation_fn": "count",
"items_expression": {
"type": "ext_get_case_history_by_date",
"case_id_expression": {
"type": "constant",
"constant": self.test_case_id
},
"filter": {
"type": "boolean_expression",
"operator": "eq",
"expression": {
"type": "property_path",
"property_path": ["update", "foo"]
},
"property_value": "a"
}
}
})
self.assertEqual(
2,
expression(
{"some_item": "item_value"},
context=EvaluationContext({"domain": self.domain}, 0),
)
)
def test_datatype(self):
for expected, datatype, original in [
(5, "integer", "5"),
(5, "integer", "5.3"),
(None, "integer", "five"),
(Decimal(5), "decimal", "5"),
(Decimal("5.3"), "decimal", "5.3"),
("5", "string", "5"),
("5", "string", 5),
(u"fo\u00E9", "string", u"fo\u00E9"),
(date(2015, 9, 30), "date", "2015-09-30"),
(None, "date", "09/30/2015"),
(datetime(2015, 9, 30, 19, 4, 27), "datetime", "2015-09-30T19:04:27Z"),
(datetime(2015, 9, 30, 19, 4, 27, 113609), "datetime", "2015-09-30T19:04:27.113609Z"),
(None, "datetime", "2015-09-30 19:04:27Z"),
(date(2015, 9, 30), "date", "2015-09-30T19:04:27Z"),
(date(2015, 9, 30), "date", datetime(2015, 9, 30)),
(None, "datetime", "2015-09-30"),
]:
getter = ExpressionFactory.from_spec({
'type': 'property_name',
'property_name': 'foo',
'datatype': datatype
})
self.assertEqual(expected, getter({'foo': original}))
def parent_id(spec, context):
spec = {
'type': 'nested',
'argument_expression': {
'type': 'array_index',
'array_expression': {
'type': 'filter_items',
'items_expression': {
'type': 'ext_root_property_name',
'property_name': 'indices',
'datatype': 'array',
},
'filter_expression': {
'type': 'boolean_expression',
'operator': 'eq',
'property_value': 'parent',
'expression': {
'type': 'property_name',
'property_name': 'identifier'
}
}
},
'index_expression': {
'type': 'constant',
'constant': 0
}
},
'value_expression': {
'type': 'property_name',
'property_name': 'referenced_id'
}
}
return ExpressionFactory.from_spec(spec, context)
def test_latest_property(self):
doc = {
"forms": [
{"received_on": datetime.date(2015, 4, 5), "weight": 21},
{"received_on": datetime.date(2015, 1, 5), "weight": 18},
{"received_on": datetime.date(2015, 3, 5), "weight": 20},
]
}
# nested(weight) <- reduce(last_item) <- sort(by received_on) <- forms
expression = ExpressionFactory.from_spec({
"type": "nested",
"argument_expression": {
"type": "reduce_items",
"items_expression": {
"type": "sort_items",
"items_expression": {"type": "property_name", "property_name": "forms"},
"sort_expression": {"type": "property_name", "property_name": "received_on"}
},
"aggregation_fn": "last_item"
},
"value_expression": {
"type": "property_name",
"property_name": "weight"
}
})
self.assertEqual(expression(doc), doc["forms"][0]["weight"])
def test_filter_items_basic(self, doc, items_ex, filter_ex, expected):
expression = ExpressionFactory.from_spec({
'type': 'filter_items',
'items_expression': items_ex,
'filter_expression': filter_ex
})
self.assertEqual(expression(doc), expected)
def test_sort_items_basic(self, doc, items_ex, sort_ex, expected):
expression = ExpressionFactory.from_spec({
'type': 'sort_items',
'items_expression': items_ex,
'sort_expression': sort_ex
})
self.assertEqual(expression(doc), expected)
def test_filtered_child_cases(self):
context = EvaluationContext({"domain": self.domain}, 0)
expression = ExpressionFactory.from_spec({
"type": "reduce_items",
"aggregation_fn": "count",
"items_expression": {
"type": "filter_items",
"filter_expression": {
"type": "boolean_expression",
"operator": "eq",
"expression": {
"type": "property_name",
"property_name": "type"
},
"property_value": "child_1"
},
"items_expression": {
"type": "icds_get_child_cases",
"case_id_expression": {
"type": "constant",
"constant": self.test_case_id
}
}
}
})
self.assertEqual(1, expression({"some_field", "some_value"}, context))
def open_in_month(spec, context):
spec = {
'type': 'conditional',
'test': {
'type': 'and',
'filters': [
{
'type': 'boolean_expression',
'operator': 'gte',
'expression': {
'type': 'diff_days',
'from_date_expression': {
'type': 'ext_root_property_name',
'property_name': 'opened_on',
'datatype': 'date',
},
'to_date_expression': {
'type': 'ext_month_end',
}
},
'property_value': 0
},
{
'type': 'or',
'filters': [
{
'type': 'boolean_expression',
'operator': 'eq',
'expression': {
'type': 'ext_root_property_name',
'property_name': 'closed',
'datatype': 'string',
},
'property_value': 'False'
},
{
'type': 'boolean_expression',
'operator': 'gte',
'expression': {
'type': 'diff_days',
'from_date_expression': {
'type': 'ext_month_start',
},
'to_date_expression': {
'type': 'ext_root_property_name',
'property_name': 'closed_on',
'datatype': 'date',
}
},
'property_value': 0
}
]
}
]
},
'expression_if_true': {
'type': 'constant',
'constant': 'yes'
},
'expression_if_false': {
'type': 'constant',
'constant': 'no'
}
}
return ExpressionFactory.from_spec(spec, context)
def test_constant_datetime_conversion(self):
self.assertEqual(datetime(2015, 2, 4, 11, 5, 24), ExpressionFactory.from_spec('2015-02-04T11:05:24Z')({}))
def count_case_forms_with_xmlns_expression(spec, context):
wrapped = CountCaseFormsWithXmlns.wrap(spec)
wrapped.configure(
ExpressionFactory.from_spec(wrapped.case_id_expression, context))
return wrapped
def setUpClass(cls):
super(TestIterationNumberExpression, cls).setUpClass()
cls.spec = ExpressionFactory.from_spec({'type': 'base_iteration_number'})
def parsed_expression(self):
if self.base_item_expression:
return ExpressionFactory.from_spec(
self.base_item_expression, context=self.get_factory_context())
return None
def icds_user_location(spec, context):
wrapped = ICDSUserLocation.wrap(spec)
wrapped.configure(user_id_expression=ExpressionFactory.from_spec(
wrapped.user_id_expression, context))
return wrapped
def get_app_version(spec, context):
wrapped = GetAppVersion.wrap(spec)
wrapped.configure(app_version_string=ExpressionFactory.from_spec(
wrapped.app_version_string, context))
return wrapped
def get_case_history_by_date(spec, context):
GetCaseHistoryByDateSpec.wrap(spec)
if spec['case_id_expression'] is None:
case_id_expression = {
'expression': {
'type': 'property_name',
'property_name': '_id'
},
'type': 'root_doc'
}
else:
case_id_expression = spec['case_id_expression']
case_history_spec = {
"type": "icds_get_case_history",
"case_id_expression": case_id_expression
}
if spec['xmlns']:
case_history_spec['xmlns'] = spec['xmlns']
filters = []
if spec['start_date'] is not None:
start_date_filter = {
'operator': 'gte',
'expression': {
'datatype': 'integer',
'from_date_expression': spec['start_date'],
'type': 'diff_days',
'to_date_expression': {
'datatype': 'date',
'type': 'property_name',
'property_name': '@date_modified'
}
},
'type': 'boolean_expression',
'property_value': 0
}
filters.append(start_date_filter)
case_history_spec['start_date'] = spec['start_date']
if spec['end_date'] is not None:
end_date_filter = {
'operator': 'gte',
'expression': {
'datatype': 'integer',
'from_date_expression': {
'datatype': 'date',
'type': 'property_name',
'property_name': '@date_modified'
},
'type': 'diff_days',
'to_date_expression': spec['end_date']
},
'type': 'boolean_expression',
'property_value': 0
}
filters.append(end_date_filter)
case_history_spec['end_date'] = spec['end_date']
if spec['filter'] is not None:
filters.append(spec['filter'])
if len(filters) > 0:
case_history_spec = {
"filter_expression": {
"type": "and",
"filters": filters
},
"type": "filter_items",
"items_expression": case_history_spec
}
spec = {
'type': 'sort_items',
'sort_expression': {
'datatype': 'date',
'type': 'property_name',
'property_name': '@date_modified',
},
"items_expression": case_history_spec
}
return ExpressionFactory.from_spec(spec, context)
def test_flatten_basic(self, doc, items_ex, expected):
expression = ExpressionFactory.from_spec({
'type': 'flatten',
'items_expression': items_ex
})
self.assertEqual(expression(doc), expected)
def village_owner_id(spec, context):
wrapped = VillageOwnerId.wrap(spec)
wrapped.configure(
case_id_expression=ExpressionFactory.from_spec(wrapped.case_id_expression, context)
)
return wrapped
def location_type_name(spec, context):
wrapped = LocationTypeSpec.wrap(spec)
wrapped.configure(location_id_expression=ExpressionFactory.from_spec(
wrapped.location_id_expression, context))
return wrapped
def test_flatten_bad_spec(self, items_ex):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec({
'type': 'flatten',
'items_expression': items_ex
})
def test_invalid_type(self):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec({
'type': 'not_a_valid_type',
})
def test_repeat_calculation(self):
_rations1, _rations2, _rations3 = 3, 4, 5
doc = {
"forms": [
{
"id":
"f1",
"child_repeat": [{
"name": "a",
"rations": _rations1
}, {
"name": "b",
"rations": 3
}, {
"name": "c",
"rations": 3
}]
},
{
"id":
"f2",
"child_repeat": [{
"name": "c",
"rations": 3
}, {
"name": "a",
"rations": _rations2
}, {
"name": "b",
"rations": 3
}]
},
{
"id":
"f3",
"child_repeat": [{
"name": "a",
"rations": _rations3
}, {
"name": "b",
"rations": 3
}, {
"name": "c",
"rations": 3
}]
},
]
}
# reduce(to sum ) <- map(weight) <- filter(by name) <- flatten(child_repeat) <- map(child_repeat) <- forms
expression = ExpressionFactory.from_spec({
"type": "reduce_items",
"items_expression": {
"type": "map_items",
"items_expression": {
"type": "filter_items",
"items_expression": {
"type": "flatten",
"items_expression": {
"type": "map_items",
"items_expression": {
"type": "property_name",
"property_name": "forms"
},
"map_expression": {
"type": "property_name",
"property_name": "child_repeat"
}
}
},
"filter_expression": {
"type": "boolean_expression",
"operator": "eq",
"expression": {
"type": "property_name",
"property_name": "name"
},
"property_value": "a"
}
},
"map_expression": {
"type": "property_name",
"property_name": "rations"
}
},
"aggregation_fn": "sum"
})
self.assertEqual(expression(doc), _rations1 + _rations2 + _rations3)
def test_property_name_no_name(self):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec({
'type': 'property_name',
})
def concatenate_strings_expression(spec, context):
wrapped = ConcatenateStrings.wrap(spec)
wrapped.configure(
[ExpressionFactory.from_spec(e, context)
for e in wrapped.expressions], )
return wrapped
def test_microbiological_endofip_test_requested_date(self):
episode_case = {
'_id': 'episode_case_id',
'domain': 'enikshay-test',
'treatment_initiation_date': '2017-09-28',
'archive_reason': None,
'treatment_outcome': 'test',
'indices': [
{'referenced_id': 'occurrence_case_id'}
]
}
occurrence_case = {
'_id': 'occurrence_case_id',
'domain': 'enikshay-test',
'indices': [
{'referenced_id': 'person_case_id'}
]
}
person_case = {
'_id': 'person_case_id',
'domain': 'enikshay-test',
'owner_id': 'owner-id'
}
subcases = [
{
'domain': 'enikshay-test',
'type': 'test',
'is_direct_test_entry': 'no',
'rft_dstb_followup': 'end_of_ip',
'test_requested_date': '2017-09-28',
'date_tested': '2017-08-10',
'test_type_value': 'microscopy-zn',
'result_recorded': 'yes'
},
{
'domain': 'enikshay-test',
'type': 'test',
'is_direct_test_entry': 'yes',
'rft_dstb_followup': 'end_of_cp',
'test_requested_date': '2017-09-28',
'date_tested': '2017-08-10',
'test_type_value': 'microscopy-zn',
'result_recorded': 'yes'
},
{
'domain': 'enikshay-test',
'type': 'test',
'rft_dstb_followup': 'end_of_cp',
'test_requested_date': '2017-09-28',
'test_type_value': 'microscopy-zn',
}
]
self.database.mock_docs = {
'episode_case_id': episode_case,
'occurrence_case_id': occurrence_case,
'person_case_id': person_case
}
endofip_test_requested_date = self._get_column('endofip_test_requested_date')
self.assertEqual(endofip_test_requested_date['datatype'], 'date')
endofip_test_requested_date_expression = ExpressionFactory.from_spec(
endofip_test_requested_date['expression'],
context=FactoryContext(self.named_expressions, {})
)
endofcp_test_requested_date = self._get_column('endofcp_test_requested_date')
self.assertEqual(endofcp_test_requested_date['datatype'], 'date')
endofcp_test_requested_date_expression = ExpressionFactory.from_spec(
endofcp_test_requested_date['expression'],
context=FactoryContext(self.named_expressions, {})
)
with mock.patch.object(SubcasesExpressionSpec, '__call__', lambda *args: subcases):
self.assertEqual(
endofip_test_requested_date_expression(episode_case, EvaluationContext(episode_case, 0)),
'2017-09-28'
)
self.assertEqual(
endofcp_test_requested_date_expression(episode_case, EvaluationContext(episode_case, 0)),
'2017-08-10'
)
def month_expression(spec, context):
wrapped = MonthExpression.wrap(spec)
wrapped.configure(
ExpressionFactory.from_spec(wrapped.month_expression, context))
return wrapped
def get_case_id_expression(self, context=None):
from corehq.apps.userreports.expressions.factory import ExpressionFactory
return ExpressionFactory.from_spec(self.case_id_expression, context)
def get_case_forms_by_date(spec, context):
GetCaseFormsByDateSpec.wrap(spec)
if spec['case_id_expression'] is None:
case_id_expression = {
"type": "ext_root_property_name",
"property_name": "_id",
}
else:
case_id_expression = spec['case_id_expression']
case_forms_expression = {
"type": "get_case_forms",
"case_id_expression": case_id_expression
}
if spec['xmlns']:
case_forms_expression['xmlns'] = spec['xmlns']
filters = []
if spec['start_date'] is not None:
start_date_filter = {
'operator': 'gte',
'expression': {
'datatype': 'integer',
'from_date_expression': spec['start_date'],
'type': 'diff_days',
'to_date_expression': {
'datatype': 'date',
'type': 'property_path',
'property_path': [
'form',
'meta',
'timeEnd'
]
}
},
'type': 'boolean_expression',
'property_value': 0
}
filters.append(start_date_filter)
if spec['end_date'] is not None:
end_date_filter = {
'operator': 'gte',
'expression': {
'datatype': 'integer',
'from_date_expression': {
'datatype': 'date',
'type': 'property_path',
'property_path': [
'form',
'meta',
'timeEnd'
]
},
'type': 'diff_days',
'to_date_expression': spec['end_date']
},
'type': 'boolean_expression',
'property_value': 0
}
filters.append(end_date_filter)
if spec['form_filter'] is not None:
filters.append(spec['form_filter'])
if len(filters) > 0:
case_forms_expression = {
"filter_expression": {
"type": "and",
"filters": filters
},
"type": "filter_items",
"items_expression": case_forms_expression
}
spec = {
"type": "sort_items",
"sort_expression": {
"type": "property_path",
"property_path": [
"form",
"meta",
"timeEnd"
],
"datatype": "date"
},
"items_expression": case_forms_expression
}
return ExpressionFactory.from_spec(spec, context)
def ccs_lactating(spec, context):
spec = {
'type': 'conditional',
'test': {
'type':
'and',
'filters': [{
'type': 'boolean_expression',
'operator': 'eq',
'expression': {
'type': 'icds_open_in_month'
},
'property_value': 'yes'
}, {
'type': 'boolean_expression',
'operator': 'eq',
'expression': {
'type': 'icds_alive_in_month'
},
'property_value': 'yes'
}, {
'type': 'not',
'filter': {
'operator': 'in',
'type': 'boolean_expression',
'expression': {
'type': 'root_doc',
'expression': {
'datatype': 'date',
'type': 'property_name',
'property_name': 'add'
}
},
'property_value': ['', None]
}
}, {
'type': 'boolean_expression',
'operator': 'gte',
'property_value': 0,
'expression': {
'type': 'diff_days',
'to_date_expression': {
'type': 'icds_month_end'
},
'from_date_expression': {
'type': 'root_doc',
'expression': {
'datatype': 'date',
'type': 'property_name',
'property_name': 'add'
}
}
}
}, {
'type': 'boolean_expression',
'operator': 'lte',
'property_value': 183,
'expression': {
'type': 'diff_days',
'from_date_expression': {
'type': 'root_doc',
'expression': {
'datatype': 'date',
'type': 'property_name',
'property_name': 'add'
}
},
'to_date_expression': {
'type': 'icds_month_start'
}
}
}]
},
'expression_if_true': {
'type': 'constant',
'constant': 'yes'
},
'expression_if_false': {
'type': 'constant',
'constant': 'no'
}
}
return ExpressionFactory.from_spec(spec, context)
def test_constant_date_conversion(self):
self.assertEqual(date(2015, 2, 4), ExpressionFactory.from_spec('2015-02-04')({}))
def test_constant_auto_detection_invalid_types(self):
for invalid_constant in ({}):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec(invalid_constant)
def test_not_microbiological_result(self):
episode_case = {
'_id': 'episode_case_id',
'domain': 'enikshay-test',
'treatment_initiation_date': '2017-09-28',
'archive_reason': None,
'treatment_outcome': 'test',
'indices': [
{'referenced_id': 'occurrence_case_id'}
]
}
occurrence_case = {
'_id': 'occurrence_case_id',
'domain': 'enikshay-test',
'indices': [
{'referenced_id': 'person_case_id'}
]
}
person_case = {
'_id': 'person_case_id',
'domain': 'enikshay-test',
'owner_id': 'owner-id'
}
subcases = [
{
'domain': 'enikshay-test',
'type': 'test',
'is_direct_test_entry': 'no',
'rft_dstb_followup': 'end_of_ip',
'test_requested_date': '2017-09-28',
'date_tested': '2017-08-10',
'date_reported': '2017-08-10',
'test_type_value': 'cytopathology',
'test_type_label': 'Cytopathology',
'result_grade': 'result_grade',
'result_recorded': 'yes',
'result_summary_display': 'result_cytopathology',
'result': 'result_cytopathology',
},
{
'domain': 'enikshay-test',
'type': 'test',
'is_direct_test_entry': 'yes',
'rft_dstb_followup': 'end_of_cp',
'test_requested_date': '2017-09-28',
'date_tested': '2017-09-10',
'date_reported': '2017-09-10',
'test_type_value': 'igra',
'result': 'result',
'result_recorded': 'yes',
'result_summary_display': 'result_igra'
},
{
'domain': 'enikshay-test',
'type': 'test',
'rft_dstb_followup': 'end_of_cp',
'test_requested_date': '2017-10-10',
'date_reported': '2017-10-10',
'test_type_value': 'other_clinical',
'test_type_label': 'Other clinical',
'result_summary_display': 'result_other_clinical'
}
]
self.database.mock_docs = {
'episode_case_id': episode_case,
'occurrence_case_id': occurrence_case,
'person_case_id': person_case
}
not_microbiological = self._get_column('not_microbiological_result')
self.assertEqual(not_microbiological['datatype'], 'string')
not_microbiological_result_expression = ExpressionFactory.from_spec(
not_microbiological['expression'],
context=FactoryContext(self.named_expressions, {})
)
with mock.patch.object(SubcasesExpressionSpec, '__call__', lambda *args: subcases):
self.assertEqual(
not_microbiological_result_expression(episode_case, EvaluationContext(episode_case, 0)),
'Cytopathology, result_cytopathology'
)
def setUp(self):
self.expression = ExpressionFactory.from_spec({'type': 'identity'})
def iterate_from_opened_date(spec, context):
spec = {
'type': 'evaluator',
'datatype': 'array',
'context_variables': {
'count': {
'type': 'conditional',
'datatype': 'integer',
'test': {
'type': 'boolean_expression',
'operator': 'eq',
'expression': {
'type': 'property_name',
'property_name': 'closed',
'datatype': 'string',
},
'property_value': 'True'
},
'expression_if_true': {
'type': 'evaluator',
'datatype': 'integer',
'context_variables': {
'difference': {
'type': 'ext_diff_calendar_months',
'from_date_expression': {
'type': 'month_start_date',
'date_expression': {
'type': 'property_name',
'datatype': 'date',
'property_name': 'opened_on'
},
},
'to_date_expression': {
'type': 'month_start_date',
'date_expression': {
'type': 'property_name',
'datatype': 'date',
'property_name': 'closed_on'
},
}
}
},
'statement': 'difference + 1'
},
'expression_if_false': {
'type': 'evaluator',
'datatype': 'integer',
'context_variables': {
'difference': {
'type': 'ext_diff_calendar_months',
'from_date_expression': {
'type': 'month_start_date',
'date_expression': {
'type': 'property_name',
'datatype': 'date',
'property_name': 'opened_on'
},
},
'to_date_expression': {
'type': 'month_start_date',
'date_expression': {
'type': 'property_name',
'datatype': 'date',
'property_name': 'modified_on'
},
}
}
},
'statement': 'difference + 1 + ' + str(NUM_FUTURE_MONTHS)
}
}
},
'statement': 'range(count)'
}
return ExpressionFactory.from_spec(spec, context)
def readable_output(self, context):
from corehq.apps.userreports.expressions.factory import ExpressionFactory
expression_object = ExpressionFactory.from_spec(
self.expression, context)
return str(expression_object)
def test_invalid_constant(self):
with self.assertRaises(BadSpecError):
ExpressionFactory.from_spec({
'type': 'constant',
})
spec = {
"type": "switch",
"switch_on": spec['boolean_property'],
"cases": {
case: {
"type": "constant",
"constant": value
}
for case, value in case_tuples
},
"default": {
"type": "constant",
"constant": None if spec['nullable'] else 0
}
}
return ExpressionFactory.from_spec(spec, context)
def icds_user_location(spec, context):
wrapped = ICDSUserLocation.wrap(spec)
wrapped.configure(user_id_expression=ExpressionFactory.from_spec(
wrapped.user_id_expression, context))
return wrapped
def icds_get_related_docs_ids(case_id):
"""gets a related case id from an ICDS ccs_record or child_health case. Expects the hierarchy:
/----> ccs_record
household -----> person --<
\----> child_health
def test_custom_expression(self):
"""Confirm that plugin framework is being bootstrapped."""
ExpressionFactory.from_spec({
"type": "abt_supervisor"
})
