def _get_and_send_report(self, language, emails): from corehq.apps.reports.views import get_scheduled_report_response, render_full_report_notification with localize(language): title = ( _(DEFAULT_REPORT_NOTIF_SUBJECT) if self.email_subject == DEFAULT_REPORT_NOTIF_SUBJECT else self.email_subject ) attach_excel = getattr(self, "attach_excel", False) content, excel_files = get_scheduled_report_response( self.owner, self.domain, self._id, attach_excel=attach_excel ) slugs = [r.report_slug for r in self.configs] for email in emails: body = render_full_report_notification(None, content, email, self).content send_html_email_async.delay( title, email, body, email_from=settings.DEFAULT_FROM_EMAIL, file_attachments=excel_files, ga_track=True, ga_tracking_info={"cd4": self.domain, "cd10": ", ".join(slugs)}, )
def _get_and_send_report(self, language, emails): from corehq.apps.reports.views import get_scheduled_report_response, render_full_report_notification with localize(language): title = ( _(DEFAULT_REPORT_NOTIF_SUBJECT) if self.email_subject == DEFAULT_REPORT_NOTIF_SUBJECT else self.email_subject ) attach_excel = getattr(self, 'attach_excel', False) content, excel_files = get_scheduled_report_response( self.owner, self.domain, self._id, attach_excel=attach_excel, send_only_active=True ) # Will be False if ALL the ReportConfigs in the ReportNotification # have a start_date in the future. if content is False: return for email in emails: body = render_full_report_notification(None, content, email, self).content send_html_email_async.delay( title, email, body, email_from=settings.DEFAULT_FROM_EMAIL, file_attachments=excel_files)
def _send_downgrade_warning(invoice, context): if invoice.is_customer_invoice: subject = _( "CommCare Alert: {}'s subscriptions will be downgraded to Community Plan after tomorrow!".format( invoice.account.name )) subscriptions_to_downgrade = _( "subscriptions on {}".format(invoice.account.name) ) bcc = None else: subject = _( "CommCare Alert: {}'s subscription will be downgraded to Community Plan after tomorrow!".format( invoice.get_domain() )) subscriptions_to_downgrade = _( "subscription for {}".format(invoice.get_domain()) ) bcc = [settings.GROWTH_EMAIL] context.update({ 'subscriptions_to_downgrade': subscriptions_to_downgrade }) send_html_email_async.delay( subject, invoice.contact_emails, render_to_string('accounting/email/downgrade_warning.html', context), render_to_string('accounting/email/downgrade_warning.txt', context), cc=[settings.ACCOUNTS_EMAIL], bcc=bcc, email_from=get_dimagi_from_email())
def activation_24hr_reminder_email(): """ Reminds inactive users registered 24 hrs ago to activate their account. """ request_reminders = RegistrationRequest.get_requests_24hrs_ago() DNS_name = get_site_domain() for request in request_reminders: user = WebUser.get_by_username(request.new_user_username) registration_link = 'http://' + DNS_name + reverse( 'registration_confirm_domain') + request.activation_guid + '/' email_context = { "domain": request.domain, "registration_link": registration_link, "full_name": user.full_name, "first_name": user.first_name, 'url_prefix': '' if settings.STATIC_CDN else 'http://' + DNS_name, } message_plaintext = render_to_string( 'registration/email/confirm_account_reminder.txt', email_context) message_html = render_to_string( 'registration/email/confirm_account.html', email_context) subject = ugettext('Reminder to Activate your CommCare project') send_html_email_async.delay( subject, request.new_user_username, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL )
def _send_overdue_notice(invoice, context): send_html_email_async.delay( ugettext('CommCare Billing Statement 30 days Overdue for {}'.format(invoice.get_domain())), invoice.contact_emails, render_to_string('accounting/30_days.html', context), render_to_string('accounting/30_days.txt', context), cc=[settings.ACCOUNTS_EMAIL], email_from=get_dimagi_from_email())
def send_confirmation_email(invitation): invited_user = invitation.email subject = "%s accepted your invitation to CommCare HQ" % invited_user recipient = WebUser.get_by_user_id(invitation.invited_by).get_email() context = {"invited_user": invited_user} html_content = render_to_string("domain/email/invite_confirmation.html", context) text_content = render_to_string("domain/email/invite_confirmation.txt", context) send_html_email_async.delay(subject, recipient, html_content, text_content=text_content)
def _send_downgrade_notice(invoice, context): send_html_email_async.delay( ugettext('Oh no! Your CommCare subscription for {} has been downgraded'.format(invoice.get_domain())), invoice.contact_emails, render_to_string('accounting/downgrade.html', context), render_to_string('accounting/downgrade.txt', context), cc=[settings.ACCOUNTS_EMAIL], email_from=get_dimagi_from_email() )
def _send_downgrade_warning(invoice, context): send_html_email_async.delay( ugettext("CommCare Alert: {}'s subscription will be downgraded to Community Plan after tomorrow!".format( invoice.get_domain() )), invoice.contact_emails, render_to_string('accounting/downgrade_warning.html', context), render_to_string('accounting/downgrade_warning.txt', context), cc=[settings.ACCOUNTS_EMAIL], email_from=get_dimagi_from_email())
def email_to_request(self): context = self.as_dict() html_content = render_to_string("{template}.html".format(template=self.TRANSFER_TO_EMAIL), context) text_content = render_to_string("{template}.txt".format(template=self.TRANSFER_TO_EMAIL), context) send_html_email_async.delay( _('Transfer of ownership for CommCare project space.'), self.to_user.email, html_content, text_content=text_content)
def send_activation_email(self): url = absolute_reverse("orgs_accept_invitation", args=[self.organization, self.get_id]) params = {"organization": self.organization, "url": url, "inviter": self.get_inviter().formatted_name} text_content = render_to_string("orgs/email/org_invite.txt", params) html_content = render_to_string("orgs/email/org_invite.html", params) subject = 'Invitation from %s to join CommCareHQ' % self.get_inviter().formatted_name send_html_email_async.delay(subject, self.email, html_content, text_content=text_content, email_from=settings.DEFAULT_FROM_EMAIL)
def _get_and_send_report(self, language, emails): from corehq.apps.reports.views import get_scheduled_report_response with localize(language): title = _("Scheduled report from CommCare HQ") attach_excel = getattr(self, 'attach_excel', False) body, excel_files = get_scheduled_report_response( self.owner, self.domain, self._id, attach_excel=attach_excel ) for email in emails: send_html_email_async.delay(title, email, body.content, email_from=settings.DEFAULT_FROM_EMAIL, file_attachments=excel_files)
def _email_app_translations_discrepancies(msgs, email, app_name): html_content = ghdiff.default_css for sheet_name, msg in msgs.items(): html_content += "<strong>{}</strong>".format(sheet_name) + msg subject = _("App Translations Discrepancies for {}").format(app_name) text_content = _("Hi, PFA file for discrepancies found for app translations.") html_attachment = { 'title': "{} Discrepancies.html".format(app_name), 'file_obj': io.StringIO(html_content), 'mimetype': 'text/html', } send_html_email_async.delay(subject, email, text_content, file_attachments=[html_attachment])
def _send_overdue_notice(invoice, context): if invoice.is_customer_invoice: bcc = None else: bcc = [settings.GROWTH_EMAIL] send_html_email_async.delay( _('CommCare Billing Statement 30 days Overdue for {}'.format(context['domain_or_account'])), invoice.contact_emails, render_to_string('accounting/email/30_days.html', context), render_to_string('accounting/email/30_days.txt', context), cc=[settings.ACCOUNTS_EMAIL], bcc=bcc, email_from=get_dimagi_from_email())
def _send_downgrade_warning(invoice, context): send_html_email_async.delay(ugettext( "CommCare Alert: {}'s subscription will be downgraded to Community Plan after tomorrow!" .format(invoice.get_domain())), invoice.contact_emails, render_to_string( 'accounting/downgrade_warning.html', context), render_to_string( 'accounting/downgrade_warning.txt', context), cc=[settings.ACCOUNTS_EMAIL], email_from=get_dimagi_from_email())
def _send_overdue_notice(invoice, context): if invoice.is_customer_invoice: bcc = None else: bcc = [settings.GROWTH_EMAIL] send_html_email_async.delay( _('CommCare Billing Statement 30 days Overdue for {}'.format(context['domain_or_account'])), invoice.contact_emails, render_to_string('accounting/email/30_days.html', context), render_to_string('accounting/email/30_days.txt', context), cc=[settings.ACCOUNTS_EMAIL], bcc=bcc, email_from=get_dimagi_from_email())
def _send_downgrade_notice(invoice, context): send_html_email_async.delay(_( 'Oh no! Your CommCare subscription for {} has been downgraded'.format( invoice.get_domain())), invoice.contact_emails, render_to_string( 'accounting/email/downgrade.html', context), render_to_string( 'accounting/email/downgrade.txt', context), cc=[settings.ACCOUNTS_EMAIL], bcc=[settings.GROWTH_EMAIL], email_from=get_dimagi_from_email())
def email_to_request(self): context = self.as_dict() html_content = render_to_string( "{template}.html".format(template=self.TRANSFER_TO_EMAIL), context) text_content = render_to_string( "{template}.txt".format(template=self.TRANSFER_TO_EMAIL), context) send_html_email_async.delay( _(u'Transfer of ownership for CommCare project space.'), self.to_user.email, html_content, text_content=text_content)
def send_confirmation_email(invitation): invited_user = invitation.email subject = '%s accepted your invitation to CommCare HQ' % invited_user recipient = WebUser.get_by_user_id(invitation.invited_by).get_email() context = { 'invited_user': invited_user, } html_content = render_to_string('domain/email/invite_confirmation.html', context) text_content = render_to_string('domain/email/invite_confirmation.txt', context) send_html_email_async.delay(subject, recipient, html_content, text_content=text_content)
def _email_app_translations_discrepancies(msgs, checker_messages, email, app_name, result_wb): """ :param msgs: messages for app translation discrepancies :param checker_messages: messages for issues found by translation checker :param email: email to :param app_name: name of the application :param result_wb: result wb of translation checker to attach with the email """ def form_email_content(msgs, checker_messages): if msgs: html_file_content = ghdiff.default_css for sheet_name, msg in msgs.items(): html_file_content += "<strong>{}</strong>".format( sheet_name) + msg text_content = _( "Hi, PFA file for discrepancies found for app translations." ) + "\n" else: html_file_content = None text_content = _( "Hi, No discrepancies found for app translations.") + "\n" if checker_messages: text_content += _( "Issues found with the workbook are as follows :") + "\n" text_content += '\n'.join([_(msg) for msg in checker_messages]) else: text_content += _("No issues found with the workbook.") return html_file_content, text_content def attachment(title, content, mimetype='text/html'): return {'title': title, 'file_obj': content, 'mimetype': mimetype} subject = _("App Translations Discrepancies for {}").format(app_name) html_file_content, text_content = form_email_content( msgs, checker_messages) attachments = [] if html_file_content: attachments.append( attachment("{} Discrepancies.html".format(app_name), io.StringIO(html_file_content))) if result_wb: attachments.append( attachment("{} TranslationChecker.xlsx".format(app_name), io.BytesIO(read_workbook_content_as_file(result_wb)), result_wb.mime_type)) send_html_email_async.delay(subject, email, linebreaksbr(text_content), file_attachments=attachments)
def _email_app_translations_discrepancies(msgs, email, app_name): message = '\n\n'.join([ """Sheet {}: {}""".format(sheet_name, '\n '.join(msgs[sheet_name])) for sheet_name in msgs if msgs.get(sheet_name) ]) subject = "App Translations Discrepancies for {}".format(app_name) body = """Hi, Following discrepancies were found for app translations. {}""".format(message) send_html_email_async.delay(subject, email, linebreaksbr(body))
def email_from_request(self): context = self.as_dict() context['settings_url'] = "{url_base}{path}".format( url_base=get_url_base(), path=reverse('transfer_domain_view', args=[self.domain])) html_content = render_to_string("{template}.html".format(template=self.TRANSFER_FROM_EMAIL), context) text_content = render_to_string("{template}.txt".format(template=self.TRANSFER_FROM_EMAIL), context) send_html_email_async.delay( _('Transfer of ownership for CommCare project space.'), self.from_user.email, html_content, text_content=text_content)
def _send_registry_email(for_domain, subject, template, context): recipients = { u.get_email() for u in WebUser.get_admins_by_domain(for_domain) } email_html = render_to_string(f'registry/email/{template}.html', context) email_plaintext = render_to_string(f'registry/email/{template}.txt', context) send_html_email_async.delay( subject, recipients, email_html, text_content=email_plaintext, )
def email_from_request(self): context = self.as_dict() context['settings_url'] = u"{url_base}{path}".format( url_base=get_url_base(), path=reverse('transfer_domain_view', args=[self.domain])) html_content = render_to_string("{template}.html".format(template=self.TRANSFER_FROM_EMAIL), context) text_content = render_to_string("{template}.txt".format(template=self.TRANSFER_FROM_EMAIL), context) send_html_email_async.delay( _(u'Transfer of ownership for CommCare project space.'), self.from_user.email, html_content, text_content=text_content)
def run_data_pull(data_pull_slug, domain, month, location_id=None, email=None): subject = _('Custom ICDS Data Pull') try: filename = DataExporter(data_pull_slug, "icds-ucr-citus", month=month, location_id=location_id).export() except Exception: if email: message = _(""" Hi, Could not generate the requested data pull. The error has been notified. Please report as an issue for quicker followup """) send_html_email_async.delay(subject, [email], message, email_from=settings.DEFAULT_FROM_EMAIL) raise else: if email and filename: db = get_blob_db() download_id = DownloadBase.new_id_prefix + make_uuid() with open(filename, 'rb') as _file: db.put( _file, domain=domain, parent_id=domain, type_code=CODES.data_export, key=download_id, timeout=24 * 60, ) exposed_download = expose_blob_download( filename, expiry=24 * 60 * 60, mimetype=Format.from_format(Format.ZIP).mimetype, content_disposition=safe_filename_header(filename), download_id=download_id) os.remove(filename) path = reverse( 'retrieve_download', kwargs={'download_id': exposed_download.download_id}) link = f"{web.get_url_base()}{path}?get_file" message = _(""" Hi, Please download the data from {link}. The data is available only for 24 hours. """).format(link=link) send_html_email_async.delay(subject, [email], message, email_from=settings.DEFAULT_FROM_EMAIL)
def send_subscription_change_alert(domain, new_subscription, old_subscription, internal_change): billing_account = (new_subscription.account if new_subscription else old_subscription.account if old_subscription else None) # this can be None, though usually this will be initiated # by an http request request = get_request() email_context = { 'domain': domain, 'domain_url': get_default_domain_url(domain), 'old_plan': old_subscription.plan_version if old_subscription else None, 'new_plan': new_subscription.plan_version if new_subscription else None, 'old_subscription': old_subscription, 'new_subscription': new_subscription, 'billing_account': billing_account, 'username': request.couch_user.username if getattr(request, 'couch_user', None) else None, 'referer': request.META.get('HTTP_REFERER') if request else None, } email_subject = "{env}Subscription Change Alert: {domain} from {old_plan} to {new_plan}".format( env=("[{}] ".format(settings.SERVER_ENVIRONMENT.upper()) if settings.SERVER_ENVIRONMENT == "staging" else ""), domain=email_context['domain'], old_plan=email_context['old_plan'], new_plan=email_context['new_plan'], ) sub_change_email_address = (settings.INTERNAL_SUBSCRIPTION_CHANGE_EMAIL if internal_change else settings.SUBSCRIPTION_CHANGE_EMAIL) send_html_email_async.delay( email_subject, sub_change_email_address, render_to_string('accounting/subscription_change_email.html', email_context), text_content=render_to_string( 'accounting/subscription_change_email.txt', email_context), )
def send_upload_fixture_complete_email(email, domain, time_start, time_end, messages): context = { "username": email, "domain": domain, "time_start": time_start, "time_end": time_end, "messages": messages } send_html_email_async.delay( "Your fixture upload is complete!", email, render_to_string('fixtures/upload_complete.html', context), render_to_string('fixtures/upload_complete.txt', context), email_from=settings.DEFAULT_FROM_EMAIL) return
def send_handoff_email(self): partner_contact = self.internal_settings_form.cleaned_data['partner_contact'] dimagi_contact = self.internal_settings_form.cleaned_data['dimagi_contact'] recipients = [partner_contact, dimagi_contact] params = {'contact_name': CouchUser.get_by_username(dimagi_contact).human_friendly_name} send_html_email_async.delay( subject="Project Support Transition", recipient=recipients, html_content=render_to_string( "domain/email/support_handoff.html", params), text_content=render_to_string( "domain/email/support_handoff.txt", params), email_from=settings.SUPPORT_EMAIL, ) messages.success(self.request, _("Sent hand-off email to {}.").format(" and ".join(recipients)))
def _notify_failure_to_user(hosted_ccz, build, user_email): build_profile = hosted_ccz.build_profile profile_name = build_profile.get('name') if build_profile else None content = "Hi,\n"\ "CCZ could not be created for the following request:\n" \ "App: {app}\n" \ "Version: {version}\n" \ "Profile: {profile}\n" \ "Link: {link}" \ "".format(app=build.name, version=hosted_ccz.version, profile=profile_name, link=hosted_ccz.link.identifier) send_html_email_async.delay( "CCZ Hosting setup failed for app {app} in project {domain}".format( app=build.name, domain=hosted_ccz.domain, ), user_email, linebreaksbr(content))
def send_handoff_email(self): partner_contact = self.internal_settings_form.cleaned_data['partner_contact'] dimagi_contact = self.internal_settings_form.cleaned_data['dimagi_contact'] recipients = [partner_contact, dimagi_contact] params = {'contact_name': CouchUser.get_by_username(dimagi_contact).human_friendly_name} send_html_email_async.delay( subject="Project Support Transition", recipient=recipients, html_content=render_to_string( "domain/email/support_handoff.html", params), text_content=render_to_string( "domain/email/support_handoff.txt", params), email_from=settings.SUPPORT_EMAIL, ) messages.success(self.request, _("Sent hand-off email to {}.").format(" and ".join(recipients)))
def send_domain_registration_email(recipient, domain_name, guid): DNS_name = get_site_domain() registration_link = 'http://' + DNS_name + reverse( 'registration_confirm_domain') + guid + '/' message_plaintext = u""" Welcome to CommCareHQ! Please click this link: {registration_link} to activate your new project. You will not be able to use your project until you have confirmed this email address. Project name: "{domain}" Username: "******" """ + REGISTRATION_EMAIL_BODY_PLAINTEXT message_html = u""" <h1>Welcome to CommCare HQ!</h1> <p>Please <a href="{registration_link}">go here to activate your new project</a>. You will not be able to use your project until you have confirmed this email address.</p> <p><strong>Project name:</strong> {domain}</p> <p><strong>Username:</strong> {username}</p> """ + REGISTRATION_EMAIL_BODY_HTML params = { "domain": domain_name, "pricing_link": PRICING_LINK, "registration_link": registration_link, "username": recipient, "users_link": USERS_LINK, "wiki_link": WIKI_LINK, } message_plaintext = message_plaintext.format(**params) message_html = message_html.format(**params) subject = 'Welcome to CommCare HQ!'.format(**locals()) try: send_html_email_async.delay(subject, recipient, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning("Can't send email, but the message was:\n%s" % message_plaintext)
def _get_and_send_report(self, language, emails): from corehq.apps.reports.views import get_scheduled_report_response with localize(language): title = ( _(DEFAULT_REPORT_NOTIF_SUBJECT) if self.email_subject == DEFAULT_REPORT_NOTIF_SUBJECT else self.email_subject ) attach_excel = getattr(self, 'attach_excel', False) body, excel_files = get_scheduled_report_response( self.owner, self.domain, self._id, attach_excel=attach_excel ) for email in emails: send_html_email_async.delay(title, email, body.content, email_from=settings.DEFAULT_FROM_EMAIL, file_attachments=excel_files)
def _email_app_translations_discrepancies(msgs, email, app_name): html_content = ghdiff.default_css for sheet_name, msg in msgs.items(): html_content += "<strong>{}</strong>".format(sheet_name) + msg subject = _("App Translations Discrepancies for {}").format(app_name) text_content = _( "Hi, PFA file for discrepancies found for app translations.") html_attachment = { 'title': "{} Discrepancies.html".format(app_name), 'file_obj': io.StringIO(html_content), 'mimetype': 'text/html', } send_html_email_async.delay(subject, email, text_content, file_attachments=[html_attachment])
def _notification_email_on_publish(domain, snapshot, published_by): params = {"domain": domain, "snapshot": snapshot, "published_by": published_by, "url_base": get_site_domain()} text_content = render_to_string( "domain/email/published_app_notification.txt", params) html_content = render_to_string( "domain/email/published_app_notification.html", params) recipients = settings.EXCHANGE_NOTIFICATION_RECIPIENTS subject = "New App on Exchange: %s" % snapshot.title try: for recipient in recipients: send_html_email_async.delay(subject, recipient, html_content, text_content=text_content, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning("Can't send notification email, " "but the message was:\n%s" % text_content)
def _notification_email_on_publish(domain, snapshot, published_by): params = {"domain": domain, "snapshot": snapshot, "published_by": published_by, "url_base": get_site_domain()} text_content = render_to_string( "domain/email/published_app_notification.txt", params) html_content = render_to_string( "domain/email/published_app_notification.html", params) recipients = settings.EXCHANGE_NOTIFICATION_RECIPIENTS subject = "New App on Exchange: %s" % snapshot.title try: for recipient in recipients: send_html_email_async.delay(subject, recipient, html_content, text_content=text_content, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning("Can't send notification email, " "but the message was:\n%s" % text_content)
def send_activation_email(self): url = absolute_reverse("orgs_accept_invitation", args=[self.organization, self.get_id]) params = { "organization": self.organization, "url": url, "inviter": self.get_inviter().formatted_name } text_content = render_to_string("orgs/email/org_invite.txt", params) html_content = render_to_string("orgs/email/org_invite.html", params) subject = 'Invitation from %s to join CommCareHQ' % self.get_inviter( ).formatted_name send_html_email_async.delay(subject, self.email, html_content, text_content=text_content, email_from=settings.DEFAULT_FROM_EMAIL)
def _send_overdue_notice(invoice, communication_model, context): if invoice.is_customer_invoice: bcc = None else: bcc = [settings.GROWTH_EMAIL] send_html_email_async.delay( _('CommCare Billing Statement 30 days Overdue for {}'.format(context['domain_or_account'])), invoice.get_contact_emails(include_domain_admins=True, filter_out_dimagi=True), render_to_string('accounting/email/30_days.html', context), render_to_string('accounting/email/30_days.txt', context), cc=[settings.ACCOUNTS_EMAIL], bcc=bcc, email_from=get_dimagi_from_email() ) communication_model.objects.create( invoice=invoice, communication_type=CommunicationType.OVERDUE_INVOICE, )
def update_linked_app_and_notify(domain, app_id, master_app_id, user_id, email): app = get_current_app(domain, app_id) subject = _("Update Status for linked app %s") % app.name try: update_linked_app(app, master_app_id, user_id) except (AppLinkError, MultimediaMissingError) as e: message = str(e) except Exception: # Send an email but then crash the process # so we know what the error was send_html_email_async.delay(subject, email, _( "Something went wrong updating your linked app. " "Our team has been notified and will monitor the situation. " "Please try again, and if the problem persists report it as an issue.")) raise else: message = _("Your linked application was successfully updated to the latest version.") send_html_email_async.delay(subject, email, message)
def pull_missing_multimedia_for_app_and_notify(domain, app_id, email): app = get_app(domain, app_id) subject = _("Update Status for linked app %s missing multimedia pull") % app.name try: pull_missing_multimedia_for_app(app) except MultimediaMissingError as e: message = str(e) except Exception: # Send an email but then crash the process # so we know what the error was send_html_email_async.delay(subject, email, _( "Something went wrong while pulling multimedia for your linked app. " "Our team has been notified and will monitor the situation. " "Please try again, and if the problem persists report it as an issue.")) raise else: message = _("Multimedia was successfully updated for the linked app.") send_html_email_async.delay(subject, email, message)
def update_linked_app_and_notify(domain, app_id, user_id, email): app = get_current_app(domain, app_id) subject = _("Update Status for linked app %s") % app.name try: update_linked_app(app, user_id) except (AppLinkError, MultimediaMissingError) as e: message = six.text_type(e) except Exception: # Send an email but then crash the process # so we know what the error was send_html_email_async.delay(subject, email, _( "Something went wrong updating your linked app. " "Our team has been notified and will monitor the situation. " "Please try again, and if the problem persists report it as an issue.")) raise else: message = _("Your linked application was successfully updated to the latest version.") send_html_email_async.delay(subject, email, message)
def send_monthly_sms_report(): subject = _('Monthly SMS report') recipients = [ '*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**' ] try: start_date = date.today().replace(day=1) - relativedelta(months=1) first_day, last_day = calendar.monthrange(start_date.year, start_date.month) end_date = start_date.replace(day=last_day) filename = call_command('get_icds_sms_usage', 'icds-cas', str(start_date), str(end_date)) with open(filename, 'rb') as f: cached_download = expose_cached_download( f.read(), expiry=24 * 60 * 60, file_extension=file_extention_from_filename(filename), mimetype=Format.from_format(Format.XLS_2007).mimetype, content_disposition='attachment; filename="%s"' % filename) path = reverse('retrieve_download', kwargs={'download_id': cached_download.download_id}) link = f"{web.get_url_base()}{path}?get_file" message = _(""" Hi, Please download the sms report for last month at {link}. The report is available only till midnight today. """).format(link=link) send_html_email_async.delay(subject, recipients, message, email_from=settings.DEFAULT_FROM_EMAIL) except Exception as e: message = _(""" Hi, Could not generate the monthly SMS report for ICDS. The error has been notified. Please report as an issue for quick followup """) send_html_email_async.delay(subject, recipients, message, email_from=settings.DEFAULT_FROM_EMAIL) raise e
def send_domain_registration_email(recipient, domain_name, guid): DNS_name = get_site_domain() registration_link = 'http://' + DNS_name + reverse('registration_confirm_domain') + guid + '/' message_plaintext = u""" Welcome to CommCareHQ! Please click this link: {registration_link} to activate your new project. You will not be able to use your project until you have confirmed this email address. Project name: "{domain}" Username: "******" """ + REGISTRATION_EMAIL_BODY_PLAINTEXT message_html = u""" <h1>Welcome to CommCare HQ!</h1> <p>Please <a href="{registration_link}">go here to activate your new project</a>. You will not be able to use your project until you have confirmed this email address.</p> <p><strong>Project name:</strong> {domain}</p> <p><strong>Username:</strong> {username}</p> """ + REGISTRATION_EMAIL_BODY_HTML params = { "domain": domain_name, "pricing_link": PRICING_LINK, "registration_link": registration_link, "username": recipient, "users_link": USERS_LINK, "wiki_link": WIKI_LINK, } message_plaintext = message_plaintext.format(**params) message_html = message_html.format(**params) subject = 'Welcome to CommCare HQ!'.format(**locals()) try: send_html_email_async.delay(subject, recipient, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning("Can't send email, but the message was:\n%s" % message_plaintext)
def send_idp_cert_expires_reminder_emails(num_days): """ Sends a reminder email to the enterprise admin email addresses specified on the IdP's owner account for any IdPs with certificates that will expire on the date `num_days` from today. :param num_days: Query IdP certs expiring `num_days` from today. """ today = datetime.datetime.utcnow().date() date_in_n_days = today + datetime.timedelta(days=num_days) day_after_that = date_in_n_days + datetime.timedelta(days=1) queryset = IdentityProvider.objects.filter( protocol=IdentityProviderProtocol.SAML, is_active=True, date_idp_cert_expiration__gte=date_in_n_days, date_idp_cert_expiration__lt=day_after_that, ) for idp in queryset.all(): context = get_idp_cert_expiration_email_context(idp) if not context["to"]: log.error(f"no admin email addresses for IdP: {idp}") try: for send_to in context["to"]: send_html_email_async.delay( context["subject"], send_to, context["html"], text_content=context["plaintext"], email_from=context["from"], bcc=context["bcc"], ) log.info( "Sent %(num_days)s-day certificate expiration reminder " "email for %(idp_name)s to %(send_to)s." % { "num_days": num_days, "idp_name": idp.name, "send_to": send_to, }) except Exception as exc: log.error( f"Failed to send cert reminder email for IdP {idp}: {exc!s}", exc_info=True, )
def send_global_domain_registration_email(requesting_user, domain_name): DNS_name = get_site_domain() registration_link = 'http://' + DNS_name + reverse("domain_homepage", args=[domain_name]) message_plaintext = u""" Hello {name}, You have successfully created and activated the project "{domain}" for the CommCare HQ user "{username}". You may access your project by following this link: {registration_link} """ + REGISTRATION_EMAIL_BODY_PLAINTEXT message_html = u""" <h1>New project "{domain}" created!</h1> <p>Hello {name},</p> <p>You may now <a href="{registration_link}">visit your newly created project</a> with the CommCare HQ User <strong>{username}</strong>.</p> """ + REGISTRATION_EMAIL_BODY_HTML params = { "name": requesting_user.first_name, "domain": domain_name, "pricing_link": PRICING_LINK, "registration_link": registration_link, "username": requesting_user.email, "users_link": USERS_LINK, "wiki_link": WIKI_LINK, } message_plaintext = message_plaintext.format(**params) message_html = message_html.format(**params) subject = 'CommCare HQ: New project created!'.format(**locals()) try: send_html_email_async.delay(subject, requesting_user.email, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning("Can't send email, but the message was:\n%s" % message_plaintext)
def transfer_domain(self, by_user, *args, transfer_via=None, **kwargs): self.confirm_time = datetime.utcnow() if 'ip' in kwargs: self.confirm_ip = kwargs['ip'] self.from_user.transfer_domain_membership(self.domain, self.to_user, is_admin=True) self.from_user.save() if by_user: log_user_change(by_domain=self.domain, for_domain=self.domain, couch_user=self.from_user, changed_by_user=by_user, changed_via=transfer_via, change_messages=UserChangeMessage.domain_removal( self.domain)) log_user_change(by_domain=self.domain, for_domain=self.domain, couch_user=self.to_user, changed_by_user=by_user, changed_via=transfer_via, change_messages=UserChangeMessage.domain_addition( self.domain)) self.to_user.save() self.active = False self.save() html_content = render_to_string( "{template}.html".format(template=self.DIMAGI_CONFIRM_EMAIL), self.as_dict()) text_content = render_to_string( "{template}.txt".format(template=self.DIMAGI_CONFIRM_EMAIL), self.as_dict()) send_html_email_async.delay( _('There has been a transfer of ownership of {domain}').format( domain=self.domain), settings.SUPPORT_EMAIL, html_content, text_content=text_content, )
def send_domain_registration_email(recipient, domain_name, guid, full_name): DNS_name = get_site_domain() registration_link = 'http://' + DNS_name + reverse( 'registration_confirm_domain') + guid + '/' params = { "domain": domain_name, "pricing_link": PRICING_LINK, "registration_link": registration_link, "full_name": full_name, "forum_link": FORUM_LINK, "wiki_link": WIKI_LINK, 'url_prefix': '' if settings.STATIC_CDN else 'http://' + DNS_name, "is_mobile_experience": (toggles.MOBILE_SIGNUP_REDIRECT_AB_TEST_CONTROLLER.enabled( recipient, toggles.NAMESPACE_USER) and toggles.MOBILE_SIGNUP_REDIRECT_AB_TEST.enabled( recipient, toggles.NAMESPACE_USER)) } message_plaintext = render_to_string( 'registration/email/confirm_account.txt', params) message_html = render_to_string('registration/email/confirm_account.html', params) subject = ugettext('Activate your CommCare project') try: send_html_email_async.delay(subject, recipient, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL, ga_track=True) except Exception: logging.warning("Can't send email, but the message was:\n%s" % message_plaintext)
def send_custom_sms_report(start_date: str, end_date: str, email: str, domain: str): subject = _('Monthly SMS report') recipients = [email] try: filename = call_command('get_icds_sms_usage', 'icds-cas', start_date, end_date) with open(filename, 'rb') as f: cached_download = expose_cached_download( f.read(), expiry=24 * 60 * 60, file_extension=file_extention_from_filename(filename), mimetype=Format.from_format(Format.XLS_2007).mimetype, content_disposition='attachment; filename="%s"' % filename) path = reverse('retrieve_download', kwargs={'download_id': cached_download.download_id}) link = f"{web.get_url_base()}{path}?get_file" message = _(""" Hi, Please download the sms report for time frame {start_date} to {end_date} (inclusive) at {link}. The report is available only for next 24 hours. """).format(link=link, start_date=start_date, end_date=end_date) send_html_email_async.delay(subject, recipients, message, email_from=settings.DEFAULT_FROM_EMAIL) except Exception as e: message = _(""" Hi, Could not generate the custom SMS report for ICDS. The error has been notified. Please report as an issue for quick followup """) send_html_email_async.delay(subject, recipients, message, email_from=settings.DEFAULT_FROM_EMAIL) raise e finally: report_tracker = CustomSMSReportTracker(domain) report_tracker.remove_report(start_date, end_date)
def mass_email(request): if not request.couch_user.is_staff: raise Http404() if request.method == "POST": form = EmailForm(request.POST) if form.is_valid(): subject = form.cleaned_data['email_subject'] body = form.cleaned_data['email_body'] real_email = form.cleaned_data['real_email'] if real_email: recipients = WebUser.view( 'users/mailing_list_emails', reduce=False, include_docs=True, ).all() else: recipients = [request.couch_user] for recipient in recipients: params = { 'email_body': body, 'user_id': recipient.get_id, 'unsub_url': get_url_base() + reverse('unsubscribe', args=[recipient.get_id]) } text_content = render_to_string("hqadmin/email/mass_email_base.txt", params) html_content = render_to_string("hqadmin/email/mass_email_base.html", params) send_html_email_async.delay(subject, recipient.email, html_content, text_content, email_from=settings.DEFAULT_FROM_EMAIL) messages.success(request, 'Your email(s) were sent successfully.') else: form = EmailForm() context = get_hqadmin_base_context(request) context['hide_filters'] = True context['form'] = form return render(request, "hqadmin/mass_email.html", context)
def _get_and_send_report(self, language, emails): from corehq.apps.reports.views import get_scheduled_report_response, render_full_report_notification with localize(language): title = (_(DEFAULT_REPORT_NOTIF_SUBJECT) if self.email_subject == DEFAULT_REPORT_NOTIF_SUBJECT else self.email_subject) attach_excel = getattr(self, 'attach_excel', False) content, excel_files = get_scheduled_report_response( self.owner, self.domain, self._id, attach_excel=attach_excel) slugs = [r.report_slug for r in self.configs] for email in emails: body = render_full_report_notification(None, content, email, self).content send_html_email_async.delay( title, email, body, email_from=settings.DEFAULT_FROM_EMAIL, file_attachments=excel_files)
def send_global_domain_registration_email(requesting_user, domain_name): DNS_name = get_site_domain() registration_link = 'http://' + DNS_name + reverse("domain_homepage", args=[domain_name]) message_plaintext = u""" Hello {name}, You have successfully created and activated the project "{domain}" for the CommCare HQ user "{username}". You may access your project by following this link: {registration_link} """ + REGISTRATION_EMAIL_BODY_PLAINTEXT message_html = u""" <h1>New project "{domain}" created!</h1> <p>Hello {name},</p> <p>You may now <a href="{registration_link}">visit your newly created project</a> with the CommCare HQ User <strong>{username}</strong>.</p> """ + REGISTRATION_EMAIL_BODY_HTML params = { "name": requesting_user.first_name, "domain": domain_name, "pricing_link": PRICING_LINK, "registration_link": registration_link, "username": requesting_user.email, "users_link": USERS_LINK, "wiki_link": WIKI_LINK, } message_plaintext = message_plaintext.format(**params) message_html = message_html.format(**params) subject = 'CommCare HQ: New project created!'.format(**locals()) try: send_html_email_async.delay(subject, requesting_user.email, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning("Can't send email, but the message was:\n%s" % message_plaintext)
def send_mobile_experience_reminder(recipient, full_name): url = absolute_reverse("login") params = { "full_name": full_name, "url": url, 'url_prefix': get_static_url_prefix(), } message_plaintext = render_to_string( 'registration/email/mobile_signup_reminder.txt', params) message_html = render_to_string( 'registration/email/mobile_signup_reminder.html', params) subject = ugettext('Visit CommCareHQ on your computer!') try: send_html_email_async.delay(subject, recipient, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning( "Can't send email, but the message was:\n%s" % message_plaintext) raise
def send_mobile_experience_reminder(recipient, full_name): url = absolute_reverse("login") params = { "full_name": full_name, "url": url, 'url_prefix': '' if settings.STATIC_CDN else 'http://' + get_site_domain(), } message_plaintext = render_to_string( 'registration/email/mobile_signup_reminder.txt', params) message_html = render_to_string( 'registration/email/mobile_signup_reminder.html', params) subject = ugettext('Visit CommCareHQ on your computer!') try: send_html_email_async.delay(subject, recipient, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning( "Can't send email, but the message was:\n%s" % message_plaintext) raise
def send_subscription_change_alert(domain, new_subscription, old_subscription, internal_change): billing_account = ( new_subscription.account if new_subscription else old_subscription.account if old_subscription else None ) # this can be None, though usually this will be initiated # by an http request request = get_request() email_context = { 'domain': domain, 'domain_url': get_default_domain_url(domain), 'old_plan': old_subscription.plan_version if old_subscription else None, 'new_plan': new_subscription.plan_version if new_subscription else None, 'old_subscription': old_subscription, 'new_subscription': new_subscription, 'billing_account': billing_account, 'username': request.couch_user.username if getattr(request, 'couch_user', None) else None, 'referer': request.META.get('HTTP_REFERER') if request else None, } email_subject = "{env}Subscription Change Alert: {domain} from {old_plan} to {new_plan}".format( env=("[{}] ".format(settings.SERVER_ENVIRONMENT.upper()) if settings.SERVER_ENVIRONMENT == "staging" else ""), domain=email_context['domain'], old_plan=email_context['old_plan'], new_plan=email_context['new_plan'], ) sub_change_email_address = (settings.INTERNAL_SUBSCRIPTION_CHANGE_EMAIL if internal_change else settings.SUBSCRIPTION_CHANGE_EMAIL) send_html_email_async.delay( email_subject, sub_change_email_address, render_to_string('accounting/email/subscription_change.html', email_context), text_content=render_to_string('accounting/email/subscription_change.txt', email_context), )
def send_domain_registration_email(recipient, domain_name, guid, full_name, first_name): DNS_name = get_site_domain() registration_link = 'http://' + DNS_name + reverse('registration_confirm_domain') + guid + '/' params = { "domain": domain_name, "pricing_link": PRICING_LINK, "registration_link": registration_link, "full_name": full_name, "first_name": first_name, "forum_link": FORUM_LINK, "wiki_link": WIKI_LINK, 'url_prefix': '' if settings.STATIC_CDN else 'http://' + DNS_name, } message_plaintext = render_to_string('registration/email/confirm_account.txt', params) message_html = render_to_string('registration/email/confirm_account.html', params) subject = ugettext('Activate your CommCare project') try: send_html_email_async.delay(subject, recipient, message_html, text_content=message_plaintext, email_from=settings.DEFAULT_FROM_EMAIL) except Exception: logging.warning("Can't send email, but the message was:\n%s" % message_plaintext)
def transfer_domain(self, *args, **kwargs): self.confirm_time = datetime.utcnow() if 'ip' in kwargs: self.confirm_ip = kwargs['ip'] self.from_user.transfer_domain_membership(self.domain, self.to_user, is_admin=True) self.from_user.save() self.to_user.save() self.active = False self.save() html_content = render_to_string( "{template}.html".format(template=self.DIMAGI_CONFIRM_EMAIL), self.as_dict()) text_content = render_to_string( "{template}.txt".format(template=self.DIMAGI_CONFIRM_EMAIL), self.as_dict()) send_html_email_async.delay( _('There has been a transfer of ownership of {domain}').format( domain=self.domain), self.DIMAGI_CONFIRM_ADDRESS, html_content, text_content=text_content )