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