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)