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):
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 _login(req, domain_name, template_name):
if req.user.is_authenticated() and req.method == "GET":
redirect_to = req.GET.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain_name:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(reverse('domain_homepage', args=[domain_name]))
if req.method == 'POST' and domain_name and '@' not in req.POST.get('auth-username', '@'):
req.POST._mutable = True
req.POST['auth-username'] = format_username(req.POST['auth-username'], domain_name)
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
context = {}
if domain_name:
domain = Domain.get_by_name(domain_name)
req_params = req.GET if req.method == 'GET' else req.POST
context.update({
'domain': domain_name,
'hr_name': domain.display_name() if domain else domain_name,
'next': req_params.get('next', '/a/%s/' % domain),
'allow_domain_requests': domain.allow_domain_requests,
})
auth_view = HQLoginView if not domain_name else CloudCareLoginView
return auth_view.as_view(template_name=template_name, extra_context=context)(req)
def post_list(self, request, **kwargs):
domain = kwargs.get('domain')
request.domain = domain
username = request.POST.get('username')
password = request.POST.get('password')
if username is None:
return HttpResponseBadRequest('Missing required parameter: username')
if password is None:
return HttpResponseBadRequest('Missing required parameter: password')
if '@' not in username:
username = format_username(username, domain)
# Convert to the appropriate type of user
couch_user = CouchUser.get_by_username(username)
if couch_user is None or not couch_user.is_member_of(domain) or not couch_user.check_password(password):
return HttpResponseForbidden()
if couch_user.is_commcare_user():
user_resource = v0_1.CommCareUserResource()
elif couch_user.is_web_user():
user_resource = v0_1.WebUserResource()
else:
return HttpResponseForbidden()
bundle = user_resource.build_bundle(obj=couch_user, request=request)
bundle = user_resource.full_dehydrate(bundle)
return user_resource.create_response(request, bundle, response_class=HttpResponse)
def clean_mobile_worker_username(
domain, username, name_too_long_message=None, name_reserved_message=None, name_exists_message=None
):
max_username_length = get_mobile_worker_max_username_length(domain)
if len(username) > max_username_length:
raise forms.ValidationError(
name_too_long_message
or _("Username %(username)s is too long. Must be under %(max_length)s characters.")
% {"username": username, "max_length": max_username_length}
)
if username in UNALLOWED_MOBILE_WORKER_NAMES:
raise forms.ValidationError(
name_reserved_message or _('The username "%(username)s" is reserved for CommCare.') % {"username": username}
)
username = format_username(username, domain)
validate_username(username)
if CouchUser.username_exists(username):
raise forms.ValidationError(name_exists_message or _("This Mobile Worker already exists."))
return username
def get_restore_as_user(request, domain):
"""
returns (user, set_cookie), where set_cookie is a function to be called on
the eventual response
"""
if not hasattr(request, 'couch_user'):
raise Http404()
def set_cookie(response): # set_coookie is a noop by default
return response
cookie_name = six.moves.urllib.parse.quote(
'restoreAs:{}:{}'.format(domain, request.couch_user.username))
username = request.COOKIES.get(cookie_name)
if username:
user = CouchUser.get_by_username(format_username(username, domain))
if user:
return user, set_cookie
else:
def set_cookie(response): # overwrite the default noop set_cookie
response.delete_cookie(cookie_name)
return response
return request.couch_user, set_cookie
def _process_log_subreport(domain, xform):
form_data = xform.form_data
logs = _get_logs(form_data, 'log_subreport', 'log')
logged_in_username = None
logged_in_user_id = None
to_save = []
for i, log in enumerate(logs):
if not log:
continue
if log["type"] == 'login':
# j2me log = user_id_prefix-username
logged_in_username = log["msg"].split('-')[1]
cc_username = format_username(logged_in_username, domain)
logged_in_user_id = get_user_id_by_username(cc_username)
elif log["type"] == 'user' and log["msg"][:5] == 'login':
# android log = login|username|user_id
msg_split = log["msg"].split('|')
logged_in_username = msg_split[1]
logged_in_user_id = msg_split[2]
to_save.append(DeviceReportEntry(
xform_id=xform.form_id,
i=i,
domain=domain,
type=log["type"],
msg=log["msg"],
# must accept either date or datetime string
date=log["@date"],
server_date=xform.received_on,
app_version=form_data.get('app_version'),
device_id=form_data.get('device_id'),
username=logged_in_username,
user_id=logged_in_user_id,
))
DeviceReportEntry.objects.bulk_create(to_save)
def _login(req, domain, domain_type, template_name, domain_context=None):
from corehq.apps.registration.views import get_domain_context
if req.user.is_authenticated() and req.method != "POST":
redirect_to = req.REQUEST.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(reverse('domain_homepage', args=[domain]))
if req.method == 'POST' and domain and '@' not in req.POST.get('username', '@'):
req.POST._mutable = True
req.POST['username'] = format_username(req.POST['username'], domain)
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
context = domain_context or get_domain_context(domain_type)
context['domain'] = domain
if domain:
context['next'] = req.REQUEST.get('next', '/a/%s/' % domain)
return django_login(req, template_name=template_name,
authentication_form=EmailAuthenticationForm if not domain else CloudCareAuthenticationForm,
extra_context=context)
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 _login(req, domain, template_name):
if req.user.is_authenticated() and req.method != "POST":
redirect_to = req.REQUEST.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(reverse('domain_homepage', args=[domain]))
if req.method == 'POST' and domain and '@' not in req.POST.get('username', '@'):
req.POST._mutable = True
req.POST['username'] = format_username(req.POST['username'], domain)
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
context = {}
if domain:
context.update({
'domain': domain,
'next': req.REQUEST.get('next', '/a/%s/' % domain),
})
return django_login(req, template_name=template_name,
authentication_form=EmailAuthenticationForm if not domain else CloudCareAuthenticationForm,
extra_context=context)
def get_id_from_name(uploaded_name, domain, cache):
'''
:param uploaded_name: A username or group name
:param domain:
:param cache:
:return: Looks for the given name and returns the corresponding id if the
user or group exists and None otherwise. Searches for user first, then
group.
'''
if uploaded_name in cache:
return cache[uploaded_name]
try:
name_as_address = uploaded_name
if '@' not in name_as_address:
name_as_address = format_username(uploaded_name, domain)
user = CouchUser.get_by_username(name_as_address)
id = getattr(user, 'couch_id', None)
except NoResultFound:
id = None
if not id:
group = Group.by_name(domain, uploaded_name, one=True)
id = getattr(group, 'get_id', None)
cache[uploaded_name] = id
return id
def clean(self):
try:
password = self.cleaned_data['password']
password_2 = self.cleaned_data['password_2']
except KeyError:
pass
else:
if password != password_2:
raise forms.ValidationError("Passwords do not match")
if self.password_format == 'n' and not password.isnumeric():
raise forms.ValidationError("Password is not numeric")
try:
username = self.cleaned_data['username']
except KeyError:
pass
else:
if len(username) > CommCareAccountForm.max_len_username:
raise forms.ValidationError(
"Username %s is too long. Must be under %d characters."
% (username, CommCareAccountForm.max_len_username))
validate_username('*****@*****.**' % username)
domain = self.cleaned_data['domain']
username = format_username(username, domain)
num_couch_users = len(CouchUser.view("users/by_username",
key=username,
reduce=False))
if num_couch_users > 0:
raise forms.ValidationError("CommCare user already exists")
# set the cleaned username to [email protected]
self.cleaned_data['username'] = username
return self.cleaned_data
def handle(self, *args, **options):
if len(args) < 1:
raise CommandError('Usage: manage.py submit_forms <domain>')
domain = args[0]
key = make_form_couch_key(domain)
submissions = XFormInstance.view('reports_forms/all_forms',
startkey=key,
endkey=key+[{}],
include_docs=True
)
ids_by_username = dict()
def get_id(username):
if username in ids_by_username:
return ids_by_username[username]
else:
userID = get_db().view('users/logins_by_username', key=username).one()
userID = userID['value'] if userID else None
ids_by_username[username] = userID
return userID
for submission in submissions:
if 'meta' in submission.form:
username = format_username(submission.form['meta']['username'], domain)
userID = get_id(username)
if userID:
submission.form['meta']['userID'] = userID
submission.save()
print submission._id, username, userID
else:
print "skipped: %s" % submission._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': _('Username {} is reserved.').format(username)}
try:
validate_email("{}@example.com".format(username))
if BAD_MOBILE_USERNAME_REGEX.search(username) is not None:
raise ValidationError("Username contained an invalid character")
except ValidationError:
if '..' in username:
return {
'error': _("Username may not contain consecutive . (period).")
}
if username.endswith('.'):
return {
'error': _("Username may not end with a . (period).")
}
return {
'error': _("Username may not contain special characters.")
}
full_username = format_username(username, self.domain)
exists = user_exists(full_username)
if exists.exists:
if exists.is_deleted:
result = {'warning': _('Username {} belonged to a user that was deleted.'
' Reusing it may have unexpected consequences.').format(username)}
else:
result = {'error': _('Username {} is already taken').format(username)}
else:
result = {'success': _('Username {} is available').format(username)}
return result
def test_assign_to_user_in_different_domain(self):
other_user = CommCareUser.create('bad-domain', format_username('bad-domain-user', self.domain), "****")
case = self._new_case()
try:
assign_case(case.case_id, other_user._id)
self.fail('reassigning to user in wrong domain should fail')
except CaseAssignmentError:
pass
def _get_unique_username(domain, base, suffix=0, tries_left=3):
if tries_left == 0:
raise AssertionError("Username {} on domain {} exists in multiple variations, "
"what's up with that?".format(base, domain))
with_suffix = "{}{}".format(base, suffix) if suffix else base
username = format_username(with_suffix, domain)
if not CommCareUser.username_exists(username):
return username
return _get_unique_username(domain, base, suffix + 1, tries_left - 1)
def get_from_user(name):
try:
name_as_address = name
if '@' not in name_as_address:
name_as_address = format_username(name, domain)
user = CouchUser.get_by_username(name_as_address)
return getattr(user, 'couch_id', None)
except NoResultFound:
return None
def create_mobile_worker(self, in_data):
if not self.can_add_extra_users:
return {
'error': _("No Permission."),
}
try:
user_data = in_data['mobileWorker']
except KeyError:
return {
'error': _("Please provide mobile worker data."),
}
try:
form_data = {}
for k, v in user_data.get('customFields', {}).items():
form_data["{}-{}".format(CUSTOM_DATA_FIELD_PREFIX, k)] = v
for f in ['username', 'password', 'first_name', 'last_name', 'location_id']:
form_data[f] = user_data[f]
form_data['domain'] = self.domain
self.request.POST = form_data
except Exception as e:
return {
'error': _("Check your request: %s" % e)
}
if self.new_mobile_worker_form.is_valid() and self.custom_data.is_valid():
username = self.new_mobile_worker_form.cleaned_data['username']
password = self.new_mobile_worker_form.cleaned_data['password']
first_name = self.new_mobile_worker_form.cleaned_data['first_name']
last_name = self.new_mobile_worker_form.cleaned_data['last_name']
location_id = self.new_mobile_worker_form.cleaned_data['location_id']
couch_user = CommCareUser.create(
self.domain,
format_username(username, self.domain),
password,
device_id="Generated from HQ",
first_name=first_name,
last_name=last_name,
user_data=self.custom_data.get_data_to_save(),
)
if location_id:
couch_user.set_location(SQLLocation.objects.get(location_id=location_id))
return {
'success': True,
'editUrl': reverse(
EditCommCareUserView.urlname,
args=[self.domain, couch_user.userID]
)
}
return {
'error': _("Forms did not validate"),
}
def get_user_id(self, username, domain):
cc_username = format_username(username, domain)
result = CouchUser.view(
'users/by_username',
key=cc_username,
include_docs=False,
)
row = result.one()
if row:
return row["id"]
def setUpClass(cls):
super(ReadableQuestionsAPITest, cls).setUpClass()
cls.project = create_domain(cls.domain)
cls.password = "******"
cls.username = format_username('reed', cls.domain)
cls.user = CommCareUser.create(
cls.domain,
cls.username,
cls.password
)
def generate_username(domain, first_name, last_name):
if first_name and last_name:
username = u'%s_%s' % (first_name, last_name)
elif first_name:
username = first_name
else:
username = '******' + uuid.uuid4().hex[:8]
username = re.sub('[^\w]', '', username)
username = username[:40]
if CouchUser.username_exists(format_username(username, domain)):
for i in range(2, 10000):
tmp_username = u'%s-%s' % (username, i)
if not CouchUser.username_exists(format_username(tmp_username, domain)):
username = tmp_username
break
# Perform standard validation
return clean_mobile_worker_username(domain, username)
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 transfer_to_domain(self, domain, app_id):
username = format_username(raw_username(self.username), domain)
self.change_username(username)
self.domain = domain
for form in self.get_forms():
form.domain = domain
form.app_id = app_id
form.save()
for case in self.get_cases():
case.domain = domain
case.save()
self.save()
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 setUpClass(cls):
super(CaseAPIMiscTests, cls).setUpClass()
cls.domain = uuid.uuid4().hex
cls.project = create_domain(cls.domain)
cls.username = uuid.uuid4().hex
cls.password = "******"
cls.user = CommCareUser.create(
cls.domain,
format_username(cls.username, cls.domain),
cls.password
)
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 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 login(req, template_name="login_and_password/login.html"):
# this view, and the one below, is overridden because
# we need to set the base template to use somewhere
# somewhere that the login page can access it.
if req.user.is_authenticated() and req.method != "POST":
return HttpResponseRedirect(reverse('homepage'))
if req.method == 'POST' and req.POST.get('domain') and '@' not in req.POST.get('username', '@'):
req.POST._mutable = True
req.POST['username'] = format_username(req.POST['username'], req.POST['domain'])
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
return django_login(req, template_name=template_name, authentication_form=EmailAuthenticationForm if not req.GET.get('domain') else CloudCareAuthenticationForm)
def _get_user_info_from_log(domain, log):
logged_in_username = None
logged_in_user_id = None
if log["type"] == 'login':
# j2me log = user_id_prefix-username
logged_in_username = log["msg"].split('-')[1]
cc_username = format_username(logged_in_username, domain)
logged_in_user_id = get_user_id_by_username(cc_username)
elif log["type"] == 'user' and log["msg"][:5] == 'login':
# android log = login|username|user_id
msg_split = log["msg"].split('|')
logged_in_username = msg_split[1]
logged_in_user_id = msg_split[2]
return logged_in_username, logged_in_user_id
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)
overwrite_cache = request.GET.get("ignore_cache") == "true"
return get_restore_response(user.domain, user, overwrite_cache=overwrite_cache, **get_restore_params(request))
def create_user(username):
return CommCareUser.create(self.domain,
format_username(username, self.domain),
password)
def _login(req, domain_name, custom_login_page, extra_context=None):
extra_context = extra_context or {}
if req.user.is_authenticated and req.method == "GET":
redirect_to = req.GET.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain_name:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(
reverse('domain_homepage', args=[domain_name]))
if req.method == 'POST' and domain_name and '@' not in req.POST.get(
'auth-username', '@'):
with mutable_querydict(req.POST):
req.POST['auth-username'] = format_username(
req.POST['auth-username'], domain_name)
if 'auth-username' in req.POST:
couch_user = CouchUser.get_by_username(
req.POST['auth-username'].lower())
if couch_user:
new_lang = couch_user.language
old_lang = req.session.get(LANGUAGE_SESSION_KEY)
update_session_language(req, old_lang, new_lang)
req.base_template = settings.BASE_TEMPLATE
context = {}
context.update(extra_context)
template_name = custom_login_page if custom_login_page else 'login_and_password/login.html'
if not custom_login_page and domain_name:
domain_obj = Domain.get_by_name(domain_name)
req_params = req.GET if req.method == 'GET' else req.POST
context.update({
'domain': domain_name,
'hr_name': domain_obj.display_name(),
'next': req_params.get('next', '/a/%s/' % domain_name),
'allow_domain_requests': domain_obj.allow_domain_requests,
'current_page': {
'page_name':
_('Welcome back to %s!') % domain_obj.display_name()
},
})
else:
commcare_hq_name = commcare_hq_names(
req)['commcare_hq_names']["COMMCARE_HQ_NAME"]
context.update({
'current_page': {
'page_name': _('Welcome back to %s!') % commcare_hq_name
},
})
if settings.SERVER_ENVIRONMENT in settings.ICDS_ENVS:
auth_view = CloudCareLoginView
else:
auth_view = HQLoginView if not domain_name else CloudCareLoginView
demo_workflow_ab_v2 = ab_tests.SessionAbTest(ab_tests.DEMO_WORKFLOW_V2,
req)
if settings.IS_SAAS_ENVIRONMENT:
context['demo_workflow_ab_v2'] = demo_workflow_ab_v2.context
response = auth_view.as_view(template_name=template_name,
extra_context=context)(req)
if settings.IS_SAAS_ENVIRONMENT:
demo_workflow_ab_v2.update_response(response)
return response
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', None, None)
return user
def create_user(username):
username = format_username(username, cls.domain)
return CommCareUser.create(cls.domain, username, cls.password)
def test_android_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 'android'
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)
incoming('+999123', '1', self.backend.hq_api_id)
self.assertRegistrationInvitation(
phone_number='999123',
app_id=self.app_id,
phone_type=SelfRegistrationInvitation.PHONE_TYPE_ANDROID,
android_only=False,
require_email=False,
custom_user_data=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,
dict(self.default_user_data, **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 id_to_username(issuer_id):
return format_username(compress_nikshay_id(issuer_id, 3), self.domain)
