def post(self, request, *args, **kwargs):
if self.invite_web_user_form.is_valid():
# If user exists and has already requested access, just add them to the project
# Otherwise, send an invitation
create_invitation = True
data = self.invite_web_user_form.cleaned_data
domain_request = DomainRequest.by_email(self.domain, data["email"])
if domain_request is not None:
domain_request.is_approved = True
domain_request.save()
user = CouchUser.get_by_username(domain_request.email)
if user is not None:
domain_request.send_approval_email()
create_invitation = False
user.add_as_web_user(self.domain, role=data["role"],
location_id=data.get("supply_point", None),
program_id=data.get("program", None))
messages.success(request, "%s added." % data["email"])
else:
messages.success(request, "Invitation sent to %s" % data["email"])
if create_invitation:
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = self.domain
invite = DomainInvitation(**data)
invite.save()
invite.send_activation_email()
return HttpResponseRedirect(reverse(
ListWebUsersView.urlname,
args=[self.domain]
))
return self.get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
if self.invite_web_user_form.is_valid():
data = self.invite_web_user_form.cleaned_data
# create invitation record
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = self.domain
invite = DomainInvitation(**data)
invite.save()
invite.send_activation_email()
messages.success(request, "Invitation sent to %s" % invite.email)
return HttpResponseRedirect(reverse(ListWebUsersView.urlname, args=[self.domain]))
return self.get(request, *args, **kwargs)
def reinvite_web_user(request, domain):
invitation_id = request.POST['invite']
try:
invitation = DomainInvitation.get(invitation_id)
invitation.send_activation_email()
return json_response({'response': _("Invitation resent"), 'status': 'ok'})
except ResourceNotFound:
return json_response({'response': _("Error while attempting resend"), 'status': 'error'})
def reinvite_web_user(request, domain):
invitation_id = request.POST['invite']
try:
invitation = DomainInvitation.get(invitation_id)
invitation.send_activation_email()
return json_response({'response': _("Invitation resent"), 'status': 'ok'})
except ResourceNotFound:
return json_response({'response': _("Error while attempting resend"), 'status': 'error'})
def invite_web_user(request, domain, template="users/invite_web_user.html"):
role_choices = UserRole.role_choices(domain)
if request.method == "POST":
current_users = [user.username for user in WebUser.by_domain(domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(domain)]
form = AdminInvitesUserForm(request.POST,
excluded_emails= current_users + pending_invites,
role_choices=role_choices
)
if form.is_valid():
data = form.cleaned_data
# create invitation record
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = domain
invite = DomainInvitation(**data)
invite.save()
invite.send_activation_email()
messages.success(request, "Invitation sent to %s" % invite.email)
return HttpResponseRedirect(reverse("web_users", args=[domain]))
else:
form = AdminInvitesUserForm(role_choices=role_choices)
context = _users_context(request, domain)
context.update(
registration_form=form
)
return render(request, template, context)
def reinvite_web_user(request, domain):
invitation_id = request.POST["invite"]
try:
invitation = DomainInvitation.get(invitation_id)
invitation.invited_on = datetime.utcnow()
invitation.save()
invitation.send_activation_email()
return json_response({"response": _("Invitation resent"), "status": "ok"})
except ResourceNotFound:
return json_response({"response": _("Error while attempting resend"), "status": "error"})
def resend_pending_invitations():
from corehq.apps.users.models import DomainInvitation
days_to_resend = (15, 29)
days_to_expire = 30
domains = Domain.get_all()
for domain in domains:
invitations = DomainInvitation.by_domain(domain.name)
for invitation in invitations:
days = (datetime.now() - invitation.invited_on).days
if days in days_to_resend:
invitation.send_activation_email(days_to_expire - days)
def resend_pending_invitations():
from corehq.apps.users.models import DomainInvitation
days_to_resend = (15, 29)
days_to_expire = 30
domains = Domain.get_all()
for domain in domains:
invitations = DomainInvitation.by_domain(domain.name)
for invitation in invitations:
days = (datetime.now() - invitation.invited_on).days
if days in days_to_resend:
invitation.send_activation_email(days_to_expire - days)
def invite_web_user_form(self):
role_choices = UserRole.role_choices(self.domain)
if self.request.method == 'POST':
current_users = [user.username for user in WebUser.by_domain(self.domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(self.domain)]
return AdminInvitesUserForm(
self.request.POST,
excluded_emails=current_users + pending_invites,
role_choices=role_choices,
domain=self.domain
)
return AdminInvitesUserForm(role_choices=role_choices, domain=self.domain)
def invite_web_user_form(self):
role_choices = UserRole.role_choices(self.domain)
if self.request.method == 'POST':
current_users = [user.username for user in WebUser.by_domain(self.domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(self.domain)]
return AdminInvitesUserForm(
self.request.POST,
excluded_emails=current_users + pending_invites,
role_choices=role_choices,
domain=self.domain
)
return AdminInvitesUserForm(role_choices=role_choices, domain=self.domain)
def invite_web_user(request, domain, template="users/invite_web_user.html"):
role_choices = UserRole.role_choices(domain)
if request.method == "POST":
current_users = [user.username for user in WebUser.by_domain(domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(domain)]
form = AdminInvitesUserForm(request.POST,
excluded_emails= current_users + pending_invites,
role_choices=role_choices
)
if form.is_valid():
data = form.cleaned_data
# create invitation record
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = domain
invite = DomainInvitation(**data)
invite.save()
invite.send_activation_email()
messages.success(request, "Invitation sent to %s" % invite.email)
return HttpResponseRedirect(reverse("web_users", args=[domain]))
else:
form = AdminInvitesUserForm(role_choices=role_choices)
context = _users_context(request, domain)
context.update(
registration_form=form
)
return render(request, template, context)
def invite_web_user_form(self):
role_choices = UserRole.role_choices(self.domain)
loc = None
if 'location_id' in self.request.GET:
from corehq.apps.locations.models import SQLLocation
loc = SQLLocation.objects.get(location_id=self.request.GET.get('location_id'))
if self.request.method == 'POST':
current_users = [user.username for user in WebUser.by_domain(self.domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(self.domain)]
return AdminInvitesUserForm(
self.request.POST,
excluded_emails=current_users + pending_invites,
role_choices=role_choices,
domain=self.domain
)
return AdminInvitesUserForm(role_choices=role_choices, domain=self.domain, location=loc)
def post(self, request, *args, **kwargs):
if self.invite_web_user_form.is_valid():
data = self.invite_web_user_form.cleaned_data
# create invitation record
data["invited_by"] = request.couch_user.user_id
data["invited_on"] = datetime.utcnow()
data["domain"] = self.domain
invite = DomainInvitation(**data)
invite.save()
invite.send_activation_email()
messages.success(request, "Invitation sent to %s" % invite.email)
return HttpResponseRedirect(reverse(ListWebUsersView.urlname, args=[self.domain]))
return self.get(request, *args, **kwargs)
def invite_web_user_form(self):
role_choices = UserRole.role_choices(self.domain)
loc = None
domain_request = DomainRequest.objects.get(id=self.request_id) if self.request_id else None
initial = {"email": domain_request.email if domain_request else None}
if "location_id" in self.request.GET:
from corehq.apps.locations.models import SQLLocation
loc = SQLLocation.objects.get(location_id=self.request.GET.get("location_id"))
if self.request.method == "POST":
current_users = [user.username for user in WebUser.by_domain(self.domain)]
pending_invites = [di.email for di in DomainInvitation.by_domain(self.domain)]
return AdminInvitesUserForm(
self.request.POST,
excluded_emails=current_users + pending_invites,
role_choices=role_choices,
domain=self.domain,
)
return AdminInvitesUserForm(initial=initial, role_choices=role_choices, domain=self.domain, location=loc)
def web_users(request, domain, template="users/web_users.html"):
context = _users_context(request, domain)
user_roles = [AdminUserRole(domain=domain)]
user_roles.extend(sorted(UserRole.by_domain(domain), key=lambda role: role.name if role.name else u'\uFFFF'))
role_labels = {}
for r in user_roles:
key = 'user-role:%s' % r.get_id if r.get_id else r.get_qualified_id()
role_labels[key] = r.name
invitations = DomainInvitation.by_domain(domain)
for invitation in invitations:
invitation.role_label = role_labels.get(invitation.role, "")
context.update({
'user_roles': user_roles,
'default_role': UserRole.get_default(),
'report_list': get_possible_reports(domain),
'invitations': invitations
})
return render(request, template, context)
def web_users(request, domain, template="users/web_users.html"):
context = _users_context(request, domain)
user_roles = [AdminUserRole(domain=domain)]
user_roles.extend(sorted(UserRole.by_domain(domain), key=lambda role: role.name if role.name else u'\uFFFF'))
role_labels = {}
for r in user_roles:
key = 'user-role:%s' % r.get_id if r.get_id else r.get_qualified_id()
role_labels[key] = r.name
invitations = DomainInvitation.by_domain(domain)
for invitation in invitations:
invitation.role_label = role_labels.get(invitation.role, "")
context.update({
'user_roles': user_roles,
'default_role': UserRole.get_default(),
'report_list': get_possible_reports(domain),
'invitations': invitations
})
return render(request, template, context)
def invite_web_user_form(self):
role_choices = UserRole.role_choices(self.domain)
loc = None
if 'location_id' in self.request.GET:
from corehq.apps.locations.models import SQLLocation
loc = SQLLocation.objects.get(
location_id=self.request.GET.get('location_id'))
if self.request.method == 'POST':
current_users = [
user.username for user in WebUser.by_domain(self.domain)
]
pending_invites = [
di.email for di in DomainInvitation.by_domain(self.domain)
]
return AdminInvitesUserForm(self.request.POST,
excluded_emails=current_users +
pending_invites,
role_choices=role_choices,
domain=self.domain)
return AdminInvitesUserForm(role_choices=role_choices,
domain=self.domain,
location=loc)
def delete_invitation(request, domain):
invitation_id = request.POST["id"]
invitation = DomainInvitation.get(invitation_id)
invitation.delete()
return json_response({"status": "ok"})
def delete_invitation(request, domain):
invitation_id = request.POST['invite']
invitation = DomainInvitation.get(invitation_id)
invitation.delete()
return json_response({'status': 'ok'})
def invitations(self):
invitations = DomainInvitation.by_domain(self.domain)
for invitation in invitations:
invitation.role_label = self.role_labels.get(invitation.role, "")
return invitations
def delete_invitation(request, domain):
invitation_id = request.POST['invite']
invitation = DomainInvitation.get(invitation_id)
invitation.delete()
return json_response({'status': 'ok'})
def invitations(self):
invitations = DomainInvitation.by_domain(self.domain)
for invitation in invitations:
invitation.role_label = self.role_labels.get(invitation.role, "")
return invitations
