def setUpClass(cls):
cls.active_user = CommCareUser.create(domain=DOMAIN, username='******', password='******')
cls.inactive_user = CommCareUser.create(domain=DOMAIN, username='******', password='******')
cls.inactive_user.is_active = False
cls.inactive_user.save()
cls.deleted_user = CommCareUser.create(domain=DOMAIN, username='******', password='******')
cls.deleted_user.retire()
def testGetUsers(self):
domain = 'group-test'
active_user = CommCareUser.create(domain=domain, username='******', password='******')
inactive_user = CommCareUser.create(domain=domain, username='******', password='******')
inactive_user.is_active = False
inactive_user.save()
deleted_user = CommCareUser.create(domain=domain, username='******', password='******')
deleted_user.retire()
group = Group(domain=domain, name='group',
users=[active_user._id, inactive_user._id, deleted_user._id])
group.save()
def _check_active_users(userlist):
self.assertEqual(len(userlist), 1)
self.assertEqual(active_user._id, userlist[0])
# try all the flavors of this
_check_active_users([u._id for u in group.get_users()])
_check_active_users(group.get_user_ids())
_check_active_users([u._id for u in group.get_static_users()])
_check_active_users(group.get_static_user_ids())
def _check_all_users(userlist):
self.assertEqual(len(userlist), 2)
self.assertTrue(active_user._id in userlist)
self.assertTrue(inactive_user._id in userlist)
self.assertFalse(deleted_user._id in userlist)
_check_all_users([u._id for u in group.get_users(is_active=False)])
_check_all_users(group.get_user_ids(is_active=False))
_check_all_users([u._id for u in group.get_static_users(is_active=False)])
_check_all_users(group.get_static_user_ids(is_active=False))
def test_sync_log(self):
from casexml.apps.phone.models import SyncLog, SimplifiedSyncLog
from corehq.apps.users.models import WebUser, CommCareUser
from casexml.apps.phone.models import get_sync_log_class_by_format
web_user = WebUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
mobile_user = CommCareUser.create(
self.domain_name, 'mobile_user1', 'secret'
)
other_user = CommCareUser.create(
'other_domain', 'mobile_user2', 'secret'
)
self.addCleanup(other_user.delete)
l1 = SyncLog(user_id=web_user._id)
l1.save()
l2 = SimplifiedSyncLog(user_id=mobile_user._id)
l2.save()
other_log = SyncLog(user_id=other_user._id)
other_log.save()
def _synclog_to_class(doc):
if doc['doc_type'] == 'SyncLog':
return get_sync_log_class_by_format(doc.get('log_format'))
expected_docs = [web_user, mobile_user, l1, l2]
not_expected_docs = [other_user, other_log]
self._dump_and_load(expected_docs, not_expected_docs, doc_to_doc_class=_synclog_to_class)
def setUpClass(cls):
super(GetRestoreUserTest, cls).setUpClass()
cls.project = Domain(name=cls.domain)
cls.project.save()
cls.other_project = Domain(name=cls.other_domain)
cls.other_project.save()
cls.web_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.commcare_user = CommCareUser.create(
username=format_username('jane', cls.domain),
domain=cls.domain,
password='******',
)
cls.other_commcare_user = CommCareUser.create(
username=format_username('john', cls.domain),
domain=cls.domain,
password='******',
)
cls.super_user = WebUser.create(
username='******',
domain=cls.other_domain,
password='******',
)
cls.super_user.is_superuser = True
cls.super_user.save()
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_user_cases(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)
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 testGroupFilters(self):
domain = "case-export-test"
active_user = CommCareUser.create(domain=domain, username="******", password="******")
inactive_user = CommCareUser.create(domain=domain, username="******", password="******")
inactive_user.is_active = False
inactive_user.save()
group = Group(domain=domain, name="group", users=[active_user._id, inactive_user._id])
group.save()
# no matter what the group should match on ownerid (but not user id)
self.assertTrue(case_group_filter(_mock_case(group._id, "nobody"), group))
self.assertTrue(case_group_filter(_mock_case(group._id, active_user._id), group))
self.assertTrue(case_group_filter(_mock_case(group._id, inactive_user._id), group))
self.assertFalse(case_group_filter(_mock_case("nobody", group._id), group))
# test active users count
self.assertTrue(case_group_filter(_mock_case(active_user._id, "nobody"), group))
self.assertTrue(case_group_filter(_mock_case("nobody", active_user._id), group))
self.assertTrue(case_group_filter(_mock_case(active_user._id, active_user._id), group))
# test inactive users don't count
self.assertFalse(case_group_filter(_mock_case(inactive_user._id, "nobody"), group))
self.assertFalse(case_group_filter(_mock_case("nobody", inactive_user._id), group))
self.assertFalse(case_group_filter(_mock_case(inactive_user._id, inactive_user._id), group))
# combinations of active and inactive should count
self.assertTrue(case_group_filter(_mock_case(active_user._id, inactive_user._id), group))
self.assertTrue(case_group_filter(_mock_case(inactive_user._id, active_user._id), group))
# duh
self.assertFalse(case_group_filter(_mock_case("nobody", "nobody-else"), group))
def test_users(self):
from corehq.apps.users.models import CommCareUser
from corehq.apps.users.models import WebUser
from django.contrib.auth.models import User
expected_object_counts = Counter({User: 3})
ccuser_1 = CommCareUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
ccuser_2 = CommCareUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
web_user = WebUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
)
self.addCleanup(ccuser_1.delete)
self.addCleanup(ccuser_2.delete)
self.addCleanup(web_user.delete)
self._dump_and_load(expected_object_counts)
def test_one_way_numbers(self):
user1 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
user2 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
user3 = CommCareUser.create(self.domain, uuid.uuid4().hex, 'abc')
self.addCleanup(user1.delete)
self.addCleanup(user2.delete)
self.addCleanup(user3.delete)
self.assertIsNone(user1.memoized_usercase)
self.assertIsNone(Content.get_two_way_entry_or_phone_number(user1))
with self.create_user_case(user2) as case:
self.assertIsNotNone(user2.memoized_usercase)
self.assertIsNone(Content.get_two_way_entry_or_phone_number(user2))
self.assertIsNone(Content.get_two_way_entry_or_phone_number(case))
with self.create_user_case(user3) as case:
# If the user has no number, the user case's number is used
update_case(self.domain, case.case_id, case_properties={'contact_phone_number': '12345678'})
case = CaseAccessors(self.domain).get_case(case.case_id)
self.assertPhoneEntryCount(1)
self.assertPhoneEntryCount(0, only_count_two_way=True)
self.assertIsNotNone(user3.memoized_usercase)
self.assertEqual(Content.get_two_way_entry_or_phone_number(user3), '12345678')
# If the user has a number, it is used before the user case's number
user3.add_phone_number('87654321')
user3.save()
self.assertPhoneEntryCount(2)
self.assertPhoneEntryCount(0, only_count_two_way=True)
self.assertEqual(Content.get_two_way_entry_or_phone_number(user3), '87654321')
# Referencing the case directly uses the case's phone number
self.assertEqual(Content.get_two_way_entry_or_phone_number(case), '12345678')
def setUp(self):
self.domain = "test-domain"
create_domain(self.domain)
self.user = CommCareUser.create(self.domain, 'reconciliation-test', 'password')
self.user.save()
self.other_user = CommCareUser.create(self.domain, 'reconciliation-test-other', 'password')
self.other_user.save()
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 setUpClass(cls):
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
email='*****@*****.**',
)
def setUpClass(cls):
super(UserAnalyticsTest, cls).setUpClass()
delete_all_users()
cls.domain = create_domain('test')
cls.active_user = CommCareUser.create(
domain='test',
username='******',
password='******',
is_active=True,
)
cls.active_user_2 = CommCareUser.create(
domain='test',
username='******',
password='******',
is_active=True,
)
cls.inactive_user = CommCareUser.create(
domain='test',
username='******',
password='******',
is_active=False
)
cls.web_user = WebUser.create(
domain='test',
username='******',
password='******',
)
update_analytics_indexes()
def testGroupFilters(self):
domain = 'case-export-test'
active_user = CommCareUser.create(domain=domain, username='******', password='******')
inactive_user = CommCareUser.create(domain=domain, username='******', password='******')
inactive_user.is_active = False
inactive_user.save()
group = Group(domain=domain, name='group', users=[active_user._id, inactive_user._id])
group.save()
# no matter what the group should match on ownerid (but not user id)
self.assertTrue(case_group_filter(_mock_case(group._id, 'nobody'), group))
self.assertTrue(case_group_filter(_mock_case(group._id, active_user._id), group))
self.assertTrue(case_group_filter(_mock_case(group._id, inactive_user._id), group))
self.assertFalse(case_group_filter(_mock_case('nobody', group._id), group))
# test active users count
self.assertTrue(case_group_filter(_mock_case(active_user._id, 'nobody'), group))
self.assertTrue(case_group_filter(_mock_case('nobody', active_user._id), group))
self.assertTrue(case_group_filter(_mock_case(active_user._id, active_user._id), group))
# test inactive users don't count
self.assertFalse(case_group_filter(_mock_case(inactive_user._id, 'nobody'), group))
self.assertFalse(case_group_filter(_mock_case('nobody', inactive_user._id), group))
self.assertFalse(case_group_filter(_mock_case(inactive_user._id, inactive_user._id), group))
# combinations of active and inactive should count
self.assertTrue(case_group_filter(_mock_case(active_user._id, inactive_user._id), group))
self.assertTrue(case_group_filter(_mock_case(inactive_user._id, active_user._id), group))
# duh
self.assertFalse(case_group_filter(_mock_case('nobody', 'nobody-else'), group))
def setUpClass(cls):
super(TestLocationOwnership, cls).setUpClass()
cls.tag = "big-mac-index"
data_type = FixtureDataType(
domain=cls.domain,
tag=cls.tag,
name="Big Mac Index",
fields=[
FixtureTypeField(field_name="cost", properties=[]),
FixtureTypeField(field_name="region", properties=[]),
],
item_attributes=[],
)
data_type.save()
def make_data_item(location_name, cost):
"""Make a fixture data item and assign it to location_name"""
data_item = FixtureDataItem(
domain=cls.domain,
data_type_id=data_type.get_id,
fields={
"cost": FieldList(
field_list=[FixtureItemField(
field_value=cost,
properties={},
)]
),
"location_name": FieldList(
field_list=[FixtureItemField(
field_value=location_name,
properties={},
)]
),
},
item_attributes={},
)
data_item.save()
FixtureOwnership(
domain=cls.domain,
owner_id=cls.locations[location_name].location_id,
owner_type='location',
data_item_id=data_item.get_id
).save()
make_data_item('Suffolk', '8')
make_data_item('Boston', '10')
make_data_item('Somerville', '7')
get_fixture_data_types_in_domain.clear(cls.domain)
cls.no_location_user = CommCareUser.create(cls.domain, 'no_location', '***')
cls.suffolk_user = CommCareUser.create(cls.domain, 'guy-from-suffolk', '***')
cls.suffolk_user.set_location(cls.locations['Suffolk'])
cls.boston_user = CommCareUser.create(cls.domain, 'guy-from-boston', '***')
cls.boston_user.set_location(cls.locations['Boston'])
cls.middlesex_user = CommCareUser.create(cls.domain, 'guy-from-middlesex', '***')
cls.middlesex_user.set_location(cls.locations['Middlesex'])
def setUpClass(cls):
super(AllCommCareUsersTest, cls).setUpClass()
delete_all_users()
hard_delete_deleted_users()
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
UserRole.init_domain_with_presets(cls.ccdomain.name)
cls.user_roles = UserRole.by_domain(cls.ccdomain.name)
cls.custom_role = UserRole.get_or_create_with_permissions(
cls.ccdomain.name,
Permissions(
edit_apps=True,
edit_web_users=True,
view_web_users=True,
view_roles=True,
),
"Custom Role"
)
cls.custom_role.save()
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_2.set_role(cls.ccdomain.name, cls.custom_role.get_qualified_id())
cls.ccuser_2.save()
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user.retire()
def setUp(self):
self.domain = 'test'
self.username = "******"
self.other_username = '******'
self.password = "******"
self.commcare_user = CommCareUser.create(self.domain, self.username, self.password)
self.commcare_user.save()
self.other_user = CommCareUser.create(self.domain, self.other_username, self.password)
self.other_user.save()
def test_user_reindexer(self):
delete_all_users()
username = '******'
CommCareUser.create(self.domain, username, 'secret')
call_command('ptop_fast_reindex_users', noinput=True, bulk=True)
results = UserES().run()
self.assertEqual(1, results.total)
user_doc = results.hits[0]
self.assertEqual(self.domain, user_doc['domain'])
self.assertEqual(username, user_doc['username'])
self.assertEqual('CommCareUser', user_doc['doc_type'])
delete_es_index(USER_INDEX)
def setUp(self):
super(RetireUserTestCase, self).setUp()
delete_all_users()
self.username = "******"
self.other_username = '******'
self.password = "******"
self.commcare_user = CommCareUser.create(self.domain, self.username, self.password)
self.commcare_user.save()
self.other_user = CommCareUser.create(self.domain, self.other_username, self.password)
self.other_user.save()
def setUpClass(cls):
super(RestorePermissionsTest, cls).setUpClass()
cls.other_project = Domain(name=cls.other_domain)
cls.other_project.save()
cls.web_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.super_user = WebUser.create(
username='******',
domain=cls.other_domain,
password='******',
)
cls.super_user.is_superuser = True
cls.super_user.save()
cls.commcare_user = CommCareUser.create(
username=format_username('super', cls.domain),
domain=cls.domain,
password='******',
)
cls.no_edit_commcare_user = CommCareUser.create(
username=format_username('noedit', cls.domain),
domain=cls.domain,
password='******',
)
cls.location_user = CommCareUser.create(
username=format_username('location', cls.domain),
domain=cls.domain,
password='******',
)
cls.wrong_location_user = CommCareUser.create(
username=format_username('wrong-location', cls.domain),
domain=cls.domain,
password='******',
)
cls.web_location_user = WebUser.create(
username='******',
domain=cls.domain,
password='******',
)
cls.commcare_user.set_location(cls.locations['usa'])
cls.web_location_user.set_location(cls.domain, cls.locations['usa'])
cls.no_edit_commcare_user.set_location(cls.locations['usa'])
cls.location_user.set_location(cls.locations['ma'])
cls.wrong_location_user.set_location(cls.locations['montreal'])
cls.restrict_user_to_assigned_locations(cls.commcare_user)
cls.restrict_user_to_assigned_locations(cls.web_location_user)
def setUpClass(cls):
super(SchedulingRecipientTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.location_types = setup_location_types(cls.domain, ['country', 'state', 'city'])
cls.country_location = make_loc('usa', domain=cls.domain, type='country')
cls.state_location = make_loc('ma', domain=cls.domain, type='state', parent=cls.country_location)
cls.city_location = make_loc('boston', domain=cls.domain, type='city', parent=cls.state_location)
cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc')
cls.mobile_user.set_location(cls.city_location)
cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc')
cls.mobile_user2.set_location(cls.state_location)
cls.mobile_user3 = CommCareUser.create(cls.domain, 'mobile3', 'abc')
cls.mobile_user3.user_data['role'] = 'pharmacist'
cls.mobile_user3.save()
cls.mobile_user4 = CommCareUser.create(cls.domain, 'mobile4', 'abc')
cls.mobile_user4.user_data['role'] = 'nurse'
cls.mobile_user4.save()
cls.mobile_user5 = CommCareUser.create(cls.domain, 'mobile5', 'abc')
cls.mobile_user5.user_data['role'] = ['nurse', 'pharmacist']
cls.mobile_user5.save()
cls.web_user = WebUser.create(cls.domain, 'web', 'abc')
cls.web_user2 = WebUser.create(cls.domain, 'web2', 'abc')
cls.web_user2.user_data['role'] = 'nurse'
cls.web_user2.save()
cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id])
cls.group.save()
cls.group2 = Group(
domain=cls.domain,
users=[
cls.mobile_user.get_id,
cls.mobile_user3.get_id,
cls.mobile_user4.get_id,
cls.mobile_user5.get_id,
]
)
cls.group2.save()
cls.case_group = CommCareCaseGroup(domain=cls.domain)
cls.case_group.save()
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 test_owned_by_user(self):
user = CommCareUser.create(self.domain, 'owned-user-test', 'password')
user.save()
owners = get_owning_users(user._id)
self.assertEqual(1, len(owners))
self.assertEqual(owners[0]._id, user._id)
self.assertTrue(isinstance(owners[0], CommCareUser))
def test_demo_user_restore(self):
from corehq.apps.users.models import CommCareUser
from corehq.apps.ota.models import DemoUserRestore
from django.contrib.auth.models import User
expected_object_counts = Counter({
User: 1,
DemoUserRestore: 1
})
user_id = uuid.uuid4().hex
user = CommCareUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
uuid=user_id
)
self.addCleanup(user.delete)
DemoUserRestore(
demo_user_id=user_id,
restore_blob_id=uuid.uuid4().hex,
content_length=1027,
restore_comment="Test migrate demo user restore"
).save()
self._dump_and_load(expected_object_counts)
def create_mobile_worker(self, username, password, phone_number, save_vn=True):
user = CommCareUser.create(self.domain, username, password,
phone_number=phone_number)
if save_vn:
user.save_verified_number(self.domain, phone_number, True, None)
self.users.append(user)
return user
def test_update(self):
self.client.login(username=self.username, password=self.password)
user = CommCareUser.create(domain=self.domain.name, username="******", password="******")
group = Group({"name": "test"})
group.save()
user_json = {
"first_name": "test",
"last_name": "last",
"email": "*****@*****.**",
"language": "pol",
"phone_numbers": ["+50253311399", "50253314588"],
"groups": [group._id],
"user_data": {"chw_id": "13/43/DFA"},
}
backend_id = user._id
response = self.client.put(
self.single_endpoint(backend_id), json.dumps(user_json), content_type="application/json"
)
self.assertEqual(response.status_code, 200, response.content)
self.assertEqual(1, len(CommCareUser.by_domain(self.domain.name)))
modified = CommCareUser.get(backend_id)
self.assertEqual(modified.username, "test")
self.assertEqual(modified.first_name, "test")
self.assertEqual(modified.last_name, "last")
self.assertEqual(modified.email, "*****@*****.**")
self.assertEqual(modified.language, "pol")
self.assertEqual(modified.get_group_ids()[0], group._id)
self.assertEqual(modified.user_data["chw_id"], "13/43/DFA")
self.assertEqual(modified.default_phone_number, "50253311399")
modified.delete()
group.delete()
def setUp(self):
self.domain = 'test'
self.username = "******"
self.password = "******"
self.domain_obj = create_domain(self.domain)
self.commcare_user = CommCareUser.create(self.domain, self.username, self.password)
self.commcare_user.save()
def bootstrap_user(
username=TEST_USER,
domain=TEST_DOMAIN,
phone_number=TEST_NUMBER,
password=TEST_PASSWORD,
backend=TEST_BACKEND,
first_name="",
last_name="",
home_loc=None,
user_data=None,
program_id=None,
):
user_data = user_data or {}
user = CommCareUser.create(
domain,
username,
password,
phone_numbers=[TEST_NUMBER],
user_data=user_data,
first_name=first_name,
last_name=last_name,
)
user.set_location(home_loc)
dm = user.get_domain_membership(domain)
dm.program_id = program_id
user.save()
user.save_verified_number(domain, phone_number, verified=True, backend_id=backend)
return CommCareUser.wrap(user.to_json())
def test_device_logs(self):
from corehq.apps.receiverwrapper.util import submit_form_locally
from phonelog.models import DeviceReportEntry, ForceCloseEntry, UserEntry, UserErrorEntry
from corehq.apps.users.models import CommCareUser
from django.contrib.auth.models import User
expected_object_counts = Counter({
User: 1,
DeviceReportEntry: 7,
UserEntry: 1,
UserErrorEntry: 2,
ForceCloseEntry: 1
})
user = CommCareUser.create(
domain=self.domain_name,
username='******',
password='******',
email='*****@*****.**',
uuid='428d454aa9abc74e1964e16d3565d6b6' # match ID in devicelog.xml
)
self.addCleanup(user.delete)
with open('corehq/ex-submodules/couchforms/tests/data/devicelogs/devicelog.xml', 'rb') as f:
xml = f.read()
submit_form_locally(xml, self.domain_name)
self._dump_and_load(expected_object_counts)
def setUp(self):
super(LocationsTest, self).setUp()
self.user = CommCareUser.create(domain=self.domain, username='******', password='******',
created_by=None, created_via=None)
self.loc = make_loc('mariposa_saloon', domain=self.domain)
self.user.set_location(self.loc)
def setUpClass(cls):
super(TestLocationOwnership, cls).setUpClass()
cls.tag = "big-mac-index"
data_type = FixtureDataType(
domain=cls.domain,
tag=cls.tag,
name="Big Mac Index",
fields=[
FixtureTypeField(field_name="cost", properties=[]),
FixtureTypeField(field_name="region", properties=[]),
],
item_attributes=[],
)
data_type.save()
def make_data_item(location_name, cost):
"""Make a fixture data item and assign it to location_name"""
data_item = FixtureDataItem(
domain=cls.domain,
data_type_id=data_type.get_id,
fields={
"cost":
FieldList(field_list=[
FixtureItemField(
field_value=cost,
properties={},
)
]),
"location_name":
FieldList(field_list=[
FixtureItemField(
field_value=location_name,
properties={},
)
]),
},
item_attributes={},
)
data_item.save()
FixtureOwnership(domain=cls.domain,
owner_id=cls.locations[location_name].location_id,
owner_type='location',
data_item_id=data_item.get_id).save()
make_data_item('Suffolk', '8')
make_data_item('Boston', '10')
make_data_item('Somerville', '7')
get_fixture_data_types_in_domain.clear(cls.domain)
cls.no_location_user = CommCareUser.create(cls.domain, 'no_location',
'***')
cls.suffolk_user = CommCareUser.create(cls.domain, 'guy-from-suffolk',
'***')
cls.suffolk_user.set_location(cls.locations['Suffolk'])
cls.boston_user = CommCareUser.create(cls.domain, 'guy-from-boston',
'***')
cls.boston_user.set_location(cls.locations['Boston'])
cls.middlesex_user = CommCareUser.create(cls.domain,
'guy-from-middlesex', '***')
cls.middlesex_user.set_location(cls.locations['Middlesex'])
def setUp(self):
super(CCUserLocationAssignmentTest, self).setUp()
self.user = CommCareUser.create(domain=self.domain,
username='******',
password='******',
last_login=datetime.now())
def setUpClass(cls):
super(SchedulingRecipientTest, cls).setUpClass()
cls.domain_obj = create_domain(cls.domain)
cls.location_types = setup_location_types(cls.domain,
['country', 'state', 'city'])
cls.country_location = make_loc('usa',
domain=cls.domain,
type='country')
cls.state_location = make_loc('ma',
domain=cls.domain,
type='state',
parent=cls.country_location)
cls.city_location = make_loc('boston',
domain=cls.domain,
type='city',
parent=cls.state_location)
cls.mobile_user = CommCareUser.create(cls.domain, 'mobile', 'abc',
None, None)
cls.mobile_user.set_location(cls.city_location)
cls.mobile_user2 = CommCareUser.create(cls.domain, 'mobile2', 'abc',
None, None)
cls.mobile_user2.set_location(cls.state_location)
cls.mobile_user3 = CommCareUser.create(cls.domain,
'mobile3',
'abc',
None,
None,
metadata={
'role': 'pharmacist',
})
cls.mobile_user3.save()
cls.mobile_user4 = CommCareUser.create(cls.domain,
'mobile4',
'abc',
None,
None,
metadata={
'role': 'nurse',
})
cls.mobile_user4.save()
cls.mobile_user5 = CommCareUser.create(cls.domain,
'mobile5',
'abc',
None,
None,
metadata={
'role':
['nurse', 'pharmacist'],
})
cls.mobile_user5.save()
full_username = normalize_username('mobile', cls.domain)
cls.full_mobile_user = CommCareUser.create(cls.domain, full_username,
'abc', None, None)
cls.definition = CustomDataFieldsDefinition(
domain=cls.domain, field_type=UserFieldsView.field_type)
cls.definition.save()
cls.definition.set_fields([
Field(
slug='role',
label='Role',
),
])
cls.definition.save()
cls.profile = CustomDataFieldsProfile(
name='nurse_profile',
fields={'role': ['nurse']},
definition=cls.definition,
)
cls.profile.save()
cls.mobile_user6 = CommCareUser.create(cls.domain,
'mobile6',
'abc',
None,
None,
metadata={
PROFILE_SLUG:
cls.profile.id,
})
cls.mobile_user5.save()
cls.web_user = WebUser.create(cls.domain, 'web', 'abc', None, None)
cls.web_user2 = WebUser.create(cls.domain,
'web2',
'abc',
None,
None,
metadata={
'role': 'nurse',
})
cls.web_user2.save()
cls.group = Group(domain=cls.domain, users=[cls.mobile_user.get_id])
cls.group.save()
cls.group2 = Group(domain=cls.domain,
users=[
cls.mobile_user.get_id,
cls.mobile_user3.get_id,
cls.mobile_user4.get_id,
cls.mobile_user5.get_id,
cls.mobile_user6.get_id,
])
cls.group2.save()
cls.case_group = CommCareCaseGroup(domain=cls.domain)
cls.case_group.save()
cls.process_pillow_changes = process_pillow_changes(
'DefaultChangeFeedPillow')
cls.process_pillow_changes.add_pillow(get_case_messaging_sync_pillow())
def setUpClass(cls):
super(ChatHistoryTestCase, cls).setUpClass()
cls.domain = 'sms-chat-history-test-domain'
cls.domain_obj = Domain(name=cls.domain)
cls.domain_obj.save()
cls.contact1_id = uuid.uuid4().hex
cls.contact2_id = uuid.uuid4().hex
cls.contact3 = CommCareUser.create(cls.domain, 'user1', '123', None,
None)
cls.chat_user = CommCareUser.create(cls.domain, 'user2', '123', None,
None)
cls.chat_user.first_name = 'Sam'
cls.chat_user.save()
cls.outgoing_from_system = SMS.objects.create(
domain=cls.domain,
direction=OUTGOING,
date=datetime(2016, 2, 18, 0, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='Remember your appointment tomorrow',
chat_user_id=None,
processed=True,
xforms_session_couch_id=None,
invalid_survey_response=False,
)
cls.outgoing_not_processed = SMS.objects.create(
domain=cls.domain,
direction=OUTGOING,
date=datetime(2016, 2, 18, 1, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='Remember your appointment next week',
chat_user_id=None,
processed=False,
xforms_session_couch_id=None,
invalid_survey_response=False,
)
cls.outgoing_from_chat = SMS.objects.create(
domain=cls.domain,
direction=OUTGOING,
date=datetime(2016, 2, 18, 2, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='How are you?',
chat_user_id=cls.chat_user.get_id,
processed=True,
xforms_session_couch_id=None,
invalid_survey_response=False,
)
cls.incoming_not_processed = SMS.objects.create(
domain=cls.domain,
direction=INCOMING,
date=datetime(2016, 2, 18, 3, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='Good',
chat_user_id=None,
processed=False,
xforms_session_couch_id=None,
invalid_survey_response=False,
)
cls.incoming_survey_answer1 = SMS.objects.create(
domain=cls.domain,
direction=INCOMING,
date=datetime(2016, 2, 18, 4, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='x',
chat_user_id=None,
processed=True,
xforms_session_couch_id='session-id',
invalid_survey_response=True,
)
cls.outgoing_survey_response1 = SMS.objects.create(
domain=cls.domain,
direction=OUTGOING,
date=datetime(2016, 2, 18, 5, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='Invalid Response',
chat_user_id=None,
processed=True,
xforms_session_couch_id='session-id',
invalid_survey_response=True,
)
cls.incoming_survey_answer2 = SMS.objects.create(
domain=cls.domain,
direction=INCOMING,
date=datetime(2016, 2, 18, 6, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='1',
chat_user_id=None,
processed=True,
xforms_session_couch_id='session-id',
invalid_survey_response=False,
)
cls.outgoing_survey_response2 = SMS.objects.create(
domain=cls.domain,
direction=OUTGOING,
date=datetime(2016, 2, 18, 7, 0),
couch_recipient_doc_type='CommCareCase',
couch_recipient=cls.contact1_id,
text='Thank you for completing the survey',
chat_user_id=None,
processed=True,
xforms_session_couch_id='session-id',
invalid_survey_response=False,
)
def setUp(self):
self.user = CommCareUser.create(TEST_DOMAIN, 'user1', '***', None, None, commit=False) # Don't commit yet
def process_sms_registration(msg):
"""
This method handles registration via sms.
Returns True if a contact was registered, False if not.
To have a case register itself, do the following:
1) Select "Enable Case Registration Via SMS" in project settings, and fill in the
associated Case Registration settings.
2) Text in "join <domain>", where <domain> is the domain to join. If the sending
number does not exist in the system, a case will be registered tied to that number.
The "join" keyword can be any keyword in REGISTRATION_KEYWORDS. This is meant to
support multiple translations.
To have a mobile worker register itself, do the following:
1) Select "Enable Mobile Worker Registration via SMS" in project settings.
2) Text in "join <domain> worker <username>", where <domain> is the domain to join and <username> is the
requested username. If the username doesn't exist it will be created, otherwise the registration will error.
If the username argument is not specified, the username will be the mobile number
The "join" and "worker" keywords can be any keyword in REGISTRATION_KEYWORDS and
REGISTRATION_MOBILE_WORKER_KEYWORDS, respectively. This is meant to support multiple
translations.
"""
registration_processed = False
text_words = msg.text.upper().split()
keyword1 = text_words[0] if len(text_words) > 0 else ""
keyword2 = text_words[1].lower() if len(text_words) > 1 else ""
keyword3 = text_words[2] if len(text_words) > 2 else ""
keyword4 = text_words[3] if len(text_words) > 3 else ""
cleaned_phone_number = strip_plus(msg.phone_number)
if is_registration_text(msg.text) and keyword2 != "":
domain_name = keyword2
if any_migrations_in_progress(domain_name):
raise DelayProcessing()
domain_obj = Domain.get_by_name(domain_name, strict=True)
if domain_obj is not None:
if domain_has_privilege(domain_obj, privileges.INBOUND_SMS):
if (keyword3 in REGISTRATION_MOBILE_WORKER_KEYWORDS
and domain_obj.sms_mobile_worker_registration_enabled):
if keyword4 != '':
username = keyword4
else:
username = cleaned_phone_number
try:
user_data = {}
username = process_username(username, domain_obj)
password = random_password()
new_user = CommCareUser.create(
domain_obj.name,
username,
password,
created_by=None,
created_via=USER_CHANGE_VIA_SMS,
metadata=user_data)
new_user.add_phone_number(cleaned_phone_number)
new_user.save()
entry = new_user.get_or_create_phone_entry(
cleaned_phone_number)
entry.set_two_way()
entry.set_verified()
entry.save()
registration_processed = True
if domain_obj.enable_registration_welcome_sms_for_mobile_worker:
send_sms(
domain_obj.name, None, cleaned_phone_number,
get_message(
MSG_REGISTRATION_WELCOME_MOBILE_WORKER,
domain=domain_obj.name))
except ValidationError as e:
send_sms(domain_obj.name, None, cleaned_phone_number,
e.messages[0])
elif domain_obj.sms_case_registration_enabled:
register_sms_contact(
domain=domain_obj.name,
case_type=domain_obj.sms_case_registration_type,
case_name="unknown",
user_id=domain_obj.sms_case_registration_user_id,
contact_phone_number=cleaned_phone_number,
contact_phone_number_is_verified="1",
owner_id=domain_obj.sms_case_registration_owner_id,
)
registration_processed = True
if domain_obj.enable_registration_welcome_sms_for_case:
send_sms(
domain_obj.name, None, cleaned_phone_number,
get_message(MSG_REGISTRATION_WELCOME_CASE,
domain=domain_obj.name))
msg.domain = domain_obj.name
msg.save()
return registration_processed
def handle(self):
text = ' '.join(self.msg.text.split()[1:])
is_district = False
sp = ""
msd_code = ""
params = {}
if text.find(self.DISTRICT_REG_DELIMITER) != -1:
phrases = [x.strip() for x in text.split(":")]
if len(phrases) != 2:
self.respond(REGISTER_HELP)
return True
name = phrases[0]
sp = phrases[1]
role = Roles.DISTRICT_PHARMACIST
message = REGISTRATION_CONFIRM_DISTRICT
is_district = True
else:
names = []
msd_codes = []
location_regex = '^({prefs})\d+'.format(prefs='|'.join(
p.lower() for p in DISTRICT_PREFIXES))
for the_string in self.args:
if re.match(location_regex, the_string.strip().lower()):
msd_codes.append(the_string.strip().lower())
else:
names.append(the_string)
name = " ".join(names)
if len(msd_codes) != 1:
self.respond(REGISTER_HELP)
return True
else:
[msd_code] = msd_codes
role = Roles.IN_CHARGE
message = REGISTRATION_CONFIRM
if is_district:
try:
loc = self._get_district_location(self.domain, sp)
params['sdp_name'] = loc.name
except SQLLocation.DoesNotExist:
self.respond(REGISTER_UNKNOWN_DISTRICT, name=sp)
return True
else:
try:
loc = self._get_facility_location(self.domain, msd_code)
params['sdp_name'] = loc.name
params['msd_code'] = loc.site_code
except SQLLocation.DoesNotExist:
self.respond(REGISTER_UNKNOWN_CODE, msd_code=msd_code)
return True
split_name = name.split(' ', 2)
first_name = ''
last_name = ''
if len(split_name) == 2:
first_name, last_name = split_name
elif split_name:
first_name = split_name[0]
if not self.user:
key = u'generating ils username for %s, %s, %s' % (
self.domain, first_name, last_name)
with CriticalSection([key]):
username = generate_username(self.domain, first_name,
last_name)
password = uuid.uuid4().hex
self.user = CommCareUser.create(self.domain,
username,
password,
phone_number=strip_plus(
self.msg.phone_number))
self.verified_contact = self.user.get_or_create_phone_entry(
self.msg.phone_number)
self.verified_contact.set_two_way()
self.verified_contact.set_verified()
self.verified_contact.save()
# As per earlier ILSGateway system, set language by default to Swahili
self.user.language = 'sw'
if first_name or last_name:
self.user.first_name = first_name
self.user.last_name = last_name
self.user.set_location(loc)
self.user.is_active = True
self.user.user_data['role'] = role
self.user.save()
params['contact_name'] = name
if params:
self.respond(message, **params)
return True
def handle(self):
text = ' '.join(self.msg.text.split()[1:])
is_district = False
sp = ""
msd_code = ""
if text.find(self.DISTRICT_REG_DELIMITER) != -1:
phrases = [x.strip() for x in text.split(":")]
if len(phrases) != 2:
self.respond(REGISTER_HELP)
return
name = phrases[0]
sp = phrases[1]
role = Roles.DISTRICT_PHARMACIST
message = REGISTRATION_CONFIRM_DISTRICT
params = {}
is_district = True
else:
names = []
msd_codes = []
location_regex = '^({prefs})\d+'.format(prefs='|'.join(
p.lower() for p in DISTRICT_PREFIXES))
for the_string in self.args:
if re.match(location_regex, the_string.strip().lower()):
msd_codes.append(the_string.strip().lower())
else:
names.append(the_string)
name = " ".join(names)
if len(msd_codes) != 1:
self.respond(REGISTER_HELP)
return
else:
[msd_code] = msd_codes
role = Roles.IN_CHARGE
message = REGISTRATION_CONFIRM
params = {"msd_code": msd_code}
if not self.user:
domains = [
config.domain for config in ILSGatewayConfig.get_all_configs()
]
for domain in domains:
if is_district:
loc = self._get_district_location(domain, sp)
else:
loc = self._get_facility_location(domain, msd_code)
if not loc:
continue
splited_name = name.split(' ', 1)
first_name = splited_name[0]
last_name = splited_name[1] if len(splited_name) > 1 else ""
clean_name = name.replace(' ', '.')
username = "******" % (clean_name, domain)
password = User.objects.make_random_password()
user = CommCareUser.create(domain=domain,
username=username,
password=password,
commit=False)
user.first_name = first_name
user.last_name = last_name
try:
user.set_default_phone_number(
self.msg.phone_number.replace('+', ''))
user.save_verified_number(
domain, self.msg.phone_number.replace('+', ''), True,
self.msg.backend_api)
except PhoneNumberInUseException as e:
v = VerifiedNumber.by_phone(self.msg.phone_number,
include_pending=True)
v.delete()
user.save_verified_number(
domain, self.msg.phone_number.replace('+', ''), True,
self.msg.backend_api)
except CommCareUser.Inconsistent:
continue
user.language = Languages.DEFAULT
params.update({'sdp_name': loc.name, 'contact_name': name})
user.user_data = {'role': role}
dm = user.get_domain_membership(domain)
dm.location_id = loc._id
user.save()
add_location(user, loc._id)
if params:
self.respond(message, **params)
def _make_user(cls, name, location):
user = CommCareUser.create(cls.domain, name, 'password')
user.set_location(location)
return user
def _setup_domain_user(cls):
cls.domain = Domain(name=cls.DOMAIN_NAME)
cls.domain.save()
cls.user = CommCareUser.create(cls.DOMAIN_NAME, cls.USERNAME, '*****')
cls.user.save()
cls.user_id = cls.user._id
def setUp(self):
self.user = CommCareUser.create('test', 'test', 'test')
def _make_user(cls, name, location):
user = CommCareUser.create(cls.domain, name, 'password')
user.set_location(location)
UserESFake.save_doc(user._doc)
return user
def setUpClass(cls):
super(HeartbeatTests, cls).setUpClass()
cls.domain = create_domain(uuid4().hex)
cls.user = CommCareUser.create(cls.domain.name, 'user1', '123')
cls.app, cls.build = cls._create_app_and_build()
cls.url = reverse('phone_heartbeat', args=[cls.domain.name, cls.build.get_id])
def setUpClass(cls):
cls.user = CommCareUser.create(cls.domain, 'test1', 'test123')
super(LocationDrilldownFilterTest, cls).setUpClass()
def setUp(self):
super(FixtureDataTest, self).setUp()
self.domain = 'qwerty'
self.tag = "district"
delete_all_users()
delete_all_fixture_data_types()
self.data_type = FixtureDataType(
domain=self.domain,
tag=self.tag,
name="Districts",
fields=[
FixtureTypeField(
field_name="state_name",
properties=[]
),
FixtureTypeField(
field_name="district_name",
properties=["lang"]
),
FixtureTypeField(
field_name="district_id",
properties=[]
),
],
item_attributes=[],
)
self.data_type.save()
self.data_item = FixtureDataItem(
domain=self.domain,
data_type_id=self.data_type.get_id,
fields={
"state_name": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_state",
properties={}
)
]
),
"district_name": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_in_HIN",
properties={"lang": "hin"}
),
FixtureItemField(
field_value="Delhi_in_ENG",
properties={"lang": "eng"}
)
]
),
"district_id": FieldList(
field_list=[
FixtureItemField(
field_value="Delhi_id",
properties={}
)
]
)
},
item_attributes={},
)
self.data_item.save()
self.user = CommCareUser.create(self.domain, 'to_delete', '***')
self.fixture_ownership = FixtureOwnership(
domain=self.domain,
owner_id=self.user.get_id,
owner_type='user',
data_item_id=self.data_item.get_id
)
self.fixture_ownership.save()
get_fixture_data_types_in_domain.clear(self.domain)
def create_or_update_users_and_groups(domain,
user_specs,
group_specs,
location_specs,
task=None):
ret = {"errors": [], "rows": []}
total = len(user_specs) + len(group_specs) + len(location_specs)
def _set_progress(progress):
if task is not None:
DownloadBase.set_progress(task, progress, total)
group_memoizer = create_or_update_groups(domain, group_specs, log=ret)
current = len(group_specs)
usernames = set()
user_ids = set()
allowed_groups = set(group_memoizer.groups)
allowed_group_names = [group.name for group in allowed_groups]
try:
for row in user_specs:
_set_progress(current)
current += 1
data, email, group_names, language, name, password, phone_number, user_id, username = (
row.get(k) for k in sorted(allowed_headers))
if password:
password = unicode(password)
group_names = group_names or []
try:
username = normalize_username(str(username), domain)
except TypeError:
username = None
except ValidationError:
ret['rows'].append({
'username':
username,
'row':
row,
'flag':
_('username cannot contain spaces or symbols'),
})
continue
status_row = {
'username': raw_username(username) if username else None,
'row': row,
}
if username in usernames or user_id in user_ids:
status_row['flag'] = 'repeat'
elif not username and not user_id:
status_row['flag'] = 'missing-data'
else:
try:
if username:
usernames.add(username)
if user_id:
user_ids.add(user_id)
if user_id:
user = CommCareUser.get_by_user_id(user_id, domain)
else:
user = CommCareUser.get_by_username(username)
def is_password(password):
if not password:
return False
for c in password:
if c != "*":
return True
return False
if user:
if user.domain != domain:
raise UserUploadError(
_('User with username %(username)r is '
'somehow in domain %(domain)r') % {
'username': user.username,
'domain': user.domain
})
if username and user.username != username:
user.change_username(username)
if is_password(password):
user.set_password(password)
status_row['flag'] = 'updated'
else:
if len(raw_username(username)
) > CommCareAccountForm.max_len_username:
ret['rows'].append({
'username':
username,
'row':
row,
'flag':
_("username cannot contain greater than %d characters"
% CommCareAccountForm.max_len_username)
})
continue
if not is_password(password):
raise UserUploadError(
_("Cannot create a new user with a blank password"
))
user = CommCareUser.create(domain,
username,
password,
uuid=user_id or '',
commit=False)
status_row['flag'] = 'created'
if phone_number:
user.add_phone_number(_fmt_phone(phone_number),
default=True)
if name:
user.set_full_name(name)
if data:
user.user_data.update(data)
if language:
user.language = language
if email:
user.email = email
user.save()
if is_password(password):
# Without this line, digest auth doesn't work.
# With this line, digest auth works.
# Other than that, I'm not sure what's going on
user.get_django_user().check_password(password)
for group_id in Group.by_user(user, wrap=False):
group = group_memoizer.get(group_id)
if group.name not in group_names:
group.remove_user(user, save=False)
for group_name in group_names:
if group_name not in allowed_group_names:
raise UserUploadError(
_("Can't add to group '%s' "
"(try adding it to your spreadsheet)") %
group_name)
group_memoizer.by_name(group_name).add_user(user,
save=False)
except (UserUploadError, CouchUser.Inconsistent) as e:
status_row['flag'] = '%s' % e
ret["rows"].append(status_row)
finally:
try:
group_memoizer.save_all()
except BulkSaveError as e:
_error_message = (
"Oops! We were not able to save some of your group changes. "
"Please make sure no one else is editing your groups "
"and try again.")
logging.exception(('BulkSaveError saving groups. '
'User saw error message "%s". Errors: %s') %
(_error_message, e.errors))
ret['errors'].append(_error_message)
create_or_update_locations(domain, location_specs, log=ret)
_set_progress(total)
return ret
def test_get_wrapped_user(self):
user = CommCareUser.create(self.domain, 'wrapped-user-test',
'password')
user.save()
wrapped = get_wrapped_owner(user._id)
self.assertTrue(isinstance(wrapped, CommCareUser))
def setUp(self):
couch_user = CommCareUser.create(self.domain, self.username,
self.password)
userID = couch_user.user_id
couch_user.first_name = self.first_name
couch_user.last_name = self.last_name
couch_user.save()
self.sm = SuccessMessage(self.message, userID, tz=self.tz)
c = Client()
app = Application.new_app(self.domain,
"Test App",
application_version=APP_V1)
app.new_module("Test Module", "en")
form = app.new_form(0, "Test Form", "en")
form.xmlns = self.xmlns
app.success_message = {"en": self.message}
app.save()
def fake_form_submission(userID=userID,
username=self.username,
xmlns=self.xmlns,
time=None):
submission = submission_template % {
"userID": userID,
"username": username,
"xmlns": xmlns
}
f = StringIO(submission.encode('utf-8'))
f.name = "tempfile.xml"
kwargs = dict(
HTTP_X_SUBMIT_TIME=json_format_datetime(time)) if time else {}
response = c.post("/a/{self.domain}/receiver/".format(self=self), {
'xml_submission_file': f,
}, **kwargs)
return response
self.num_forms_today = 0
self.num_forms_this_week = 0
now = datetime.utcnow()
tznow = now + self.tz
week_start = tznow - timedelta(days=tznow.weekday())
week_start = datetime(week_start.year, week_start.month,
week_start.day) - self.tz
day_start = datetime(tznow.year, tznow.month, tznow.day) - self.tz
spacing = 6
for h in xrange((24 / spacing) * 8):
time = now - timedelta(hours=spacing * h)
response = fake_form_submission(time=time)
if time > week_start:
self.num_forms_this_week += 1
if time > day_start:
self.num_forms_today += 1
self.failUnlessEqual(
response.content,
get_simple_response_xml((
"Thanks {self.first_name} ({self.first_name} {self.last_name})! "
"You have submitted {self.num_forms_today} forms today "
"and {self.num_forms_this_week} forms since Monday."
).format(self=self),
nature=ResponseNature.SUBMIT_SUCCESS))
def arbitrary_commcare_user(domain, is_active=True):
username = unique_name()
commcare_user = CommCareUser.create(domain, username, 'test123')
commcare_user.is_active = is_active
commcare_user.save()
return commcare_user
def create_or_update_users_and_groups(domain, user_specs, group_specs):
ret = {"errors": [], "rows": []}
group_memoizer = create_or_update_groups(domain, group_specs, log=ret)
usernames = set()
user_ids = set()
allowed_groups = set(group_memoizer.groups)
allowed_group_names = [group.name for group in allowed_groups]
try:
for row in user_specs:
data, group_names, language, name, password, phone_number, user_id, username = (
row.get(k) for k in sorted(allowed_headers)
)
password = unicode(password)
group_names = group_names or []
try:
username = normalize_username(username, domain)
except TypeError:
username = None
except ValidationError:
ret['rows'].append({
'username': username,
'row': row,
'flag': _('username cannot contain spaces or symbols'),
})
continue
status_row = {
'username': raw_username(username) if username else None,
'row': row,
}
if username in usernames or user_id in user_ids:
status_row['flag'] = 'repeat'
elif not username and not user_id:
status_row['flag'] = 'missing-data'
else:
try:
if username:
usernames.add(username)
if user_id:
user_ids.add(user_id)
if user_id:
user = CommCareUser.get_by_user_id(user_id, domain)
else:
user = CommCareUser.get_by_username(username)
if user:
if user.domain != domain:
raise Exception(_('User with username %(username)r is somehow in domain %(domain)r') %
{'username': user.username, 'domain': user.domain})
if username and user.username != username:
user.change_username(username)
if password:
user.set_password(password)
status_row['flag'] = 'updated'
else:
if not password:
raise Exception(_("Cannot create a new user with a blank password"))
user = CommCareUser.create(domain, username, password, uuid=user_id or '')
status_row['flag'] = 'created'
if phone_number:
user.add_phone_number(_fmt_phone(phone_number), default=True)
if name:
user.set_full_name(name)
if data:
user.user_data.update(data)
if language:
user.language = language
user.save()
if password:
# Without this line, digest auth doesn't work.
# With this line, digest auth works.
# Other than that, I'm not sure what's going on
user.get_django_user().check_password(password)
for group_id in Group.by_user(user, wrap=False):
group = group_memoizer.get(group_id)
if group.name not in group_names:
group.remove_user(user, save=False)
for group_name in group_names:
if group_name not in allowed_group_names:
raise Exception(_("Can't add to group '%s' (try adding it to your spreadsheet)") % group_name)
group_memoizer.by_name(group_name).add_user(user, save=False)
except Exception, e:
status_row['flag'] = '%s' % e
ret["rows"].append(status_row)
finally:
group_memoizer.save_all()
return ret
def setUpClass(cls):
super(AllCommCareUsersTest, cls).setUpClass()
delete_all_users()
hard_delete_deleted_users()
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
bootstrap_location_types(cls.ccdomain.name)
UserRole.init_domain_with_presets(cls.ccdomain.name)
cls.user_roles = UserRole.by_domain(cls.ccdomain.name)
cls.custom_role = UserRole.get_or_create_with_permissions(
cls.ccdomain.name,
Permissions(
edit_apps=True,
edit_web_users=True,
view_web_users=True,
view_roles=True,
), "Custom Role")
cls.custom_role.save()
cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district")
cls.loc2 = make_loc('madagascar',
domain=cls.ccdomain.name,
type="district")
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_1.set_location(cls.loc1)
cls.ccuser_1.save()
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_2.set_role(cls.ccdomain.name,
cls.custom_role.get_qualified_id())
cls.ccuser_2.set_location(cls.loc2)
cls.ccuser_2.save()
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
email='*****@*****.**',
)
cls.retired_user.retire()
def setUpClass(cls):
super(GetCaseTest, cls).setUpClass()
cls.domain = Domain(name='foo')
cls.domain.save()
cls.user = CommCareUser.create(cls.domain.name, 'username', 's3cr3t')
def setUp(self):
self.domain = 'test-domain'
self.user = CommCareUser.create(self.domain, 'test-user', '123', None, None)
def setUpClass(cls):
super(AllCommCareUsersTest, cls).setUpClass()
delete_all_users()
hard_delete_deleted_users()
cls.ccdomain = Domain(name='cc_user_domain')
cls.ccdomain.save()
cls.other_domain = Domain(name='other_domain')
cls.other_domain.save()
bootstrap_location_types(cls.ccdomain.name)
initialize_domain_with_default_roles(cls.ccdomain.name)
cls.user_roles = UserRole.objects.get_by_domain(cls.ccdomain.name)
cls.custom_role = UserRole.create(cls.ccdomain.name, "Custom Role")
cls.loc1 = make_loc('spain', domain=cls.ccdomain.name, type="district")
cls.loc2 = make_loc('madagascar',
domain=cls.ccdomain.name,
type="district")
cls.ccuser_1 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_1.set_location(cls.loc1)
cls.ccuser_1.save()
cls.ccuser_2 = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_2.set_role(cls.ccdomain.name,
cls.custom_role.get_qualified_id())
cls.ccuser_2.set_location(cls.loc2)
cls.ccuser_2.save()
cls.web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.location_restricted_web_user = WebUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.location_restricted_web_user.add_to_assigned_locations(
domain=cls.ccdomain.name, location=cls.loc2)
cls.ccuser_other_domain = CommCareUser.create(
domain=cls.other_domain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.retired_user = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.retired_user.retire(cls.ccdomain.name, deleted_by=None)
cls.ccuser_inactive = CommCareUser.create(
domain=cls.ccdomain.name,
username='******',
password='******',
created_by=None,
created_via=None,
email='*****@*****.**',
)
cls.ccuser_inactive.is_active = False
cls.ccuser_inactive.save()
cls.ccuser_inactive.set_location(cls.loc2)
def _get_or_create_user(domain):
username = format_username('nick', domain)
user = CommCareUser.get_by_username(username, strict=True)
if not user:
user = CommCareUser.create(domain, username, 'secret')
return user
def setUpClass(cls):
delete_all_cases()
cls.domain = Domain(name='foo')
cls.domain.save()
cls.user = CommCareUser.create(cls.domain.name, 'somebody', 'password')
cls.user_id = cls.user._id
def setUpClass(cls):
super(TestPracticeUserRestore, cls).setUpClass()
cls.domain = "practice-user-domain"
cls.project = create_domain(cls.domain)
cls.user = CommCareUser.create(cls.domain, '*****@*****.**', 'secret')
def test_owner_filter(self):
setup_locations_and_types(
self.domain, ['state', 'health-department', 'team', 'sub-team'],
[], [('State1', [
('HealthDepartment1', [
('Team1', [
('SubTeam1', []),
('SubTeam2', []),
]),
('Team2', []),
]),
])])
team1 = SQLLocation.objects.filter(domain=self.domain,
name='Team1').first()
health_department = SQLLocation.objects.filter(
domain=self.domain, name='HealthDepartment1').first()
self.addCleanup(delete_all_locations)
user = CommCareUser.create(self.domain,
'm2',
'abc',
None,
None,
location=team1)
send_to_elasticsearch('users', user.to_json())
self.es.indices.refresh(USER_INDEX_INFO.index)
self.addCleanup(delete_all_users)
cases = [
new_case(
domain=self.domain,
foo="peach",
bar="plumb",
server_modified_on=datetime.utcnow() + timedelta(hours=-1),
owner_id='123',
),
new_case(
domain=self.domain,
foo="orange",
bar="melon",
server_modified_on=datetime.utcnow(),
owner_id=user.
user_id, # this user is part of the team1 location.
),
new_case(
domain=self.domain,
foo="grape",
bar="pineapple",
server_modified_on=datetime.utcnow(),
),
]
for case in cases:
send_to_elasticsearch("cases", case.to_json())
self.addCleanup(self._cleanup_case(case.case_id))
self.es.indices.refresh(CASE_INDEX_INFO.index)
self.export_instance.filters.show_project_data = False
self.export_instance.filters.locations = [
health_department.location_id
]
self.export_instance.filters.users = ['123']
self.export_instance.save()
checkpoint = _generate_incremental_export(self.incremental_export)
data = checkpoint.get_blob().read().decode("utf-8-sig")
expected = "Foo column,Bar column\r\npeach,plumb\r\norange,melon\r\n"
self.assertEqual(data, expected)
def create_or_update_users_and_groups(domain,
user_specs,
upload_user,
group_memoizer=None,
update_progress=None):
ret = {"errors": [], "rows": []}
group_memoizer = group_memoizer or GroupMemoizer(domain)
group_memoizer.load_all()
current = 0
can_assign_locations = domain_has_privilege(domain, privileges.LOCATIONS)
if can_assign_locations:
location_cache = SiteCodeToLocationCache(domain)
domain_obj = Domain.get_by_name(domain)
allowed_group_names = [group.name for group in group_memoizer.groups]
roles_by_name = {role.name: role for role in UserRole.by_domain(domain)}
validators = get_user_import_validators(domain_obj, user_specs,
allowed_group_names,
list(roles_by_name))
try:
for row in user_specs:
if update_progress:
update_progress(current)
current += 1
username = row.get('username')
status_row = {
'username': username,
'row': row,
}
try:
for validator in validators:
validator(row)
except UserUploadError as e:
status_row['flag'] = str(e)
ret['rows'].append(status_row)
continue
data = row.get('data')
email = row.get('email')
group_names = list(map(str, row.get('group') or []))
language = row.get('language')
name = row.get('name')
password = row.get('password')
phone_number = row.get('phone-number')
uncategorized_data = row.get('uncategorized_data')
user_id = row.get('user_id')
location_codes = row.get('location_code') or []
if location_codes and not isinstance(location_codes, list):
location_codes = [location_codes]
# ignore empty
location_codes = [code for code in location_codes if code]
role = row.get('role', None)
web_user = row.get('web_user')
try:
username = normalize_username(str(username),
domain) if username else None
password = str(password) if password else None
is_active = spec_value_to_boolean_or_none(row, 'is_active')
is_account_confirmed = spec_value_to_boolean_or_none(
row, 'is_account_confirmed')
send_account_confirmation_email = spec_value_to_boolean_or_none(
row, 'send_confirmation_email')
remove_web_user = spec_value_to_boolean_or_none(
row, 'remove_web_user')
if user_id:
user = CommCareUser.get_by_user_id(user_id, domain)
if not user:
raise UserUploadError(
_("User with ID '{user_id}' not found").format(
user_id=user_id, domain=domain))
if username and user.username != username:
raise UserUploadError(
_('Changing usernames is not supported: %(username)r to %(new_username)r'
) % {
'username': user.username,
'new_username': username
})
# note: explicitly not including "None" here because that's the default value if not set.
# False means it was set explicitly to that value
if is_account_confirmed is False and not web_user:
raise UserUploadError(
_(f"You can only set 'Is Account Confirmed' to 'False' on a new User."
))
if is_password(password):
user.set_password(password)
status_row['flag'] = 'updated'
else:
kwargs = {}
if is_account_confirmed is not None and not web_user:
kwargs['is_account_confirmed'] = is_account_confirmed
user = CommCareUser.create(
domain,
username,
password,
created_by=upload_user,
created_via=USER_CHANGE_VIA_BULK_IMPORTER,
commit=False,
**kwargs)
status_row['flag'] = 'created'
if phone_number:
user.add_phone_number(_fmt_phone(phone_number),
default=True)
if name:
user.set_full_name(str(name))
if data:
user.user_data.update(data)
if uncategorized_data:
user.user_data.update(uncategorized_data)
if language:
user.language = language
if email:
user.email = email.lower()
if is_active is not None:
user.is_active = is_active
if can_assign_locations:
# Do this here so that we validate the location code before we
# save any other information to the user, this way either all of
# the user's information is updated, or none of it
location_ids = []
for code in location_codes:
loc = get_location_from_site_code(code, location_cache)
location_ids.append(loc.location_id)
locations_updated = set(
user.assigned_location_ids) != set(location_ids)
primary_location_removed = (
user.location_id and not location_ids
or user.location_id not in location_ids)
if primary_location_removed:
user.unset_location(commit=False)
if locations_updated:
user.reset_locations(location_ids, commit=False)
if role:
role_qualified_id = roles_by_name[role].get_qualified_id()
user.set_role(domain, role_qualified_id)
if web_user:
user.user_data.update({'login_as_user': web_user})
user.save()
if web_user:
if not upload_user.can_edit_web_users():
raise UserUploadError(
_("Only users with the edit web users permission can upload web users"
))
current_user = CouchUser.get_by_username(web_user)
if remove_web_user:
if not current_user or not current_user.is_member_of(
domain):
raise UserUploadError(
_(f"You cannot remove a web user that is not a member of this project. {web_user} is not a member."
))
else:
current_user.delete_domain_membership(domain)
current_user.save()
else:
if not role:
raise UserUploadError(
_(f"You cannot upload a web user without a role. {web_user} does not have a role"
))
if not current_user and is_account_confirmed:
raise UserUploadError(
_(f"You can only set 'Is Account Confirmed' to 'True' on an existing Web User. {web_user} is a new username."
))
if current_user and not current_user.is_member_of(
domain) and is_account_confirmed:
current_user.add_as_web_user(
domain,
role=role_qualified_id,
location_id=user.location_id)
elif not current_user or not current_user.is_member_of(
domain):
invite_data = {
'email': web_user,
'invited_by': upload_user.user_id,
'invited_on': datetime.utcnow(),
'domain': domain,
'role': role_qualified_id,
'supply_point': user.location_id
}
invite = Invitation(**invite_data)
invite.save()
if send_account_confirmation_email:
invite.send_activation_email()
elif current_user.is_member_of(domain):
# edit existing user in the domain
current_user.set_role(domain, role_qualified_id)
if user.location_id:
current_user.set_location(
domain, user.location_id)
else:
current_user.unset_location(domain)
current_user.save()
if send_account_confirmation_email and not web_user:
send_account_confirmation_if_necessary(user)
if is_password(password):
# Without this line, digest auth doesn't work.
# With this line, digest auth works.
# Other than that, I'm not sure what's going on
# Passing use_primary_db=True because of https://dimagi-dev.atlassian.net/browse/ICDS-465
user.get_django_user(
use_primary_db=True).check_password(password)
for group in group_memoizer.by_user_id(user.user_id):
if group.name not in group_names:
group.remove_user(user)
for group_name in group_names:
group_memoizer.by_name(group_name).add_user(user,
save=False)
except (UserUploadError, CouchUser.Inconsistent) as e:
status_row['flag'] = str(e)
ret["rows"].append(status_row)
finally:
try:
group_memoizer.save_all()
except BulkSaveError as e:
_error_message = (
"Oops! We were not able to save some of your group changes. "
"Please make sure no one else is editing your groups "
"and try again.")
logging.exception(('BulkSaveError saving groups. '
'User saw error message "%s". Errors: %s') %
(_error_message, e.errors))
ret['errors'].append(_error_message)
return ret
