def make_meta_block(self, instance_id=None, timestart=None, timeend=None, webuser=None): if timestart is None: timestart = datetime.utcnow() if timeend is None: timeend = datetime.utcnow() if webuser is None: if CommCareUser.get_by_username('*****@*****.**') is None: raise Exception("Pact importer user not created") webuser = CommCareUser.get_by_username('*****@*****.**') if instance_id is None: instance_id = uuid.uuid4().hex meta_block = """ <meta> <deviceID>pact_case_importer</deviceID> <timeStart>%(timestart)s</timeStart> <timeEnd>%(timeend)s</timeEnd> <username>%(username)s</username> <userID>%(userid)s</userID> <instanceID>%(instance_id)s</instanceID> </meta>""" % { "username": webuser.username, "userid": webuser.get_id, "timestart": timestart.strftime('%Y-%m-%dT%H:%M:%SZ'), "timeend": timeend.strftime('%Y-%m-%dT%H:%M:%SZ'), "instance_id": instance_id, } return meta_block
def tearDown(self): user = CommCareUser.get_by_username('*****@*****.**') if user: user.delete() user = CommCareUser.get_by_username('*****@*****.**') if user: user.delete()
def setUp(self): self.domain = Domain.get_by_name(TEST_DOMAIN) self.loc1 = Location.by_site_code(TEST_DOMAIN, 'loc1') self.loc2 = Location.by_site_code(TEST_DOMAIN, 'loc2') self.dis = Location.by_site_code(TEST_DOMAIN, 'dis1') self.user_fac1 = CommCareUser.get_by_username('stella') self.user_fac2 = CommCareUser.get_by_username('bella') self.user_dis = CommCareUser.get_by_username('trella') self.msd_user = CommCareUser.get_by_username('msd_person')
def setUp(self): super(ILSTestScript, self).setUp() self.domain = Domain.get_by_name(TEST_DOMAIN) self.loc1 = self.get_location_by_site_code('loc1') self.loc2 = self.get_location_by_site_code('loc2') self.dis = self.get_location_by_site_code('dis1') self.user_fac1 = CommCareUser.get_by_username('stella') self.user_fac1_en = CommCareUser.get_by_username('stella_en') self.user_fac2 = CommCareUser.get_by_username('bella') self.user_dis = CommCareUser.get_by_username('trella') self.msd_user = CommCareUser.get_by_username('msd_person')
def tearDownClass(cls): MobileBackend.load_by_name(TEST_DOMAIN, TEST_BACKEND).delete() CommCareUser.get_by_username('stella').delete() CommCareUser.get_by_username('super').delete() delete_all_locations() LocationType.objects.all().delete() for product in Product.by_domain(TEST_DOMAIN): product.delete() SQLProduct.objects.all().delete() EWSGhanaConfig.for_domain(TEST_DOMAIN).delete() DocDomainMapping.objects.all().delete() generator.delete_all_subscriptions() Domain.get_by_name(TEST_DOMAIN).delete()
def tearDownClass(cls): delete_domain_phone_numbers(TEST_DOMAIN) CommCareUser.get_by_username('stella').delete() CommCareUser.get_by_username('super').delete() FacilityInCharge.objects.all().delete() LocationType.objects.all().delete() for product in Product.by_domain(TEST_DOMAIN): product.delete() SQLProduct.objects.all().delete() EWSGhanaConfig.for_domain(TEST_DOMAIN).delete() DocDomainMapping.objects.all().delete() Domain.get_by_name(TEST_DOMAIN).delete() super(EWSScriptTest, cls).tearDownClass()
def tearDownClass(cls): CommCareUser.get_by_username("stella").delete() CommCareUser.get_by_username("super").delete() FacilityInCharge.objects.all().delete() delete_all_locations() LocationType.objects.all().delete() for product in Product.by_domain(TEST_DOMAIN): product.delete() SQLProduct.objects.all().delete() EWSGhanaConfig.for_domain(TEST_DOMAIN).delete() DocDomainMapping.objects.all().delete() generator.delete_all_subscriptions() cls.sms_backend_mapping.delete() cls.backend.delete() Domain.get_by_name(TEST_DOMAIN).delete()
def handle(self, *args, **options): username = options['username'] if not username: print "You need a username!" print "Usage: ./manage.py mem_profile_restore --username [email protected]" return couch_user = CommCareUser.get_by_username(username) project = couch_user.project restore_config = RestoreConfig( project=project, restore_user=couch_user.to_ota_restore_user(), params=RestoreParams( version=V2, include_item_count=True, ), cache_settings=RestoreCacheSettings( force_cache=True, cache_timeout=1, overwrite_cache=False, ) ) with resident_set_size(): restore_config.get_payload()
def get(self, request, *args, **kwargs): full_username = request.GET.get('as', '') if not full_username or '@' not in full_username: return HttpResponseBadRequest('Please specify a user using ?as=user@domain') username, domain = full_username.split('@') if not domain.endswith(settings.HQ_ACCOUNT_ROOT): full_username = format_username(username, domain) self.user = CommCareUser.get_by_username(full_username) if not self.user: return HttpResponseNotFound('User %s not found.' % full_username) self.app_id = kwargs.get('app_id', None) raw = request.GET.get('raw') == 'true' if raw: response, _ = self._get_restore_response() return response download = request.GET.get('download') == 'true' if download: response, _ = self._get_restore_response() response['Content-Disposition'] = "attachment; filename={}-restore.xml".format(username) return response return super(AdminRestoreView, self).get(request, *args, **kwargs)
def recipient(self): if self.recipient_type == self.RECIPIENT_TYPE_SELF: return self.case elif self.recipient_type == self.RECIPIENT_TYPE_CASE_OWNER: return self.case_owner elif self.recipient_type == self.RECIPIENT_TYPE_LAST_SUBMITTING_USER: if self.case and self.case.modified_by: return CouchUser.get_by_user_id(self.case.modified_by, domain=self.domain) return None elif self.recipient_type == self.RECIPIENT_TYPE_PARENT_CASE: if self.case: return self.case.parent return None elif self.recipient_type == self.RECIPIENT_TYPE_ALL_CHILD_CASES: if self.case: return list(self.case.get_subcases(index_identifier=DEFAULT_PARENT_IDENTIFIER)) return None elif self.recipient_type == self.RECIPIENT_TYPE_CUSTOM: custom_function = to_function( settings.AVAILABLE_CUSTOM_SCHEDULING_RECIPIENTS[self.recipient_id][0] ) return custom_function(self) elif self.recipient_type == self.RECIPIENT_TYPE_CASE_PROPERTY_USER: username = self.case.get_case_property(self.recipient_id) full_username = format_username(username, self.domain) return CommCareUser.get_by_username(full_username) elif self.recipient_type == self.RECIPIENT_TYPE_CASE_PROPERTY_EMAIL: return EmailAddressRecipient(self.case, self.recipient_id) else: return super(CaseScheduleInstanceMixin, self).recipient
def handle(self, user_list_file, site_code, *args, **kwargs): with open(user_list_file) as fin: users_to_delete = fin.readlines() users_to_delete = [user.strip() for user in users_to_delete] choice = input('Total {} users will be deleted: (Y/N)'.format(len(users_to_delete))) if not choice.startswith('y'): print("Nice!!! Its good to be safe than to be sorry") return print("Deleting users") users_submitted_forms = list() for user in users_to_delete: user_name = user + '@icds-cas.commcarehq.org' mobile_user = CommCareUser.get_by_username(user_name) if not mobile_user: continue if not mobile_user.reporting_metadata.last_submission_for_user.submission_date and\ not mobile_user.reporting_metadata.last_sync_for_user.sync_date: mobile_user.retire() else: users_submitted_forms.append(mobile_user) print("users submitted forms:") print('\n'.join([user.username for user in users_submitted_forms])) print('\n{} users deleted. ' 'Deleting Location with site_code {}'.format(len(users_to_delete)-len(users_submitted_forms), site_code)) location_to_delete = SQLLocation.objects.get(domain='icds-cas', site_code=site_code) location_to_delete.delete() print("Deleted Location as well. Thank you for Using our services")
def test_other_registration_from_invite(self): self.domain_obj.sms_mobile_worker_registration_enabled = True self.domain_obj.enable_registration_welcome_sms_for_mobile_worker = True self.domain_obj.save() user_data = {'abc': 'def'} # Initiate Registration Workflow SelfRegistrationInvitation.initiate_workflow( self.domain, [SelfRegistrationUserInfo('999123', user_data)], app_id=self.app_id, ) self.assertRegistrationInvitation( phone_number='999123', app_id=self.app_id, phone_type=None, android_only=False, require_email=False, custom_user_data=user_data, status=SelfRegistrationInvitation.STATUS_PENDING, ) self.assertLastOutgoingSMS( '+999123', [_MESSAGES[MSG_MOBILE_WORKER_INVITATION_START]]) # Choose phone type 'other' incoming('+999123', '2', self.backend.hq_api_id) self.assertRegistrationInvitation( phone_number='999123', app_id=self.app_id, phone_type=SelfRegistrationInvitation.PHONE_TYPE_OTHER, android_only=False, require_email=False, custom_user_data=user_data, status=SelfRegistrationInvitation.STATUS_PENDING, ) self.assertLastOutgoingSMS( '+999123', [_MESSAGES[MSG_MOBILE_WORKER_JAVA_INVITATION].format(self.domain)]) # Register over SMS incoming('+999123', 'JOIN {} WORKER test'.format(self.domain), self.backend.hq_api_id) user = CommCareUser.get_by_username( format_username('test', self.domain)) self.assertIsNotNone(user) self.assertEqual(user.user_data, dict(self.default_user_data, **user_data)) self.assertEqual( PhoneNumber.get_two_way_number('999123').owner_id, user.get_id) self.assertLastOutgoingSMS( '+999123', [_MESSAGES[MSG_REGISTRATION_WELCOME_MOBILE_WORKER]]) self.assertRegistrationInvitation( status=SelfRegistrationInvitation.STATUS_REGISTERED, )
def validate_sms_users(self): for sms_user in iterate_over_api_objects(self.endpoint.get_smsusers): description = "" user = CommCareUser.get_by_username(self.get_username(sms_user)[0]) if not user: description = "Not exists" EWSMigrationProblem.objects.create( domain=self.domain, external_id=sms_user.id, object_type='smsuser', description=description ) continue phone_numbers = { apply_leniency(connection.phone_number) for connection in sms_user.phone_numbers } if phone_numbers - set(user.phone_numbers): description += "Invalid phone numbers, " phone_to_backend = { connection.phone_number: connection.backend for connection in sms_user.phone_numbers } default_phone_number = [ connection.phone_number for connection in sms_user.phone_numbers if connection.default ] default_phone_number = default_phone_number[0] if default_phone_number else None if default_phone_number and (apply_leniency(default_phone_number) != user.default_phone_number): description += "Invalid default phone number, " for phone_number in user.phone_numbers: vn = VerifiedNumber.by_phone(phone_number) if not vn or vn.owner_id != user.get_id: description += "Phone number not verified, " else: backend = phone_to_backend.get(phone_number) if backend == 'message_tester' and vn.backend_id != 'MOBILE_BACKEND_TEST' \ or (backend != 'message_tester' and vn.backend_id): description += "Invalid backend, " if description: migration_problem, _ = EWSMigrationProblem.objects.get_or_create( domain=self.domain, object_id=user.get_id, object_type='smsuser' ) migration_problem.external_id = sms_user.id migration_problem.description = description.rstrip(' ,') migration_problem.save() else: EWSMigrationProblem.objects.filter( domain=self.domain, external_id=sms_user.id, object_type='smsuser' ).delete()
def _process_user_ownership(di, old_data_item, transaction): """Removes users from data items and add new ones based on the user column. Note the removal does not happen within a context of the "transaction" """ errors = [] domain = old_data_item.domain old_users = old_data_item.users for user in old_users: old_data_item.remove_user(user) for raw_username in di.get('user', []): try: username = normalize_username(str(raw_username), domain) except ValidationError: errors.append( _("Invalid username: '******'. Row is not added") % {'name': raw_username} ) continue user = CommCareUser.get_by_username(username) if user: old_data_item.add_user(user) else: errors.append( _("Unknown user: '******'. But the row is successfully added") % {'name': raw_username} ) return errors
def test_update_user_numeric_username(self): import_users_and_groups(self.domain.name, [self._get_spec(username=123)], [], self.uploading_user, mock.MagicMock()) self.assertIsNotNone( CommCareUser.get_by_username('{}@{}.commcarehq.org'.format( '123', self.domain.name)))
def test_login_as(self): self.web_user.is_superuser = True self.web_user.save() restore_uri = reverse('ota_restore', args=[self.domain]) auth_header = _get_auth_header(self.web_user_username, self.web_user_password) client = Client(HTTP_AUTHORIZATION=auth_header) device_id = "foo" # get the seq id before the change is published kafka_seq = get_topic_offset(topics.SYNCLOG_SQL) resp = client.get(restore_uri, data={ 'as': self.username, "device_id": device_id }, follow=True) self.assertEqual(resp.status_code, 200) pillow = get_user_sync_history_pillow() pillow.process_changes(since=kafka_seq, forever=False) restored_as_user = CommCareUser.get_by_username(self.username) self.assertEqual(len(restored_as_user.devices), 1) self.assertEqual(restored_as_user.devices[0].device_id, device_id)
def post(self, request, *args, **kwargs): domain = request.GET.get('domain') case_type = request.GET.get('case_type') user_name = request.GET.get('user') properties = json.loads(request.body) case_id = properties['case_id'] properties.pop('case_id') couch_user = CommCareUser.get_by_username(user_name) if not couch_user.is_member_of(domain): return HttpResponseForbidden("This user does not have access to this domain.") case = get_case_or_404(domain, case_id) if not case.type == case_type: return HttpResponseBadRequest("Case type mismatch") factory = CaseFactory(domain=domain) factory.update_case( case_id=case_id, update=properties ) return HttpResponse("Case {case_id} updated".format(case_id=case_id))
def check_username(self, in_data): try: username = in_data['username'].strip() except KeyError: return HttpResponseBadRequest('You must specify a username') if username == 'admin' or username == 'demo_user': return {'error': _(u'Username {} is reserved.').format(username)} if '@' in username: return { 'error': _(u'Username {} cannot contain "@".').format(username) } if ' ' in username: return { 'error': _(u'Username {} cannot contain ' 'spaces.').format(username) } full_username = format_username(username, self.domain) if CommCareUser.get_by_username(full_username, strict=True): result = { 'error': _(u'Username {} is already taken').format(username) } else: result = { 'success': _(u'Username {} is available').format(username) } return result
def test_sms_registration_no_user(self): # Test with no username no_username_phone_number = "+99912345678" incoming(no_username_phone_number, 'JOIN {} WORKER'.format(self.domain), self.backend.hq_api_id) self.assertIsNotNone(CommCareUser.get_by_username( format_username(strip_plus(no_username_phone_number), self.domain) ))
def test_create_basic(self): user = CommCareUser.create( self.domain, 'mw1', 's3cr4t', None, None, email='*****@*****.**', device_id='my-pixel', first_name='Mobile', last_name='Worker', ) self.addCleanup(user.delete, deleted_by=None) self.assertEqual(self.domain, user.domain) self.assertEqual('mw1', user.username) self.assertEqual('*****@*****.**', user.email) self.assertEqual(['my-pixel'], user.device_ids) self.assertEqual('Mobile', user.first_name) self.assertEqual(True, user.is_active) self.assertEqual(True, user.is_account_confirmed) # confirm user was created / can be accessed self.assertIsNotNone(CommCareUser.get_by_username('mw1')) self.assertEqual(1, User.objects.filter(username='******').count()) # confirm user can login self.assertEqual(True, self.client.login(username='******', password='******'))
def handle(self, *args, **options): username = options['username'] if not username: print "You need a username!" print "Usage: ./manage.py mem_profile_restore --username [email protected]" return couch_user = CommCareUser.get_by_username(username) project = couch_user.project restore_config = RestoreConfig( project=project, restore_user=couch_user.to_ota_restore_user(), params=RestoreParams( version=V2, include_item_count=True, ), cache_settings=RestoreCacheSettings( force_cache=True, cache_timeout=1, overwrite_cache=False, )) with resident_set_size(): restore_config.get_payload()
def get(self, request, *args, **kwargs): full_username = request.GET.get('as', '') if not full_username or '@' not in full_username: return HttpResponseBadRequest('Please specify a user using ?as=user@domain') username, domain = full_username.split('@') if not domain.endswith(settings.HQ_ACCOUNT_ROOT): full_username = format_username(username, domain) self.user = CommCareUser.get_by_username(full_username) if not self.user: return HttpResponseNotFound('User %s not found.' % full_username) if not self._validate_user_access(self.user): raise Http404() self.app_id = kwargs.get('app_id', None) raw = request.GET.get('raw') == 'true' if raw: response, _ = self._get_restore_response() return response download = request.GET.get('download') == 'true' if download: response, _ = self._get_restore_response() response['Content-Disposition'] = "attachment; filename={}-restore.xml".format(username) return response return super(AdminRestoreView, self).get(request, *args, **kwargs)
def test_sms_registration_disabled(self): self.domain_obj.sms_mobile_worker_registration_enabled = False self.domain_obj.save() formatted_username = format_username('tester', self.domain) phone_number = "+9991234567" # Test without mobile worker registration enabled incoming(phone_number, 'JOIN {} WORKER tester'.format(self.domain), self.backend.hq_api_id) self.assertIsNone(CommCareUser.get_by_username(formatted_username))
def test_get_status(self): now = datetime.utcnow() couch_user = CommCareUser.get_by_username(self.username) UserFixtureStatus( user_id=self.couch_user._id, fixture_type=UserFixtureType.CHOICES[0][0], last_modified=now ).save() self.assertEqual(self.couch_user.fixture_status("fake_status"), UserFixtureStatus.DEFAULT_LAST_MODIFIED) self.assertEqual(couch_user.fixture_status(UserFixtureType.CHOICES[0][0]), now)
def test_upload_with_user_id(self): bulk_upload_async(self.domain.name, list(self.user_specs), list([]), list([])) user = CommCareUser.get_by_username('{}@{}.commcarehq.org'.format( self.user_specs[0]['username'], self.domain.name)) self.assertNotEqual(self.user_specs[0]['user_id'], user._id) self.assertEqual(self.user_specs[0]['phone-number'], user.phone_number) self.assertEqual(self.user_specs[0]['name'], user.name)
def test_sms_registration(self): formatted_username = format_username('tester', self.domain) # Test without mobile worker registration enabled incoming('+9991234567', 'JOIN {} WORKER tester'.format(self.domain), self.backend.hq_api_id) self.assertIsNone(CommCareUser.get_by_username(formatted_username)) # Test with mobile worker registration enabled self.domain_obj.sms_mobile_worker_registration_enabled = True self.domain_obj.save() incoming('+9991234567', 'JOIN {} WORKER tester'.format(self.domain), self.backend.hq_api_id) self.assertIsNotNone(CommCareUser.get_by_username(formatted_username)) # Test a duplicate registration prev_num_users = num_mobile_users(self.domain) incoming('+9991234568', 'JOIN {} WORKER tester'.format(self.domain), self.backend.hq_api_id) current_num_users = num_mobile_users(self.domain) self.assertEqual(prev_num_users, current_num_users)
def admin_fetch_key_records(request, domain): last_issued = request.GET.get('last_issued') if last_issued: last_issued = string_to_datetime(last_issued).replace(tzinfo=None) username = request.GET.get('as', '') key_user = CommCareUser.get_by_username(username) if not key_user: return HttpResponseNotFound('User %s not found.' % username) payload = FetchKeyRecords(domain, key_user._id, last_issued).get_payload() return HttpResponse(payload)
def clean(self): user = CommCareUser.get_by_username(username=self.full_username) if user is None: raise forms.ValidationError("Cannot find user '{}'".format(self.full_username)) # Allowed only login as mobile user # web user would need stronger checks # https://github.com/dimagi/commcare-hq/pull/6940#issuecomment-108765585 if not user.is_commcare_user(): raise forms.ValidationError("User '{}' is not a CommCareUser".format(self.full_username)) return self.cleaned_data
def get_grouping_name(self, user): """ Get the name of province/cbo/user (depending on what is selected) """ if not self.selected_province(): return FixtureDataItem.get(user).fields_without_attributes['name'] elif not self.selected_cbo(): return Group.get(user).name else: return CommCareUser.get_by_username(user).name
def test_sms_registration(self): formatted_username = format_username("tester", self.domain) incoming("+9991234567", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") # Test without mobile worker registration enabled self.assertIsNone(CommCareUser.get_by_username(formatted_username)) # Enable mobile worker registration setattr(self.domain_obj, "sms_mobile_worker_registration_enabled", True) self.domain_obj.save() incoming("+9991234567", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") self.assertIsNotNone(CommCareUser.get_by_username(formatted_username)) # Test a duplicate registration prev_num_users = num_mobile_users(self.domain) incoming("+9991234568", "JOIN {} WORKER tester".format(self.domain), "TEST_CASE_BACKEND") current_num_users = num_mobile_users(self.domain) self.assertEqual(prev_num_users, current_num_users)
def test_arrived_help(self): self.user_fac1.language = 'en' self.user_fac1.save() language_message = """ 5551234 > language hin 5551234 < {0} """.format(LANGUAGE_CONFIRM % dict(language='Hindi')) self.run_script(language_message) user = CommCareUser.get_by_username('stella') self.assertEqual(user.language, 'hin')
def test_arrived_help(self): self.user_fac1.language = 'en' self.user_fac1.save() language_message = """ 5551234 > language hin 5551234 < {0} """.format(unicode(LANGUAGE_CONFIRM) % dict(language='Hindi')) self.run_script(language_message) user = CommCareUser.get_by_username('stella') self.assertEqual(user.language, 'hin')
def test_android_only_registration_from_invite(self): self.domain_obj.sms_mobile_worker_registration_enabled = True self.domain_obj.enable_registration_welcome_sms_for_mobile_worker = True self.domain_obj.save() # Initiate Registration Workflow with patch('corehq.apps.sms.models.SelfRegistrationInvitation.odk_url') as mock_odk_url, \ patch.object(SelfRegistrationInvitation, 'get_user_registration_url', return_value=DUMMY_REGISTRATION_URL), \ patch.object(SelfRegistrationInvitation, 'get_app_info_url', return_value=DUMMY_APP_INFO_URL): mock_odk_url.__get__ = Mock(return_value=DUMMY_APP_ODK_URL) SelfRegistrationInvitation.initiate_workflow( self.domain, [SelfRegistrationUserInfo('999123')], app_id=self.app_id, android_only=True, ) self.assertRegistrationInvitation( phone_number='999123', app_id=self.app_id, phone_type=SelfRegistrationInvitation.PHONE_TYPE_ANDROID, android_only=True, require_email=False, custom_user_data={}, status=SelfRegistrationInvitation.STATUS_PENDING, ) self.assertLastOutgoingSMS('+999123', [ _MESSAGES[MSG_MOBILE_WORKER_ANDROID_INVITATION].format( DUMMY_REGISTRATION_URL), '[commcare app - do not delete] {}'.format(DUMMY_APP_INFO_URL_B64), ]) invite = self._get_sms_registration_invitation() c = Client() response = c.post( '/a/{}/settings/users/commcare/register/{}/'.format( self.domain, invite.token), { 'username': '******', 'password': '******', 'password2': 'abc', 'email': '*****@*****.**', }) self.assertEqual(response.status_code, 200) user = CommCareUser.get_by_username( format_username('new_user', self.domain)) self.assertIsNotNone(user) self.assertEqual(user.user_data, self.default_user_data) self.assertEqual(user.email, '*****@*****.**') self.assertEqual( PhoneNumber.get_two_way_number('999123').owner_id, user.get_id) self.assertRegistrationInvitation( status=SelfRegistrationInvitation.STATUS_REGISTERED, )
def output(usernames, path): with open(path, 'w') as out: writer = csv.writer(out) writer.writerow(["Username", "Location", "State"]) for username in usernames: user = CommCareUser.get_by_username(username) loc = user.sql_location loc_name = loc.name if loc else '' state = loc.get_ancestor_of_type('state') if loc else None state_name = state.name if state else '' writer.writerow([username, loc_name, state_name])
def test_get_status(self): now = datetime.utcnow() couch_user = CommCareUser.get_by_username(self.username) UserFixtureStatus( user_id=self.couch_user._id, fixture_type=UserFixtureType.CHOICES[0][0], last_modified=now, ).save() self.assertEqual(self.couch_user.fixture_status("fake_status"), UserFixtureStatus.DEFAULT_LAST_MODIFIED) self.assertEqual(couch_user.fixture_status(UserFixtureType.CHOICES[0][0]), now)
def make_user(username): user = CommCareUser.get_by_username( '%s@%s.commcarehq.org' % (username, self.domain)) if user: return _report_user_dict(user) return SimplifiedUserInfo( raw_username=username, username_in_report=username, user_id=None, is_active=None, )
def test_stop(self): bootstrap_user(self.loc1, username='******', domain=self.domain.name, phone_number='643', first_name='stop', last_name='Person') script = """ 643 > stop 643 < {0} """.format(unicode(STOP_CONFIRM)) self.run_script(script) contact = CommCareUser.get_by_username('stop_person') self.assertFalse(contact.is_active)
def test_multi_domain(self): dm = DomainPermissionsMirror(source=self.domain.name, mirror=self.other_domain.name) dm.save() import_users_and_groups( self.domain.name, [self._get_spec(username=123, domain=self.other_domain.name)], [], self.uploading_user, mock.MagicMock()) self.assertIsNotNone( CommCareUser.get_by_username('{}@{}.commcarehq.org'.format( '123', self.other_domain.name)))
def clean(self): username = self.cleaned_data["username"] domain = self.cleaned_data["domain"] # Ensure that the username exists either as the raw input or with fully qualified name if domain: extended_username = u"{}@{}.commcarehq.org".format(username, domain) user = CommCareUser.get_by_username(username=extended_username) self.cleaned_data["username"] = extended_username if user is None: raise forms.ValidationError(u"Cannot find user '{}' for domain '{}'".format(username, domain)) else: user = CommCareUser.get_by_username(username=username) if user is None: raise forms.ValidationError(u"Cannot find user '{}'".format(username)) if not user.is_commcare_user(): raise forms.ValidationError(u"User '{}' is not a CommCareUser".format(username)) return self.cleaned_data
def make_user(username): user = CommCareUser.get_by_username('%s@%s.commcarehq.org' % (username, self.domain)) if user: return _report_user_dict(user) return SimplifiedUserInfo( raw_username=username, username_in_report=username, user_id=None, is_active=None, )
def post(self, request): """View's dispatch method automatically calls this""" try: workbook = WorkbookJSONReader(request.file) except AttributeError: return HttpResponseBadRequest("Error processing your Excel (.xlsx) file") try: data_types = workbook.get_worksheet(title='types') except KeyError: return HttpResponseBadRequest("Workbook does not have a sheet called 'types'") for dt in data_types: print "DataType" print dt for di in workbook.get_worksheet(title=dt['tag']): print "DataItem" print di for dt in data_types: data_type = FixtureDataType( domain=self.domain, name=dt['name'], tag=dt['tag'], fields=dt['field'], ) data_type.save() data_items = workbook.get_worksheet(data_type.tag) for di in data_items: print di data_item = FixtureDataItem( domain=self.domain, data_type_id=data_type.get_id, fields=di['field'] ) data_item.save() for group_name in di.get('group', []): group = Group.by_name(self.domain, group_name) if group: data_item.add_group(group) else: messages.error(request, "Unknown group: %s" % group_name) for raw_username in di.get('user', []): username = normalize_username(raw_username, self.domain) user = CommCareUser.get_by_username(username) if user: data_item.add_user(user) else: messages.error(request, "Unknown user: %s" % raw_username) return HttpResponseRedirect(reverse('fixture_view', args=[self.domain]))
def setUp(self): super(UTHTests, self).setUp() delete_all_xforms() delete_all_cases() self.domain = create_domain(UTH_DOMAIN) username = format_username("vscan_user", UTH_DOMAIN) self.vscan_user = CommCareUser.get_by_username(username) or CommCareUser.create(UTH_DOMAIN, username, "secret") self.case_id = self.create_scan_case(self.vscan_user._id, "VH014466XK", "123123", "2014-03-28T10:48:49Z")
def test_other_registration_from_invite(self): self.domain_obj.sms_mobile_worker_registration_enabled = True self.domain_obj.enable_registration_welcome_sms_for_mobile_worker = True self.domain_obj.save() user_data = {'abc': 'def'} # Initiate Registration Workflow SelfRegistrationInvitation.initiate_workflow( self.domain, [SelfRegistrationUserInfo('999123', user_data)], app_id=self.app_id, ) self.assertRegistrationInvitation( phone_number='999123', app_id=self.app_id, phone_type=None, android_only=False, require_email=False, custom_user_data=user_data, status=SelfRegistrationInvitation.STATUS_PENDING, ) self.assertLastOutgoingSMS('+999123', [_MESSAGES[MSG_MOBILE_WORKER_INVITATION_START]]) # Choose phone type 'other' incoming('+999123', '2', self.backend.hq_api_id) self.assertRegistrationInvitation( phone_number='999123', app_id=self.app_id, phone_type=SelfRegistrationInvitation.PHONE_TYPE_OTHER, android_only=False, require_email=False, custom_user_data=user_data, status=SelfRegistrationInvitation.STATUS_PENDING, ) self.assertLastOutgoingSMS('+999123', [_MESSAGES[MSG_MOBILE_WORKER_JAVA_INVITATION].format(self.domain)]) # Register over SMS incoming('+999123', 'JOIN {} WORKER test'.format(self.domain), self.backend.hq_api_id) user = CommCareUser.get_by_username(format_username('test', self.domain)) self.assertIsNotNone(user) self.assertEqual(user.user_data, user_data) self.assertEqual(PhoneNumber.by_phone('999123').owner_id, user.get_id) self.assertLastOutgoingSMS('+999123', [_MESSAGES[MSG_REGISTRATION_WELCOME_MOBILE_WORKER]]) self.assertRegistrationInvitation( status=SelfRegistrationInvitation.STATUS_REGISTERED, )
def test_sms_registration(self): formatted_username = format_username('tester', self.domain) phone_number = "+9991234567" incoming(phone_number, 'JOIN {} WORKER tester'.format(self.domain), self.backend.hq_api_id) self.assertIsNotNone(CommCareUser.get_by_username(formatted_username)) # Test a duplicate registration prev_num_users = num_mobile_users(self.domain) incoming('+9991234568', 'JOIN {} WORKER tester'.format(self.domain), self.backend.hq_api_id) current_num_users = num_mobile_users(self.domain) self.assertEqual(prev_num_users, current_num_users)
def clean(self): user = CommCareUser.get_by_username(username=self.full_username) if user is None: raise forms.ValidationError("Cannot find user '{}'".format( self.full_username)) # Allowed only login as mobile user # web user would need stronger checks # https://github.com/dimagi/commcare-hq/pull/6940#issuecomment-108765585 if not user.is_commcare_user(): raise forms.ValidationError( "User '{}' is not a CommCareUser".format(self.full_username)) return self.cleaned_data
def _get_inactive_dashboard_user_rows(not_logged_in_week): from corehq.apps.users.models import CommCareUser rows = ['"Username","Location","State"'] for username in not_logged_in_week: user = CommCareUser.get_by_username(username) loc = user.sql_location loc_name = loc.name.encode('ascii', 'replace').decode() if loc else '' state = loc.get_ancestor_of_type('state') if loc else None state_name = state.name.encode('ascii', 'replace').decode() if state else '' rows.append('"{}","{}","{}"'.format(username, loc_name, state_name)) return rows
def admin_restore(request): full_username = request.GET.get('as', '') if not full_username or '@' not in full_username: return HttpResponseBadRequest('Please specify a user using ?as=user@domain') username, domain = full_username.split('@') if not domain.endswith(settings.HQ_ACCOUNT_ROOT): full_username = format_username(username, domain) user = CommCareUser.get_by_username(full_username) if not user: return HttpResponseNotFound('User %s not found.' % full_username) return get_restore_response(user.domain, user, **get_restore_params(request))
def setUp(self): delete_all_xforms() delete_all_cases() self.domain = create_domain(UTH_DOMAIN) username = format_username('vscan_user', UTH_DOMAIN) self.vscan_user = CommCareUser.get_by_username( username) or CommCareUser.create(UTH_DOMAIN, username, 'secret') self.case_id = self.create_scan_case(self.vscan_user._id, 'VH014466XK', '123123', '2014-03-28T10:48:49Z')
def admin_restore(request): full_username = request.GET.get('as', '') if not full_username or '@' not in full_username: return HttpResponseBadRequest('Please specify a user using ?as=user@domain') username, domain = full_username.split('@') if not domain.endswith(settings.HQ_ACCOUNT_ROOT): full_username = format_username(username, domain) user = CommCareUser.get_by_username(full_username) if not user: return HttpResponseNotFound('User %s not found.' % full_username) return get_restore_response(user, **get_restore_params(request))
def clean(self): username = self.cleaned_data['username'] domain = self.cleaned_data['domain'] # Ensure that the username exists either as the raw input or with fully qualified name if domain: extended_username = u"{}@{}.commcarehq.org".format(username, domain) user = CommCareUser.get_by_username(username=extended_username) self.cleaned_data['username'] = extended_username if user is None: raise forms.ValidationError( u"Cannot find user '{}' for domain '{}'".format(username, domain) ) else: user = CommCareUser.get_by_username(username=username) if user is None: raise forms.ValidationError(u"Cannot find user '{}'".format(username)) if not user.is_commcare_user(): raise forms.ValidationError(u"User '{}' is not a CommCareUser".format(username)) return self.cleaned_data
def test_android_only_registration_from_invite(self): self.domain_obj.sms_mobile_worker_registration_enabled = True self.domain_obj.enable_registration_welcome_sms_for_mobile_worker = True self.domain_obj.save() # Initiate Registration Workflow with patch('corehq.apps.sms.models.SelfRegistrationInvitation.odk_url') as mock_odk_url, \ patch.object(SelfRegistrationInvitation, 'get_user_registration_url', return_value=DUMMY_REGISTRATION_URL), \ patch.object(SelfRegistrationInvitation, 'get_app_info_url', return_value=DUMMY_APP_INFO_URL): mock_odk_url.__get__ = Mock(return_value=DUMMY_APP_ODK_URL) SelfRegistrationInvitation.initiate_workflow( self.domain, [SelfRegistrationUserInfo('999123')], app_id=self.app_id, android_only=True, ) self.assertRegistrationInvitation( phone_number='999123', app_id=self.app_id, phone_type=SelfRegistrationInvitation.PHONE_TYPE_ANDROID, android_only=True, require_email=False, custom_user_data={}, status=SelfRegistrationInvitation.STATUS_PENDING, ) self.assertLastOutgoingSMS('+999123', [ _MESSAGES[MSG_MOBILE_WORKER_ANDROID_INVITATION].format(DUMMY_REGISTRATION_URL), '[commcare app - do not delete] {}'.format(DUMMY_APP_INFO_URL_B64), ]) invite = self._get_sms_registration_invitation() c = Client() response = c.post('/a/{}/settings/users/commcare/register/{}/'.format(self.domain, invite.token), { 'username': '******', 'password': '******', 'password2': 'abc', 'email': '*****@*****.**', }) self.assertEqual(response.status_code, 200) user = CommCareUser.get_by_username(format_username('new_user', self.domain)) self.assertIsNotNone(user) self.assertEqual(user.user_data, {}) self.assertEqual(user.email, '*****@*****.**') self.assertEqual(PhoneNumber.by_phone('999123').owner_id, user.get_id) self.assertRegistrationInvitation( status=SelfRegistrationInvitation.STATUS_REGISTERED, )
def create_domain_and_user(domain_name, username): domain = create_domain(domain_name) user = CommCareUser.get_by_username(username) if user: user.delete() user = CommCareUser.create(domain_name, username, '***') domain.call_center_config.enabled = True domain.call_center_config.case_owner_id = user.user_id domain.call_center_config.case_type = CASE_TYPE domain.save() sync_call_center_user_case(user) return domain, user