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 setUp(self):
super(CallCenterCaseSharingTest, self).setUp()
self.domain = create_domain(self.domain_name)
self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***')
self.domain.call_center_config.enabled = True
self.domain.call_center_config.case_owner_id = self.supervisor.get_id
self.domain.call_center_config.case_type = 'cc_flw'
self.domain.save()
self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***')
sync_call_center_user_case(self.user)
self.group = Group(
domain=self.domain_name,
name='case sharing group',
case_sharing=True,
users=[self.user.user_id]
)
self.group.save()
load_data(
self.domain_name,
self.user.user_id,
'not this user',
self.group.get_id,
case_opened_by=self.user.user_id,
case_closed_by=self.user.user_id)
# create one case of each type so that we get the indicators where there is no data for the period
create_cases_for_types(self.domain_name, ['person', 'dog'])
def setUp(self):
super(CallCenterCaseSharingTest, self).setUp()
self.domain = create_domain(self.domain_name)
self.supervisor = CommCareUser.create(self.domain_name,
'supervisor@' + self.domain_name,
'***')
self.domain.call_center_config.enabled = True
self.domain.call_center_config.case_owner_id = self.supervisor.get_id
self.domain.call_center_config.case_type = 'cc_flw'
self.domain.save()
self.user = CommCareUser.create(self.domain_name,
'user@' + self.domain_name, '***')
sync_call_center_user_case(self.user)
self.group = Group(domain=self.domain_name,
name='case sharing group',
case_sharing=True,
users=[self.user.user_id])
self.group.save()
load_data(self.domain_name,
self.user.user_id,
'not this user',
self.group.get_id,
case_opened_by=self.user.user_id,
case_closed_by=self.user.user_id)
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 setUpClass(cls):
domain_name = 'cc_test_case_sharing'
cls.domain = create_domain(domain_name)
cls.supervisor = CommCareUser.create(domain_name,
'supervisor@' + domain_name,
'***')
cls.domain.call_center_config.enabled = True
cls.domain.call_center_config.case_owner_id = cls.supervisor.get_id
cls.domain.call_center_config.case_type = 'cc_flw'
cls.domain.save()
cls.user = CommCareUser.create(domain_name, 'user@' + domain_name,
'***')
sync_call_center_user_case(cls.user)
cls.group = Group(domain=domain_name,
name='case sharing group',
case_sharing=True,
users=[cls.user.user_id])
cls.group.save()
load_data(domain_name,
cls.user.user_id,
'not this user',
cls.group.get_id,
case_opened_by=cls.user.user_id,
case_closed_by=cls.user.user_id)
# create one case of each type so that we get the indicators where there is no data for the period
create_cases_for_types(domain_name, ['person', 'dog'])
def setUp(self):
super(CallCenterCaseSharingTest, self).setUp()
self.domain = create_domain(self.domain_name)
self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***')
self.domain.call_center_config.enabled = True
self.domain.call_center_config.case_owner_id = self.supervisor.get_id
self.domain.call_center_config.case_type = 'cc_flw'
self.domain.save()
self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***')
sync_call_center_user_case(self.user)
self.group = Group(
domain=self.domain_name,
name='case sharing group',
case_sharing=True,
users=[self.user.user_id]
)
self.group.save()
load_data(
self.domain_name,
self.user.user_id,
'not this user',
self.group.get_id,
case_opened_by=self.user.user_id,
case_closed_by=self.user.user_id)
# create one case of each type so that we get the indicators where there is no data for the period
create_cases_for_types(self.domain_name, ['person', 'dog'])
def test_sync_full_name(self):
name = 'Ricky Bowwood'
self.user.set_full_name(name)
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertIsNotNone(case)
self.assertEquals(case.name, name)
def setUpClass(cls):
domain_name = 'cc_test_case_sharing'
cls.domain = create_domain(domain_name)
cls.supervisor = CommCareUser.create(domain_name, 'supervisor@' + domain_name, '***')
cls.domain.call_center_config.enabled = True
cls.domain.call_center_config.case_owner_id = cls.supervisor.get_id
cls.domain.call_center_config.case_type = 'cc_flw'
cls.domain.save()
cls.user = CommCareUser.create(domain_name, 'user@' + domain_name, '***')
sync_call_center_user_case(cls.user)
cls.group = Group(
domain=domain_name,
name='case sharing group',
case_sharing=True,
users=[cls.user.user_id]
)
cls.group.save()
load_data(
domain_name,
cls.user.user_id,
'not this user',
cls.group.get_id,
case_opened_by=cls.user.user_id,
case_closed_by=cls.user.user_id)
# create one case of each type so that we get the indicators where there is no data for the period
create_cases_for_types(domain_name, ['person', 'dog'])
def test_sync_full_name(self):
name = 'Ricky Bowwood'
self.user.set_full_name(name)
sync_call_center_user_case(self.user)
case = self._get_user_case()
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(self):
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertIsNotNone(case)
self.assertEquals(case.name, self.user.username)
self.assertEquals(case.get_case_property('username'), self.user.raw_username)
self.assertIsNotNone(case.get_case_property('language'))
self.assertIsNotNone(case.get_case_property('phone_number'))
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_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_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_retired(self):
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertIsNotNone(case)
self.user.base_doc += DELETED_SUFFIX
sync_call_center_user_case(self.user)
case = self._get_user_case()
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 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 = self._get_user_case()
self.assertIsNotNone(case)
self.user.base_doc += DELETED_SUFFIX
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertTrue(case.closed)
def test_sync_inactive(self):
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertIsNotNone(case)
self.user.is_active = False
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertTrue(case.closed)
def test_sync_full_name(self):
other_user = CommCareUser.create(TEST_DOMAIN, 'user7', '***')
self.addCleanup(other_user.delete)
name = 'Ricky Bowwood'
other_user.set_full_name(name)
sync_call_center_user_case(other_user)
case = self._get_user_case(other_user._id)
self.assertIsNotNone(case)
self.assertEqual(case.name, name)
def test_sync(self):
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertIsNotNone(case)
self.assertEqual(case.name, self.user.username)
self.assertEqual(case.get_case_property('username'),
self.user.raw_username)
self.assertIsNotNone(case.get_case_property('language'))
self.assertIsNotNone(case.get_case_property('phone_number'))
def test_sync_inactive(self):
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertIsNotNone(case)
self.user.is_active = False
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertTrue(case.closed)
def create_domain_and_user(domain_name, username):
domain = create_domain(domain_name)
user = CommCareUser.create(domain_name, username, '***')
domain.call_center_config.enabled = True
domain.call_center_config.case_owner_id = user.user_id
domain.call_center_config.case_type = CASE_TYPE
domain.save()
sync_call_center_user_case(user)
return domain, user
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, include_docs=True)
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, include_docs=True)
self.assertEquals(case.name, name)
def create_domain_and_user(domain_name, username):
domain = create_domain(domain_name)
user = CommCareUser.create(domain_name, username, '***')
domain.call_center_config.enabled = True
domain.call_center_config.case_owner_id = user.user_id
domain.call_center_config.case_type = CASE_TYPE
domain.save()
sync_call_center_user_case(user)
return domain, user
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 = self._get_user_case()
self.assertIsNotNone(case)
self.assertEqual(case.get_case_property('blank_val'), '')
self.assertEqual(case.get_case_property('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_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 = self._get_user_case()
self.assertIsNotNone(case)
self.assertEquals(case.get_case_property('blank_val'), '')
self.assertEquals(case.get_case_property('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_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 = self._get_user_case()
self.assertEqual(case.owner_id, cases[0].owner_id)
def setUp(self):
super(CallCenterTestOpenedClosed, self).setUp()
self.domain = create_domain(self.domain_name)
self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***')
self.domain.call_center_config.enabled = True
self.domain.call_center_config.case_owner_id = self.supervisor.get_id
self.domain.call_center_config.case_type = 'cc_flw'
self.domain.save()
self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***')
sync_call_center_user_case(self.user)
load_data(self.domain_name, self.user.user_id, case_opened_by='not me', case_closed_by='not me')
# create one case of each type so that we get the indicators where there is no data for the period
create_cases_for_types(self.domain_name, ['person', 'dog'])
def setUp(self):
super(CallCenterTestOpenedClosed, self).setUp()
self.domain = create_domain(self.domain_name)
self.supervisor = CommCareUser.create(self.domain_name, 'supervisor@' + self.domain_name, '***')
self.domain.call_center_config.enabled = True
self.domain.call_center_config.case_owner_id = self.supervisor.get_id
self.domain.call_center_config.case_type = 'cc_flw'
self.domain.save()
self.user = CommCareUser.create(self.domain_name, 'user@' + self.domain_name, '***')
sync_call_center_user_case(self.user)
load_data(self.domain_name, self.user.user_id, case_opened_by='not me', case_closed_by='not me')
# create one case of each type so that we get the indicators where there is no data for the period
create_cases_for_types(self.domain_name, ['person', 'dog'])
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 = self._get_user_case()
self.assertEqual(case.owner_id, cases[0].owner_id)
def setUp(self):
super(CallCenterTestOpenedClosed, self).setUp()
self.domain = create_domain(self.domain_name)
self.supervisor = CommCareUser.create(self.domain_name,
'supervisor@' + self.domain_name,
'***')
self.domain.call_center_config.enabled = True
self.domain.call_center_config.case_owner_id = self.supervisor.get_id
self.domain.call_center_config.case_type = 'cc_flw'
self.domain.save()
self.user = CommCareUser.create(self.domain_name,
'user@' + self.domain_name, '***')
sync_call_center_user_case(self.user)
load_data(self.domain_name,
self.user.user_id,
case_opened_by='not me',
case_closed_by='not me')
def sync_user_cases_signal(sender, **kwargs):
user = kwargs["couch_user"]
sync_call_center_user_case(user)
sync_usercase(user)
def sync_user_cases_signal(sender, **kwargs):
user = kwargs["couch_user"]
sync_call_center_user_case(user)
sync_usercase(user)
def test_no_location_sync(self):
self.user.unset_location()
self.user.save()
sync_call_center_user_case(self.user)
self.assertCallCenterCaseOwner("")
def test_opened_by_id_is_system(self):
sync_call_center_user_case(self.user)
case = self._get_user_case()
self.assertEqual(case.opened_by, CALLCENTER_USER)
