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 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):
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):
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):
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 _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_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 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 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 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 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 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 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
