def test_sync_full_name(self):
name = 'Ricky Bowwood'
self.user.set_full_name(name)
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.assertEquals(case.name, name)
def test_sync(self):
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.assertEquals(case.name, self.user.username)
self.assertEquals(case.username, self.user.raw_username)
self.assertIsNotNone(case.language)
self.assertIsNotNone(case.phone_number)
def test_sync_inactive(self):
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.user.is_active = False
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertTrue(case.closed)
def test_sync_inactive(self):
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertIsNotNone(case)
self.user.is_active = False
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertTrue(case.closed)
def test_sync_inactive(self):
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.user.is_active = False
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertTrue(case.closed)
def get_user_case_id(self, user_id):
try:
case = get_case_by_domain_hq_user_id(self.domain.name, user_id)
if case:
return case['id']
else:
# No case for this user so return a tag instead to enable removing this
# row from the results
return NO_CASE_TAG
def test_sync_full_name(self):
name = 'Ricky Bowwood'
self.user.set_full_name(name)
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
self.assertIsNotNone(case)
self.assertEquals(case.name, name)
def test_sync_custom_user_data(self):
self.user.user_data = {'': 'blank_key', 'blank_val': '', 'ok': 'good'}
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
self.assertIsNotNone(case)
self.assertEquals(case.blank_val, '')
self.assertEquals(case.ok, 'good')
def test_sync_retired(self):
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.user.base_doc += DELETED_SUFFIX
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertTrue(case.closed)
def test_sync_retired(self):
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.user.base_doc += DELETED_SUFFIX
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertTrue(case.closed)
def test_sync_retired(self):
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertIsNotNone(case)
self.user.base_doc += DELETED_SUFFIX
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertTrue(case.closed)
def test_sync(self):
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
self.assertIsNotNone(case)
self.assertEquals(case.name, self.user.username)
self.assertEquals(case.username, self.user.raw_username)
self.assertIsNotNone(case.language)
self.assertIsNotNone(case.phone_number)
def test_sync_update_update(self):
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.assertEquals(case.name, self.user.username)
name = 'Ricky Bowwood'
self.user.set_full_name(name)
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertEquals(case.name, name)
def test_sync_update_update(self):
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertIsNotNone(case)
self.assertEquals(case.name, self.user.username)
name = 'Ricky Bowwood'
self.user.set_full_name(name)
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertEquals(case.name, name)
def test_sync_retired(self):
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
self.assertIsNotNone(case)
self.user.base_doc += DELETED_SUFFIX
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
self.assertTrue(case.closed)
def test_sync_inactive(self):
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
self.assertIsNotNone(case)
self.user.is_active = False
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
self.assertTrue(case.closed)
def test_sync_custom_user_data(self):
self.user.user_data = {
'': 'blank_key',
'blank_val': '',
'ok': 'good',
'name with spaces': 'ok',
'8starts_with_a_number': '0',
'xml_starts_with_xml': '0',
'._starts_with_punctuation': '0',
}
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.assertEquals(case.blank_val, '')
self.assertEquals(case.ok, 'good')
def test_reactivate_user(self):
"""Confirm that reactivating a user re-opens its user case."""
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertIsNotNone(user_case)
self.user.is_active = False
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertTrue(user_case.closed)
self.user.is_active = True
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertFalse(user_case.closed)
def test_caching(self):
user_case = get_case_by_domain_hq_user_id(self.cc_domain.name, self.cc_user._id, CASE_TYPE)
expected_indicators = {'a': 1, 'b': 2}
cached_data = CachedIndicators(
user_id=self.cc_user.get_id,
case_id=user_case.case_id,
domain=self.cc_domain.name,
indicators=expected_indicators
)
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache
)
locmem_cache.set(cache_key(self.cc_user.get_id, indicator_set.reference_date), cached_data.to_json())
self.assertEqual(
set(indicator_set.user_to_case_map.keys()),
set([self.cc_user.get_id, self.cc_user_no_data.get_id])
)
self.assertEquals(indicator_set.users_needing_data, set([self.cc_user_no_data.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.cc_user_no_data.get_id]))
self.check_cc_indicators(indicator_set.get_data(), expected_indicators)
def sync_user_case(commcare_user, case_type, owner_id, case=None):
"""
Each time a CommCareUser is saved this method gets called and creates or updates
a case associated with the user with the user's details.
This is also called to create user cases when the usercase is used for the
first time.
"""
with CriticalSection(['user_case_%s_for_%s' % (case_type, commcare_user._id)]):
domain = commcare_user.project
fields = _get_user_case_fields(commcare_user)
case = case or get_case_by_domain_hq_user_id(domain.name, commcare_user._id, case_type)
close = commcare_user.to_be_deleted() or not commcare_user.is_active
user_case_helper = _UserCaseHelper(domain, owner_id)
def case_should_be_reopened(case, user_case_should_be_closed):
return case and case.closed and not user_case_should_be_closed
if not case:
user_case_helper.create_user_case(case_type, commcare_user, fields)
else:
if case_should_be_reopened(case, close):
user_case_helper.re_open_case(case)
changed = _user_case_changed(case, case_type, close, fields, owner_id)
if changed:
user_case_helper.update_user_case(case, case_type, fields)
if close and not case.closed:
user_case_helper.close_user_case(case, case_type)
def test_caching(self):
user_case = get_case_by_domain_hq_user_id(self.cc_domain.name,
self.cc_user._id, CASE_TYPE)
expected_indicators = {'a': 1, 'b': 2}
cached_data = CachedIndicators(user_id=self.cc_user.get_id,
case_id=user_case.case_id,
domain=self.cc_domain.name,
indicators=expected_indicators)
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache)
locmem_cache.set(
cache_key(self.cc_user.get_id, indicator_set.reference_date),
cached_data.to_json())
self.assertEqual(
set(indicator_set.user_to_case_map.keys()),
set([self.cc_user.get_id, self.cc_user_no_data.get_id]))
self.assertEquals(indicator_set.users_needing_data,
set([self.cc_user_no_data.get_id]))
self.assertEqual(indicator_set.owners_needing_data,
set([self.cc_user_no_data.get_id]))
self.check_cc_indicators(indicator_set.get_data(), expected_indicators)
def test_sync(self):
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.assertEquals(case.name, self.user.username)
self.assertEquals(case.username, self.user.raw_username)
self.assertIsNotNone(case.language)
self.assertIsNotNone(case.phone_number)
def test_sync(self):
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertIsNotNone(case)
self.assertEquals(case.name, self.user.username)
self.assertEquals(case.username, self.user.raw_username)
self.assertIsNotNone(case.language)
self.assertIsNotNone(case.phone_number)
def test_update_deactivated_user(self):
"""
Confirm that updating a deactivated user also updates the user case.
"""
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertIsNotNone(user_case)
self.user.is_active = False
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertTrue(user_case.closed)
self.user.user_data = {'foo': 'bar'}
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertTrue(user_case.closed)
self.assertEquals(user_case.foo, 'bar')
def test_sync_log(self):
user_case = get_case_by_domain_hq_user_id(self.cc_domain.name, self.cc_user.get_id, include_docs=True)
indicator_set = CallCenterIndicators(
self.cc_domain, self.cc_user, custom_cache=locmem_cache, override_cases=[user_case]
)
self.assertEqual(indicator_set.user_to_case_map.keys(), [self.cc_user.get_id])
self.assertEqual(indicator_set.users_needing_data, set([self.cc_user.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.cc_user.get_id]))
self._test_indicators(self.cc_user, indicator_set.get_data(), expected_standard_indicators())
def test_sync_usercase_custom_user_data_on_create(self):
"""
Custom user data should be synced when the user is created
"""
self.user.user_data = {
'completed_training': 'yes',
}
self.user.save()
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertIsNotNone(case)
self.assertEquals(case.completed_training, 'yes')
def test_sync_custom_user_data(self):
self.user.user_data = {
'': 'blank_key',
'blank_val': '',
'ok': 'good'
}
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertIsNotNone(case)
self.assertEquals(case.blank_val, '')
self.assertEquals(case.ok, 'good')
def get_user_case_id(self, user_id):
try:
case = get_case_by_domain_hq_user_id(self.domain.name, user_id)
if case:
return case['id']
else:
# No case for this user so return a tag instead to enable removing this
# row from the results
return NO_CASE_TAG
except MultipleResultsFound:
return NO_CASE_TAG
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)
try:
case = get_case_by_domain_hq_user_id(domain.name,
commcare_user._id,
include_docs=True)
found = bool(case)
def _get_call_center_case_and_owner(user, domain):
"""
Return the appropriate owner id for the given users call center case.
"""
case = get_case_by_domain_hq_user_id(user.project.name, user._id, domain.call_center_config.case_type)
if domain.call_center_config.use_user_location_as_owner:
owner_id = call_center_location_owner(user, domain.call_center_config.user_location_ancestor_level)
elif case and case.owner_id:
owner_id = case.owner_id
else:
owner_id = domain.call_center_config.case_owner_id
return CallCenterCaseAndOwner(case, owner_id)
def test_update_and_reactivate_in_one_save(self):
"""
Confirm that a usercase can be updated and reactived in a single save of the user model
"""
"""
Confirm that updating a deactivated user also updates the user case.
"""
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertIsNotNone(user_case)
self.user.is_active = False
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertTrue(user_case.closed)
self.user.user_data = {'foo': 'bar'}
self.user.is_active = True
self.user.save()
user_case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, USERCASE_TYPE)
self.assertFalse(user_case.closed)
self.assertEquals(user_case.foo, 'bar')
def sync_user_cases(commcare_user):
from casexml.apps.case.tests.util import CaseBlock
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,
'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
if found:
caseblock = CaseBlock(
create=False,
case_id=case._id,
version=V2,
owner_id=domain.call_center_config.case_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=domain.call_center_config.case_owner_id,
user_id=commcare_user._id,
version=V2,
case_type=domain.call_center_config.case_type,
update=fields
)
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain, commcare_user.username, commcare_user._id)
def sync_user_cases(commcare_user):
domain = commcare_user.project
if not (domain and domain.call_center_config.enabled):
return
# remove any blank fields
fields = {k: v for k, v in commcare_user.user_data.items() if k}
# language or phone_number can be null and will break
# case submission
fields.update({
'name': commcare_user.name or commcare_user.raw_username,
'username': commcare_user.raw_username,
'email': commcare_user.email,
'language': commcare_user.language or '',
'phone_number': commcare_user.phone_number or ''
})
try:
case = get_case_by_domain_hq_user_id(domain.name,
commcare_user._id,
include_docs=True)
found = bool(case)
def test_sync_log(self):
user_case = get_case_by_domain_hq_user_id(self.cc_domain.name, self.cc_user.get_id, CASE_TYPE)
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache,
override_cases=[user_case]
)
self.assertEqual(indicator_set.user_to_case_map.keys(), [self.cc_user.get_id])
self.assertEqual(indicator_set.users_needing_data, set([self.cc_user.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.cc_user.get_id]))
self._test_indicators(self.cc_user, indicator_set.get_data(), expected_standard_indicators())
def test_sync_custom_user_data(self):
self.user.user_data = {
"": "blank_key",
"blank_val": "",
"ok": "good",
"name with spaces": "ok",
"8starts_with_a_number": "0",
"xml_starts_with_xml": "0",
"._starts_with_punctuation": "0",
}
sync_user_cases(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, include_docs=True)
self.assertIsNotNone(case)
self.assertEquals(case.blank_val, "")
self.assertEquals(case.ok, "good")
def test_sync_custom_user_data(self):
self.user.user_data = {
'': 'blank_key',
'blank_val': '',
'ok': 'good',
'name with spaces': 'ok',
'8starts_with_a_number': '0',
'xml_starts_with_xml': '0',
'._starts_with_punctuation': '0',
}
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertIsNotNone(case)
self.assertEquals(case.blank_val, '')
self.assertEquals(case.ok, 'good')
def test_caching(self):
user_case = get_case_by_domain_hq_user_id(self.cc_domain.name, self.cc_user._id, include_docs=True)
expected_indicators = {'a': 1, 'b': 2}
cached_data = CachedIndicators(
user_id=self.cc_user.get_id,
case_id=user_case.case_id,
domain=self.cc_domain.name,
indicators=expected_indicators
)
locmem_cache.set(cache_key(self.cc_user.get_id), cached_data.to_json())
indicator_set = CallCenterIndicators(self.cc_domain, self.cc_user, custom_cache=locmem_cache)
self.assertEqual(indicator_set.all_user_ids, set([self.cc_user.get_id, self.cc_user_no_data.get_id]))
self.assertEquals(indicator_set.users_needing_data, set([self.cc_user_no_data.get_id]))
self.assertEqual(indicator_set.owners_needing_data, set([self.cc_user_no_data.get_id]))
self.check_cc_indicators(indicator_set.get_data(), expected_indicators)
def test_call_center_not_default_case_owner(self):
"""
call center case owner should not change on sync
"""
factory = CaseFactory(domain=TEST_DOMAIN, case_defaults={
'user_id': self.user_id,
'owner_id': 'another_user',
'case_type': CASE_TYPE,
'update': {'hq_user_id': self.user_id}
})
cases = factory.create_or_update_cases([
CaseStructure(attrs={'create': True})
])
sync_call_center_user_case(self.user)
case = get_case_by_domain_hq_user_id(TEST_DOMAIN, self.user._id, CASE_TYPE)
self.assertEqual(case.owner_id, cases[0].owner_id)
def get_cloudcare_session_data(suite_gen, domain_name, form, couch_user):
from corehq.apps.hqcase.utils import get_case_by_domain_hq_user_id
datums = suite_gen.get_new_case_id_datums_meta(form)
session_data = {datum['datum'].id: uuid.uuid4().hex for datum in datums}
if couch_user.doc_type == 'CommCareUser': # smsforms.app.start_session could pass a CommCareCase
try:
extra_datums = suite_gen.get_extra_case_id_datums(form)
except SuiteError as err:
_assert = soft_assert(['nhooper_at_dimagi_dot_com'.replace('_at_', '@').replace('_dot_', '.')])
_assert(False, 'Domain "%s": %s' % (domain_name, err))
else:
if suite_gen.any_usercase_datums(extra_datums):
usercase = get_case_by_domain_hq_user_id(domain_name, couch_user.get_id, USERCASE_TYPE)
if usercase:
session_data[USERCASE_ID] = usercase.get_id
return session_data
def _test_indicators(self, user, data_set, expected):
user_case = get_case_by_domain_hq_user_id(user.domain, user.user_id, CASE_TYPE)
case_id = user_case.case_id
self.assertIn(case_id, data_set)
user_data = data_set[case_id]
mismatches = []
for k, v in expected.items():
expected_value = user_data.pop(k, None)
if expected_value != v:
mismatches.append('{}: {} != {}'.format(k, v, expected_value))
if mismatches:
self.fail('Mismatching indicators:\n{}'.format('\t\n'.join(mismatches)))
if user_data:
self.fail('Additional indicators:\n{}'.format('\t\n'.join(user_data.keys())))
def get_cloudcare_session_data(domain_name, form, couch_user):
from corehq.apps.hqcase.utils import get_case_by_domain_hq_user_id
from corehq.apps.app_manager.suite_xml import SuiteGenerator
datums = SuiteGenerator.get_new_case_id_datums_meta(form)
session_data = {datum['datum'].id: uuid.uuid4().hex for datum in datums}
if couch_user.doc_type == 'CommCareUser': # smsforms.app.start_session could pass a CommCareCase
try:
extra_datums = SuiteGenerator.get_extra_case_id_datums(form)
except SuiteError as err:
_assert = soft_assert(['nhooper_at_dimagi_dot_com'.replace('_at_', '@').replace('_dot_', '.')])
_assert(False, 'Domain "%s": %s' % (domain_name, err))
else:
if SuiteGenerator.any_usercase_datums(extra_datums):
usercase = get_case_by_domain_hq_user_id(domain_name, couch_user.get_id, USERCASE_TYPE)
if usercase:
session_data[USERCASE_ID] = usercase.get_id
return session_data
def test_sync_log(self):
user_case = get_case_by_domain_hq_user_id(self.cc_domain.name,
self.cc_user.get_id,
CASE_TYPE)
indicator_set = CallCenterIndicators(
self.cc_domain.name,
self.cc_domain.default_timezone,
self.cc_domain.call_center_config.case_type,
self.cc_user,
custom_cache=locmem_cache,
override_cases=[user_case])
self.assertEqual(indicator_set.user_to_case_map.keys(),
[self.cc_user.get_id])
self.assertEqual(indicator_set.users_needing_data,
set([self.cc_user.get_id]))
self.assertEqual(indicator_set.owners_needing_data,
set([self.cc_user.get_id]))
self._test_indicators(self.cc_user, indicator_set.get_data(),
expected_standard_indicators())
def _test_indicators(self, user, data_set, expected):
user_case = get_case_by_domain_hq_user_id(user.domain, user.user_id,
CASE_TYPE)
case_id = user_case.case_id
self.assertIn(case_id, data_set)
user_data = data_set[case_id]
mismatches = []
for k, v in expected.items():
expected_value = user_data.pop(k, None)
if expected_value != v:
mismatches.append('{}: {} != {}'.format(k, v, expected_value))
if mismatches:
self.fail('Mismatching indicators:\n{}'.format(
'\t\n'.join(mismatches)))
if user_data:
self.fail('Additional indicators:\n{}'.format('\t\n'.join(
user_data.keys())))
class CallCenterUtilsTests(TestCase):
@classmethod
def setUpClass(cls):
cls.domain = create_domain(TEST_DOMAIN)
user = CommCareUser.create(TEST_DOMAIN, 'user1', '***')
cls.user_id = user.user_id
cls.domain.call_center_config.enabled = True
cls.domain.call_center_config.case_owner_id = user.user_id
cls.domain.call_center_config.case_type = 'cc_flw'
cls.domain.save()
@classmethod
def tearDownClass(cls):
cls.domain.delete()
def setUp(self):
self.user = CommCareUser.get(self.user_id)
def tearDown(self):
case = get_case_by_domain_hq_user_id(TEST_DOMAIN,
self.user._id,
include_docs=True)
case.delete()
def callcenter_test(request):
user_id = request.GET.get("user_id")
date_param = request.GET.get("date")
enable_caching = request.GET.get('cache')
doc_id = request.GET.get('doc_id')
if not user_id and not doc_id:
return render(request, "hqadmin/callcenter_test.html", {"enable_caching": enable_caching})
error = None
user = None
user_case = None
domain = None
if user_id:
try:
user = CommCareUser.get(user_id)
domain = user.project
except ResourceNotFound:
error = "User Not Found"
elif doc_id:
try:
doc = CommCareUser.get_db().get(doc_id)
domain = Domain.get_by_name(doc['domain'])
doc_type = doc.get('doc_type', None)
if doc_type == 'CommCareUser':
case_type = domain.call_center_config.case_type
user_case = get_case_by_domain_hq_user_id(doc['domain'], doc['_id'], case_type)
elif doc_type == 'CommCareCase':
if doc.get('hq_user_id'):
user_case = CommCareCase.wrap(doc)
else:
error = 'Case ID does does not refer to a Call Center Case'
except ResourceNotFound:
error = "User Not Found"
try:
query_date = dateutil.parser.parse(date_param)
except ValueError:
error = "Unable to parse date, using today"
query_date = date.today()
def view_data(case_id, indicators):
new_dict = SortedDict()
key_list = sorted(indicators.keys())
for key in key_list:
new_dict[key] = indicators[key]
return {
'indicators': new_dict,
'case': CommCareCase.get(case_id),
}
if user or user_case:
custom_cache = None if enable_caching else cache.caches['dummy']
cci = CallCenterIndicators(
domain.name,
domain.default_timezone,
domain.call_center_config.case_type,
user,
custom_cache=custom_cache,
override_date=query_date,
override_cases=[user_case] if user_case else None
)
data = {case_id: view_data(case_id, values) for case_id, values in cci.get_data().items()}
else:
data = {}
context = {
"error": error,
"mobile_user": user,
"date": json_format_date(query_date),
"enable_caching": enable_caching,
"data": data,
"doc_id": doc_id
}
return render(request, "hqadmin/callcenter_test.html", context)
def get_case_by_domain_hq_user_id(domain, user_id, case_type):
return get_case_by_domain_hq_user_id(domain, user_id, case_type)
def sync_user_case(commcare_user, case_type, owner_id, copy_user_data=True):
"""
Each time a CommCareUser is saved this method gets called and creates or updates
a case associated with the user with the user's details.
This is also called to create user cases when the usercase is used for the
first time.
"""
with CriticalSection(['user_case_%s_for_%s' % (case_type, commcare_user._id)]):
domain = commcare_user.project
def valid_element_name(name):
try:
ElementTree.fromstring('<{}/>'.format(name))
return True
except ElementTree.ParseError:
return False
# remove any keys that aren't valid XML element names
fields = {k: v for k, v in commcare_user.user_data.items() if valid_element_name(k)} if copy_user_data else {}
# language or phone_number can be null and will break
# case submission
fields.update({
'name': commcare_user.name or commcare_user.raw_username,
'username': commcare_user.raw_username,
'email': commcare_user.email,
'language': commcare_user.language or '',
'phone_number': commcare_user.phone_number or ''
})
case = get_case_by_domain_hq_user_id(domain.name, commcare_user._id, case_type)
close = commcare_user.to_be_deleted() or not commcare_user.is_active
caseblock = None
if case:
props = dict(case.dynamic_case_properties())
changed = close != case.closed
changed = changed or case.type != case_type
changed = changed or case.name != fields['name']
if not changed:
for field, value in fields.items():
if field != 'name' and props.get(field) != value:
changed = True
break
if changed:
caseblock = CaseBlock(
create=False,
case_id=case._id,
version=V2,
case_type=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=case_type,
update=fields
)
if caseblock:
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain.name)
def sync_user_case(commcare_user, case_type, owner_id, copy_user_data=True):
"""
Each time a CommCareUser is saved this method gets called and creates or updates
a case associated with the user with the user's details.
This is also called to create user cases when the usercase is used for the
first time.
"""
with CriticalSection(
['user_case_%s_for_%s' % (case_type, commcare_user._id)]):
domain = commcare_user.project
def valid_element_name(name):
try:
ElementTree.fromstring('<{}/>'.format(name))
return True
except ElementTree.ParseError:
return False
# remove any keys that aren't valid XML element names
fields = {
k: v
for k, v in commcare_user.user_data.items()
if valid_element_name(k)
} if copy_user_data else {}
# language or phone_number can be null and will break
# case submission
fields.update({
'name': commcare_user.name or commcare_user.raw_username,
'username': commcare_user.raw_username,
'email': commcare_user.email,
'language': commcare_user.language or '',
'phone_number': commcare_user.phone_number or ''
})
case = get_case_by_domain_hq_user_id(domain.name, commcare_user._id,
case_type)
close = commcare_user.to_be_deleted() or not commcare_user.is_active
caseblock = None
if case:
props = dict(case.dynamic_case_properties())
changed = close != case.closed
changed = changed or case.type != case_type
changed = changed or case.name != fields['name']
if not changed:
for field, value in fields.items():
if field != 'name' and props.get(field) != value:
changed = True
break
if changed:
caseblock = CaseBlock(create=False,
case_id=case._id,
version=V2,
case_type=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=case_type,
update=fields)
if caseblock:
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain.name)
def test_get_usercase(self):
usercase = get_case_by_domain_hq_user_id(self.domain.name,
self.user._id, USERCASE_TYPE)
self.assertIsNotNone(usercase)
self.assertEqual(usercase.name, 'bar')
def sync_user_cases(commcare_user):
"""
Each time a CommCareUser is saved this method gets called and creates or updates
a case associated with the user with the user's details.
"""
domain = commcare_user.project
if not (domain and domain.call_center_config.enabled):
return
def valid_element_name(name):
try:
ElementTree.fromstring('<{}/>'.format(name))
return True
except ElementTree.ParseError:
return False
# remove any keys that aren't valid XML element names
fields = {k: v for k, v in commcare_user.user_data.items() if valid_element_name(k)}
# language or phone_number can be null and will break
# case submission
fields.update({
'name': commcare_user.name or commcare_user.raw_username,
'username': commcare_user.raw_username,
'email': commcare_user.email,
'language': commcare_user.language or '',
'phone_number': commcare_user.phone_number or ''
})
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
caseblock = None
if found:
props = dict(case.dynamic_case_properties())
changed = close != case.closed
changed = changed or case.type != domain.call_center_config.case_type
changed = changed or case.name != fields['name']
if not changed:
for field, value in fields.items():
if field != 'name' and props.get(field) != value:
changed = True
break
if changed:
caseblock = CaseBlock(
create=False,
case_id=case._id,
version=V2,
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
)
if caseblock:
casexml = ElementTree.tostring(caseblock.as_xml())
submit_case_blocks(casexml, domain.name)
def get_case_by_domain_hq_user_id(domain, user_id, case_type):
return get_case_by_domain_hq_user_id(domain, user_id, case_type)
def callcenter_test(request):
user_id = request.GET.get("user_id")
date_param = request.GET.get("date")
enable_caching = request.GET.get('cache')
doc_id = request.GET.get('doc_id')
if not user_id and not doc_id:
return render(request, "hqadmin/callcenter_test.html", {"enable_caching": enable_caching})
error = None
user = None
user_case = None
domain = None
if user_id:
try:
user = CommCareUser.get(user_id)
domain = user.project
except ResourceNotFound:
error = "User Not Found"
elif doc_id:
try:
doc = CommCareUser.get_db().get(doc_id)
domain = Domain.get_by_name(doc['domain'])
doc_type = doc.get('doc_type', None)
if doc_type == 'CommCareUser':
case_type = domain.call_center_config.case_type
user_case = get_case_by_domain_hq_user_id(doc['domain'], doc['_id'], case_type)
elif doc_type == 'CommCareCase':
if doc.get('hq_user_id'):
user_case = CommCareCase.wrap(doc)
else:
error = 'Case ID does does not refer to a Call Center Case'
except ResourceNotFound:
error = "User Not Found"
try:
query_date = dateutil.parser.parse(date_param)
except ValueError:
error = "Unable to parse date, using today"
query_date = date.today()
def view_data(case_id, indicators):
new_dict = SortedDict()
key_list = sorted(indicators.keys())
for key in key_list:
new_dict[key] = indicators[key]
return {
'indicators': new_dict,
'case': CommCareCase.get(case_id),
}
if user or user_case:
custom_cache = None if enable_caching else cache.get_cache('django.core.cache.backends.dummy.DummyCache')
cci = CallCenterIndicators(
domain.name,
domain.default_timezone,
domain.call_center_config.case_type,
user,
custom_cache=custom_cache,
override_date=query_date,
override_cases=[user_case] if user_case else None
)
data = {case_id: view_data(case_id, values) for case_id, values in cci.get_data().items()}
else:
data = {}
context = {
"error": error,
"mobile_user": user,
"date": json_format_date(query_date),
"enable_caching": enable_caching,
"data": data,
"doc_id": doc_id
}
return render(request, "hqadmin/callcenter_test.html", context)
