def domains_for_user(request, selected_domain=None): """ Generate pulldown menu for domains. Cache the entire string alongside the couch_user's doc_id that can get invalidated when the user doc updates via save. """ domain_list = [] if selected_domain != 'public': cached_domains = cache_core.get_cached_prop(request.couch_user.get_id, 'domain_list') if cached_domains: domain_list = [Domain.wrap(x) for x in cached_domains] else: try: domain_list = Domain.active_for_user(request.couch_user) cache_core.cache_doc_prop(request.couch_user.get_id, 'domain_list', [x.to_json() for x in domain_list]) except Exception: if settings.DEBUG: raise else: domain_list = Domain.active_for_user(request.user) notify_exception(request) domain_list = [dict( url=reverse('domain_homepage', args=[d.name]), name=d.long_display_name() ) for d in domain_list] context = { 'is_public': selected_domain == 'public', 'domain_list': domain_list, 'current_domain': selected_domain, } template = { style_utils.BOOTSTRAP_2: 'hqwebapp/partials/domain_list_dropdown.html', style_utils.BOOTSTRAP_3: 'style/includes/domain_list_dropdown.html', }[style_utils.bootstrap_version(request)] return mark_safe(render_to_string(template, context))
def domains_for_user(request, selected_domain=None): lst = list() lst.append('<ul class="dropdown-menu nav-list dropdown-orange">') new_domain_url = reverse("registration_domain") if selected_domain == 'public': # viewing the public domain with a different db, so the user's domains can't readily be accessed. lst.append('<li><a href="%s">Back to My Projects...</a></li>' % reverse("domain_select")) lst.append('<li class="divider"></li>') else: try: domain_list = Domain.active_for_user(request.couch_user) except Exception: if settings.DEBUG: raise else: domain_list = Domain.active_for_user(request.user) notify_exception(request) if len(domain_list) > 0: lst.append('<li class="nav-header">My Projects</li>') for domain in domain_list: default_url = reverse("domain_homepage", args=[domain.name]) lst.append('<li><a href="%s">%s</a></li>' % (default_url, domain.long_display_name())) else: lst.append('<li class="nav-header">No Projects</li>') lst.append('<li class="divider"></li>') lst.append('<li><a href="%s">New Project...</a></li>' % new_domain_url) lst.append('<li><a href="%s">CommCare Exchange...</a></li>' % reverse("appstore")) lst.append("</ul>") return "".join(lst)
def register_domain(request, domain_type=None): domain_type = domain_type or 'commcare' assert domain_type in DOMAIN_TYPES _render = partial(render_registration_view, domain_type=domain_type) is_new = False referer_url = request.GET.get('referer', '') active_domains_for_user = Domain.active_for_user(request.user) if len(active_domains_for_user) <= 0 and not request.user.is_superuser: is_new = True domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(domains_for_user) > 0: vals = dict(requested_domain=domains_for_user[0]) return _render(request, 'registration/confirmation_waiting.html', { 'requested_domain': domains_for_user[0] }) if request.method == 'POST': nextpage = request.POST.get('next') org = request.POST.get('org') form = DomainRegistrationForm(request.POST) if form.is_valid(): reqs_today = RegistrationRequest.get_requests_today() max_req = settings.DOMAIN_MAX_REGISTRATION_REQUESTS_PER_DAY if reqs_today >= max_req: vals = {'error_msg':'Number of domains requested today exceeds limit ('+str(max_req)+') - contact Dimagi', 'show_homepage_link': 1 } return _render(request, 'error.html', vals) request_new_domain( request, form, org, new_user=is_new, domain_type=domain_type) requested_domain = form.cleaned_data['domain_name'] if is_new: vals = dict(alert_message="An email has been sent to %s." % request.user.username, requested_domain=requested_domain) return _render(request, 'registration/confirmation_sent.html', vals) else: messages.success(request, '<strong>The project {project_name} was successfully created!</strong> An email has been sent to {username} for your records.'.format( username=request.user.username, project_name=requested_domain ), extra_tags="html") if nextpage: return HttpResponseRedirect(nextpage) if referer_url: return redirect(referer_url) return HttpResponseRedirect(reverse("domain_homepage", args=[requested_domain])) else: if nextpage: # messages.error(request, "The new project could not be created! Please make sure to fill out all fields of the form.") return orgs_landing(request, org, form=form) else: form = DomainRegistrationForm(initial={'domain_type': domain_type}) return _render(request, 'registration/domain_request.html', { 'form': form, 'is_new': is_new, })
def redirect_to_default(req, domain=None): if not req.user.is_authenticated(): if domain != None: url = reverse('domain_login', args=[domain]) else: try: from corehq.apps.prelogin.views import HomePublicView url = reverse(HomePublicView.urlname) except ImportError: # this happens when the prelogin app is not included. url = reverse('landing_page') else: if domain: domain = normalize_domain_name(domain) domains = [Domain.get_by_name(domain)] else: domains = Domain.active_for_user(req.user) if 0 == len(domains) and not req.user.is_superuser: return redirect('registration_domain', domain_type=get_domain_type(None, req)) elif 1 == len(domains): if domains[0]: domain = domains[0].name if (req.couch_user.is_commcare_user() and not is_mobile_worker_with_report_access( req.couch_user, domain)): url = reverse("cloudcare_main", args=[domain, ""]) else: url = reverse('dashboard_default', args=[domain]) else: raise Http404 else: url = settings.DOMAIN_SELECT_URL return HttpResponseRedirect(url)
def resend_confirmation(request): dom_req = None try: dom_req = RegistrationRequest.get_request_for_username(request.user.username) except Exception: pass if not dom_req: inactive_domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(inactive_domains_for_user) > 0: for domain in inactive_domains_for_user: domain.is_active = True domain.save() return redirect('domain_select') if request.method == 'POST': # If the form has been submitted... try: send_domain_registration_email(dom_req.new_user_username, dom_req.domain, dom_req.activation_guid) except Exception: vals = {'error_msg':'There was a problem with your request', 'error_details':sys.exc_info(), 'show_homepage_link': 1 } return render_to_response(request, 'error.html', vals) else: vals = dict(alert_message="An email has been sent to %s." % dom_req.new_user_username, requested_domain=dom_req.domain) return render_to_response(request, 'registration/confirmation_sent.html', vals) vals = dict(requested_domain=dom_req.domain) return render_to_response(request, 'registration/confirmation_resend.html', vals)
def select(request, domain_select_template='domain/select.html'): domains_for_user = Domain.active_for_user(request.user) if not domains_for_user: return redirect('registration_domain') return render(request, domain_select_template, {})
def resend_confirmation(request): try: dom_req = RegistrationRequest.get_request_for_username(request.user.username) except Exception: dom_req = None if not dom_req: inactive_domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(inactive_domains_for_user) > 0: for domain in inactive_domains_for_user: domain.is_active = True domain.save() return redirect('domain_select') _render = partial( render_registration_view, domain_type='commtrack' if dom_req.project.commtrack_enabled else None) if request.method == 'POST': try: send_domain_registration_email(dom_req.new_user_username, dom_req.domain, dom_req.activation_guid) except Exception: vals = {'error_msg':'There was a problem with your request', 'error_details':sys.exc_info(), 'show_homepage_link': 1 } return _render(request, 'error.html', vals) else: vals = dict(alert_message="An email has been sent to %s." % dom_req.new_user_username, requested_domain=dom_req.domain) return _render(request, 'registration/confirmation_sent.html', vals) return _render(request, 'registration/confirmation_resend.html', { 'requested_domain': dom_req.domain })
def register_user(request, domain_type=None): domain_type = domain_type or "commcare" assert domain_type in DOMAIN_TYPES context = get_domain_context(domain_type) if request.user.is_authenticated(): # Redirect to a page which lets user choose whether or not to create a new account domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: return redirect("registration_domain") else: return redirect("homepage") else: if request.method == "POST": form = NewWebUserRegistrationForm(request.POST) if form.is_valid(): activate_new_user(form, ip=get_ip(request)) new_user = authenticate(username=form.cleaned_data["email"], password=form.cleaned_data["password"]) login(request, new_user) return redirect("registration_domain", domain_type=domain_type) else: form = NewWebUserRegistrationForm(initial={"domain_type": domain_type}) context.update({"form": form, "domain_type": domain_type}) return render(request, "registration/create_new_user.html", context)
def redirect_to_default(req, domain=None): if not req.user.is_authenticated(): if domain != None: url = reverse('domain_login', args=[domain]) else: # this actually gets hijacked by the static site, but is necessary url = reverse('corehq.apps.hqwebapp.views.landing_page') else: if domain: domain = normalize_domain_name(domain) domains = [Domain.get_by_name(domain)] else: domains = Domain.active_for_user(req.user) if 0 == len(domains) and not req.user.is_superuser: return redirect('registration_domain') elif 1 == len(domains): if domains[0]: domain = domains[0].name if req.couch_user.is_commcare_user(): if not is_mobile_worker_with_report_access( req.couch_user, domain): url = reverse("cloudcare_main", args=[domain, ""]) else: url = reverse("saved_reports", args=[domain]) elif req.couch_user.can_view_reports(domain) or req.couch_user.get_viewable_reports(domain): url = reverse('corehq.apps.reports.views.default', args=[domain]) else: url = reverse('corehq.apps.app_manager.views.default', args=[domain]) else: raise Http404 else: url = settings.DOMAIN_SELECT_URL return HttpResponseRedirect(url)
def select( request, redirect_field_name = REDIRECT_FIELD_NAME, domain_select_template = 'domain/select.html' ): domains_for_user = Domain.active_for_user(request.user) if not domains_for_user: return redirect('registration_domain') redirect_to = request.REQUEST.get(redirect_field_name, '') if request.method == 'POST': # If the form has been submitted... form = DomainSelectionForm(domain_list=domains_for_user, data=request.POST) # A form bound to the POST data if form.is_valid(): # We've just checked the submitted data against a freshly-retrieved set of domains # associated with the user. It's safe to set the domain in the sesssion (and we'll # check again on views validated with the domain-checking decorator) form.save(request) # Needs request because it saves domain in session # Weak attempt to give user a good UX - make sure redirect_to isn't garbage. domain = form.cleaned_data['domain_list'].name if not redirect_to or '//' in redirect_to or ' ' in redirect_to: redirect_to = reverse('domain_homepage', args=[domain]) return HttpResponseRedirect(redirect_to) # Redirect after POST else: # An unbound form form = DomainSelectionForm( domain_list=domains_for_user ) vals = dict( next = redirect_to, form = form ) return render_to_response(request, domain_select_template, vals)
def register_user(request, domain_type=None): domain_type = domain_type or 'commcare' if domain_type not in DOMAIN_TYPES: raise Http404() context = get_domain_context(domain_type) if request.user.is_authenticated(): # Redirect to a page which lets user choose whether or not to create a new account domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: return redirect("registration_domain", domain_type=domain_type) else: return redirect("homepage") else: if request.method == 'POST': form = NewWebUserRegistrationForm(request.POST) if form.is_valid(): activate_new_user(form, ip=get_ip(request)) new_user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password']) login(request, new_user) return redirect( 'registration_domain', domain_type=domain_type) else: form = NewWebUserRegistrationForm( initial={'domain_type': domain_type}) context.update({ 'form': form, 'domain_type': domain_type }) return render(request, 'registration/create_new_user.html', context)
def register_user(request, domain_type=None): domain_type = domain_type or 'commcare' if domain_type not in DOMAIN_TYPES: raise Http404() prefilled_email = request.GET.get('e', '') context = get_domain_context(domain_type) if request.user.is_authenticated(): # Redirect to a page which lets user choose whether or not to create a new account domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: return redirect("registration_domain", domain_type=domain_type) else: return redirect("homepage") else: if request.method == 'POST': form = NewWebUserRegistrationForm(request.POST) if form.is_valid(): activate_new_user(form, ip=get_ip(request)) new_user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password']) login(request, new_user) track_workflow.delay(new_user.email, "Requested new account") meta = { 'HTTP_X_FORWARDED_FOR': request.META.get('HTTP_X_FORWARDED_FOR'), 'REMOTE_ADDR': request.META.get('REMOTE_ADDR'), 'opt_into_emails': form.cleaned_data['email_opt_in'], } track_created_hq_account_on_hubspot.delay(new_user, request.COOKIES, meta) requested_domain = form.cleaned_data['hr_name'] if form.cleaned_data['create_domain']: org = None try: requested_domain = request_new_domain( request, form, org, new_user=True, domain_type=domain_type) except NameUnavailableException: context.update({ 'error_msg': _('Project name already taken - please try another'), 'show_homepage_link': 1 }) return render(request, 'error.html', context) context = get_domain_context(form.cleaned_data['domain_type']).update({ 'alert_message': _("An email has been sent to %s.") % request.user.username, 'requested_domain': requested_domain, 'track_domain_registration': True, }) return render(request, 'registration/confirmation_sent.html', context) else: form = NewWebUserRegistrationForm( initial={'domain_type': domain_type, 'email': prefilled_email, 'create_domain': True}) context.update({ 'form': form, 'domain_type': domain_type, }) return render(request, 'registration/create_new_user.html', context)
def domains_for_user(request, selected_domain=None): """ Generate pulldown menu for domains. Cache the entire string alongside the couch_user's doc_id that can get invalidated when the user doc updates via save. """ lst = list() lst.append('<ul class="dropdown-menu nav-list dropdown-orange">') new_domain_url = reverse("registration_domain") if selected_domain == 'public': # viewing the public domain with a different db, so the user's domains can't readily be accessed. lst.append('<li><a href="%s">%s...</a></li>' % (reverse("domain_select"), _("Back to My Projects"))) lst.append('<li class="divider"></li>') else: cached_domains = cache_core.get_cached_prop(request.couch_user.get_id, 'domain_list') if cached_domains: domain_list = [Domain.wrap(x) for x in cached_domains] else: try: domain_list = Domain.active_for_user(request.couch_user) cache_core.cache_doc_prop(request.couch_user.get_id, 'domain_list', [x.to_json() for x in domain_list]) except Exception: if settings.DEBUG: raise else: domain_list = Domain.active_for_user(request.user) notify_exception(request) if len(domain_list) > 0: lst.append('<li class="nav-header">%s</li>' % _('My Projects')) for domain in domain_list: default_url = reverse("domain_homepage", args=[domain.name]) lst.append('<li><a href="%s">%s</a></li>' % (default_url, domain.long_display_name())) else: lst.append('<li class="nav-header">No Projects</li>') lst.append('<li class="divider"></li>') lst.append('<li><a href="%s">%s...</a></li>' % (new_domain_url, _('New Project'))) lst.append('<li><a href="%s">%s...</a></li>' % (reverse("appstore"), _('CommCare Exchange'))) lst.append("</ul>") domain_list_str = "".join(lst) return domain_list_str
def register_user(request): prefilled_email = request.GET.get('e', '') context = get_domain_context() if request.user.is_authenticated(): # Redirect to a page which lets user choose whether or not to create a new account domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: return redirect("registration_domain") else: return redirect("homepage") else: if request.method == 'POST': form = NewWebUserRegistrationForm(request.POST) if form.is_valid(): activate_new_user(form, ip=get_ip(request)) new_user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password']) track_workflow(new_user.email, "Requested new account") login(request, new_user) requested_domain = form.cleaned_data['hr_name'] if form.cleaned_data['create_domain']: try: requested_domain = request_new_domain( request, form, is_new_user=True) except NameUnavailableException: context.update({ 'current_page': {'page_name': _('Oops!')}, 'error_msg': _('Project name already taken - please try another'), 'show_homepage_link': 1 }) return render(request, 'error.html', context) context.update({ 'requested_domain': requested_domain, 'track_domain_registration': True, 'current_page': {'page_name': _('Confirmation Email Sent')}, }) return render(request, 'registration/confirmation_sent.html', context) context.update({'create_domain': form.cleaned_data['create_domain']}) else: form = NewWebUserRegistrationForm( initial={'email': prefilled_email, 'create_domain': True}) context.update({'create_domain': True}) meta = get_meta(request) track_clicked_signup_on_hubspot(prefilled_email, request.COOKIES, meta) context.update({ 'form': form, 'current_page': {'page_name': _('Create an Account')}, 'hide_password_feedback': settings.ENABLE_DRACONIAN_SECURITY_FEATURES, 'is_register_user': True, }) return render(request, 'registration/create_new_user.html', context)
def dispatch(self, request, *args, **kwargs): if request.user.is_authenticated(): # Redirect to a page which lets user choose whether or not to create a new account domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: return redirect("registration_domain") else: return redirect("homepage") response = super(UserRegistrationView, self).dispatch(request, *args, **kwargs) return response
def list_my_domains(request): domain_list = Domain.active_for_user(request.user) lst = list() lst.append('<ul class="nav nav-pills nav-stacked">') for domain in domain_list: default_url = reverse("domain_homepage", args=[domain.name]) lst.append('<li><a href="%s">%s</a></li>' % (default_url, domain.display_name())) lst.append('</ul>') return "".join(lst)
def get(self, request, *args, **kwargs): if self.is_new_user: pending_domains = Domain.active_for_user(request.user, is_active=False) if len(pending_domains) > 0: context = get_domain_context() context.update({ 'requested_domain': pending_domains[0], 'current_page': {'page_name': _('Confirm Account')}, }) return render(request, 'registration/confirmation_waiting.html', context) return super(RegisterDomainView, self).get(request, *args, **kwargs)
def redirect_to_default(req, domain=None): if not req.user.is_authenticated: if domain != None: url = reverse('domain_login', args=[domain]) else: url = reverse('login') elif domain and _two_factor_needed(domain, req): return TemplateResponse( request=req, template='two_factor/core/otp_required.html', status=403, ) else: if domain: domain = normalize_domain_name(domain) domains = [Domain.get_by_name(domain)] else: domains = Domain.active_for_user(req.user) if 0 == len(domains) and not req.user.is_superuser: from corehq.apps.registration.views import track_domainless_new_user track_domainless_new_user(req) return redirect('registration_domain') elif 1 == len(domains): from corehq.apps.dashboard.views import dashboard_default from corehq.apps.users.models import DomainMembershipError if domains[0]: domain = domains[0].name couch_user = req.couch_user try: role = couch_user.get_role(domain) except DomainMembershipError: # commcare users without roles should always be denied access if couch_user.is_commcare_user(): raise Http404() else: # web users without roles are redirected to the dashboard default # view since some domains allow web users to request access if they # don't have it return dashboard_default(req, domain) else: if role and role.default_landing_page: url = get_redirect_url(role.default_landing_page, domain) elif couch_user.is_commcare_user(): url = reverse(get_cloudcare_urlname(domain), args=[domain]) else: return dashboard_default(req, domain) else: raise Http404() else: url = settings.DOMAIN_SELECT_URL return HttpResponseRedirect(url)
def dispatch(self, request, *args, **kwargs): if request.user.is_authenticated: # Redirect to a page which lets user choose whether or not to create a new account domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: track_domainless_new_user(request) return redirect("registration_domain") else: return redirect("homepage") response = super(UserRegistrationView, self).dispatch(request, *args, **kwargs) if settings.IS_SAAS_ENVIRONMENT: ab_tests.SessionAbTest(ab_tests.DEMO_WORKFLOW_V2, request).update_response(response) return response
def track_domainless_new_user(request): if settings.UNIT_TESTING: # don't trigger soft assert in a test return user = request.user is_new_user = not (Domain.active_for_user(user) or user.is_superuser) if is_new_user: _domainless_new_user_soft_assert( False, ("A new user '{}' was redirected to " "RegisterDomainView on '{}', which shouldn't " "actually happen.").format( user.username, settings.SERVER_ENVIRONMENT ) )
def redirect_to_default(req, domain=None): from corehq.apps.cloudcare.views import FormplayerMain if not req.user.is_authenticated(): if domain != None: url = reverse('domain_login', args=[domain]) else: if settings.ENABLE_PRELOGIN_SITE: try: from corehq.apps.prelogin.views import HomePublicView url = reverse(HomePublicView.urlname) except ImportError: # this happens when the prelogin app is not included. url = reverse('login') else: url = reverse('login') elif domain and _two_factor_needed(domain, req): return TemplateResponse( request=req, template='two_factor/core/otp_required.html', status=403, ) else: if domain: domain = normalize_domain_name(domain) domains = [Domain.get_by_name(domain)] else: domains = Domain.active_for_user(req.user) if 0 == len(domains) and not req.user.is_superuser: return redirect('registration_domain') elif 1 == len(domains): if domains[0]: domain = domains[0].name couch_user = req.couch_user if (couch_user.is_commcare_user() and couch_user.can_view_some_reports(domain)): if toggles.USE_FORMPLAYER_FRONTEND.enabled(domain): url = reverse(FormplayerMain.urlname, args=[domain]) else: url = reverse("cloudcare_main", args=[domain, ""]) else: from corehq.apps.dashboard.views import dashboard_default return dashboard_default(req, domain) else: raise Http404 else: url = settings.DOMAIN_SELECT_URL return HttpResponseRedirect(url)
def list_my_domains(request): cached_val = cache_core.get_cached_prop(request.couch_user.get_id, 'list_my_domains') if cached_val: return cached_val.get('list_my_domains', "") domain_list = Domain.active_for_user(request.user) lst = list() lst.append('<ul class="nav nav-pills nav-stacked">') for domain in domain_list: default_url = reverse("domain_homepage", args=[domain.name]) lst.append('<li><a href="%s">%s</a></li>' % (default_url, domain.display_name())) lst.append('</ul>') my_domain_list_str = "".join(lst) ret = {"list_my_domains": my_domain_list_str} cache_core.cache_doc_prop(request.couch_user.get_id, 'list_my_domains', ret) return my_domain_list_str
def process_view(self, request, view_func, view_args, view_kwargs): user = request.user # Lookup is done via the ContentTypes framework, stored in the domain_membership table # id(user) == id(request.user), so we can save a lookup into request by using 'user' alone active_domains = Domain.active_for_user(user) user.active_domains = active_domains user.selected_domain = None # default case domain_from_session = request.session.get(_SESSION_KEY_SELECTED_DOMAIN, None) if domain_from_session and domain_from_session in active_domains: user.selected_domain = domain_from_session if not domain_from_session and len(active_domains) == 1: request.session[_SESSION_KEY_SELECTED_DOMAIN] = active_domains[0] user.selected_domain = active_domains[0] return None
def resend_confirmation(request): try: dom_req = RegistrationRequest.get_request_for_username(request.user.username) except Exception: dom_req = None if not dom_req: inactive_domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(inactive_domains_for_user) > 0: for domain in inactive_domains_for_user: domain.is_active = True domain.save() return redirect('domain_select') context = get_domain_context() if request.method == 'POST': try: send_domain_registration_email(dom_req.new_user_username, dom_req.domain, dom_req.activation_guid, request.user.get_full_name(), request.user.first_name) except Exception: context.update({ 'current_page': {'page_name': _('Oops!')}, 'error_msg': _('There was a problem with your request'), 'error_details': sys.exc_info(), 'show_homepage_link': 1, }) return render(request, 'error.html', context) else: context.update({ 'requested_domain': dom_req.domain, 'current_page': {'page_name': ('Confirmation Email Sent')}, }) return render(request, 'registration/confirmation_sent.html', context) context.update({ 'requested_domain': dom_req.domain, 'current_page': {'page_name': _('Resend Confirmation Email')}, }) return render(request, 'registration/confirmation_resend.html', context)
def resend_confirmation(request): try: dom_req = RegistrationRequest.get_request_for_username(request.user.username) except Exception: dom_req = None if not dom_req: inactive_domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(inactive_domains_for_user) > 0: for domain in inactive_domains_for_user: domain.is_active = True domain.save() return redirect('domain_select') context = get_domain_context(dom_req.project.domain_type) if request.method == 'POST': try: send_domain_registration_email(dom_req.new_user_username, dom_req.domain, dom_req.activation_guid, request.user.get_full_name()) except Exception: context.update({ 'error_msg': _('There was a problem with your request'), 'error_details': sys.exc_info(), 'show_homepage_link': 1, }) return render(request, 'error.html', context) else: context.update({ 'alert_message': _( "An email has been sent to %s.") % dom_req.new_user_username, 'requested_domain': dom_req.domain }) return render(request, 'registration/confirmation_sent.html', context) context.update({ 'requested_domain': dom_req.domain }) return render(request, 'registration/confirmation_resend.html', context)
def resend_confirmation(request): try: dom_req = RegistrationRequest.get_request_for_username(request.user.username) except Exception: dom_req = None if not dom_req: inactive_domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(inactive_domains_for_user) > 0: for domain in inactive_domains_for_user: domain.is_active = True domain.save() return redirect("domain_select") context = get_domain_context(dom_req.project.domain_type) if request.method == "POST": try: send_domain_registration_email(dom_req.new_user_username, dom_req.domain, dom_req.activation_guid) except Exception: context.update( { "error_msg": _("There was a problem with your request"), "error_details": sys.exc_info(), "show_homepage_link": 1, } ) return render(request, "error.html", context) else: context.update( { "alert_message": _("An email has been sent to %s.") % dom_req.new_user_username, "requested_domain": dom_req.domain, } ) return render(request, "registration/confirmation_sent.html", context) context.update({"requested_domain": dom_req.domain}) return render(request, "registration/confirmation_resend.html", context)
def select(request, domain_select_template='domain/select.html', do_not_redirect=False): domains_for_user = Domain.active_for_user(request.user) if not domains_for_user: from corehq.apps.registration.views import track_domainless_new_user track_domainless_new_user(request) return redirect('registration_domain') email = request.couch_user.get_email() open_invitations = [e for e in Invitation.by_email(email) if not e.is_expired] additional_context = { 'domains_for_user': domains_for_user, 'open_invitations': open_invitations, 'current_page': {'page_name': _('Select A Project')}, } last_visited_domain = request.session.get('last_visited_domain') if open_invitations \ or do_not_redirect \ or not last_visited_domain: return render(request, domain_select_template, additional_context) else: domain_obj = Domain.get_by_name(last_visited_domain) if domain_obj and domain_obj.is_active: # mirrors logic in login_and_domain_required if ( request.couch_user.is_member_of(domain_obj) or (request.user.is_superuser and not domain_obj.restrict_superusers) or domain_obj.is_snapshot ): try: from corehq.apps.dashboard.views import dashboard_default return dashboard_default(request, last_visited_domain) except Http404: pass del request.session['last_visited_domain'] return render(request, domain_select_template, additional_context)
def domains_for_user(context, request, selected_domain=None): """ Generate pulldown menu for domains. Cache the entire string alongside the couch_user's doc_id that can get invalidated when the user doc updates via save. """ domain_list = [] if selected_domain != 'public': domain_list = Domain.active_for_user(request.couch_user) domain_list = [dict( url=reverse('domain_homepage', args=[d.name]), name=d.long_display_name() ) for d in domain_list] ctxt = { 'is_public': selected_domain == 'public', 'domain_list': domain_list, 'current_domain': selected_domain, 'DOMAIN_TYPE': context['DOMAIN_TYPE'] } template = { style_utils.BOOTSTRAP_2: 'style/bootstrap2/partials/domain_list_dropdown.html', style_utils.BOOTSTRAP_3: 'style/bootstrap3/partials/domain_list_dropdown.html', }[style_utils.get_bootstrap_version()] return mark_safe(render_to_string(template, ctxt))
def register_user(request): if request.user.is_authenticated(): # Redirect to a page which lets user choose whether or not to create a new account vals = {} domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: return redirect("registration_domain") else: return redirect("domain_list") else: if request.method == 'POST': # If the form has been submitted... form = NewWebUserRegistrationForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass activate_new_user(form) new_user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password']) login(request, new_user) return redirect('registration_domain') else: form = NewWebUserRegistrationForm() # An unbound form vals = dict(form = form) return render_to_response(request, 'registration/create_new_user.html', vals)
def view_generic(request, domain, app_id=None, module_id=None, form_id=None, copy_app_form=None, release_manager=False): """ This is the main view for the app. All other views redirect to here. """ if form_id and not module_id: return bail(request, domain, app_id) app = module = form = None try: if app_id: app = get_app(domain, app_id) if module_id: try: module = app.get_module(module_id) except ModuleNotFoundException: raise Http404() if not module.unique_id: module.get_or_create_unique_id() app.save() if form_id: try: form = module.get_form(form_id) except IndexError: raise Http404() except ModuleNotFoundException: return bail(request, domain, app_id) # Application states that should no longer exist if app: if app.application_version == APP_V1: _assert = soft_assert() _assert(False, 'App version 1.0', { 'domain': domain, 'app_id': app_id }) template = get_app_manager_template( domain, 'app_manager/v1/no_longer_supported.html', 'app_manager/v2/no_longer_supported.html', ) return render(request, template, { 'domain': domain, 'app': app, }) if not app.vellum_case_management: # Soft assert but then continue rendering; template will contain a user-facing warning _assert = soft_assert(['jschweers' + '@' + 'dimagi.com']) _assert(False, 'vellum_case_management=False', { 'domain': domain, 'app_id': app_id }) context = get_apps_base_context(request, domain, app) if app and app.copy_of: # don't fail hard. return HttpResponseRedirect( reverse( "view_app", args=[domain, app.copy_of] # TODO - is this right? )) # grandfather in people who set commcare sense earlier if app and 'use_commcare_sense' in app: if app['use_commcare_sense']: if 'features' not in app.profile: app.profile['features'] = {} app.profile['features']['sense'] = 'true' del app['use_commcare_sense'] app.save() context.update({ 'module': module, 'form': form, }) lang = context['lang'] if app and not module and hasattr(app, 'translations'): context.update({"translations": app.translations.get(lang, {})}) if form: template, form_context = get_form_view_context_and_template( request, domain, form, context['langs']) context.update({ 'case_properties': get_all_case_properties(app), 'usercase_properties': get_usercase_properties(app), }) context.update(form_context) elif module: template = get_module_template(domain, module) # make sure all modules have unique ids app.ensure_module_unique_ids(should_save=True) module_context = get_module_view_context(app, module, lang) context.update(module_context) elif app: context.update(get_app_view_context(request, app)) v2_template = ('app_manager/v2/app_view_release_manager.html' if release_manager else 'app_manager/v2/app_view_settings.html') template = get_app_manager_template(domain, 'app_manager/v1/app_view.html', v2_template) if release_manager: context.update(get_releases_context(request, domain, app_id)) context.update({ 'is_app_settings_page': not release_manager, }) else: from corehq.apps.dashboard.views import NewUserDashboardView if toggles.APP_MANAGER_V2.enabled(domain): context.update(NewUserDashboardView.get_page_context(domain)) template = NewUserDashboardView.template_name else: return HttpResponseRedirect( reverse(NewUserDashboardView.urlname, args=[domain])) # update multimedia context for forms and modules. menu_host = form or module if menu_host: default_file_name = 'module%s' % module_id if form_id: default_file_name = '%s_form%s' % (default_file_name, form_id) specific_media = { 'menu': { 'menu_refs': app.get_menu_media(module, module_id, form=form, form_index=form_id, to_language=lang), 'default_file_name': '{name}_{lang}'.format(name=default_file_name, lang=lang), } } if module and module.uses_media(): def _make_name(suffix): return "{default_name}_{suffix}_{lang}".format( default_name=default_file_name, suffix=suffix, lang=lang, ) specific_media['case_list_form'] = { 'menu_refs': app.get_case_list_form_media(module, module_id, to_language=lang), 'default_file_name': _make_name('case_list_form'), } specific_media['case_list_menu_item'] = { 'menu_refs': app.get_case_list_menu_item_media(module, module_id, to_language=lang), 'default_file_name': _make_name('case_list_menu_item'), } specific_media['case_list_lookup'] = { 'menu_refs': app.get_case_list_lookup_image(module, module_id), 'default_file_name': '{}_case_list_lookup'.format(default_file_name), } if hasattr(module, 'product_details'): specific_media['product_list_lookup'] = { 'menu_refs': app.get_case_list_lookup_image(module, module_id, type='product'), 'default_file_name': '{}_product_list_lookup'.format(default_file_name), } context.update({ 'multimedia': { "object_map": app.get_object_map(), 'upload_managers': { 'icon': MultimediaImageUploadController( "hqimage", reverse(ProcessImageFileUploadView.name, args=[app.domain, app.get_id])), 'audio': MultimediaAudioUploadController( "hqaudio", reverse(ProcessAudioFileUploadView.name, args=[app.domain, app.get_id])), }, } }) try: context['multimedia']['references'] = app.get_references() except ReportConfigurationNotFoundError: pass context['multimedia'].update(specific_media) error = request.GET.get('error', '') context.update({ 'error': error, 'app': app, }) # Pass form for Copy Application to template domain_names = [d.name for d in Domain.active_for_user(request.couch_user)] domain_names.sort() if app and copy_app_form is None: toggle_enabled = toggles.EXPORT_ZIPPED_APPS.enabled( request.user.username) copy_app_form = CopyApplicationForm( domain, app_id, export_zipped_apps_enabled=toggle_enabled) context.update({ 'domain_names': domain_names, }) linked_apps_enabled = toggles.LINKED_APPS.enabled(domain) context.update({ 'copy_app_form': copy_app_form, 'linked_apps_enabled': linked_apps_enabled, }) context['latest_commcare_version'] = get_commcare_versions( request.user)[-1] if app and app.doc_type == 'Application' and has_privilege( request, privileges.COMMCARE_LOGO_UPLOADER): uploader_slugs = ANDROID_LOGO_PROPERTY_MAPPING.keys() from corehq.apps.hqmedia.controller import MultimediaLogoUploadController from corehq.apps.hqmedia.views import ProcessLogoFileUploadView context.update({ "sessionid": request.COOKIES.get('sessionid'), 'uploaders': [ MultimediaLogoUploadController( slug, reverse( ProcessLogoFileUploadView.name, args=[domain, app_id, slug], )) for slug in uploader_slugs ], "refs": { slug: ApplicationMediaReference( app.logo_refs.get(slug, {}).get("path", slug), media_class=CommCareImage, module_id=app.logo_refs.get(slug, {}).get("m_id"), ).as_dict() for slug in uploader_slugs }, "media_info": { slug: app.logo_refs.get(slug) for slug in uploader_slugs if app.logo_refs.get(slug) }, }) live_preview_ab = ab_tests.ABTest(ab_tests.LIVE_PREVIEW, request) domain_obj = Domain.get_by_name(domain) context.update({ 'live_preview_ab': live_preview_ab.context, 'is_onboarding_domain': domain_obj.is_onboarding_domain, 'show_live_preview': (toggles.PREVIEW_APP.enabled(domain) or toggles.PREVIEW_APP.enabled(request.couch_user.username) or (domain_obj.is_onboarding_domain and live_preview_ab.version == ab_tests.LIVE_PREVIEW_ENABLED)) }) response = render(request, template, context) live_preview_ab.update_response(response) response.set_cookie('lang', encode_if_unicode(lang)) return response
def _get_domain_list(couch_user): domains = Domain.active_for_user(couch_user) return [{ 'url': reverse('domain_homepage', args=[domain.name]), 'name': domain.long_display_name(), } for domain in domains]
def register_domain(request, domain_type=None): domain_type = domain_type or 'commcare' if domain_type not in DOMAIN_TYPES or request.couch_user.is_commcare_user( ): raise Http404() context = get_domain_context(domain_type) is_new = False referer_url = request.GET.get('referer', '') active_domains_for_user = Domain.active_for_user(request.user) if len(active_domains_for_user) <= 0 and not request.user.is_superuser: is_new = True domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(domains_for_user) > 0: context['requested_domain'] = domains_for_user[0] return render(request, 'registration/confirmation_waiting.html', context) if request.method == 'POST': nextpage = request.POST.get('next') org = request.POST.get('org') form = DomainRegistrationForm(request.POST) if form.is_valid(): reqs_today = RegistrationRequest.get_requests_today() max_req = settings.DOMAIN_MAX_REGISTRATION_REQUESTS_PER_DAY if reqs_today >= max_req: context.update({ 'error_msg': _('Number of domains requested today exceeds limit (%d) - contact Dimagi' ) % max_req, 'show_homepage_link': 1 }) return render(request, 'error.html', context) try: domain_name = request_new_domain(request, form, org, new_user=is_new, domain_type=domain_type) except NameUnavailableException: context.update({ 'error_msg': _('Project name already taken - please try another'), 'show_homepage_link': 1 }) return render(request, 'error.html', context) if is_new: context.update({ 'alert_message': _("An email has been sent to %s.") % request.user.username, 'requested_domain': domain_name, 'track_domain_registration': True, }) return render(request, 'registration/confirmation_sent.html', context) else: if nextpage: return HttpResponseRedirect(nextpage) if referer_url: return redirect(referer_url) return HttpResponseRedirect( reverse("domain_homepage", args=[domain_name])) else: if nextpage: return orgs_landing(request, org, form=form) else: form = DomainRegistrationForm(initial={'domain_type': domain_type}) context.update({ 'form': form, 'is_new': is_new, }) return render(request, 'registration/domain_request.html', context)
def is_new_user(self): user = self.request.user return not (Domain.active_for_user(user) or user.is_superuser)
def resend_confirmation(request): try: dom_req = RegistrationRequest.get_request_for_username( request.user.username) except Exception: dom_req = None if not dom_req: inactive_domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(inactive_domains_for_user) > 0: for domain in inactive_domains_for_user: domain.is_active = True domain.save() return redirect('domain_select') context = get_domain_context() default_page_name = _('Resend Confirmation Email') if request.method == 'POST': if (datetime.utcnow() - dom_req.request_time ).seconds < CONFIRMATION_RESEND_LIMIT_SECONDS: context = { 'message_body': _(f'Please wait at least {CONFIRMATION_RESEND_LIMIT_SECONDS} ' f'seconds before requesting again.'), 'current_page': { 'page_name': default_page_name }, } return render(request, 'registration/confirmation_error.html', context) try: dom_req.request_time = datetime.utcnow() dom_req.request_ip = get_ip(request) dom_req.save() send_domain_registration_email(dom_req.new_user_username, dom_req.domain, dom_req.activation_guid, request.user.get_full_name(), request.user.first_name) except Exception: context.update({ 'current_page': { 'page_name': _('Oops!') }, 'error_msg': _('There was a problem with your request'), 'show_homepage_link': 1, }) return render(request, 'error.html', context) else: context.update({ 'requested_domain': dom_req.domain, 'current_page': { 'page_name': _('Confirmation Email Sent') }, }) return render(request, 'registration/confirmation_sent.html', context) context.update({ 'requested_domain': dom_req.domain, 'current_page': { 'page_name': default_page_name }, }) return render(request, 'registration/confirmation_resend.html', context)
def view_generic(request, domain, app_id=None, module_id=None, form_id=None, copy_app_form=None, release_manager=False, module_unique_id=None, form_unique_id=None): """ This is the main view for the app. All other views redirect to here. """ if form_id and not module_id and module_unique_id is None: return bail(request, domain, app_id) app = module = form = None try: if app_id: app = get_app(domain, app_id) if module_id: try: module = app.get_module(module_id) except ModuleNotFoundException: raise Http404() if not module.unique_id: module.get_or_create_unique_id() app.save() elif module_unique_id: try: module = app.get_module_by_unique_id(module_unique_id) except ModuleNotFoundException: raise Http404() module_id = module.id if form_id and module is not None: try: form = module.get_form(form_id) except IndexError: raise Http404() elif form_unique_id: try: form = app.get_form(form_unique_id) except FormNotFoundException: raise Http404() form_id = form.id if form is not None and module is None: # this is the case where only the form_unique_id is given module = form.get_module() module_id = module.id except (ModuleNotFoundException, FormNotFoundException): return bail(request, domain, app_id) # Application states that should no longer exist if app: if app.application_version == APP_V1: _assert = soft_assert() _assert(False, 'App version 1.0', { 'domain': domain, 'app_id': app_id }) return render(request, "app_manager/no_longer_supported.html", { 'domain': domain, 'app': app, }) if not app.vellum_case_management and not app.is_remote_app(): # Soft assert but then continue rendering; template will contain a user-facing warning _assert = soft_assert(['jschweers' + '@' + 'dimagi.com']) _assert(False, 'vellum_case_management=False', { 'domain': domain, 'app_id': app_id }) if (form is not None and "usercase_preload" in getattr(form, "actions", {}) and form.actions.usercase_preload.preload): _assert = soft_assert(['dmiller' + '@' + 'dimagi.com']) _assert( False, 'User property easy refs + old-style config = bad', { 'domain': domain, 'app_id': app_id, 'module_id': module_id, 'module_unique_id': module_unique_id, 'form_id': form_id, 'form_unique_id': form_unique_id, }) context = get_apps_base_context(request, domain, app) if app and app.copy_of: # redirect to "main" app rather than specific build return HttpResponseRedirect( reverse("view_app", args=[domain, app.copy_of])) # grandfather in people who set commcare sense earlier if app and 'use_commcare_sense' in app: if app['use_commcare_sense']: if 'features' not in app.profile: app.profile['features'] = {} app.profile['features']['sense'] = 'true' del app['use_commcare_sense'] app.save() context.update({ 'module': module, 'form': form, }) lang = context['lang'] if app and not module and hasattr(app, 'translations'): context.update({"translations": app.translations.get(lang, {})}) if app and not app.is_remote_app(): context.update({ 'add_ons': add_ons.get_dict(request, app, module, form), 'add_ons_layout': add_ons.get_layout(request), }) if form: template, form_context = get_form_view_context_and_template( request, domain, form, context['langs']) context.update(form_context) elif module: template = get_module_template(request.user, module) # make sure all modules have unique ids app.ensure_module_unique_ids(should_save=True) module_context = get_module_view_context(app, module, lang) context.update(module_context) elif app: context.update(get_app_view_context(request, app)) template = 'app_manager/app_view_settings.html' if release_manager: template = 'app_manager/app_view_release_manager.html' if release_manager: context.update(get_releases_context(request, domain, app_id)) context.update({ 'is_app_settings_page': not release_manager, }) else: from corehq.apps.dashboard.views import DomainDashboardView return HttpResponseRedirect( reverse(DomainDashboardView.urlname, args=[domain])) # update multimedia context for forms and modules. menu_host = form or module if menu_host: default_file_name = 'module%s' % module_id if form: default_file_name = '%s_form%s' % (default_file_name, form_id) specific_media = [{ 'menu_refs': app.get_menu_media(module, module_id, form=form, form_index=form_id, to_language=lang), 'default_file_name': '{name}_{lang}'.format(name=default_file_name, lang=lang), }] if not form and module and not isinstance( module, ReportModule) and module.uses_media(): def _make_name(suffix): return "{default_name}_{suffix}_{lang}".format( default_name=default_file_name, suffix=suffix, lang=lang, ) specific_media.append({ 'menu_refs': app.get_case_list_form_media(module, module_id, to_language=lang), 'default_file_name': _make_name('case_list_form'), 'qualifier': 'case_list_form_', }) specific_media.append({ 'menu_refs': app.get_case_list_menu_item_media(module, module_id, to_language=lang), 'default_file_name': _make_name('case_list_menu_item'), 'qualifier': 'case_list-menu_item_', }) if (toggles.CASE_LIST_LOOKUP.enabled(request.user.username) or toggles.CASE_LIST_LOOKUP.enabled(app.domain)): specific_media.append({ 'menu_refs': app.get_case_list_lookup_image(module, module_id), 'default_file_name': '{}_case_list_lookup'.format(default_file_name), 'qualifier': 'case-list-lookupcase', }) if hasattr(module, 'product_details'): specific_media.append({ 'menu_refs': app.get_case_list_lookup_image(module, module_id, type='product'), 'default_file_name': '{}_product_list_lookup'.format(default_file_name), 'qualifier': 'case-list-lookupproduct', }) uploaders = { 'icon': MultimediaImageUploadController( "hqimage", reverse(ProcessImageFileUploadView.name, args=[app.domain, app.get_id])), 'audio': MultimediaAudioUploadController( "hqaudio", reverse(ProcessAudioFileUploadView.name, args=[app.domain, app.get_id])), } context.update({ 'multimedia': { "object_map": app.get_object_map(), 'upload_managers': uploaders, 'upload_managers_js': {type: u.js_options for type, u in six.iteritems(uploaders)}, } }) context['module_icon'] = None if toggles.CUSTOM_ICON_BADGES.enabled(domain): context[ 'module_icon'] = module.custom_icon if module.custom_icon else CustomIcon( ) try: context['multimedia']['references'] = app.get_references() except ReportConfigurationNotFoundError: pass context['nav_menu_media_specifics'] = specific_media error = request.GET.get('error', '') context.update({ 'error': error, 'app': app, }) # Pass form for Copy Application to template domain_names = [d.name for d in Domain.active_for_user(request.couch_user)] domain_names.sort() if app and copy_app_form is None: toggle_enabled = toggles.EXPORT_ZIPPED_APPS.enabled( request.user.username) copy_app_form = CopyApplicationForm( domain, app, export_zipped_apps_enabled=toggle_enabled) context.update({ 'domain_names': domain_names, }) linked_domains_enabled = toggles.LINKED_DOMAINS.enabled(domain) context.update({ 'copy_app_form': copy_app_form, 'linked_domains_enabled': linked_domains_enabled, }) context['latest_commcare_version'] = get_commcare_versions( request.user)[-1] if app and app.doc_type == 'Application' and has_privilege( request, privileges.COMMCARE_LOGO_UPLOADER): uploader_slugs = list(ANDROID_LOGO_PROPERTY_MAPPING.keys()) from corehq.apps.hqmedia.controller import MultimediaLogoUploadController from corehq.apps.hqmedia.views import ProcessLogoFileUploadView uploaders = [ MultimediaLogoUploadController( slug, reverse( ProcessLogoFileUploadView.name, args=[domain, app_id, slug], )) for slug in uploader_slugs ] context.update({ "sessionid": request.COOKIES.get('sessionid'), "uploaders": uploaders, "uploaders_js": [u.js_options for u in uploaders], "refs": { slug: ApplicationMediaReference( app.logo_refs.get(slug, {}).get("path", slug), media_class=CommCareImage, module_id=app.logo_refs.get(slug, {}).get("m_id"), ).as_dict() for slug in uploader_slugs }, "media_info": { slug: app.logo_refs.get(slug) for slug in uploader_slugs if app.logo_refs.get(slug) }, }) context.update({ 'show_live_preview': app and should_show_preview_app(request, app, request.couch_user.username), 'can_preview_form': request.couch_user.has_permission(domain, 'edit_data') }) confirm = request.session.pop('CONFIRM', False) context.update({'confirm': confirm}) response = render(request, template, context) response.set_cookie('lang', encode_if_unicode(lang)) return response
def register_domain(request, domain_type=None): domain_type = domain_type or 'commcare' if domain_type not in DOMAIN_TYPES or request.couch_user.is_commcare_user( ): raise Http404() context = get_domain_context(domain_type) is_new = False referer_url = request.GET.get('referer', '') active_domains_for_user = Domain.active_for_user(request.user) if len(active_domains_for_user) <= 0 and not request.user.is_superuser: is_new = True domains_for_user = Domain.active_for_user(request.user, is_active=False) if len(domains_for_user) > 0: context['requested_domain'] = domains_for_user[0] return render(request, 'registration/confirmation_waiting.html', context) if request.method == 'POST': nextpage = request.POST.get('next') org = request.POST.get('org') form = DomainRegistrationForm(request.POST) if form.is_valid(): reqs_today = RegistrationRequest.get_requests_today() max_req = settings.DOMAIN_MAX_REGISTRATION_REQUESTS_PER_DAY if reqs_today >= max_req: context.update({ 'error_msg': _('Number of domains requested today exceeds limit (%d) - contact Dimagi' ) % max_req, 'show_homepage_link': 1 }) return render(request, 'error.html', context) request_new_domain(request, form, org, new_user=is_new, domain_type=domain_type) requested_domain = form.cleaned_data['domain_name'] if is_new: context.update({ 'alert_message': _("An email has been sent to %s.") % request.user.username, 'requested_domain': requested_domain }) return render(request, 'registration/confirmation_sent.html', context) else: messages.success( request, _('<strong>The project {project} was successfully created!</strong> ' 'An email has been sent to {user} for your records.' ).format(project=requested_domain, user=request.user.username), extra_tags="html") if nextpage: return HttpResponseRedirect(nextpage) if referer_url: return redirect(referer_url) return HttpResponseRedirect( reverse("domain_homepage", args=[requested_domain])) else: if nextpage: return orgs_landing(request, org, form=form) else: form = DomainRegistrationForm(initial={'domain_type': domain_type}) context.update({ 'form': form, 'is_new': is_new, }) return render(request, 'registration/domain_request.html', context)
def register_user(request, domain_type=None): domain_type = domain_type or 'commcare' if domain_type not in DOMAIN_TYPES: raise Http404() prefilled_email = request.GET.get('e', '') context = get_domain_context(domain_type) if request.user.is_authenticated(): # Redirect to a page which lets user choose whether or not to create a new account domains_for_user = Domain.active_for_user(request.user) if len(domains_for_user) == 0: return redirect("registration_domain", domain_type=domain_type) else: return redirect("homepage") else: if request.method == 'POST': form = NewWebUserRegistrationForm(request.POST) if form.is_valid(): activate_new_user(form, ip=get_ip(request)) new_user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password']) login(request, new_user) track_workflow.delay(new_user.email, "Requested new account") meta = { 'HTTP_X_FORWARDED_FOR': request.META.get('HTTP_X_FORWARDED_FOR'), 'REMOTE_ADDR': request.META.get('REMOTE_ADDR'), 'opt_into_emails': form.cleaned_data['email_opt_in'], } track_created_hq_account_on_hubspot.delay( new_user, request.COOKIES, meta) requested_domain = form.cleaned_data['hr_name'] if form.cleaned_data['create_domain']: org = None try: requested_domain = request_new_domain( request, form, org, new_user=True, domain_type=domain_type) except NameUnavailableException: context.update({ 'error_msg': _('Project name already taken - please try another' ), 'show_homepage_link': 1 }) return render(request, 'error.html', context) context = get_domain_context( form.cleaned_data['domain_type']).update({ 'alert_message': _("An email has been sent to %s.") % request.user.username, 'requested_domain': requested_domain, 'track_domain_registration': True, }) return render(request, 'registration/confirmation_sent.html', context) else: form = NewWebUserRegistrationForm( initial={ 'domain_type': domain_type, 'email': prefilled_email, 'create_domain': True }) context.update({ 'form': form, 'domain_type': domain_type, }) return render(request, 'registration/create_new_user.html', context)
def _get_domain_list(couch_user): domains = Domain.active_for_user(couch_user) return [ {"url": reverse("domain_homepage", args=[domain.name]), "name": domain.long_display_name()} for domain in domains ]
def get_domain_links_for_dropdown(couch_user, view_name="domain_homepage"): # Returns dicts with keys 'name', 'display_name', and 'url' return _domains_to_links(Domain.active_for_user(couch_user), view_name)