def test_domain_transfer(self):
self.transfer.transfer_domain(by_user=self.user, transfer_via='test')
self.assertFalse(self.transfer.active)
self.assertFalse(self.transfer.from_user.is_member_of(self.domain))
self.assertTrue(self.transfer.to_user.is_member_of(self.domain))
user_history = UserHistory.objects.get(
user_id=self.transfer.from_user.get_id)
self.assertEqual(user_history.by_domain, self.domain.name)
self.assertEqual(user_history.for_domain, self.domain.name)
self.assertEqual(user_history.changed_by, self.user.get_id)
self.assertEqual(user_history.change_messages,
UserChangeMessage.domain_removal(self.domain.name))
self.assertEqual(user_history.changed_via, 'test')
self.assertEqual(user_history.changes, {})
user_history = UserHistory.objects.get(
user_id=self.transfer.to_user.get_id)
self.assertEqual(user_history.by_domain, self.domain.name)
self.assertEqual(user_history.for_domain, self.domain.name)
self.assertEqual(user_history.changed_by, self.user.get_id)
self.assertEqual(user_history.change_messages,
UserChangeMessage.domain_addition(self.domain.name))
self.assertEqual(user_history.changed_via, 'test')
self.assertEqual(user_history.changes, {})
def transfer_domain(self, by_user, *args, transfer_via=None, **kwargs):
self.confirm_time = datetime.utcnow()
if 'ip' in kwargs:
self.confirm_ip = kwargs['ip']
self.from_user.transfer_domain_membership(self.domain,
self.to_user,
is_admin=True)
self.from_user.save()
if by_user:
log_user_change(by_domain=self.domain,
for_domain=self.domain,
couch_user=self.from_user,
changed_by_user=by_user,
changed_via=transfer_via,
change_messages=UserChangeMessage.domain_removal(
self.domain))
log_user_change(by_domain=self.domain,
for_domain=self.domain,
couch_user=self.to_user,
changed_by_user=by_user,
changed_via=transfer_via,
change_messages=UserChangeMessage.domain_addition(
self.domain))
self.to_user.save()
self.active = False
self.save()
html_content = render_to_string(
"{template}.html".format(template=self.DIMAGI_CONFIRM_EMAIL),
self.as_dict())
text_content = render_to_string(
"{template}.txt".format(template=self.DIMAGI_CONFIRM_EMAIL),
self.as_dict())
send_html_email_async.delay(
_('There has been a transfer of ownership of {domain}').format(
domain=self.domain),
settings.SUPPORT_EMAIL,
html_content,
text_content=text_content,
)
def __call__(self, request, uuid, **kwargs):
# add the correct parameters to this instance
self.request = request
if 'domain' in kwargs:
self.domain = kwargs['domain']
if request.GET.get('switch') == 'true':
logout(request)
return redirect_to_login(request.path)
if request.GET.get('create') == 'true':
logout(request)
return HttpResponseRedirect(request.path)
try:
invitation = Invitation.objects.get(uuid=uuid)
except (Invitation.DoesNotExist, ValidationError):
messages.error(
request,
_("Sorry, it looks like your invitation has expired. "
"Please check the invitation link you received and try again, or "
"request a project administrator to send you the invitation again."
))
return HttpResponseRedirect(reverse("login"))
if invitation.is_accepted:
messages.error(
request,
_("Sorry, that invitation has already been used up. "
"If you feel this is a mistake please ask the inviter for "
"another invitation."))
return HttpResponseRedirect(reverse("login"))
self.validate_invitation(invitation)
if invitation.is_expired:
return HttpResponseRedirect(reverse("no_permissions"))
# Add zero-width space to username for better line breaking
username = self.request.user.username.replace("@", "​@")
context = {
'formatted_username': username,
'domain': self.domain,
'invite_to': self.domain,
'invite_type': _('Project'),
'hide_password_feedback': has_custom_clean_password(),
}
if request.user.is_authenticated:
context['current_page'] = {'page_name': _('Project Invitation')}
else:
context['current_page'] = {
'page_name': _('Project Invitation, Account Required')
}
if request.user.is_authenticated:
is_invited_user = request.couch_user.username.lower(
) == invitation.email.lower()
if self.is_invited(invitation, request.couch_user
) and not request.couch_user.is_superuser:
if is_invited_user:
# if this invite was actually for this user, just mark it accepted
messages.info(
request,
_("You are already a member of {entity}.").format(
entity=self.inviting_entity))
invitation.is_accepted = True
invitation.save()
else:
messages.error(
request,
_("It looks like you are trying to accept an invitation for "
"{invited} but you are already a member of {entity} with the "
"account {current}. Please sign out to accept this invitation "
"as another user.").format(
entity=self.inviting_entity,
invited=invitation.email,
current=request.couch_user.username))
return HttpResponseRedirect(
self.redirect_to_on_success(invitation.email, self.domain))
if not is_invited_user:
messages.error(
request,
_("The invited user {invited} and your user {current} "
"do not match!").format(
invited=invitation.email,
current=request.couch_user.username))
if request.method == "POST":
couch_user = CouchUser.from_django_user(request.user,
strict=True)
invitation.accept_invitation_and_join_domain(couch_user)
log_user_change(
by_domain=invitation.domain,
for_domain=invitation.domain,
couch_user=couch_user,
changed_by_user=CouchUser.get_by_user_id(
invitation.invited_by),
changed_via=USER_CHANGE_VIA_INVITATION,
change_messages=UserChangeMessage.domain_addition(
invitation.domain))
track_workflow(
request.couch_user.get_email(),
"Current user accepted a project invitation",
{"Current user accepted a project invitation": "yes"})
send_hubspot_form(HUBSPOT_EXISTING_USER_INVITE_FORM, request)
return HttpResponseRedirect(
self.redirect_to_on_success(invitation.email, self.domain))
else:
mobile_user = CouchUser.from_django_user(
request.user).is_commcare_user()
context.update({
'mobile_user':
mobile_user,
"invited_user":
invitation.email
if request.couch_user.username != invitation.email else "",
})
return render(request, self.template, context)
else:
idp = None
if settings.ENFORCE_SSO_LOGIN:
idp = IdentityProvider.get_active_identity_provider_by_username(
invitation.email)
if request.method == "POST":
form = WebUserInvitationForm(request.POST,
is_sso=idp is not None)
if form.is_valid():
# create the new user
invited_by_user = CouchUser.get_by_user_id(
invitation.invited_by)
if idp:
signup_request = AsyncSignupRequest.create_from_invitation(
invitation)
return HttpResponseRedirect(
idp.get_login_url(signup_request.username))
user = activate_new_user_via_reg_form(
form,
created_by=invited_by_user,
created_via=USER_CHANGE_VIA_INVITATION,
domain=invitation.domain,
is_domain_admin=False,
)
user.save()
messages.success(
request,
_("User account for %s created!") %
form.cleaned_data["email"])
invitation.accept_invitation_and_join_domain(user)
messages.success(
self.request,
_('You have been added to the "{}" project space.').
format(self.domain))
authenticated = authenticate(
username=form.cleaned_data["email"],
password=form.cleaned_data["password"],
request=request)
if authenticated is not None and authenticated.is_active:
login(request, authenticated)
track_workflow(
request.POST['email'],
"New User Accepted a project invitation",
{"New User Accepted a project invitation": "yes"})
send_hubspot_form(HUBSPOT_NEW_USER_INVITE_FORM, request,
user)
return HttpResponseRedirect(
self.redirect_to_on_success(invitation.email,
invitation.domain))
else:
if (CouchUser.get_by_username(invitation.email)
or User.objects.filter(
username__iexact=invitation.email).count() > 0):
login_url = reverse("login")
accept_invitation_url = reverse(
'domain_accept_invitation',
args=[invitation.domain, invitation.uuid])
return HttpResponseRedirect(
f"{login_url}"
f"?next={accept_invitation_url}"
f"&username={invitation.email}")
form = WebUserInvitationForm(
initial={
'email': invitation.email,
},
is_sso=idp is not None,
)
context.update({
'is_sso': idp is not None,
'idp_name': idp.name if idp else None,
'invited_user': invitation.email,
})
context.update({"form": form})
return render(request, self.template, context)