def test_archie_modified_on(self):
case_id = uuid.uuid4().hex
now = datetime.utcnow().replace(microsecond=0)
earlier = now - timedelta(hours=1)
way_earlier = now - timedelta(days=1)
# make sure we timestamp everything so they have the right order
create_block = CaseBlock(case_id,
create=True,
date_modified=way_earlier)
post_case_blocks([create_block.as_xml()],
form_extras={'received_on': way_earlier})
update_block = CaseBlock(case_id,
update={'foo': 'bar'},
date_modified=earlier)
post_case_blocks([update_block.as_xml()],
form_extras={'received_on': earlier})
case = CommCareCase.objects.get_case(case_id, 'test-domain')
self.assertEqual(earlier, case.modified_on)
second_form = XFormInstance.objects.get_form(case.xform_ids[-1],
'test-domain')
second_form.archive()
case = CommCareCase.objects.get_case(case_id, 'test-domain')
self.assertEqual(way_earlier, case.modified_on)
def test_archie_modified_on(self):
case_id = uuid.uuid4().hex
now = datetime.utcnow().replace(microsecond=0)
earlier = now - timedelta(hours=1)
way_earlier = now - timedelta(days=1)
# make sure we timestamp everything so they have the right order
create_block = CaseBlock(case_id,
create=True,
date_modified=way_earlier)
post_case_blocks([create_block.as_xml()],
form_extras={'received_on': way_earlier})
update_block = CaseBlock(case_id,
update={'foo': 'bar'},
date_modified=earlier)
post_case_blocks([update_block.as_xml()],
form_extras={'received_on': earlier})
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
self.assertEqual(earlier, case.modified_on)
second_form = FormAccessors(REBUILD_TEST_DOMAIN).get_form(
case.xform_ids[-1])
second_form.archive()
case = case_accessors.get_case(case_id)
self.assertEqual(way_earlier, case.modified_on)
def create_case_from_dhis2(dhis2_child, domain, user):
"""
Create a new case using the data pulled from DHIS2
:param dhis2_child: TRACKED_ENTITY (i.e. "Child") from DHIS2
:param domain: (str) The name of the domain
:param user: (Document) The owner of the new case
:return: New case ID
"""
case_id = uuid.uuid4().hex
update = {
k: dhis2_child[v]
for k, v in NUTRITION_ASSESSMENT_PROGRAM_FIELDS.iteritems()
}
update['dhis_org_id'] = dhis2_child['Org unit']
# Do the inverse of push_case() to 'Gender' / 'child_gender'
if 'child_gender' in update:
if update['child_gender'] == 'Undefined':
del update['child_gender']
else:
update['child_gender'] = update['child_gender'].lower()
caseblock = CaseBlock(create=True,
case_id=case_id,
owner_id=user.userID,
user_id=user.userID,
version=V2,
case_type=CASE_TYPE,
case_name=update[CASE_NAME] if CASE_NAME else '',
external_id=dhis2_child['Instance'],
update=update)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain)
return case_id
def submit_mapping_case_block(user, index):
mapping = user.get_location_map_case()
if mapping:
caseblock = CaseBlock(
create=False,
case_id=mapping._id,
version=V2,
index=index
)
else:
caseblock = CaseBlock(
create=True,
case_type=const.USER_LOCATION_OWNER_MAP_TYPE,
case_id=location_map_case_id(user),
version=V2,
owner_id=user._id,
index=index,
case_name=const.USER_LOCATION_OWNER_MAP_TYPE.replace('-', ' '),
user_id=const.COMMTRACK_USERNAME,
)
submit_case_blocks(
ElementTree.tostring(
caseblock.as_xml(format_datetime=json_format_datetime)
),
user.domain,
)
def test_case_block_index_supports_relationship(self):
"""
CaseBlock index should allow the relationship to be set
"""
case_block = CaseBlock(
case_id='abcdef',
case_type='at_risk',
date_modified='2015-07-24',
date_opened='2015-07-24',
index={
'host': IndexAttrs(case_type='newborn', case_id='123456', relationship='extension')
},
)
self.assertEqual(
ElementTree.tostring(case_block.as_xml()).decode('utf-8'),
re.sub(r'(\n| {2,})', '', """
<case case_id="abcdef" date_modified="2015-07-24" xmlns="http://commcarehq.org/case/transaction/v2">
<update>
<case_type>at_risk</case_type>
<date_opened>2015-07-24</date_opened>
</update>
<index>
<host case_type="newborn" relationship="extension">123456</host>
</index>
</case>
""")
)
def submit_mapping_case_block(user, index):
mapping = user.get_location_map_case()
if mapping:
caseblock = CaseBlock(
create=False,
case_id=mapping.case_id,
index=index
)
else:
caseblock = CaseBlock(
create=True,
case_type=const.USER_LOCATION_OWNER_MAP_TYPE,
case_id=location_map_case_id(user),
owner_id=user._id,
index=index,
case_name=const.USER_LOCATION_OWNER_MAP_TYPE.replace('-', ' '),
user_id=const.COMMTRACK_USERNAME,
)
submit_case_blocks(
ElementTree.tostring(caseblock.as_xml()),
user.domain,
device_id=__name__ + ".submit_mapping_case_block"
)
def submit_mapping_case_block(user, index):
mapping = user.get_location_map_case()
if mapping:
caseblock = CaseBlock(
create=False,
case_id=mapping._id,
version=V2,
index=index
)
else:
caseblock = CaseBlock(
create=True,
case_type=USER_LOCATION_OWNER_MAP_TYPE,
case_id=location_map_case_id(user),
version=V2,
owner_id=user._id,
index=index
)
submit_case_blocks(
ElementTree.tostring(caseblock.as_xml()),
user.domain,
user.username,
user._id
)
def test_case_block_index_omit_child(self):
"""
CaseBlock index relationship omit relationship attribute if set to "child"
"""
case_block = CaseBlock(
case_id='123456',
case_type='newborn',
date_modified='2015-07-24',
index={
'parent': IndexAttrs(case_type='mother', case_id='789abc', relationship='child')
},
)
self.assertEqual(
ElementTree.tostring(case_block.as_xml()),
re.sub(r'(\n| {2,})', '', """
<case case_id="123456" date_modified="2015-07-24" xmlns="http://commcarehq.org/case/transaction/v2">
<update>
<case_type>newborn</case_type>
</update>
<index>
<parent case_type="mother">789abc</parent>
</index>
</case>
""")
)
def testBadIndexReferenceDomain(self):
case_in_other_domain = self.MOTHER_CASE_ID
parent_domain = 'parent'
child_domain = 'child'
post_case_blocks([
CaseBlock(create=True,
case_id=case_in_other_domain,
user_id=USER_ID,
version=V2).as_xml()
],
form_extras={'domain': parent_domain})
block = CaseBlock(create=True,
case_id='child-case-id',
user_id=USER_ID,
version=V2,
index={'bad': ('bad-case', case_in_other_domain)})
xform, _ = post_case_blocks([block.as_xml()],
form_extras={'domain': child_domain})
self.assertIsInstance(xform, XFormError)
self.assertEqual(xform.doc_type, 'XFormError')
self.assertIn('IllegalCaseId', xform.problem)
self.assertIn('Bad case id', xform.problem)
def test_case_block_index_default_relationship(self):
"""
CaseBlock index relationship should default to "child"
"""
case_block = CaseBlock(
case_id='123456',
case_type='newborn',
date_modified='2015-07-24',
date_opened='2015-07-24',
index={
'parent': ChildIndexAttrs(case_type='mother', case_id='789abc')
},
)
self.assertEqual(
ElementTree.tostring(case_block.as_xml()).decode('utf-8'),
re.sub(
r'(\n| {2,})', '', """
<case case_id="123456" date_modified="2015-07-24" xmlns="http://commcarehq.org/case/transaction/v2">
<update>
<case_type>newborn</case_type>
<date_opened>2015-07-24</date_opened>
</update>
<index>
<parent case_type="mother">789abc</parent>
</index>
</case>
"""))
def make_supply_point_product(supply_point_case, product_uuid, owner_id=None):
domain = supply_point_case.domain
id = uuid.uuid4().hex
user_id = const.get_commtrack_user_id(domain)
owner_id = owner_id or get_owner_id(supply_point_case) or user_id
username = const.COMMTRACK_USERNAME
product_name = Product.get(product_uuid).name
caseblock = CaseBlock(
case_id=id,
create=True,
version=V2,
case_name=product_name,
user_id=user_id,
owner_id=owner_id,
case_type=const.SUPPLY_POINT_PRODUCT_CASE_TYPE,
update={
"product": product_uuid
},
index={
const.PARENT_CASE_REF: (const.SUPPLY_POINT_CASE_TYPE,
supply_point_case._id),
}
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain, username, user_id,
xmlns=const.COMMTRACK_SUPPLY_POINT_PRODUCT_XMLNS)
sppc = SupplyPointProductCase.get(id)
sppc.bind_to_location(supply_point_case.location)
sppc.save()
return sppc
def reassign_household(domain,
household_case_id,
old_owner_id,
new_owner_id,
supervisor_id,
deprecation_time=None,
household_child_case_ids=None):
from custom.icds.location_reassignment.tasks import process_ucr_changes
if deprecation_time is None:
deprecation_time = datetime.utcnow()
if household_child_case_ids:
case_ids = household_child_case_ids
else:
case_ids = get_household_child_case_ids_by_owner(
domain, household_case_id, old_owner_id)
case_ids.append(household_case_id)
case_blocks = []
for case_id in case_ids:
updates = {
'location_reassignment_last_owner_id': old_owner_id,
'location_reassignment_datetime': deprecation_time
}
if supervisor_id:
updates['location_reassignment_last_supervisor_id'] = supervisor_id
case_block = CaseBlock(case_id,
update=updates,
owner_id=new_owner_id,
user_id=SYSTEM_USER_ID)
case_block = ElementTree.tostring(case_block.as_xml()).decode('utf-8')
case_blocks.append(case_block)
if case_blocks:
submit_case_blocks(case_blocks, domain, user_id=SYSTEM_USER_ID)
process_ucr_changes.delay(domain, case_ids)
def test_case_block_index_default_relationship(self):
"""
CaseBlock index relationship should default to "child"
"""
case_block = CaseBlock(
case_id='123456',
case_type='newborn',
date_modified='2015-07-24',
date_opened='2015-07-24',
index={
'parent': ChildIndexAttrs(case_type='mother', case_id='789abc')
},
)
self.assertEqual(
ElementTree.tostring(case_block.as_xml()).decode('utf-8'),
re.sub(r'(\n| {2,})', '', """
<case case_id="123456" date_modified="2015-07-24" xmlns="http://commcarehq.org/case/transaction/v2">
<update>
<case_type>newborn</case_type>
<date_opened>2015-07-24</date_opened>
</update>
<index>
<parent case_type="mother">789abc</parent>
</index>
</case>
""")
)
def _post_util(create=False,
case_id=None,
user_id=None,
owner_id=None,
case_type=None,
form_extras=None,
close=False,
date_modified=None,
**kwargs):
form_extras = form_extras or {}
form_extras['domain'] = REBUILD_TEST_DOMAIN
uid = lambda: uuid.uuid4().hex
case_id = case_id or uid()
block = CaseBlock(create=create,
case_id=case_id,
user_id=user_id or uid(),
owner_id=owner_id or uid(),
case_type=case_type or 'test',
date_modified=date_modified,
update=kwargs,
close=close)
block = block.as_xml()
post_case_blocks([block], form_extras)
return case_id
def create_case_from_dhis2(dhis2_child, domain, user):
"""
Create a new case using the data pulled from DHIS2
:param dhis2_child: TRACKED_ENTITY (i.e. "Child") from DHIS2
:param domain: (str) The name of the domain
:param user: (Document) The owner of the new case
:return: New case ID
"""
case_id = uuid.uuid4().hex
update = {k: dhis2_child[v] for k, v in NUTRITION_ASSESSMENT_PROGRAM_FIELDS.iteritems()}
update['dhis_org_id'] = dhis2_child['Org unit']
# Do the inverse of push_case() to 'Gender' / 'child_gender'
if 'child_gender' in update:
if update['child_gender'] == 'Undefined':
del update['child_gender']
else:
update['child_gender'] = update['child_gender'].lower()
caseblock = CaseBlock(
create=True,
case_id=case_id,
owner_id=user.userID,
user_id=user.userID,
case_type=CASE_TYPE,
case_name=update[CASE_NAME] if CASE_NAME else '',
external_id=dhis2_child['Instance'],
update=update
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain)
return case_id
def test_case_block_index_supports_relationship(self):
"""
CaseBlock index should allow the relationship to be set
"""
case_block = CaseBlock(
case_id='abcdef',
case_type='at_risk',
date_modified='2015-07-24',
date_opened='2015-07-24',
index={
'host':
IndexAttrs(case_type='newborn',
case_id='123456',
relationship='extension')
},
)
self.assertEqual(
ElementTree.tostring(case_block.as_xml()).decode('utf-8'),
re.sub(
r'(\n| {2,})', '', """
<case case_id="abcdef" date_modified="2015-07-24" xmlns="http://commcarehq.org/case/transaction/v2">
<update>
<case_type>at_risk</case_type>
<date_opened>2015-07-24</date_opened>
</update>
<index>
<host case_type="newborn" relationship="extension">123456</host>
</index>
</case>
"""))
def create_case(cls,
case_type,
parent_case_id=None,
parent_case_type=None,
parent_identifier=None,
parent_relationship=None,
update=None,
case_name=None,
owner_id=None):
kwargs = {}
if parent_case_id:
kwargs['index'] = {
parent_identifier:
(parent_case_type, parent_case_id, parent_relationship)
}
if case_name:
kwargs['case_name'] = case_name
if owner_id:
kwargs['owner_id'] = owner_id
caseblock = CaseBlock(uuid.uuid4().hex,
case_type=case_type,
create=True,
update=update,
**kwargs)
case = submit_case_blocks(ElementTree.tostring(caseblock.as_xml()),
cls.domain)[1][0]
cls.created_case_ids.append(case.case_id)
return case
def test_reprocess_xform_error(self):
case_id = uuid.uuid4().hex
parent_case_id = uuid.uuid4().hex
case = CaseBlock(
create=True,
case_id=case_id,
user_id='user1',
owner_id='user1',
case_type='demo',
case_name='child',
index={'parent': ('parent_type', parent_case_id)}
)
post_case_blocks([case.as_xml()], domain=self.domain)
form_accessors = FormAccessors(self.domain)
error_forms = form_accessors.get_forms_by_type('XFormError', 10)
self.assertEqual(1, len(error_forms))
form = error_forms[0]
reprocess_xform_error(form)
error_forms = form_accessors.get_forms_by_type('XFormError', 10)
self.assertEqual(1, len(error_forms))
case = CaseBlock(
create=True,
case_id=parent_case_id,
user_id='user1',
owner_id='user1',
case_type='parent_type',
case_name='parent',
)
post_case_blocks([case.as_xml()], domain=self.domain)
reprocess_xform_error(form_accessors.get_form(form.form_id))
form = form_accessors.get_form(form.form_id)
# self.assertTrue(form.initial_processing_complete) Can't change this with SQL forms at the moment
self.assertTrue(form.is_normal)
self.assertIsNone(form.problem)
case = CaseAccessors(self.domain).get_case(case_id)
self.assertEqual(1, len(case.indices))
self.assertEqual(case.indices[0].referenced_id, parent_case_id)
self._validate_case(case)
def testBadIndexReference(self):
block = CaseBlock(create=True, case_id=self.CASE_ID, user_id=USER_ID, version=V2,
index={'bad': ('bad-case', 'not-an-existing-id')})
try:
post_case_blocks([block.as_xml()])
self.fail("Submitting against a bad case in an index should fail!")
except IllegalCaseId:
pass
def create_case_blocks(case_ids):
case_blocks = []
for case_id in case_ids:
case_block = CaseBlock(case_id,
update={PHONE_NUMBER_PROPERTY: ''},
user_id=SYSTEM_USER_ID)
case_block = ElementTree.tostring(case_block.as_xml()).decode('utf-8')
case_blocks.append(case_block)
return case_blocks
def _create_case_blocks(updates, case_property):
case_blocks = []
for case_id, new_value in updates.items():
case_block = CaseBlock(case_id,
update={case_property: new_value},
user_id=SYSTEM_USER_ID)
case_block = ElementTree.tostring(case_block.as_xml()).decode('utf-8')
case_blocks.append(case_block)
return case_blocks
def testArchiveModifiedOn(self):
case_id = uuid.uuid4().hex
now = datetime.utcnow().replace(microsecond=0)
earlier = now - timedelta(hours=1)
way_earlier = now - timedelta(days=1)
# make sure we timestamp everything so they have the right order
create_block = CaseBlock(case_id, create=True, date_modified=way_earlier)
FormProcessorInterface.post_case_blocks([create_block.as_xml()], form_extras={'received_on': way_earlier})
update_block = CaseBlock(case_id, update={'foo': 'bar'}, date_modified=earlier)
FormProcessorInterface.post_case_blocks([update_block.as_xml()], form_extras={'received_on': earlier})
case = CommCareCase.get(case_id)
self.assertEqual(earlier, case.modified_on)
second_form = XFormInstance.get(case.xform_ids[-1])
second_form.archive()
case = CommCareCase.get(case_id)
self.assertEqual(way_earlier, case.modified_on)
def test_globally_unique_case_id(self):
case_id = uuid.uuid4().hex
case = CaseBlock(
create=True,
case_id=case_id,
user_id='user1',
owner_id='user1',
case_type='demo',
case_name='create_case'
)
with override_settings(TESTS_SHOULD_USE_SQL_BACKEND=False):
post_case_blocks([case.as_xml()], domain='domain1')
with override_settings(TESTS_SHOULD_USE_SQL_BACKEND=True):
xform, cases = post_case_blocks([case.as_xml()], domain='domain2')
self.assertEqual(0, len(cases))
self.assertTrue(xform.is_error)
self.assertIn('IllegalCaseId', xform.problem)
def _create_case(cls, parent_id):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(case_id=case_id,
case_type=cls.case_type,
date_opened=cls.case_date_opened,
case_name=cls.case_name,
update=cls._get_case_property_values(),
index={'parent': (cls.case_type, parent_id)})
post_case_blocks([caseblock.as_xml()], domain=cls.domain)
return case_id
def reassign_cases(domain, case_ids, new_owner_id):
case_blocks = []
for case_id in case_ids:
case_block = CaseBlock(case_id,
owner_id=new_owner_id,
user_id=SYSTEM_USER_ID)
case_block = ElementTree.tostring(case_block.as_xml()).decode('utf-8')
case_blocks.append(case_block)
if case_blocks:
submit_case_blocks(case_blocks, domain, user_id=SYSTEM_USER_ID)
def create_case_blocks(self, updates):
case_blocks = []
for case_id, mother_name in updates.items():
case_block = CaseBlock(case_id,
update={MOTHER_NAME_PROPERTY: mother_name},
user_id=SYSTEM_USER_ID)
case_block = ElementTree.tostring(
case_block.as_xml()).decode('utf-8')
case_blocks.append(case_block)
return case_blocks
def to_xml(to_update):
caseblock = CaseBlock(
create=False,
case_id=to_update.case.case_id,
user_id=MOTECH_ID,
owner_id=to_update.new_owner_id or CaseBlock.undefined,
case_type=to_update.new_type or CaseBlock.undefined,
)
return ElementTree.tostring(caseblock.as_xml())
def _create_case_blocks(updates):
case_blocks = []
for case_id, case_updates in updates.items():
case_block = CaseBlock(case_id,
update=case_updates,
user_id=SYSTEM_USER_ID)
case_block = ElementTree.tostring(
case_block.as_xml()).decode('utf-8')
case_blocks.append(case_block)
return case_blocks
def test_date_opened_coercion(self):
delete_all_users()
self.project = Domain(name='some-domain')
self.project.save()
user = create_restore_user(self.project.name)
case_id = uuid.uuid4().hex
modified_on = datetime.utcnow()
case = CaseBlock(
create=True,
case_id=case_id,
user_id=user.user_id, owner_id=user.user_id, case_type='demo',
case_name='create_case', date_modified=modified_on, date_opened=modified_on, update={
'dynamic': '123'
}
)
post_case_blocks([case.as_xml()], domain='some-domain')
# update the date_opened to date type to check for value on restore
case.date_opened = case.date_opened.date()
check_user_has_case(self, user, case.as_xml())
def update_case_external_id(case, external_id):
"""
Update the external_id of a case
"""
caseblock = CaseBlock(
create=False,
case_id=case['_id'],
external_id=external_id
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, case['domain'])
def to_xml(to_update):
caseblock = CaseBlock(
create=False,
case_id=to_update.case.case_id,
version=V2,
user_id=MOTECH_ID,
owner_id=to_update.new_owner_id or CaseBlock.undefined,
case_type=to_update.new_type or CaseBlock.undefined,
)
return ElementTree.tostring(caseblock.as_xml())
def testBadIndexReference(self):
CASE_ID = 'test-bad-index-case'
block = CaseBlock(create=True,
case_id=CASE_ID,
user_id=USER_ID,
version=V2,
index={'bad': ('bad-case', 'not-an-existing-id')})
try:
post_case_blocks([block.as_xml()])
self.fail("Submitting against a bad case in an index should fail!")
except IllegalCaseId:
pass
def _create_closed_case(cls):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
case_id=case_id,
case_type=cls.case_type,
date_opened=cls.closed_case_date_opened,
date_modified=cls.closed_case_date_closed,
case_name=cls.case_name,
close=True,
)
post_case_blocks([caseblock.as_xml()], domain=cls.domain)
return case_id
def _create_closed_case(cls):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
case_id=case_id,
case_type=cls.case_type,
date_opened=cls.closed_case_date_opened,
date_modified=cls.closed_case_date_closed,
case_name=cls.case_name,
close=True,
)
post_case_blocks([caseblock.as_xml()], domain=cls.domain)
return case_id
def pull_child_entities(settings, dhis2_children):
"""
Create new child cases for nutrition tracking in CommCare.
Sets external_id on new child cases, and CCHQ Case ID on DHIS2
tracked entity instances. (CCHQ Case ID is initially unset because the
case is new and does not exist in CommCare.)
:param settings: DHIS2 settings, incl. relevant domain
:param dhis2_children: A list of dictionaries of Child tracked entities
from the DHIS2 API where CCHQ Case ID is unset
This fulfills the third requirement of `DHIS2 Integration`_.
.. _DHIS2 Integration: https://www.dropbox.com/s/8djk1vh797t6cmt/WV Sri Lanka Detailed Requirements.docx
"""
dhis2_api = Dhis2Api(settings.dhis2.host, settings.dhis2.username, settings.dhis2.password,
settings.dhis2.top_org_unit_name)
for dhis2_child in dhis2_children:
# Add each child separately. Although this is slower, it avoids problems if a DHIS2 API call fails
# ("Instance" is DHIS2's friendly name for "id")
case = get_case_by_external_id(settings.domain, dhis2_child['Instance'])
if case:
case_id = case['case_id']
else:
user = get_user_by_org_unit(settings.domain, dhis2_child['Org unit'], settings.dhis2.top_org_unit_name)
if not user:
# No user is assigned to this organisation unit (i.e. region or facility). Now what?
# TODO: Now what? Ascend to parent org unit?
continue
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
create=True,
case_id=case_id,
owner_id=user.userID,
user_id=user.userID,
version=V2,
case_type='child_gmp', # TODO: Move to a constant / setting
external_id=dhis2_child['Instance'],
update={
'name': dhis2_child['Name'],
'height': dhis2_child['Height'],
'weight': dhis2_child['Weight'],
'age': dhis2_child['Age at time of visit'],
'bmi': dhis2_child['Body-mass index'],
}
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, settings.domain)
dhis2_child['CCHQ Case ID'] = case_id
dhis2_api.update_te_inst(dhis2_child)
def testUserRestoreWithCase(self):
restore_user = create_restore_user(domain=self.domain)
expected_case_block = CaseBlock(
create=True,
case_id='my-case-id',
user_id=restore_user.user_id,
owner_id=restore_user.user_id,
case_type='test-case-type',
update={'external_id': 'someexternal'},
)
_, [case] = post_case_blocks([expected_case_block.as_xml()], {'domain': self.domain})
assert_user_has_case(self, restore_user, case.case_id)
def setUpClass(cls):
super(TestFormProcessorCouch, cls).setUpClass()
cls.case_id = uuid.uuid4().hex
case = CaseBlock(
create=True,
case_id=cls.case_id,
user_id='user1',
owner_id='user1',
case_type='demo',
case_name='wrap?'
)
cls.domain = uuid.uuid4().hex
cls.case = post_case_blocks([case.as_xml()], domain=cls.domain)[1][0]
def testUserRestoreWithCase(self):
restore_user = create_restore_user(domain=self.domain)
expected_case_block = CaseBlock(
create=True,
case_id='my-case-id',
user_id=restore_user.user_id,
owner_id=restore_user.user_id,
case_type='test-case-type',
update={'external_id': 'someexternal'},
)
_, [case] = post_case_blocks([expected_case_block.as_xml()],
{'domain': self.domain})
assert_user_has_case(self, restore_user, case.case_id)
def sync_user_cases(commcare_user):
domain = commcare_user.project
if not (domain and domain.call_center_config.enabled):
return
# language or phone_number can be null and will break
# case submission
fields = {
'name': commcare_user.name or commcare_user.raw_username,
'email': commcare_user.email,
'language': commcare_user.language or '',
'phone_number': commcare_user.phone_number or ''
}
# fields comes second to prevent custom user data overriding
fields = dict(commcare_user.user_data, **fields)
found = False
try:
case = get_case_by_domain_hq_user_id(domain.name, commcare_user._id, include_docs=True)
found = bool(case)
except MultipleResultsFound:
return
close = commcare_user.to_be_deleted() or not commcare_user.is_active
owner_id = domain.call_center_config.case_owner_id
if found:
caseblock = CaseBlock(
create=False,
case_id=case._id,
version=V2,
owner_id=owner_id,
case_type=domain.call_center_config.case_type,
close=close,
update=fields
)
else:
fields['hq_user_id'] = commcare_user._id
caseblock = CaseBlock(
create=True,
case_id=uuid.uuid4().hex,
owner_id=owner_id,
user_id=owner_id,
version=V2,
case_type=domain.call_center_config.case_type,
update=fields
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain.name)
def _create_case(cls, parent_id):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
case_id=case_id,
case_type=cls.case_type,
date_opened=cls.case_date_opened,
case_name=cls.case_name,
update=cls._get_case_property_values(),
index={
'parent': (cls.case_type, parent_id)
}
)
post_case_blocks([caseblock.as_xml()], domain=cls.domain)
return case_id
def test_archie_modified_on(self):
case_id = uuid.uuid4().hex
now = datetime.utcnow().replace(microsecond=0)
earlier = now - timedelta(hours=1)
way_earlier = now - timedelta(days=1)
# make sure we timestamp everything so they have the right order
create_block = CaseBlock(case_id, create=True, date_modified=way_earlier)
post_case_blocks(
[create_block.as_xml()], form_extras={'received_on': way_earlier}
)
update_block = CaseBlock(case_id, update={'foo': 'bar'}, date_modified=earlier)
post_case_blocks(
[update_block.as_xml()], form_extras={'received_on': earlier}
)
case_accessors = CaseAccessors(REBUILD_TEST_DOMAIN)
case = case_accessors.get_case(case_id)
self.assertEqual(earlier, case.modified_on)
second_form = FormAccessors(REBUILD_TEST_DOMAIN).get_form(case.xform_ids[-1])
second_form.archive()
case = case_accessors.get_case(case_id)
self.assertEqual(way_earlier, case.modified_on)
def testBadIndexReferenceDomain(self):
case_in_other_domain = 'text-index-mother-case'
parent_domain = 'parent'
child_domain = 'child'
post_case_blocks([
CaseBlock(create=True, case_id=case_in_other_domain, user_id=USER_ID,
version=V2).as_xml()
], form_extras={'domain': parent_domain})
block = CaseBlock(create=True, case_id='child-case-id', user_id=USER_ID, version=V2,
index={'bad': ('bad-case', case_in_other_domain)})
with self.assertRaisesRegexp(IllegalCaseId, 'Bad case id'):
post_case_blocks([block.as_xml()], form_extras={'domain': child_domain})
def test_long_value_validation(self):
case_id = uuid.uuid4().hex
case = CaseBlock(
create=True,
case_id=case_id,
user_id='user1',
owner_id='user1',
case_type='demo',
case_name='this is a very long case name that exceeds the 255 char limit' * 5
)
xform, cases = post_case_blocks([case.as_xml()], domain=DOMAIN)
self.assertEqual(0, len(cases))
self.assertTrue(xform.is_error)
self.assertIn('CaseValueError', xform.problem)
def update_supply_point_product_stock_level(spp, current_stock):
caseblock = CaseBlock(
case_id=spp._id,
create=False,
version=V2,
user_id=spp.user_id,
owner_id=spp.owner_id,
case_type=const.SUPPLY_POINT_PRODUCT_CASE_TYPE,
update={
"current_stock": current_stock
},
)
username = const.COMMTRACK_USERNAME
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, spp.domain, username, spp.user_id,
xmlns=const.COMMTRACK_SUPPLY_POINT_PRODUCT_XMLNS)
def test_dont_rebuild(self, rebuild_case):
""" Don't rebuild cases that are owned by other users """
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
create=True,
case_id=case_id,
owner_id=self.commcare_user._id,
user_id=self.commcare_user._id,
)
casexml = ElementTree.tostring(caseblock.as_xml(), encoding='utf-8').decode('utf-8')
submit_case_blocks(casexml, self.domain, user_id=self.commcare_user._id)
self.other_user.retire(self.domain, deleted_by=None)
self.assertEqual(rebuild_case.call_count, 0)
def test_dont_rebuild(self, rebuild_case):
""" Don't rebuild cases that are owned by other users """
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
create=True,
case_id=case_id,
owner_id=self.commcare_user._id,
user_id=self.commcare_user._id,
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, self.domain, user_id=self.commcare_user._id)
self.other_user.retire()
self.assertEqual(rebuild_case.call_count, 0)
def _create_tech_issue_delegate_for_escalation(tech_issue, owner_id):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
case_id,
case_type='tech_issue_delegate',
create=True,
update={'change_in_level': '1'},
user_id=SYSTEM_USER_ID,
owner_id=owner_id,
case_name=tech_issue.name,
index={'parent': (tech_issue.type, tech_issue.case_id, 'child')},
)
return submit_case_blocks(
ElementTree.tostring(caseblock.as_xml()),
tech_issue.domain,
user_id=SYSTEM_USER_ID,
xmlns=AUTO_UPDATE_XMLNS,
)
def test_rebuild_cases_with_new_owner(self, rebuild_case):
"""
If cases have a different owner to the person who submitted it
rebuild it when the submitter is retired.
"""
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
create=True,
case_id=case_id,
owner_id=self.commcare_user._id,
user_id=self.commcare_user._id,
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, self.domain, user_id=self.other_user._id)
self.other_user.retire()
rebuild_case.assert_called_once_with(case_id)
def test_rebuild_cases_with_new_owner(self, rebuild_case):
"""
If cases have a different owner to the person who submitted it
rebuild it when the submitter is retired.
"""
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
create=True,
case_id=case_id,
owner_id=self.commcare_user._id,
user_id=self.commcare_user._id,
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, self.domain, user_id=self.other_user._id)
self.other_user.retire()
rebuild_case.assert_called_once_with(case_id)
def testBadIndexReferenceDomain(self):
case_in_other_domain = self.MOTHER_CASE_ID
parent_domain = 'parent'
child_domain = 'child'
post_case_blocks([
CaseBlock(create=True, case_id=case_in_other_domain, user_id=self.user.user_id).as_xml()
], form_extras={'domain': parent_domain})
block = CaseBlock(create=True, case_id='child-case-id', user_id=self.user.user_id,
index={'bad': ('bad-case', case_in_other_domain)})
xform, _ = post_case_blocks([block.as_xml()],
form_extras={'domain': child_domain})
self.assertTrue(xform.is_error)
self.assertEqual(xform.doc_type, 'XFormError')
self.assertIn('IllegalCaseId', xform.problem)
self.assertIn('Bad case id', xform.problem)
def _create_tech_issue_delegate_for_escalation(tech_issue, owner_id):
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
case_id,
case_type='tech_issue_delegate',
create=True,
update={'change_in_level': '1'},
user_id=SYSTEM_USER_ID,
owner_id=owner_id,
case_name=tech_issue.name,
index={'parent': (tech_issue.type, tech_issue.case_id, 'child')},
)
return submit_case_blocks(
ElementTree.tostring(caseblock.as_xml()).decode('utf-8'),
tech_issue.domain,
user_id=SYSTEM_USER_ID,
xmlns=AUTO_UPDATE_XMLNS,
device_id=__name__ + "._create_tech_issue_delegate_for_escalation",
)
def create_case(cls,
case_type,
parent_case_id=None,
parent_case_type=None,
parent_identifier=None,
parent_relationship=None):
kwargs = {}
if parent_case_id:
kwargs['index'] = {
parent_identifier:
(parent_case_type, parent_case_id, parent_relationship)
}
caseblock = CaseBlock(uuid.uuid4().hex,
case_type=case_type,
create=True,
**kwargs)
return submit_case_blocks(ElementTree.tostring(caseblock.as_xml()),
cls.domain)[1][0]
def to_xml(self):
extras = {}
if self.owner_id:
extras['owner_id'] = self.owner_id
if self.create:
extras['case_name'] = self.product_stock_case.name
extras['index'] = {
const.PARENT_CASE_REF: (const.SUPPLY_POINT_PRODUCT_CASE_TYPE,
self.product_stock_case._id),
}
caseblock = CaseBlock(case_id=self.id,
create=self.create,
version=V2,
user_id=self.user_id,
case_type=const.REQUISITION_CASE_TYPE,
update=copy(self.custom_fields),
close=self.close,
**extras)
return ElementTree.tostring(
caseblock.as_xml(format_datetime=json_format_datetime))
def test_rebuild_cases_with_new_owner(self, rebuild_case):
"""
If cases have a different owner to the person who submitted it
rebuild it when the submitter is retired.
"""
case_id = uuid.uuid4().hex
caseblock = CaseBlock(
create=True,
case_id=case_id,
owner_id=self.commcare_user._id,
user_id=self.commcare_user._id,
)
casexml = ElementTree.tostring(caseblock.as_xml(), encoding='utf-8').decode('utf-8')
submit_case_blocks(casexml, self.domain, user_id=self.other_user._id)
self.other_user.retire(self.domain, deleted_by=None)
detail = UserArchivedRebuild(user_id=self.other_user.user_id)
rebuild_case.assert_called_once_with(self.domain, case_id, detail)
def _post_util(create=False, case_id=None, user_id=None, owner_id=None,
case_type=None, form_extras=None, close=False, date_modified=None,
**kwargs):
form_extras = form_extras or {}
form_extras['domain'] = REBUILD_TEST_DOMAIN
uid = lambda: uuid.uuid4().hex
case_id = case_id or uid()
block = CaseBlock(create=create,
case_id=case_id,
user_id=user_id or uid(),
owner_id=owner_id or uid(),
case_type=case_type or 'test',
date_modified=date_modified,
update=kwargs,
close=close)
block = block.as_xml()
post_case_blocks([block], form_extras)
return case_id
def to_xml(self):
extras = {}
if self.owner_id:
extras['owner_id'] = self.owner_id
if self.create:
extras['case_name'] = self.product_stock_case.name
extras['index'] = {
const.PARENT_CASE_REF: (const.SUPPLY_POINT_PRODUCT_CASE_TYPE,
self.product_stock_case._id),
}
caseblock = CaseBlock(
case_id=self.id,
create=self.create,
version=V2,
user_id=self.user_id,
case_type=const.REQUISITION_CASE_TYPE,
update = copy(self.custom_fields),
close=self.close,
**extras
)
return ElementTree.tostring(caseblock.as_xml(format_datetime=json_format_datetime))
def reassign_household_case(domain, household_case_id, old_owner_id, new_owner_id, supervisor_id,
deprecation_time=None):
if deprecation_time is None:
deprecation_time = datetime.utcnow()
case_ids = get_household_and_child_case_ids_by_owner(domain, household_case_id, old_owner_id)
case_ids.add(household_case_id)
case_blocks = []
for case_id in case_ids:
updates = {
'location_reassignment_last_owner_id': old_owner_id,
'location_reassignment_datetime': deprecation_time
}
if supervisor_id:
updates['location_reassignment_last_supervisor_id'] = supervisor_id
case_block = CaseBlock(case_id,
update=updates,
owner_id=new_owner_id,
user_id=SYSTEM_USER_ID)
case_block = ElementTree.tostring(case_block.as_xml()).decode('utf-8')
case_blocks.append(case_block)
if case_blocks:
submit_case_blocks(case_blocks, domain, user_id=SYSTEM_USER_ID)
def testBadIndexReferenceDomain(self):
case_in_other_domain = 'text-index-mother-case'
parent_domain = 'parent'
child_domain = 'child'
post_case_blocks([
CaseBlock(create=True,
case_id=case_in_other_domain,
user_id=USER_ID,
version=V2).as_xml()
],
form_extras={'domain': parent_domain})
block = CaseBlock(create=True,
case_id='child-case-id',
user_id=USER_ID,
version=V2,
index={'bad': ('bad-case', case_in_other_domain)})
with self.assertRaisesRegexp(IllegalCaseId, 'Bad case id'):
post_case_blocks([block.as_xml()],
form_extras={'domain': child_domain})
def submit_mapping_case_block(user, index):
mapping = user.get_location_map_case()
if mapping:
caseblock = CaseBlock(
create=False,
case_id=mapping._id,
version=V2,
index=index
)
else:
caseblock = CaseBlock(
create=True,
case_type=const.USER_LOCATION_OWNER_MAP_TYPE,
case_id=location_map_case_id(user),
version=V2,
owner_id=user._id,
index=index
)
submit_case_blocks(
ElementTree.tostring(caseblock.as_xml()),
user.domain,
)
def test_default_relationship(self):
parent_case_id = uuid.uuid4().hex
post_case_blocks([
CaseBlock(create=True,
case_id=parent_case_id,
user_id=self.user.user_id).as_xml()
],
domain=self.project.name)
create_index = CaseBlock(
create=True,
case_id=self.CASE_ID,
user_id=self.user.user_id,
owner_id=self.user.user_id,
)
# set outside constructor to skip validation
create_index.index = {
'parent':
IndexAttrs(case_type='parent',
case_id=parent_case_id,
relationship='')
}
form, cases = post_case_blocks([create_index.as_xml()],
domain=self.project.name)
self.assertEqual(cases[0].indices[0].relationship, 'child')
