def delete_domain_membership(request, domain, couch_user_id, domain_name):
removing_self = request.couch_user.get_id == couch_user_id
user = WebUser.get_by_user_id(couch_user_id, domain_name)
# don't let a user remove another user's domain membership if they're not the admin of the domain or a superuser
if not removing_self and not (request.couch_user.is_domain_admin(domain_name) or request.couch_user.is_superuser):
messages.error(request, _("You don't have the permission to remove this user's membership"))
elif user.is_domain_admin(domain_name): # don't let a domain admin be removed from the domain
if removing_self:
error_msg = ugettext_noop("Unable remove membership because you are the admin of %s" % domain_name)
else:
error_msg = ugettext_noop("Unable remove membership because %(user)s is the admin of %(domain)s" % {
'user': user.username,
'domain': domain_name
})
messages.error(request, error_msg)
else:
user.delete_domain_membership(domain_name)
user.save()
if removing_self:
success_msg = ugettext_noop("You are no longer a part of the %s project space" % domain_name)
else:
success_msg = ugettext_noop("%(user)s is no longer a part of the %(domain)s project space" % {
'user': user.username,
'domain': domain_name
})
messages.success(request, success_msg)
if removing_self and not user.is_member_of(domain):
return HttpResponseRedirect(reverse("homepage"))
return HttpResponseRedirect(reverse("user_account", args=(domain, couch_user_id)))
def get_members(self, is_active=True):
users = [WebUser.get_by_user_id(user_id) for user_id in self.member_ids]
users = [user for user in users if not user.is_deleted()]
if is_active is True:
return [user for user in users if user.is_active]
else:
return users
def fmt_export_data(self, export):
"""Returns the object used for each row (per export) in the exports table.
This data will eventually be processed as a JSON object.
:return dict
"""
from corehq.apps.export.views.new import DeleteNewCustomExportView
formname = export.formname if isinstance(export, FormExportInstance) else None
return {
'id': export.get_id,
'isDeid': export.is_safe,
'name': export.name,
'description': export.description,
'sharing': export.sharing,
'owner_username': (
WebUser.get_by_user_id(export.owner_id).username
if export.owner_id else UNKNOWN_EXPORT_OWNER
),
'can_edit': export.can_edit(self.request.couch_user),
'exportType': export.type,
'formname': formname,
'deleteUrl': reverse(DeleteNewCustomExportView.urlname,
args=(self.domain, export.type, export.get_id)),
'downloadUrl': reverse(self._download_view(export).urlname, args=(self.domain, export.get_id)),
'editUrl': reverse(self._edit_view(export).urlname, args=(self.domain, export.get_id)),
'lastBuildDuration': '',
'addedToBulk': False,
}
def undo_remove_web_user(request, domain, record_id):
record = DomainRemovalRecord.get(record_id)
record.undo()
messages.success(request, 'You have successfully restored {username}.'.format(
username=WebUser.get_by_user_id(record.user_id).username
))
return HttpResponseRedirect(reverse('web_users', args=[domain]))
def send_confirmation_email(invitation):
invited_user = invitation.email
subject = "%s accepted your invitation to CommCare HQ" % invited_user
recipient = WebUser.get_by_user_id(invitation.invited_by).get_email()
context = {"invited_user": invited_user}
html_content = render_to_string("domain/email/invite_confirmation.html", context)
text_content = render_to_string("domain/email/invite_confirmation.txt", context)
send_html_email_async.delay(subject, recipient, html_content, text_content=text_content)
def remove_web_user(request, domain, couch_user_id):
user = WebUser.get_by_user_id(couch_user_id, domain)
record = user.delete_domain_membership(domain, create_record=True)
user.save()
messages.success(request, 'You have successfully removed {username} from your domain. <a href="{url}" class="post-link">Undo</a>'.format(
username=user.username,
url=reverse('undo_remove_web_user', args=[domain, record.get_id])
), extra_tags="html")
return HttpResponseRedirect(reverse('web_users', args=[domain]))
def add_member(self, couch_user_id):
from corehq.apps.users.models import WebUser
if not isinstance(couch_user_id, basestring):
couch_user_id = couch_user_id.user_id
if couch_user_id not in self.member_ids:
self.member_ids.append(couch_user_id)
user = WebUser.get_by_user_id(couch_user_id)
user.teams.append([self.name, self.get_id])
user.save()
self.save()
def domain_accounts(request, domain, couch_user_id, template="users/domain_accounts.html"):
context = _users_context(request, domain)
couch_user = WebUser.get_by_user_id(couch_user_id, domain)
if request.method == "POST" and 'domain' in request.POST:
domain = request.POST['domain']
couch_user.add_domain_membership(domain)
couch_user.save()
messages.success(request, 'Domain added')
context.update({"user": request.user})
return render(request, template, context)
def remove_member(self, couch_user_id):
from corehq.apps.users.models import WebUser
if couch_user_id in self.member_ids:
for i in range(0,len(self.member_ids)):
if self.member_ids[i] == couch_user_id:
del self.member_ids[i]
user = WebUser.get_by_user_id(couch_user_id)
user.teams.remove([self.name, self.get_id])
self.save()
user.save()
return
def page_context(self):
owner_id = self.export_instance.owner_id
return {
'export_instance': self.export_instance,
'export_home_url': self.export_home_url,
'allow_deid': has_privilege(self.request, privileges.DEIDENTIFIED_DATA),
'has_excel_dashboard_access': domain_has_privilege(self.domain, EXCEL_DASHBOARD),
'has_daily_saved_export_access': domain_has_privilege(self.domain, DAILY_SAVED_EXPORT),
'can_edit': self.export_instance.can_edit(self.request.couch_user),
'has_other_owner': owner_id and owner_id != self.request.couch_user.user_id,
'owner_name': WebUser.get_by_user_id(owner_id).username if owner_id else None,
}
def remove_web_user(request, domain, couch_user_id):
user = WebUser.get_by_user_id(couch_user_id, domain)
# if no user, very likely they just pressed delete twice in rapid succession so
# don't bother doing anything.
if user:
record = user.delete_domain_membership(domain, create_record=True)
user.save()
messages.success(request, 'You have successfully removed {username} from your domain. <a href="{url}" class="post-link">Undo</a>'.format(
username=user.username,
url=reverse('undo_remove_web_user', args=[domain, record.get_id])
), extra_tags="html")
return HttpResponseRedirect(reverse(ListWebUsersView.urlname, args=[domain]))
def update_domain_date(user_id, domain):
from corehq.apps.users.models import WebUser
user = WebUser.get_by_user_id(user_id, domain)
domain_membership = user.get_domain_membership(domain)
today = datetime.today().date()
if domain_membership and (not domain_membership.last_accessed
or domain_membership.last_accessed < today):
domain_membership.last_accessed = today
try:
user.save()
except ResourceConflict:
pass
def fmt_export_data(self, export):
"""Returns the object used for each row (per export) in the exports table.
This data will eventually be processed as a JSON object.
:return dict
"""
from corehq.apps.export.views.new import DeleteNewCustomExportView
formname = export.formname if isinstance(export,
FormExportInstance) else None
return {
'id':
export.get_id,
'isDeid':
export.is_safe,
'name':
export.name,
'description':
export.description,
'sharing':
export.sharing,
'owner_username': (WebUser.get_by_user_id(export.owner_id).username
if export.owner_id else UNKNOWN_EXPORT_OWNER),
'can_edit':
export.can_edit(self.request.couch_user),
'exportType':
export.type,
'filters':
self._get_filters(export),
'formname':
formname,
'deleteUrl':
reverse(DeleteNewCustomExportView.urlname,
args=(self.domain, export.type, export.get_id)),
'downloadUrl':
reverse(self._download_view(export).urlname,
args=(self.domain, export.get_id)),
'editUrl':
reverse(self._edit_view(export).urlname,
args=(self.domain, export.get_id)),
'editNameUrl':
reverse(EditExportNameView.urlname,
args=(self.domain, export.get_id)),
'editDescriptionUrl':
reverse(EditExportDescription.urlname,
args=(self.domain, export.get_id)),
'lastBuildDuration':
'',
'addedToBulk':
False,
'emailedExport':
self._get_daily_saved_export_metadata(export),
'odataUrl':
self._get_odata_url(export),
}
def users(request, domain):
response = reverse("user_account", args=[domain, request.couch_user._id])
if request.couch_user:
try:
user = WebUser.get_by_user_id(request.couch_user._id, domain)
if user and user.has_permission(domain, 'edit_web_users'):
response = reverse("web_users", args=[domain])
elif user and user.has_permission(domain, 'edit_commcare_users'):
response = reverse("commcare_users", args=[domain])
except Exception as e:
logging.exception("Failed to grab user object: %s", e)
return HttpResponseRedirect(response)
def remove_web_user(request, domain, couch_user_id):
user = WebUser.get_by_user_id(couch_user_id, domain)
# if no user, very likely they just pressed delete twice in rapid succession so
# don't bother doing anything.
if user:
record = user.delete_domain_membership(domain, create_record=True)
user.save()
messages.success(request, 'You have successfully removed {username} from your domain. <a href="{url}" class="post-link">Undo</a>'.format(
username=user.username,
url=reverse('undo_remove_web_user', args=[domain, record.get_id])
), extra_tags="html")
return HttpResponseRedirect(reverse('web_users', args=[domain]))
def send_confirmation_email(invitation):
invited_user = invitation.email
subject = '%s accepted your invitation to CommCare HQ' % invited_user
recipient = WebUser.get_by_user_id(invitation.invited_by).get_email()
context = {
'invited_user': invited_user,
}
html_content = render_to_string('domain/email/invite_confirmation.html',
context)
text_content = render_to_string('domain/email/invite_confirmation.txt',
context)
send_HTML_email(subject, recipient, html_content,
text_content=text_content)
def send_confirmation_email(invitation):
invited_user = invitation.email
subject = '%s accepted your invitation to CommCare HQ' % invited_user
recipient = WebUser.get_by_user_id(invitation.invited_by).get_email()
context = {
'invited_user': invited_user,
}
html_content = render_to_string('domain/email/invite_confirmation.html',
context)
text_content = render_to_string('domain/email/invite_confirmation.txt',
context)
send_html_email_async.delay(subject, recipient, html_content,
text_content=text_content)
def domain_accounts(request,
domain,
couch_user_id,
template="users/domain_accounts.html"):
context = _users_context(request, domain)
couch_user = WebUser.get_by_user_id(couch_user_id, domain)
if request.method == "POST" and 'domain' in request.POST:
domain = request.POST['domain']
couch_user.add_domain_membership(domain)
couch_user.save()
messages.success(request, 'Domain added')
context.update({"user": request.user})
return render(request, template, context)
def send_hubspot_form_task_v2(form_id,
web_user_id,
hubspot_cookie,
meta,
extra_fields=None):
# TODO - else avoids transient celery errors. Can remove after deploying to all environments.
web_user = WebUser.get_by_user_id(web_user_id) if isinstance(
web_user_id, six.string_types) else web_user_id
_send_form_to_hubspot(form_id,
web_user,
hubspot_cookie,
meta,
extra_fields=extra_fields)
def delete_domain_membership(request, domain, couch_user_id, domain_name):
removing_self = request.couch_user.get_id == couch_user_id
user = WebUser.get_by_user_id(couch_user_id, domain_name)
# don't let a user remove another user's domain membership if they're not the admin of the domain or a superuser
if not removing_self and not (
request.couch_user.is_domain_admin(domain_name)
or request.couch_user.is_superuser):
messages.error(
request,
_("You don't have the permission to remove this user's membership")
)
elif user.is_domain_admin(
domain_name
): # don't let a domain admin be removed from the domain
if removing_self:
error_msg = ugettext_noop(
"Unable remove membership because you are the admin of %s" %
domain_name)
else:
error_msg = ugettext_noop(
"Unable remove membership because %(user)s is the admin of %(domain)s"
% {
'user': user.username,
'domain': domain_name
})
messages.error(request, error_msg)
else:
user.delete_domain_membership(domain_name)
user.save()
if removing_self:
success_msg = ugettext_noop(
"You are no longer a part of the %s project space" %
domain_name)
else:
success_msg = ugettext_noop(
"%(user)s is no longer a part of the %(domain)s project space"
% {
'user': user.username,
'domain': domain_name
})
messages.success(request, success_msg)
if removing_self and not user.is_member_of(domain):
return HttpResponseRedirect(reverse("homepage"))
return HttpResponseRedirect(
reverse("user_account", args=(domain, couch_user_id)))
def track_confirmed_account_on_hubspot(webuser_id):
webuser = WebUser.get_by_user_id(webuser_id)
vid = _get_user_hubspot_id(webuser)
if vid:
# Only track the property if the contact already exists.
try:
domain = webuser.domain_memberships[0].domain
except (IndexError, AttributeError):
domain = ''
_track_on_hubspot(webuser, {
'confirmed_account': True,
'domain': domain
})
def test_scheduled_report(request, domain, couch_user_id, report_id):
rep = ReportNotification.get(report_id)
try:
user = WebUser.get_by_user_id(couch_user_id, domain)
except CouchUser.AccountTypeError:
user = CommCareUser.get_by_user_id(couch_user_id, domain)
try:
send_report(rep, user)
except SMTPRecipientsRefused:
messages.error(request, "You have no email address configured")
else:
messages.success(request, "Test message sent to %s" % user.get_email())
return HttpResponseRedirect(reverse("user_account", args=(domain, couch_user_id )))
def domain_accounts(request, domain, couch_user_id, template="users/domain_accounts.html"):
context = _users_context(request, domain)
couch_user = WebUser.get_by_user_id(couch_user_id, domain)
if request.method == "POST" and 'domain' in request.POST:
domain = request.POST['domain']
couch_user.add_domain_membership(domain)
couch_user.save()
messages.success(request,'Domain added')
my_domains = couch_user.get_domains()
all_domains = Domain.get_all()
context['other_domains'] = [d.name for d in all_domains if d.name not in my_domains]
context.update({"user": request.user,
"domains": couch_user.get_domains(),
})
return render_to_response(request, template, context)
def get_timezone_for_user(couch_user_or_id, domain):
if couch_user_or_id and not isinstance(couch_user_or_id, AnonymousCouchUser):
if isinstance(couch_user_or_id, CouchUser):
requesting_user = couch_user_or_id
else:
assert isinstance(couch_user_or_id, six.string_types)
try:
requesting_user = WebUser.get_by_user_id(couch_user_or_id)
except CouchUser.AccountTypeError:
requesting_user = None
if requesting_user:
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
return coerce_timezone_value(domain_membership.timezone)
return get_timezone_for_domain(domain)
def import_users(domain, user_specs, group_specs, upload_user_id,
upload_record_id, is_web_upload, task):
from corehq.apps.user_importer.importer import create_or_update_commcare_users_and_groups, \
create_or_update_groups, create_or_update_web_users
upload_user = WebUser.get_by_user_id(upload_user_id)
DownloadBase.set_progress(task, 0, 100)
total = len(user_specs) + len(group_specs)
DownloadBase.set_progress(task, 0, total)
group_memoizer, group_results = create_or_update_groups(
domain, group_specs)
DownloadBase.set_progress(task, len(group_specs), total)
def _update_progress(value, start=0):
DownloadBase.set_progress(task, start + value, total)
if is_web_upload:
user_results = create_or_update_web_users(
domain,
user_specs,
upload_user=upload_user,
upload_record_id=upload_record_id,
update_progress=functools.partial(_update_progress,
start=len(group_specs)))
else:
user_results = create_or_update_commcare_users_and_groups(
domain,
user_specs,
upload_user=upload_user,
upload_record_id=upload_record_id,
group_memoizer=group_memoizer,
update_progress=functools.partial(_update_progress,
start=len(group_specs)))
results = {
'errors': group_results['errors'] + user_results['errors'],
'rows': user_results['rows']
}
upload_record = UserUploadRecord.objects.using(DEFAULT_DB_ALIAS).get(
pk=upload_record_id)
upload_record.task_id = task.request.id
upload_record.result = results
upload_record.save()
DownloadBase.set_progress(task, total, total)
return {'messages': results}
def get_timezone_for_user(couch_user_or_id, domain):
if couch_user_or_id:
if isinstance(couch_user_or_id, CouchUser):
requesting_user = couch_user_or_id
else:
assert isinstance(couch_user_or_id, basestring)
try:
requesting_user = WebUser.get_by_user_id(couch_user_or_id)
except CouchUser.AccountTypeError:
requesting_user = None
if requesting_user:
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
return coerce_timezone_value(domain_membership.timezone)
return get_timezone_for_domain(domain)
def send_test_scheduled_report(request, domain, scheduled_report_id):
from corehq.apps.reports.tasks import send_report
from corehq.apps.users.models import CouchUser, CommCareUser, WebUser
user_id = request.couch_user._id
notification = ReportNotification.get(scheduled_report_id)
try:
user = WebUser.get_by_user_id(user_id, domain)
except CouchUser.AccountTypeError:
user = CommCareUser.get_by_user_id(user_id, domain)
try:
send_report.delay(notification._id)
except Exception, e:
import logging
logging.exception(e)
messages.error(request, "An error occured, message unable to send")
def send_test_scheduled_report(request, domain, scheduled_report_id):
from corehq.apps.reports.tasks import send_report
from corehq.apps.users.models import CouchUser, CommCareUser, WebUser
user_id = request.couch_user._id
notification = ReportNotification.get(scheduled_report_id)
try:
user = WebUser.get_by_user_id(user_id, domain)
except CouchUser.AccountTypeError:
user = CommCareUser.get_by_user_id(user_id, domain)
try:
send_report.delay(notification._id)
except Exception, e:
import logging
logging.exception(e)
messages.error(request, "An error occured, message unable to send")
def get_timezone(couch_user_id, domain):
#todo cleanup
timezone = None
if couch_user_id:
try:
requesting_user = WebUser.get_by_user_id(couch_user_id)
except CouchUser.AccountTypeError:
return pytz.utc
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
timezone = tz_utils.coerce_timezone_value(domain_membership.timezone)
if not timezone:
current_domain = Domain.get_by_name(domain)
try:
timezone = tz_utils.coerce_timezone_value(current_domain.default_timezone)
except pytz.UnknownTimeZoneError:
timezone = pytz.utc
return timezone
def page_context(self):
owner_id = self.export_instance.owner_id
schema = self.get_export_schema(
self.domain,
self.request.GET.get('app_id')
or getattr(self.export_instance, 'app_id'),
self.export_instance.identifier,
)
if self.export_instance.owner_id or not self.export_instance._id:
sharing_options = SharingOption.CHOICES
else:
sharing_options = [SharingOption.EDIT_AND_EXPORT]
allow_deid = has_privilege(self.request, privileges.DEIDENTIFIED_DATA)
if self.export_instance.is_odata_config:
allow_deid = allow_deid and toggles.ALLOW_DEID_ODATA_FEED.enabled(
self.domain)
return {
'export_instance':
self.export_instance,
'export_home_url':
self.export_home_url,
'allow_deid':
allow_deid,
'has_excel_dashboard_access':
domain_has_privilege(self.domain, EXCEL_DASHBOARD),
'has_daily_saved_export_access':
domain_has_privilege(self.domain, DAILY_SAVED_EXPORT),
'can_edit':
self.export_instance.can_edit(self.request.couch_user),
'has_other_owner':
owner_id and owner_id != self.request.couch_user.user_id,
'owner_name':
WebUser.get_by_user_id(owner_id).username if owner_id else None,
'format_options': ["xls", "xlsx", "csv"],
'number_of_apps_to_process':
schema.get_number_of_apps_to_process(),
'sharing_options':
sharing_options,
'terminology':
self.terminology,
}
def get_timezone_for_user(couch_user_or_id, domain):
if couch_user_or_id and not isinstance(couch_user_or_id,
AnonymousCouchUser):
if isinstance(couch_user_or_id, CouchUser):
requesting_user = couch_user_or_id
else:
assert isinstance(couch_user_or_id, six.string_types)
soft_assert_type_text(couch_user_or_id)
try:
requesting_user = WebUser.get_by_user_id(couch_user_or_id)
except CouchUser.AccountTypeError:
requesting_user = None
if requesting_user:
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
return coerce_timezone_value(domain_membership.timezone)
return get_timezone_for_domain(domain)
def get_timezone_for_user(couch_user_or_id, domain):
# todo cleanup
timezone = None
if couch_user_or_id:
if isinstance(couch_user_or_id, CouchUser):
requesting_user = couch_user_or_id
else:
assert isinstance(couch_user_or_id, basestring)
try:
requesting_user = WebUser.get_by_user_id(couch_user_or_id)
except CouchUser.AccountTypeError:
return pytz.utc
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
timezone = coerce_timezone_value(domain_membership.timezone)
if not timezone:
current_domain = Domain.get_by_name(domain)
timezone = coerce_timezone_value(current_domain.default_timezone)
return timezone
def get_timezone_for_user(couch_user_or_id, domain):
# todo cleanup
timezone = None
if couch_user_or_id:
if isinstance(couch_user_or_id, CouchUser):
requesting_user = couch_user_or_id
else:
assert isinstance(couch_user_or_id, basestring)
try:
requesting_user = WebUser.get_by_user_id(couch_user_or_id)
except CouchUser.AccountTypeError:
return pytz.utc
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
timezone = coerce_timezone_value(domain_membership.timezone)
if not timezone:
current_domain = Domain.get_by_name(domain)
timezone = coerce_timezone_value(current_domain.default_timezone)
return timezone
def page_context(self):
owner_id = self.export_instance.owner_id
return {
'export_instance':
self.export_instance,
'export_home_url':
self.export_home_url,
'allow_deid':
has_privilege(self.request, privileges.DEIDENTIFIED_DATA),
'has_excel_dashboard_access':
domain_has_privilege(self.domain, EXCEL_DASHBOARD),
'has_daily_saved_export_access':
domain_has_privilege(self.domain, DAILY_SAVED_EXPORT),
'can_edit':
self.export_instance.can_edit(self.request.couch_user),
'has_other_owner':
owner_id and owner_id != self.request.couch_user.user_id,
'owner_name':
WebUser.get_by_user_id(owner_id).username if owner_id else None,
}
def remove_web_user(request, domain, couch_user_id):
user = WebUser.get_by_user_id(couch_user_id, domain)
# if no user, very likely they just pressed delete twice in rapid succession so
# don't bother doing anything.
if user:
record = user.delete_domain_membership(domain, create_record=True)
user.save()
if record:
message = _('You have successfully removed {username} from your '
'project space. <a href="{url}" class="post-link">Undo</a>')
messages.success(request, message.format(
username=user.username,
url=reverse('undo_remove_web_user', args=[domain, record.get_id])
), extra_tags="html")
else:
message = _('It appears {username} has already been removed from your project space.')
messages.success(request, message.format(username=user.username))
return HttpResponseRedirect(
reverse(ListWebUsersView.urlname, args=[domain]))
def get_timezone(couch_user_id, domain):
#todo cleanup
timezone = None
if couch_user_id:
try:
requesting_user = WebUser.get_by_user_id(couch_user_id)
except CouchUser.AccountTypeError:
return pytz.utc
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
timezone = tz_utils.coerce_timezone_value(
domain_membership.timezone)
if not timezone:
current_domain = Domain.get_by_name(domain)
try:
timezone = tz_utils.coerce_timezone_value(
current_domain.default_timezone)
except pytz.UnknownTimeZoneError:
timezone = pytz.utc
return timezone
def orgs_landing(request, org, template="orgs/orgs_landing.html", form=None, add_form=None, add_member_form=None, add_team_form=None, update_form=None):
organization = Organization.get_by_name(org)
reg_form_empty = not form
add_form_empty = not add_form
add_member_form_empty = not add_member_form
add_team_form_empty = not add_team_form
update_form_empty = not update_form
reg_form = form or DomainRegistrationForm(initial={'org': organization.name})
add_form = add_form or AddProjectForm(org)
add_member_form = add_member_form or AddMemberForm(org)
add_team_form = add_team_form or AddTeamForm(org)
update_form = update_form or UpdateOrgInfo(initial={'org_title': organization.title, 'email': organization.email, 'url': organization.url, 'location': organization.location})
current_teams = Team.get_by_org(org)
current_domains = Domain.get_by_organization(org)
members = [WebUser.get_by_user_id(user_id) for user_id in organization.members]
vals = dict( org=organization, domains=current_domains, reg_form=reg_form,
add_form=add_form, reg_form_empty=reg_form_empty, add_form_empty=add_form_empty, update_form=update_form, update_form_empty=update_form_empty, add_member_form=add_member_form, add_member_form_empty=add_member_form_empty, add_team_form=add_team_form, add_team_form_empty=add_team_form_empty, teams=current_teams, members=members)
return render_to_response(request, template, vals)
def get_timezone_for_user(couch_user_or_id, domain):
if couch_user_or_id and not isinstance(couch_user_or_id,
AnonymousCouchUser):
if isinstance(couch_user_or_id, CouchUser):
requesting_user = couch_user_or_id
else:
assert isinstance(couch_user_or_id, str), type(couch_user_or_id)
try:
requesting_user = WebUser.get_by_user_id(couch_user_or_id)
except CouchUser.AccountTypeError:
requesting_user = None
if requesting_user:
domain_membership = requesting_user.get_domain_membership(domain)
if domain_membership:
if settings.SERVER_ENVIRONMENT in settings.ICDS_ENVS:
if domain_membership.override_global_tz:
return coerce_timezone_value(
domain_membership.timezone)
else:
return coerce_timezone_value(domain_membership.timezone)
return get_timezone_for_domain(domain)
def update_hubspot_properties(webuser_id, properties):
webuser = WebUser.get_by_user_id(webuser_id)
vid = _get_user_hubspot_id(webuser)
if vid:
_track_on_hubspot(webuser, properties)
def track_user_sign_in_on_hubspot(webuser_id, hubspot_cookie, meta):
webuser = WebUser.get_by_user_id(webuser_id)
_send_form_to_hubspot(HUBSPOT_SIGNIN_FORM_ID, webuser, hubspot_cookie,
meta)
def register_fcm_device_token(request, domain, couch_user_id, device_token):
user = WebUser.get_by_user_id(couch_user_id)
user.fcm_device_token = device_token
user.save()
return HttpResponse()
def owner(self):
id = self.owner_id
try:
return WebUser.get_by_user_id(id)
except CouchUser.AccountTypeError:
return CommCareUser.get_by_user_id(id)
def track_built_app_on_hubspot(webuser_id):
webuser = WebUser.get_by_user_id(webuser_id)
vid = _get_user_hubspot_id(webuser)
if vid:
# Only track the property if the contact already exists.
_track_on_hubspot(webuser, {'built_app': True})
def send_hubspot_form_task_v2(form_id, web_user_id, hubspot_cookie, meta,
extra_fields=None):
# TODO - else avoids transient celery errors. Can remove after deploying to all environments.
web_user = WebUser.get_by_user_id(web_user_id) if isinstance(web_user_id, six.string_types) else web_user_id
_send_form_to_hubspot(form_id, web_user, hubspot_cookie, meta,
extra_fields=extra_fields)
def send_hubspot_form_task_v2(form_id, web_user_id, hubspot_cookie, meta,
extra_fields=None):
web_user = WebUser.get_by_user_id(web_user_id)
_send_form_to_hubspot(form_id, web_user, hubspot_cookie, meta,
extra_fields=extra_fields)
def add_domain_membership(request, domain, couch_user_id, domain_name):
user = WebUser.get_by_user_id(couch_user_id, domain)
if domain_name:
user.add_domain_membership(domain_name)
user.save()
return HttpResponseRedirect(reverse("user_account", args=(domain, couch_user_id)))
def update_subscription_properties_by_user(web_user_id, properties):
web_user = WebUser.get_by_user_id(web_user_id)
identify(web_user.username, properties)
update_hubspot_properties(web_user, properties)
def tearDown(self):
WebUser.get_by_user_id(self.web_user.user_id).delete()
self.domain_obj.delete()
def send_hubspot_form_task(form_id, web_user_id, hubspot_cookie, meta,
extra_fields=None):
web_user = WebUser.get_by_user_id(web_user_id)
_send_form_to_hubspot(form_id, web_user, hubspot_cookie, meta,
extra_fields=extra_fields)
def add_domain_membership(request, domain, couch_user_id, domain_name):
user = WebUser.get_by_user_id(couch_user_id, domain)
if domain_name:
user.add_domain_membership(domain_name)
user.save()
return HttpResponseRedirect(reverse("user_account", args=(domain, couch_user_id)))
def tearDown(self):
WebUser.get_by_user_id(self.web_user.user_id).delete()
self.domain_obj.delete()
def register_fcm_device_token(request, domain, couch_user_id, device_token):
user = WebUser.get_by_user_id(couch_user_id)
user.fcm_device_token = device_token
user.save()
return HttpResponse()
def owner(self):
id = self.owner_id
try:
return WebUser.get_by_user_id(id)
except CouchUser.AccountTypeError:
return CommCareUser.get_by_user_id(id)
def tearDown(self):
WebUser.get_by_user_id(self.web_user.user_id).delete(deleted_by=None)
self.domain_obj.delete()
super().tearDown()
def update_subscription_properties_by_user(web_user_id, properties):
web_user = WebUser.get_by_user_id(web_user_id)
identify_v2(web_user.username, properties)
update_hubspot_properties_v2(web_user, properties)
def account(request, domain, couch_user_id, template="users/account.html"):
context = _users_context(request, domain)
couch_user = CouchUser.get_by_user_id(couch_user_id, domain)
if not couch_user:
raise Http404
context.update({
'couch_user': couch_user,
})
if couch_user.is_commcare_user():
context.update({
'reset_password_form': SetPasswordForm(user=""),
'only_numeric': (request.project.password_format() == 'n'),
})
if couch_user.is_deleted():
if couch_user.is_commcare_user():
return render_to_response(request, 'users/deleted_account.html', context)
else:
raise Http404
# phone-numbers tab
if request.method == "POST" and request.POST['form_type'] == "phone-numbers":
phone_number = request.POST['phone_number']
if re.match(r'\d+', phone_number):
couch_user.add_phone_number(phone_number)
couch_user.save()
#messages.success(request, 'Phone number added')
else:
messages.error(request, "Please enter digits only")
# domain-accounts tab
if not couch_user.is_commcare_user():
all_domains = couch_user.get_domains()
admin_domains = []
for d in all_domains:
if couch_user.is_domain_admin(d):
admin_domains.append(d)
context.update({"user": request.user,
"domains": admin_domains
})
# scheduled reports tab
context.update({
# for phone-number tab
'phone_numbers': couch_user.phone_numbers,
# for commcare-accounts tab
# "other_commcare_accounts": other_commcare_accounts,
})
#project settings tab
if couch_user.user_id == request.couch_user.user_id and not couch_user.is_commcare_user():
web_user = WebUser.get_by_user_id(couch_user.user_id)
dm = web_user.get_domain_membership(domain)
if dm:
domain_obj = Domain.get_by_name(domain)
if request.method == "POST" and request.POST['form_type'] == "project-settings":
# deal with project settings data
project_settings_form = ProjectSettingsForm(request.POST)
if project_settings_form.is_valid():
if project_settings_form.save(web_user, domain):
messages.success(request, "Your project settings were successfully saved!")
else:
messages.error(request, "There seems to have been an error saving your project settings. Please try again!")
else:
project_settings_form = ProjectSettingsForm(initial={'global_timezone': domain_obj.default_timezone,
'user_timezone': dm.timezone,
'override_global_tz': dm.override_global_tz})
context.update({
'proj_settings_form': project_settings_form,
'override_global_tz': dm.override_global_tz
})
# for basic tab
context.update(_handle_user_form(request, domain, couch_user))
return render_to_response(request, template, context)
