def _create_new_account(self, reg_form): activate_new_user(reg_form, ip=get_ip(self.request)) new_user = authenticate(username=reg_form.cleaned_data['email'], password=reg_form.cleaned_data['password']) if 'phone_number' in reg_form.cleaned_data and reg_form.cleaned_data[ 'phone_number']: web_user = WebUser.get_by_username(new_user.username) web_user.phone_numbers.append( reg_form.cleaned_data['phone_number']) web_user.save() is_mobile = reg_form.cleaned_data.get('is_mobile') email = new_user.email properties = {} if is_mobile: toggles.MOBILE_SIGNUP_REDIRECT_AB_TEST_CONTROLLER.set(email, True) variation = toggles.MOBILE_SIGNUP_REDIRECT_AB_TEST.enabled( email, toggles.NAMESPACE_USER) properties = { "mobile_signups_test_march2018test": "variation" if variation else "control" } track_workflow(email, "Requested new account", properties) login(self.request, new_user)
def _create_new_account(self, reg_form): activate_new_user(reg_form, ip=get_ip(self.request)) new_user = authenticate(username=reg_form.cleaned_data['email'], password=reg_form.cleaned_data['password']) web_user = WebUser.get_by_username(new_user.username) if 'phone_number' in reg_form.cleaned_data and reg_form.cleaned_data[ 'phone_number']: web_user.phone_numbers.append( reg_form.cleaned_data['phone_number']) web_user.save() email = new_user.email # registration analytics persona = reg_form.cleaned_data['persona'] persona_other = reg_form.cleaned_data['persona_other'] appcues_ab_test = toggles.APPCUES_AB_TEST.enabled( web_user.username, toggles.NAMESPACE_USER) track_workflow(email, "Requested New Account") track_workflow(email, "Persona Field Filled Out", { 'personachoice': persona, 'personaother': persona_other, }) track_web_user_registration_hubspot.delay( web_user, { 'buyer_persona': persona, 'buyer_persona_other': persona_other, "appcues_test": "On" if appcues_ab_test else "Off", }) login(self.request, new_user)
def post(self, request, *args, **kwargs): if self.form.is_valid(): app_source = self.form.get_selected_source() url_names_map = { 'list': 'configure_list_report', 'chart': 'configure_chart_report', 'table': 'configure_table_report', 'worker': 'configure_worker_report', 'map': 'configure_map_report', } url_name = url_names_map[self.report_type] get_params = { 'report_name': self.form.cleaned_data['report_name'], 'chart_type': self.form.cleaned_data['chart_type'], 'application': app_source.application, 'source_type': app_source.source_type, 'source': app_source.source, } track_workflow( request.user.email, "Successfully submitted the first part of the Report Builder " "wizard where you give your report a name and choose a data source" ) add_event(request, [ "Report Builder", "Successful Click on Next (Data Source)", app_source.source_type, ]) return HttpResponseRedirect( reverse(url_name, args=[self.domain], params=get_params)) else: return self.get(request, *args, **kwargs)
def send_preparation_analytics(self, export_instances, export_filters): send_hubspot_form(HUBSPOT_DOWNLOADED_EXPORT_FORM_ID, self.request) track_workflow(self.request.couch_user.username, 'Downloaded {} Exports With {}Data'.format( self.model[0].upper() + self.model[1:], '' if any(get_export_size(instance, export_filters) > 0 for instance in export_instances) else 'No ', ))
def update_linked_model(self, in_data): model = in_data['model'] type_ = model['type'] detail = model['detail'] detail_obj = wrap_detail(type_, detail) if detail else None master_link = get_domain_master_link(self.domain) error = "" try: update_model_type(master_link, type_, detail_obj) model_detail = detail_obj.to_json() if detail_obj else None master_link.update_last_pull(type_, self.request.couch_user._id, model_detail=model_detail) except (DomainLinkError, UnsupportedActionError) as e: error = str(e) track_workflow(self.request.couch_user.username, "Linked domain: updated '{}' model".format(type_)) timezone = get_timezone_for_request() return { 'success': not error, 'error': error, 'last_update': server_to_user_time(master_link.last_pull, timezone) }
def _track_build_for_app_preview(domain, couch_user, app_id, message): track_workflow(couch_user.username, message, properties={ 'domain': domain, 'app_id': app_id, 'is_dimagi': couch_user.is_dimagi, 'preview_app_enabled': True, })
def pull_master_app(request, domain, app_id): async_update = request.POST.get('notify') == 'on' if async_update: update_linked_app_and_notify_task.delay(domain, app_id, request.couch_user.get_id, request.couch_user.email) messages.success( request, _('Your request has been submitted. We will notify you via email once completed.' )) else: app = get_current_app(domain, app_id) try: update_linked_app(app, request.couch_user.get_id) except AppLinkError as e: messages.error(request, six.text_type(e)) return HttpResponseRedirect( reverse_util('app_settings', params={}, args=[domain, app_id])) messages.success( request, _('Your linked application was successfully updated to the latest version.' )) track_workflow(request.couch_user.username, "Linked domain: master app pulled") return HttpResponseRedirect( reverse_util('app_settings', params={}, args=[domain, app_id]))
def _process_invitation(request, invitation, web_user, is_new_user=False): """ Processes the Invitation (if available) and sets up the user in the new domain they were invited to. :param request: HttpRequest :param invitation: Invitation or None :param web_user: WebUser """ if invitation.is_expired: request.sso_new_user_messages['error'].append( _("Could not accept invitation because it is expired.") ) return invitation.accept_invitation_and_join_domain(web_user) request.sso_new_user_messages['success'].append( _('You have been added to the "{}" project space.').format( invitation.domain, ) ) if settings.IS_SAAS_ENVIRONMENT and is_new_user: track_workflow( web_user.username, "New User Accepted a project invitation with SSO", {"New User Accepted a project invitation": "yes"} ) send_hubspot_form( HUBSPOT_NEW_USER_INVITE_FORM, request, user=web_user )
def commit(self, request): export = self.export_instance_cls.wrap( json.loads(request.body.decode('utf-8'))) if (self.domain != export.domain or (export.export_format == "html" and not domain_has_privilege(self.domain, EXCEL_DASHBOARD)) or (export.is_daily_saved_export and not domain_has_privilege(self.domain, DAILY_SAVED_EXPORT))): raise BadExportConfiguration() if not export._rev: if toggles.EXPORT_OWNERSHIP.enabled(request.domain): export.owner_id = request.couch_user.user_id if getattr(settings, "ENTERPRISE_MODE"): # default auto rebuild to False for enterprise clusters # only do this on first save to prevent disabling on every edit export.auto_rebuild_enabled = False if export.is_odata_config: for table_id, table in enumerate(export.tables): labels = [] for column in table.columns: is_reserved_number = (column.label == 'number' and table_id > 0 and table.selected) if ((column.label in ['formid', 'caseid'] and PROPERTY_TAG_INFO in column.tags) or is_reserved_number): column.selected = True elif (column.label in ['formid', 'caseid'] and PROPERTY_TAG_INFO not in column.tags): # make sure hidden (eg deleted) labels that are # formid/caseid are never selected column.selected = False if column.label not in labels and column.selected: labels.append(column.label) elif column.selected: raise ExportODataDuplicateLabelException( _("Column labels must be unique. " "'{}' appears more than once.").format( column.label)) num_nodes = sum( [1 for table in export.tables[1:] if table.selected]) if hasattr(self, 'is_copy') and self.is_copy: event_title = "[BI Integration] Clicked Save button for feed copy" else: event_title = "[BI Integration] Clicked Save button for feed creation" track_workflow( request.user.username, event_title, { "Feed Type": export.type, "Number of additional nodes": num_nodes, }) export.save() messages.success( request, mark_safe( _("Export <strong>{}</strong> saved.").format(export.name))) return export._id
def post(self, request, *args, **kwargs): if self.form.is_valid(): app_source = self.form.get_selected_source() url_names_map = { 'list': 'configure_list_report', 'chart': 'configure_chart_report', 'table': 'configure_table_report', 'worker': 'configure_worker_report', 'map': 'configure_map_report', } url_name = url_names_map[self.report_type] get_params = { 'report_name': self.form.cleaned_data['report_name'], 'chart_type': self.form.cleaned_data['chart_type'], 'application': app_source.application, 'source_type': app_source.source_type, 'source': app_source.source, } track_workflow( request.user.email, "Successfully submitted the first part of the Report Builder " "wizard where you give your report a name and choose a data source" ) return HttpResponseRedirect( reverse(url_name, args=[self.domain]) + '?' + urlencode(get_params) ) else: return self.get(request, *args, **kwargs)
def _process_new_user_data(request, new_web_user): """ If available, this makes sure we apply any relevant user data :param request: HttpRequest :param new_web_user: WebUser :return: """ user_data = get_new_sso_user_data_from_session(request) if not user_data: return phone_number = user_data['phone_number'] if phone_number: new_web_user.phone_numbers.append(phone_number) new_web_user.save() if settings.IS_SAAS_ENVIRONMENT: track_workflow(new_web_user.username, "Requested New Account via SSO", { 'environment': settings.SERVER_ENVIRONMENT, }) track_workflow( new_web_user.username, "Persona Field Filled Out via SSO", { 'personachoice': user_data['persona'], 'personaother': user_data['persona_other'], }) track_web_user_registration_hubspot( request, new_web_user, user_data['additional_hubspot_data'], )
def dispatch(self, request_type, request, **kwargs): if toggles.API_BLACKLIST.enabled_for_request(request): msg = ("API access has been temporarily cut off due to too many " "requests. To re-enable, please contact support.") raise ImmediateHttpResponse( HttpResponse(json.dumps({"error": msg}), content_type="application/json", status=401)) if request.user.is_superuser or domain_has_privilege( request.domain, privileges.API_ACCESS): if isinstance(self, DomainSpecificResourceMixin): track_workflow( request.user.username, "API Request", properties={ 'domain': request.domain, 'is_dimagi': request.user.username.endswith('@dimagi.com'), }) return super(HqBaseResource, self).dispatch(request_type, request, **kwargs) else: raise ImmediateHttpResponse( HttpResponse(json.dumps({ "error": "Your current subscription does not have access to this feature" }), content_type="application/json", status=401))
def confirm_domain(request, guid=None): error = None # Did we get a guid? if guid is None: error = _( 'An account activation key was not provided. If you think this ' 'is an error, please contact the system administrator.') # Does guid exist in the system? else: req = RegistrationRequest.get_by_guid(guid) if not req: error = _( 'The account activation key "%s" provided is invalid. If you ' 'think this is an error, please contact the system ' 'administrator.') % guid if error is not None: context = { 'message_body': error, 'current_page': { 'page_name': 'Account Not Activated' }, } return render(request, 'registration/confirmation_error.html', context) requested_domain = Domain.get_by_name(req.domain) # Has guid already been confirmed? if requested_domain.is_active: assert (req.confirm_time is not None and req.confirm_ip is not None) messages.success( request, 'Your account %s has already been activated. ' 'No further validation is required.' % req.new_user_username) return HttpResponseRedirect( reverse("dashboard_default", args=[requested_domain])) # Set confirm time and IP; activate domain and new user who is in the req.confirm_time = datetime.utcnow() req.confirm_ip = get_ip(request) req.save() requested_domain.is_active = True requested_domain.save() requesting_user = WebUser.get_by_username(req.new_user_username) send_new_request_update_email(requesting_user, get_ip(request), requested_domain.name, is_confirming=True) messages.success( request, 'Your account has been successfully activated. Thank you for taking ' 'the time to confirm your email address: %s.' % (requesting_user.username)) track_workflow(requesting_user.email, "Confirmed new project") track_confirmed_account_on_hubspot.delay(requesting_user) return HttpResponseRedirect( reverse("dashboard_default", args=[requested_domain]))
def _create_new_account(self, reg_form): activate_new_user(reg_form, ip=get_ip(self.request)) new_user = authenticate( username=reg_form.cleaned_data['email'], password=reg_form.cleaned_data['password'] ) track_workflow(new_user.email, "Requested new account") login(self.request, new_user)
def create_new_export_instance(self, schema, username, export_settings=None): export = self.export_instance_cls.generate_instance_from_schema(schema, export_settings=export_settings) track_workflow(username, f'{self.metric_name} - Clicked Add Export Popup', properties={ 'domain': self.domain }) return export
def app_from_template(request, domain, slug): send_hubspot_form(HUBSPOT_APP_TEMPLATE_FORM_ID, request) track_workflow(request.couch_user.username, "User created an application from a template") clear_app_cache(request, domain) build = load_app_from_slug(domain, request.user.username, slug) cloudcare_state = '{{"appId":"{}"}}'.format(build._id) return HttpResponseRedirect(reverse(FormplayerMain.urlname, args=[domain]) + '#' + cloudcare_state)
def _track_new_report_events(self): track_workflow( self.request.user.email, "Successfully created a new report in the Report Builder") add_event(self.request, [ "Report Builder", "Click On Done On New Report (Successfully)", self.report_type, ])
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 confirm_domain(request, guid=None): error = None # Did we get a guid? if guid is None: error = _('An account activation key was not provided. If you think this ' 'is an error, please contact the system administrator.') # Does guid exist in the system? else: req = RegistrationRequest.get_by_guid(guid) if not req: error = _('The account activation key "%s" provided is invalid. If you ' 'think this is an error, please contact the system ' 'administrator.') % guid if error is not None: context = { 'message_body': error, 'current_page': {'page_name': 'Account Not Activated'}, } return render(request, 'registration/confirmation_error.html', context) requested_domain = Domain.get_by_name(req.domain) # Has guid already been confirmed? if requested_domain.is_active: assert(req.confirm_time is not None and req.confirm_ip is not None) messages.success(request, 'Your account %s has already been activated. ' 'No further validation is required.' % req.new_user_username) return HttpResponseRedirect(reverse("dashboard_default", args=[requested_domain])) # Set confirm time and IP; activate domain and new user who is in the req.confirm_time = datetime.utcnow() req.confirm_ip = get_ip(request) req.save() requested_domain.is_active = True requested_domain.save() requesting_user = WebUser.get_by_username(req.new_user_username) send_new_request_update_email(requesting_user, get_ip(request), requested_domain.name, is_confirming=True) messages.success(request, 'Your account has been successfully activated. Thank you for taking ' 'the time to confirm your email address: %s.' % (requesting_user.username)) track_workflow(requesting_user.email, "Confirmed new project") track_confirmed_account_on_hubspot.delay(requesting_user) url = reverse("dashboard_default", args=[requested_domain]) # If user already created an app (via prelogin demo), send them there apps = get_apps_in_domain(requested_domain.name, include_remote=False) if len(apps) == 1: app = apps[0] if len(app.modules) == 1 and len(app.modules[0].forms) == 1: url = reverse('form_source', args=[requested_domain.name, app.id, 0, 0]) return HttpResponseRedirect(url)
def post(self, request, *args, **kwargs): referer_url = request.GET.get('referer', '') nextpage = request.POST.get('next') form = DomainRegistrationForm(request.POST) context = self.get_context_data(form=form) 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({ 'current_page': { 'page_name': _('Oops!') }, '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, is_new_user=self.is_new_user) 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) if self.is_new_user: context.update({ 'requested_domain': domain_name, 'current_page': { 'page_name': _('Confirm Account') }, }) track_workflow(self.request.user.email, "Created new project") 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])) return self.render_to_response(context)
def download_daily_saved_export(req, domain, export_instance_id): with CriticalSection( ['export-last-accessed-{}'.format(export_instance_id)]): try: export_instance = get_properly_wrapped_export_instance( export_instance_id) except ResourceNotFound: raise Http404(_("Export not found")) assert domain == export_instance.domain if export_instance.export_format == "html": if not domain_has_privilege(domain, EXCEL_DASHBOARD): raise Http404 elif export_instance.is_daily_saved_export: if not domain_has_privilege(domain, DAILY_SAVED_EXPORT): raise Http404 if not export_instance.filters.is_location_safe_for_user(req): return location_restricted_response(req) if not can_download_daily_saved_export(export_instance, domain, req.couch_user): raise Http404 if export_instance.export_format == "html": message = "Download Excel Dashboard" else: message = "Download Saved Export" track_workflow(req.couch_user.username, message, properties={ 'domain': domain, 'is_dimagi': req.couch_user.is_dimagi }) if should_update_export(export_instance.last_accessed): try: rebuild_saved_export(export_instance_id, manual=False) except Exception: notify_exception( req, 'Failed to rebuild export during download', { 'export_instance_id': export_instance_id, 'domain': domain, }, ) export_instance.last_accessed = datetime.utcnow() export_instance.save() payload = export_instance.get_payload(stream=True) format = Format.from_format(export_instance.export_format) return get_download_response(payload, export_instance.file_size, format, export_instance.filename, req)
def _track_build_for_app_preview(domain, couch_user, app_id, message): track_workflow(couch_user.username, message, properties={ 'domain': domain, 'app_id': app_id, 'is_dimagi': couch_user.is_dimagi, 'preview_app_enabled': ( toggles.PREVIEW_APP.enabled(domain) or toggles.PREVIEW_APP.enabled(couch_user.username) ) })
def clean_password(self): if settings.ENFORCE_SSO_LOGIN and self.is_sso: # This field is not used with SSO. A randomly generated # password as a fallback is created in SsoBackend. return try: return clean_password(self.cleaned_data.get('password')) except forms.ValidationError: track_workflow(self.cleaned_data.get('email'), 'Password Failure') raise
def rows(self): track_workflow(self.request.couch_user.username, "Case List Explorer: Search Performed") send_email_to_dev_more( self.domain, self.request.couch_user.username, XpathCaseSearchFilter.get_value(self.request, self.domain), self.es_results['hits'].get('total', 0) ) data = (flatten_result(row) for row in self.es_results['hits'].get('hits', [])) return self._get_rows(data)
def rows(self): track_workflow(self.request.couch_user.username, "Case List Explorer: Search Performed") send_email_to_dev_more( self.domain, self.request.couch_user.username, XpathCaseSearchFilter.get_value(self.request, self.domain), self.es_results['hits'].get('total', 0)) data = (flatten_result(row) for row in self.es_results['hits'].get('hits', [])) return self._get_rows(data)
def _track_new_report_events(self): track_workflow( self.request.user.email, "Successfully created a new report in the Report Builder" ) add_event(self.request, [ "Report Builder", "Click On Done On New Report (Successfully)", self.report_type, ])
def create_domain_link(self, in_data): domain_to_link = in_data['downstream_domain'] try: domain_link = link_domains(self.request.couch_user, self.domain, domain_to_link) except (DomainDoesNotExist, DomainLinkAlreadyExists, DomainLinkNotAllowed, DomainLinkError) as e: return {'success': False, 'message': str(e)} track_workflow(self.request.couch_user.username, "Linked domain: domain link created") domain_link_view_model = build_domain_link_view_model(domain_link, get_timezone_for_request()) return {'success': True, 'domain_link': domain_link_view_model}
def delete_domain_link(self, in_data): linked_domain = in_data['linked_domain'] link = DomainLink.objects.filter(linked_domain=linked_domain, master_domain=self.domain).first() link.deleted = True link.save() track_workflow(self.request.couch_user.username, "Linked domain: domain link deleted") return { 'success': True, }
def _create_new_account(self, reg_form): activate_new_user(reg_form, ip=get_ip(self.request)) new_user = authenticate(username=reg_form.cleaned_data['email'], password=reg_form.cleaned_data['password']) if 'phone_number' in reg_form.cleaned_data and reg_form.cleaned_data[ 'phone_number']: web_user = WebUser.get_by_username(new_user.username) web_user.phone_numbers.append( reg_form.cleaned_data['phone_number']) web_user.save() track_workflow(new_user.email, "Requested new account") login(self.request, new_user)
def _create_new_account(self, reg_form, additional_hubspot_data=None): activate_new_user_via_reg_form(reg_form, created_by=None, created_via=USER_CHANGE_VIA_WEB, ip=get_ip(self.request)) new_user = authenticate(username=reg_form.cleaned_data['email'], password=reg_form.cleaned_data['password'], request=self.request) web_user = WebUser.get_by_username(new_user.username, strict=True) if 'phone_number' in reg_form.cleaned_data and reg_form.cleaned_data[ 'phone_number']: web_user.phone_numbers.append( reg_form.cleaned_data['phone_number']) web_user.save() if settings.IS_SAAS_ENVIRONMENT: email = new_user.email # registration analytics # only do anything with this in a SAAS environment persona = reg_form.cleaned_data['persona'] persona_other = reg_form.cleaned_data['persona_other'] track_workflow(email, "Requested New Account", { 'environment': settings.SERVER_ENVIRONMENT, }) track_workflow(email, "Persona Field Filled Out", { 'personachoice': persona, 'personaother': persona_other, }) if not additional_hubspot_data: additional_hubspot_data = {} additional_hubspot_data.update({ 'buyer_persona': persona, 'buyer_persona_other': persona_other, }) track_web_user_registration_hubspot(self.request, web_user, additional_hubspot_data) if not persona or (persona == 'Other' and not persona_other): # There shouldn't be many instances of this. _assert = soft_assert('@'.join(['bbuczyk', 'dimagi.com']), exponential_backoff=False) _assert( False, "[BAD PERSONA DATA] Persona fields during " "login submitted empty. User: {}".format(email)) login(self.request, new_user)
def post(self, request, *args, **kwargs): referer_url = request.GET.get('referer', '') nextpage = request.POST.get('next') form = DomainRegistrationForm(request.POST) context = self.get_context_data(form=form) if not form.is_valid(): return self.render_to_response(context) if settings.RESTRICT_DOMAIN_CREATION and not request.user.is_superuser: context.update({ 'current_page': {'page_name': _('Oops!')}, 'error_msg': _('Your organization has requested that project creation be restricted. ' 'For more information, please speak to your administrator.'), }) return render(request, 'error.html', context) reqs_today = RegistrationRequest.get_requests_today() max_req = settings.DOMAIN_MAX_REGISTRATION_REQUESTS_PER_DAY if reqs_today >= max_req: context.update({ 'current_page': {'page_name': _('Oops!')}, 'error_msg': _( 'Number of projects 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, is_new_user=self.is_new_user) 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) if self.is_new_user: context.update({ 'requested_domain': domain_name, 'current_page': {'page_name': _('Confirm Account')}, }) track_workflow(self.request.user.email, "Created new project") return render(request, 'registration/confirmation_sent.html', context) if nextpage: return HttpResponseRedirect(nextpage) if referer_url: return redirect(referer_url) return HttpResponseRedirect(reverse("domain_homepage", args=[domain_name]))
def download_daily_saved_export(req, domain, export_instance_id): with CriticalSection(['export-last-accessed-{}'.format(export_instance_id)]): try: export_instance = get_properly_wrapped_export_instance(export_instance_id) except ResourceNotFound: raise Http404(_("Export not found")) assert domain == export_instance.domain if export_instance.export_format == "html": if not domain_has_privilege(domain, EXCEL_DASHBOARD): raise Http404 elif export_instance.is_daily_saved_export: if not domain_has_privilege(domain, DAILY_SAVED_EXPORT): raise Http404 if not export_instance.filters.is_location_safe_for_user(req): return location_restricted_response(req) if not can_download_daily_saved_export(export_instance, domain, req.couch_user): raise Http404 if export_instance.export_format == "html": message = "Download Excel Dashboard" else: message = "Download Saved Export" track_workflow(req.couch_user.username, message, properties={ 'domain': domain, 'is_dimagi': req.couch_user.is_dimagi }) if should_update_export(export_instance.last_accessed): try: rebuild_saved_export(export_instance_id, manual=False) except Exception: notify_exception( req, 'Failed to rebuild export during download', { 'export_instance_id': export_instance_id, 'domain': domain, }, ) export_instance.last_accessed = datetime.utcnow() export_instance.save() payload = export_instance.get_payload(stream=True) format = Format.from_format(export_instance.export_format) return get_download_response(payload, export_instance.file_size, format, export_instance.filename, req)
def _create_new_account(self, reg_form, additional_hubspot_data=None): activate_new_user(reg_form, ip=get_ip(self.request)) new_user = authenticate( username=reg_form.cleaned_data['email'], password=reg_form.cleaned_data['password'] ) web_user = WebUser.get_by_username(new_user.username, strict=True) if 'phone_number' in reg_form.cleaned_data and reg_form.cleaned_data['phone_number']: web_user.phone_numbers.append(reg_form.cleaned_data['phone_number']) web_user.save() if settings.IS_SAAS_ENVIRONMENT: email = new_user.email # registration analytics # only do anything with this in a SAAS environment persona = reg_form.cleaned_data['persona'] persona_other = reg_form.cleaned_data['persona_other'] track_workflow(email, "Requested New Account", { 'environment': settings.SERVER_ENVIRONMENT, }) track_workflow(email, "Persona Field Filled Out", { 'personachoice': persona, 'personaother': persona_other, }) if not additional_hubspot_data: additional_hubspot_data = {} additional_hubspot_data.update({ 'buyer_persona': persona, 'buyer_persona_other': persona_other, }) track_web_user_registration_hubspot( self.request, web_user, additional_hubspot_data ) if not persona or (persona == 'Other' and not persona_other): # There shouldn't be many instances of this. _assert = soft_assert('@'.join(['bbuczyk', 'dimagi.com']), exponential_backoff=False) _assert( False, "[BAD PERSONA DATA] Persona fields during " "login submitted empty. User: {}".format(email) ) login(self.request, new_user)
def confirm_domain(request, guid=None): error = None # Did we get a guid? if guid is None: error = _('An account activation key was not provided. If you think this ' 'is an error, please contact the system administrator.') # Does guid exist in the system? else: req = RegistrationRequest.get_by_guid(guid) if not req: error = _('The account activation key "%s" provided is invalid. If you ' 'think this is an error, please contact the system ' 'administrator.') % guid if error is not None: context = { 'message_title': _('Account not activated'), 'message_subtitle': _('Email not yet confirmed'), 'message_body': error, } return render(request, 'registration/confirmation_error.html', context) requested_domain = Domain.get_by_name(req.domain) # Has guid already been confirmed? if requested_domain.is_active: assert(req.confirm_time is not None and req.confirm_ip is not None) messages.success(request, 'Your account %s has already been activated. ' 'No further validation is required.' % req.new_user_username) return HttpResponseRedirect(reverse("dashboard_default", args=[requested_domain])) # Set confirm time and IP; activate domain and new user who is in the req.confirm_time = datetime.utcnow() req.confirm_ip = get_ip(request) req.save() requested_domain.is_active = True requested_domain.save() requesting_user = WebUser.get_by_username(req.new_user_username) send_new_request_update_email(requesting_user, get_ip(request), requested_domain.name, is_confirming=True) messages.success(request, 'Your account has been successfully activated. Thank you for taking ' 'the time to confirm your email address: %s.' % (requesting_user.username)) track_workflow(requesting_user.email, "Confirmed new project") track_confirmed_account_on_hubspot.delay(requesting_user) return HttpResponseRedirect(reverse("dashboard_default", args=[requested_domain]))
def pull_master_app(request, domain, app_id): async_update = request.POST.get('notify') == 'on' if async_update: update_linked_app_and_notify_task.delay(domain, app_id, request.couch_user.get_id, request.couch_user.email) messages.success(request, _('Your request has been submitted. We will notify you via email once completed.')) else: app = get_current_app(domain, app_id) try: update_linked_app(app, request.couch_user.get_id) except AppLinkError as e: messages.error(request, six.text_type(e)) return HttpResponseRedirect(reverse_util('app_settings', params={}, args=[domain, app_id])) messages.success(request, _('Your linked application was successfully updated to the latest version.')) track_workflow(request.couch_user.username, "Linked domain: master app pulled") return HttpResponseRedirect(reverse_util('app_settings', params={}, args=[domain, app_id]))
def default_new_app(request, domain): """New Blank Application according to defaults. So that we can link here instead of creating a form and posting to the above link, which was getting annoying for the Dashboard. """ send_hubspot_form(HUBSPOT_APP_TEMPLATE_FORM_ID, request) track_workflow(request.couch_user.username, "User created a new blank application") lang = 'en' app = Application.new_app(domain, _("Untitled Application"), lang=lang) add_ons.init_app(request, app) if request.project.secure_submissions: app.secure_submissions = True clear_app_cache(request, domain) app.save() return HttpResponseRedirect(reverse('view_app', args=[domain, app._id]))
def update_linked_model(self, in_data): model = in_data['model'] type_ = model['type'] detail = model['detail'] detail_obj = wrap_detail(type_, detail) if detail else None master_link = get_domain_master_link(self.domain) update_model_type(master_link, type_, detail_obj) master_link.update_last_pull(type_, self.request.couch_user._id, model_details=detail_obj) track_workflow(self.request.couch_user.username, "Linked domain: updated '{}' model".format(type_)) timezone = get_timezone_for_request() return { 'success': True, 'last_update': server_to_user_time(master_link.last_pull, timezone) }
def update_linked_model(self, in_data): model = in_data['model'] type_ = model['type'] detail = model['detail'] detail_obj = wrap_detail(type, detail) if detail else None master_link = get_domain_master_link(self.domain) update_model_type(master_link, type_, detail_obj) master_link.update_last_pull(type_, self.request.couch_user._id, model_details=detail_obj) track_workflow(self.request.couch_user.username, "Linked domain: updated '{}' model".format(type_)) timezone = get_timezone_for_request() return { 'success': True, 'last_update': server_to_user_time(master_link.last_pull, timezone) }
def post(self, *args, **kwargs): if self.report_form.is_valid(): if self.report_form.existing_report: try: report_configuration = self.report_form.update_report() except ValidationError as e: messages.error(self.request, e.message) return self.get(*args, **kwargs) else: report_configuration = self.report_form.create_report() track_workflow( self.request.user.email, "Successfully created a new report in the Report Builder" ) return HttpResponseRedirect( reverse(ConfigurableReport.slug, args=[self.domain, report_configuration._id]) ) return self.get(*args, **kwargs)
def _process_new_user_data(request, new_web_user, async_signup): """ If available, this makes sure we apply any relevant user data :param request: HttpRequest :param new_web_user: WebUser :param async_signup: AsyncSignupRequest """ if not async_signup: if settings.IS_SAAS_ENVIRONMENT: track_workflow( new_web_user.username, "Requested New Account via SSO (Bypassed Signup Form)", { 'environment': settings.SERVER_ENVIRONMENT, } ) return if async_signup.invitation: return if async_signup.phone_number: new_web_user.phone_numbers.append(async_signup.phone_number) new_web_user.save() if settings.IS_SAAS_ENVIRONMENT: track_workflow( new_web_user.username, "Requested New Account via SSO", { 'environment': settings.SERVER_ENVIRONMENT, } ) if async_signup.persona: track_workflow( new_web_user.username, "Persona Field Filled Out via SSO", { 'personachoice': async_signup.persona, 'personaother': async_signup.persona_other, } ) track_web_user_registration_hubspot( request, new_web_user, async_signup.additional_hubspot_data, ) else: track_workflow( new_web_user.username, "New User created through SSO, but Persona info missing" )
def dispatch(self, request_type, request, **kwargs): if toggles.API_BLACKLIST.enabled_for_request(request): msg = ("API access has been temporarily cut off due to too many " "requests. To re-enable, please contact support.") raise ImmediateHttpResponse(HttpResponse( json.dumps({"error": msg}), content_type="application/json", status=401)) if request.user.is_superuser or domain_has_privilege(request.domain, privileges.API_ACCESS): if isinstance(self, DomainSpecificResourceMixin): track_workflow(request.user.username, "API Request", properties={ 'domain': request.domain, 'is_dimagi': request.user.username.endswith('@dimagi.com'), }) return super(HqBaseResource, self).dispatch(request_type, request, **kwargs) else: raise ImmediateHttpResponse(HttpResponse( json.dumps({"error": "Your current subscription does not have access to this feature"}), content_type="application/json", status=401))
def _build_query(self, sort=True): query = super(CaseListExplorer, self)._build_query() query = self._populate_sort(query, sort) xpath = XpathCaseSearchFilter.get_value(self.request, self.domain) if xpath: try: query = query.xpath_query(self.domain, xpath) except CaseFilterError as e: track_workflow(self.request.couch_user.username, "Case List Explorer: Query Error") error = "<p>{}.</p>".format(escape(e)) bad_part = "<p>{} <strong>{}</strong></p>".format( _("The part of your search query that caused this error is: "), escape(e.filter_part) ) if e.filter_part else "" raise BadRequestError("{}{}".format(error, bad_part)) if '/' in xpath: track_workflow(self.request.couch_user.username, "Case List Explorer: Related case search") return query
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: track_workflow(request.couch_user.get_email(), "Sent a project invitation", {"Sent a project invitation": "yes"}) meta = get_meta(request) track_sent_invite_on_hubspot.delay(request.couch_user, request.COOKIES, meta) 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 = Invitation(**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(): # 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: track_workflow(request.couch_user.get_email(), "Sent a project invitation", {"Sent a project invitation": "yes"}) meta = get_meta(request) track_sent_invite_on_hubspot.delay(request.couch_user, request.COOKIES, meta) 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 = Invitation(**data) invite.save() invite.send_activation_email() return HttpResponseRedirect(reverse( ListWebUsersView.urlname, args=[self.domain] )) return self.get(request, *args, **kwargs)
def export_table(self): self._is_exporting = True track_workflow(self.request.couch_user.username, "Case List Explorer: Export button clicked") return super(CaseListExplorer, self).export_table
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']) meta = { 'HTTP_X_FORWARDED_FOR': request.META.get('HTTP_X_FORWARDED_FOR'), 'REMOTE_ADDR': request.META.get('REMOTE_ADDR'), } # request.META can't be pickled for use by the task, so we copy the pertinent properties track_created_hq_account_on_hubspot.delay( CouchUser.get_by_username(new_user.username), request.COOKIES, meta ) 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']: 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) context.update({'create_domain': form.cleaned_data['create_domain']}) else: form = NewWebUserRegistrationForm( initial={'domain_type': domain_type, 'email': prefilled_email, 'create_domain': True}) context.update({'create_domain': True}) context.update({ 'form': form, 'domain_type': domain_type, }) return render(request, 'registration/create_new_user.html', context)
def __call__(self, request, invitation_id, **kwargs): logging.info("Don't use this view in more apps until it gets cleaned up.") # add the correct parameters to this instance self.request = request self.inv_id = invitation_id if 'domain' in kwargs: self.domain = kwargs['domain'] if request.GET.get('switch') == 'true': logout(request) return redirect_to_login(request.path) if request.GET.get('create') == 'true': logout(request) return HttpResponseRedirect(request.path) try: invitation = Invitation.get(invitation_id) except ResourceNotFound: messages.error(request, _("Sorry, it looks like your invitation has expired. " "Please check the invitation link you received and try again, or request a " "project administrator to send you the invitation again.")) return HttpResponseRedirect(reverse("login")) if invitation.is_accepted: messages.error(request, _("Sorry, that invitation has already been used up. " "If you feel this is a mistake please ask the inviter for " "another invitation.")) return HttpResponseRedirect(reverse("login")) self.validate_invitation(invitation) if invitation.is_expired: return HttpResponseRedirect(reverse("no_permissions")) # Add zero-width space to username for better line breaking username = self.request.user.username.replace("@", "​@") context = { 'create_domain': False, 'formatted_username': username, 'domain': self.domain, 'invite_to': self.domain, 'invite_type': _('Project'), 'hide_password_feedback': settings.ENABLE_DRACONIAN_SECURITY_FEATURES, } if request.user.is_authenticated: context['current_page'] = {'page_name': _('Project Invitation')} else: context['current_page'] = {'page_name': _('Project Invitation, Account Required')} if request.user.is_authenticated(): is_invited_user = request.couch_user.username.lower() == invitation.email.lower() if self.is_invited(invitation, request.couch_user) and not request.couch_user.is_superuser: if is_invited_user: # if this invite was actually for this user, just mark it accepted messages.info(request, _("You are already a member of {entity}.").format( entity=self.inviting_entity)) invitation.is_accepted = True invitation.save() else: messages.error(request, _("It looks like you are trying to accept an invitation for " "{invited} but you are already a member of {entity} with the " "account {current}. Please sign out to accept this invitation " "as another user.").format( entity=self.inviting_entity, invited=invitation.email, current=request.couch_user.username, )) return HttpResponseRedirect(self.redirect_to_on_success) if not is_invited_user: messages.error(request, _("The invited user {invited} and your user {current} do not match!").format( invited=invitation.email, current=request.couch_user.username)) if request.method == "POST": couch_user = CouchUser.from_django_user(request.user) self._invite(invitation, couch_user) track_workflow(request.couch_user.get_email(), "Current user accepted a project invitation", {"Current user accepted a project invitation": "yes"}) meta = get_meta(request) track_existing_user_accepted_invite_on_hubspot.delay(request.couch_user, request.COOKIES, meta) return HttpResponseRedirect(self.redirect_to_on_success) else: mobile_user = CouchUser.from_django_user(request.user).is_commcare_user() context.update({ 'mobile_user': mobile_user, "invited_user": invitation.email if request.couch_user.username != invitation.email else "", }) return render(request, self.template, context) else: if request.method == "POST": form = WebUserInvitationForm(request.POST) if form.is_valid(): # create the new user user = activate_new_user(form, domain=invitation.domain) user.save() messages.success(request, _("User account for %s created!") % form.cleaned_data["email"]) self._invite(invitation, user) authenticated = authenticate(username=form.cleaned_data["email"], password=form.cleaned_data["password"]) if authenticated is not None and authenticated.is_active: login(request, authenticated) track_workflow(request.POST['email'], "New User Accepted a project invitation", {"New User Accepted a project invitation": "yes"}) meta = get_meta(request) track_new_user_accepted_invite_on_hubspot.delay(user, request.COOKIES, meta) return HttpResponseRedirect(reverse("domain_homepage", args=[invitation.domain])) else: if CouchUser.get_by_username(invitation.email): return HttpResponseRedirect(reverse("login") + '?next=' + reverse('domain_accept_invitation', args=[invitation.domain, invitation.get_id])) form = WebUserInvitationForm(initial={ 'email': invitation.email, 'hr_name': invitation.domain, 'create_domain': False, }) context.update({"form": form}) return render(request, self.template, context)
def edit_module_attr(request, domain, app_id, module_unique_id, attr): """ Called to edit any (supported) module attribute, given by attr """ attributes = { "all": None, "auto_select_case": None, "case_list": ('case_list-show', 'case_list-label'), "case_list-menu_item_media_audio": None, "case_list-menu_item_media_image": None, 'case_list-menu_item_use_default_image_for_all': None, 'case_list-menu_item_use_default_audio_for_all': None, "case_list_form_id": None, "case_list_form_label": None, "case_list_form_media_audio": None, "case_list_form_media_image": None, 'case_list_form_use_default_image_for_all': None, 'case_list_form_use_default_audio_for_all': None, "case_list_post_form_workflow": None, "case_type": None, 'comment': None, "display_separately": None, "has_schedule": None, "media_audio": None, "media_image": None, "module_filter": None, "name": None, "name_enum": None, "parent_module": None, "put_in_root": None, "root_module_id": None, "source_module_id": None, "task_list": ('task_list-show', 'task_list-label'), "excl_form_ids": None, "display_style": None, "custom_icon_form": None, "custom_icon_text_body": None, "custom_icon_xpath": None, "use_default_image_for_all": None, "use_default_audio_for_all": None, } if attr not in attributes: return HttpResponseBadRequest() def should_edit(attribute): if attribute == attr: return True if 'all' == attr: if attributes[attribute]: for param in attributes[attribute]: if not request.POST.get(param): return False return True else: return request.POST.get(attribute) is not None app = get_app(domain, app_id) try: module = app.get_module_by_unique_id(module_unique_id) except ModuleNotFoundException: # temporary fallback module = app.get_module(module_unique_id) lang = request.COOKIES.get('lang', app.langs[0]) resp = {'update': {}, 'corrections': {}} if should_edit("custom_icon_form"): error_message = handle_custom_icon_edits(request, module, lang) if error_message: return json_response( {'message': error_message}, status_code=400 ) if should_edit("name_enum"): name_enum = json.loads(request.POST.get("name_enum")) module.name_enum = [MappingItem(i) for i in name_enum] if should_edit("case_type"): case_type = request.POST.get("case_type", None) if case_type == USERCASE_TYPE and not isinstance(module, AdvancedModule): return HttpResponseBadRequest('"{}" is a reserved case type'.format(USERCASE_TYPE)) elif case_type and not is_valid_case_type(case_type, module): return HttpResponseBadRequest("case type is improperly formatted") else: old_case_type = module["case_type"] module["case_type"] = case_type # rename other reference to the old case type all_advanced_modules = [] modules_with_old_case_type_exist = False for mod in app.modules: if isinstance(mod, AdvancedModule): all_advanced_modules.append(mod) modules_with_old_case_type_exist |= mod.case_type == old_case_type for mod in all_advanced_modules: for form in mod.forms: for action in form.actions.get_load_update_actions(): if action.case_type == old_case_type and action.details_module == module_unique_id: action.case_type = case_type if mod.unique_id == module_unique_id or not modules_with_old_case_type_exist: for action in form.actions.get_open_actions(): if action.case_type == old_case_type: action.case_type = case_type if should_edit("put_in_root"): module["put_in_root"] = json.loads(request.POST.get("put_in_root")) if should_edit("display_style"): module["display_style"] = request.POST.get("display_style") if should_edit("source_module_id"): module["source_module_id"] = request.POST.get("source_module_id") if should_edit("display_separately"): module["display_separately"] = json.loads(request.POST.get("display_separately")) if should_edit("parent_module"): parent_module = request.POST.get("parent_module") module.parent_select.module_id = parent_module if module_case_hierarchy_has_circular_reference(module): return HttpResponseBadRequest(_("The case hierarchy contains a circular reference.")) if should_edit("auto_select_case"): module["auto_select_case"] = request.POST.get("auto_select_case") == 'true' if app.enable_module_filtering and should_edit('module_filter'): module['module_filter'] = request.POST.get('module_filter') if should_edit('case_list_form_id'): module.case_list_form.form_id = request.POST.get('case_list_form_id') if should_edit('case_list_form_label'): module.case_list_form.label[lang] = request.POST.get('case_list_form_label') if should_edit('case_list_post_form_workflow'): module.case_list_form.post_form_workflow = request.POST.get('case_list_post_form_workflow') if should_edit("name"): name = request.POST.get("name", None) module["name"][lang] = name resp['update'] = {'.variable-module_name': trans(module.name, [lang], use_delim=False)} if should_edit('comment'): module.comment = request.POST.get('comment') for SLUG in ('case_list', 'task_list'): show = '{SLUG}-show'.format(SLUG=SLUG) label = '{SLUG}-label'.format(SLUG=SLUG) if request.POST.get(show) == 'true' and (request.POST.get(label) == ''): # Show item, but empty label, was just getting ignored return HttpResponseBadRequest("A label is required for {SLUG}".format(SLUG=SLUG)) if should_edit(SLUG): module[SLUG].show = json.loads(request.POST[show]) module[SLUG].label[lang] = request.POST[label] if should_edit("root_module_id"): old_root = module['root_module_id'] if not request.POST.get("root_module_id"): module["root_module_id"] = None else: module["root_module_id"] = request.POST.get("root_module_id") if not old_root and module['root_module_id']: track_workflow(request.couch_user.username, "User associated module with a parent") elif old_root and not module['root_module_id']: track_workflow(request.couch_user.username, "User orphaned a child module") if should_edit('excl_form_ids') and isinstance(module, ShadowModule): excl = request.POST.getlist('excl_form_ids') excl.remove('0') # Placeholder value to make sure excl_form_ids is POSTed when no forms are excluded module.excluded_form_ids = excl handle_media_edits(request, module, should_edit, resp, lang) handle_media_edits(request, module.case_list_form, should_edit, resp, lang, prefix='case_list_form_') handle_media_edits(request, module.case_list, should_edit, resp, lang, prefix='case_list-menu_item_') app.save(resp) resp['case_list-show'] = module.requires_case_details() return HttpResponse(json.dumps(resp))
def rows(self): track_workflow(self.request.couch_user.username, "Case List Explorer: Search Performed") data = (flatten_result(row) for row in self.es_results['hits'].get('hits', [])) return self._get_rows(data)
def clean_password(self): try: return clean_password(self.cleaned_data.get('password')) except forms.ValidationError: track_workflow(self.cleaned_data.get('email'), 'Password Failure') raise
def __call__(self, request, invitation_id, **kwargs): logging.warning("Don't use this view in more apps until it gets cleaned up.") # add the correct parameters to this instance self.request = request self.inv_id = invitation_id if "domain" in kwargs: self.domain = kwargs["domain"] if request.GET.get("switch") == "true": logout(request) return redirect_to_login(request.path) if request.GET.get("create") == "true": logout(request) return HttpResponseRedirect(request.path) try: invitation = Invitation.get(invitation_id) except ResourceNotFound: messages.error( request, _( "Sorry, it looks like your invitation has expired. " "Please check the invitation link you received and try again, or request a " "project administrator to send you the invitation again." ), ) return HttpResponseRedirect(reverse("login")) if invitation.is_accepted: messages.error( request, _( "Sorry, that invitation has already been used up. " "If you feel this is a mistake please ask the inviter for " "another invitation." ), ) return HttpResponseRedirect(reverse("login")) self.validate_invitation(invitation) if invitation.is_expired: return HttpResponseRedirect(reverse("no_permissions")) context = self.added_context() if request.user.is_authenticated(): is_invited_user = request.couch_user.username.lower() == invitation.email.lower() if self.is_invited(invitation, request.couch_user) and not request.couch_user.is_superuser: if is_invited_user: # if this invite was actually for this user, just mark it accepted messages.info( request, _("You are already a member of {entity}.").format(entity=self.inviting_entity) ) invitation.is_accepted = True invitation.save() else: messages.error( request, _( "It looks like you are trying to accept an invitation for " "{invited} but you are already a member of {entity} with the " "account {current}. Please sign out to accept this invitation " "as another user." ).format( entity=self.inviting_entity, invited=invitation.email, current=request.couch_user.username ), ) return HttpResponseRedirect(self.redirect_to_on_success) if not is_invited_user: messages.error( request, _("The invited user {invited} and your user {current} do not match!").format( invited=invitation.email, current=request.couch_user.username ), ) if request.method == "POST": couch_user = CouchUser.from_django_user(request.user) self._invite(invitation, couch_user) track_workflow( request.couch_user.get_email(), "Current user accepted a project invitation", {"Current user accepted a project invitation": "yes"}, ) meta = get_meta(request) track_existing_user_accepted_invite_on_hubspot.delay(request.couch_user, request.COOKIES, meta) return HttpResponseRedirect(self.redirect_to_on_success) else: mobile_user = CouchUser.from_django_user(request.user).is_commcare_user() context.update( { "mobile_user": mobile_user, "invited_user": invitation.email if request.couch_user.username != invitation.email else "", } ) return render(request, self.template, context) else: if request.method == "POST": form = NewWebUserRegistrationForm(request.POST) if form.is_valid(): # create the new user user = activate_new_user(form) user.save() messages.success(request, _("User account for %s created!") % form.cleaned_data["email"]) self._invite(invitation, user) authenticated = authenticate( username=form.cleaned_data["email"], password=form.cleaned_data["password"] ) if authenticated is not None and authenticated.is_active: login(request, authenticated) track_workflow( request.POST["email"], "New User Accepted a project invitation", {"New User Accepted a project invitation": "yes"}, ) meta = get_meta(request) track_new_user_accepted_invite_on_hubspot.delay(user, request.COOKIES, meta) return HttpResponseRedirect(reverse("domain_homepage", args=[invitation.domain])) else: if CouchUser.get_by_username(invitation.email): return HttpResponseRedirect( reverse("login") + "?next=" + reverse("domain_accept_invitation", args=[invitation.domain, invitation.get_id]) ) domain = Domain.get_by_name(invitation.domain) form = NewWebUserRegistrationForm( initial={ "email": invitation.email, "hr_name": domain.display_name() if domain else invitation.domain, "create_domain": False, } ) context.update({"form": form}) return render(request, self.template, context)
def confirm_domain(request, guid=''): with CriticalSection(['confirm_domain_' + guid]): error = None # Did we get a guid? if not guid: error = _('An account activation key was not provided. If you think this ' 'is an error, please contact the system administrator.') # Does guid exist in the system? else: req = RegistrationRequest.get_by_guid(guid) if not req: error = _('The account activation key "%s" provided is invalid. If you ' 'think this is an error, please contact the system ' 'administrator.') % guid if error is not None: context = { 'message_body': error, 'current_page': {'page_name': 'Account Not Activated'}, } return render(request, 'registration/confirmation_error.html', context) requested_domain = Domain.get_by_name(req.domain) view_name = "dashboard_default" view_args = [requested_domain.name] if not domain_has_apps(req.domain): if False and settings.IS_SAAS_ENVIRONMENT and domain_is_on_trial(req.domain): view_name = "app_from_template" view_args.append("appcues") else: view_name = "default_new_app" # Has guid already been confirmed? if requested_domain.is_active: assert(req.confirm_time is not None and req.confirm_ip is not None) messages.success(request, 'Your account %s has already been activated. ' 'No further validation is required.' % req.new_user_username) return HttpResponseRedirect(reverse(view_name, args=view_args)) # Set confirm time and IP; activate domain and new user who is in the req.confirm_time = datetime.utcnow() req.confirm_ip = get_ip(request) req.save() requested_domain.is_active = True requested_domain.save() requesting_user = WebUser.get_by_username(req.new_user_username) send_new_request_update_email(requesting_user, get_ip(request), requested_domain.name, is_confirming=True) messages.success(request, 'Your account has been successfully activated. Thank you for taking ' 'the time to confirm your email address: %s.' % (requesting_user.username)) track_workflow(requesting_user.email, "Confirmed new project") track_confirmed_account_on_hubspot_v2.delay(requesting_user) request.session['CONFIRM'] = True if settings.IS_SAAS_ENVIRONMENT: # For AppCues v3, land new user in Web Apps view_name = get_cloudcare_urlname(requested_domain.name) return HttpResponseRedirect(reverse(view_name, args=view_args))