def send_signup_email(to: str, registration_key: str): if config.auth.internal.signup.notify.base_url is not None: nc = NotificationsAPIClient( config.auth.internal.signup.notify.api_key, base_url=config.auth.internal.signup.notify.base_url) nc.send_email_notification( to, config.auth.internal.signup.notify.registration_template, personalisation={ "fqdn": config.ui.fqdn, "registration_key": registration_key }) else: message = dedent(f""" We have received your request to register for {config.ui.fqdn}. To confirm your account registration, please visit the link below: https://{config.ui.fqdn}/login.html?registration_key={registration_key} If you did not make this request, you can safely ignore this email. """) title = f"Confirm your account registration for {config.ui.fqdn}" send_email(title, message, to)
def send_mail( self, subject_template_name, email_template_name, context, from_email, to_email, html_email_template_name=None, ): user = context.get("user") url = context.get("base_url") + reverse( "password_reset_confirm", kwargs={ "uidb64": urlsafe_base64_encode(force_bytes(user.pk)), "token": context.get("token"), }, ) notifications_client = NotificationsAPIClient( settings.NOTIFY_API_KEY, base_url=settings.NOTIFY_ENDPOINT) try: notifications_client.send_email_notification( email_address=user.email, template_id=settings.PASSWORD_RESET_EMAIL_TEMPLATE_ID.get( context.get("language") or "en"), personalisation={ "name": user.name, "url": url, }, ) except HTTPError as e: raise Exception(e)
def notify_about_deletion(self, person: Person, deleted_by: User) -> None: if deleted_by == person.user: return None # Find a the most suitable email. email = ((person.user and person.user.email) or person.contact_email or person.email) # If we can't find one, return. if not email: return None context = { "profile_name": person.full_name, "editor_name": deleted_by.get_full_name(), } if settings.APP_ENV in ("local", "test"): logger.info(f"{person.full_name}'s profile was deleted") return notification_client = NotificationsAPIClient( settings.GOVUK_NOTIFY_API_KEY) notification_client.send_email_notification( email, settings.PROFILE_DELETED_EMAIL_TEMPLATE_ID, personalisation=context, )
def send_mail(self, subject_template_name, email_template_name, context, from_email, to_email, html_email_template_name=None): """ Uses govuk notify to deliver email providing a link for the user to reset their password. """ if not settings.NOTIFY_APIKEY: return notifications_client = NotificationsAPIClient(settings.NOTIFY_APIKEY) # TODO: We should look up the template IDs from configuration # somewhere. template_id = '22afa457-ee83-4af2-aab7-db5299f54b6b' del context['user'] del context['email'] context['uid'] = context['uid'].decode("utf-8") try: notifications_client.send_email_notification( email_address=to_email, template_id=template_id, personalisation=context, reference=None) except Exception as e: logger.exception(e) raise e
def send_dataset_update_emails(update_emails_data_environment_variable): if update_emails_data_environment_variable not in os.environ: raise ValueError( f"Could not find data in environment for `{update_emails_data_environment_variable}`" ) dataset_info = json.loads( os.environ[update_emails_data_environment_variable]) dataset_url = dataset_info['dataset_url'] dataset_name = dataset_info['dataset_name'] emails = dataset_info['emails'] client = NotificationsAPIClient(os.environ['NOTIFY_API_KEY']) logger.info( f"Sending `dataset updated` emails to subscribers for " f"this pipeline (`{update_emails_data_environment_variable}`).") for email in emails: client.send_email_notification( email_address=email, template_id=os.environ['NOTIFY_TEMPLATE_ID__DATASET_UPDATED'], personalisation={ "dataset_name": dataset_name, "dataset_url": dataset_url }, )
def send_activated_email(to: str, user: str, email: str, admin: str): if config.auth.internal.signup.notify.base_url is not None: nc = NotificationsAPIClient( config.auth.internal.signup.notify.api_key, base_url=config.auth.internal.signup.notify.base_url) nc.send_email_notification( to, config.auth.internal.signup.notify.activated_template, personalisation={ "fqdn": config.ui.fqdn, "user": user, "admin": admin, "email": email }) else: message = dedent(f""" The following account was activated on {config.ui.fqdn}. Username: {user} Email: {email} The account was activated by: {admin} Login at https://{config.ui.fqdn}/login.html """) title = f"Account for {user} now active on {config.ui.fqdn}" send_email(title, message, to)
def generate_s3_and_send_email( barrier_ids: List[int], s3_filename: str, email: str, first_name: str, field_titles: Dict[str, str], ) -> None: queryset = Barrier.objects.filter(id__in=barrier_ids) serializer = BarrierCsvExportSerializer(queryset, many=True) # save the download event in the database BarrierSearchCSVDownloadEvent.objects.create( email=email, barrier_ids=",".join(barrier_ids), ) presigned_url = generate_and_upload_to_s3(s3_filename, field_titles, serializer) client = NotificationsAPIClient(settings.NOTIFY_API_KEY) client.send_email_notification( email_address=email, template_id=settings.NOTIFY_GENERATED_FILE_ID, personalisation={ "first_name": first_name.capitalize(), "file_name": s3_filename, "file_url": presigned_url, }, )
def send_approvals_email(request_id): print('Sending mail') approver, requestor, user, reason, team_name, items_to_approve, sc = get_approval_details( request_id) print(approver) approval_url = 'https://' + settings.DOMAIN_NAME + '/access-requests/' attention_for = get_username(approver) requestor = get_username(requestor) user = get_username(user) emailaddr = get_test_email_addreess(approver) notifications_client = NotificationsAPIClient(settings.GOV_NOTIFY_API_KEY) notifications_client.send_email_notification( email_address=emailaddr, template_id=settings.EMAIL_UUID, personalisation={ 'name': attention_for, 'sc': sc, 'requester': requestor, 'user': user, 'reason': reason, 'team': team_name, 'services': items_to_approve, 'url': approval_url } )
def send_authorize_email(to: str, user: str, email: str): if config.auth.internal.signup.notify.base_url is not None: nc = NotificationsAPIClient( config.auth.internal.signup.notify.api_key, base_url=config.auth.internal.signup.notify.base_url) nc.send_email_notification( to, config.auth.internal.signup.notify.authorization_template, personalisation={ "fqdn": config.ui.fqdn, "user": user, "email": email }) else: message = dedent(f""" The following user has created an account and is waiting that his account gets activated. User: {user} Email: {email} You can browse to the link below to activate the account: https://{config.ui.fqdn}/admin/users.html """) title = f"A new {config.ui.fqdn} user is waiting for your authorization" send_email(title, message, to)
def send_reset_email(to: str, reset_id: str): if config.auth.internal.signup.notify.base_url is not None: nc = NotificationsAPIClient( config.auth.internal.signup.notify.api_key, base_url=config.auth.internal.signup.notify.base_url) nc.send_email_notification( to, config.auth.internal.signup.notify.password_reset_template, personalisation={ "fqdn": config.ui.fqdn, "reset_id": reset_id }) else: message = dedent(f""" We have received a request to have your password reset for {config.ui.fqdn}. To reset your password, please visit the link below: https://{config.ui.fqdn}/reset.html?reset_id={reset_id} If you did not make this request, you can safely ignore this email and your password will remain the same. """) title = f"Password reset request for {config.ui.fqdn}" send_email(title, message, to)
def send_requestor_email(request_id): print('Sending mail') if Request.objects.get(id=request_id).rejected: status = 'has been rejected' rejection_reason = ', because: ' + Request.objects.get( id=request_id).rejected_reason else: status = 'is being reviewed' rejection_reason = '.' approver, requestor, user, reason, team_name, items_to_approve, sc = get_approval_details( request_id) attention_for = get_username(requestor) approver = get_username(approver) user = get_username(user) emailaddr = get_test_email_addreess(requestor) notifications_client = NotificationsAPIClient(settings.GOV_NOTIFY_API_KEY) notifications_client.send_email_notification( email_address=emailaddr, template_id=settings.EMAIL_REQUESTOR_UUID, personalisation={ 'name': attention_for, 'approver': approver, 'request_id': request_id, 'user': user, 'status': status, 'services': items_to_approve, 'rejection_reason': rejection_reason } )
def notify_about_changes(self, request: HttpRequest, person: Person) -> None: editor = request.user.profile if editor == person: return None context = { "profile_name": person.full_name, "editor_name": editor.full_name, "profile_url": request.build_absolute_uri( reverse("profile-view", kwargs={"profile_slug": person.slug})), } if settings.APP_ENV in ("local", "test"): logger.info(NOTIFY_ABOUT_CHANGES_LOG_MESSAGE.format(**context)) return notification_client = NotificationsAPIClient( settings.GOVUK_NOTIFY_API_KEY) notification_client.send_email_notification( person.email, settings.PROFILE_EDITED_EMAIL_TEMPLATE_ID, personalisation=context, )
def send_default_investment_email(pir_report): notifications_client = NotificationsAPIClient(settings.GOV_NOTIFY_API_KEY) notifications_client.send_email_notification( email_address=pir_report.email, template_id=settings.DEFAULT_EMAIL_UUID, personalisation={ 'name': pir_report.name, })
def send_email(user, saved_searches): client = NotificationsAPIClient(settings.NOTIFY_API_KEY) client.send_email_notification( email_address=user.email, template_id=settings.NOTIFY_SAVED_SEARCHES_TEMPLATE_ID, personalisation={ "first_name": user.first_name, "saved_searches": get_saved_searches_markdown(saved_searches), "dashboard_link": settings.DMAS_BASE_URL, })
class NotifyService: """ Service that wraps the Government of Canada Notifications API """ def __init__(self, api_key=None, end_point=None): self.client = None if api_key is None or end_point is None: logging.info("Notifications disabled, no api key or end point specified.") else: self.client = NotificationsAPIClient(api_key, base_url=end_point) def send_email(self, address, template_id, details): """ Send a new email using the GC notification client Args: address: The email address template_id: The id of the template to use details: Dictionary of personalization variables """ if self.client: try: self.client.send_email_notification( email_address=address, template_id=template_id, personalisation=details, ) except HTTPError as e: raise Exception(e) else: logging.info(f"Notifications disabled. Otherwise would email: {address}.") def send_sms(self, phone_number, template_id, details): """ Send a new SMS using the GC notification client Args: phone_number: The phone number to send to template_id: The id of the template to use details: Dictionary of personalization variables """ if self.client: try: self.client.send_sms_notification( phone_number=phone_number, template_id=template_id, personalisation=details, ) except HTTPError as e: raise Exception(e) else: logging.info( f"Notifications disabled. Otherwise would text to: {phone_number}." )
def send_email(template_id, email_address, personalisation=None, reference=None): client = NotificationsAPIClient(settings.NOTIFY_API_KEY) client.send_email_notification( template_id=template_id, email_address=email_address, personalisation=personalisation, reference=reference, )
def send_barrier_inactivity_reminders(): """ Get list of all barriers with modified_on and activity_reminder_sent dates older than 6 months For each barrier sent a reminder notification to the barrier owner """ # datetime 6 months ago inactivity_theshold_date = timezone.now() - timedelta( days=settings.BARRIER_INACTIVITY_THESHOLD_DAYS) repeat_reminder_theshold_date = timezone.now() - timedelta( days=settings.BARRIER_REPEAT_REMINDER_THESHOLD_DAYS) barriers_needing_reminder = Barrier.objects.filter( modified_on__lt=inactivity_theshold_date).filter( Q(activity_reminder_sent__isnull=True) | Q(activity_reminder_sent__lt=repeat_reminder_theshold_date)) for barrier in barriers_needing_reminder: recipient = barrier.barrier_team.filter(role="Owner").first() if not recipient: recipient = barrier.barrier_team.filter(role="Reporter").first() if not recipient: logger.warn(f"No recipient found for barrier {barrier.id}") continue if not recipient.user: logger.warn( f"No user found for recipient {recipient.id} and barrier {barrier.id}" ) continue recipient = recipient.user full_name = f"{recipient.first_name} {recipient.last_name}" client = NotificationsAPIClient(settings.NOTIFY_API_KEY) client.send_email_notification( email_address=recipient.email, template_id=settings.BARRIER_INACTIVITY_REMINDER_NOTIFICATION_ID, personalisation={ "barrier_title": barrier.title, "barrier_url": f"{settings.DMAS_BASE_URL}/barriers/{barrier.id}/", "full_name": full_name, "barrier_created_date": barrier.created_on.strftime("%d %B %Y"), }, ) barrier.activity_reminder_sent = timezone.now() barrier.save()
def __send_email__(self, emails, data): notifications_client = NotificationsAPIClient(settings.NOTIFY_API_KEY) FILE_NAME = 'report.csv' with open(FILE_NAME, 'w') as csvFile: f = csv.writer(csvFile) f.writerows(data['csv']) csvFile.close() for to in emails: with open(FILE_NAME, 'rb') as f: response = notifications_client.send_email_notification( email_address=to, template_id=settings.NOTIFY_TEMPLATE_ID, personalisation={ 'subject': data['subject'], 'content': data['content'], 'summary': data['summary'], 'report': prepare_upload(f), 'signature': data['signature'] } ) os.remove(FILE_NAME)
def send_mail(self, template_prefix, email, context): notifications_client = NotificationsAPIClient( settings.NOTIFY_API_KEY, base_url=settings.NOTIFY_ENDPOINT) try: notifications_client.send_email_notification( email_address=context.get("email"), template_id=settings.INVITATION_EMAIL_TEMPLATE_ID.get( context.get("language") or "en"), personalisation={ "url": context.get("invite_url"), "admin_email": context.get("inviter").email, }, ) except HTTPError as e: raise Exception(e)
def page_problem_found(request): message_sent = False if request.method == "POST": form = PageProblemFoundForm(request.POST) if form.is_valid(): page_url = form.cleaned_data["page_url"] trying_to = form.cleaned_data["trying_to"] what_went_wrong = form.cleaned_data["what_went_wrong"] notification_client = NotificationsAPIClient( settings.GOVUK_NOTIFY_API_KEY) message_sent = notification_client.send_email_notification( email_address=settings.SUPPORT_REQUEST_EMAIL, template_id=settings.PAGE_PROBLEM_EMAIL_TEMPLATE_ID, personalisation={ "user_name": request.user.get_full_name(), "user_email": request.user.email, "page_url": page_url, "trying_to": trying_to, "what_went_wrong": what_went_wrong, }, ) else: form = PageProblemFoundForm() return TemplateResponse( request, "core/page_problem_found.html", { "form": form, "message_sent": message_sent }, )
def send_completed_email(completed_tasks): print('Sending mail') notifications_client = NotificationsAPIClient(settings.GOV_NOTIFY_API_KEY) out = defaultdict(list) for item in completed_tasks: service_str = item['services__service_name'] + \ ', link to docs: ' + \ Services.objects.get(service_name=item['services__service_name']).service_docs + \ ', service url: ' + \ Services.objects.get(service_name=item['services__service_name']).service_url out[item['request_id']].append(service_str) for x in out: confirmation_user = Request.objects.get(id=x).user_email confirmation_requestor = Request.objects.get(id=x).requestor if out[x][0].partition(',')[0] in ['google analytics', 'github', 'ukgov paas']: services = '[' + out[x][0] + ' - ' + RequestItem.objects.get( request_id=x, services__service_name=out[x][0]).additional_info + ']' else: services = out[x] attention_for = get_username(confirmation_user) emailaddr = get_test_email_addreess(confirmation_user) notifications_client.send_email_notification( email_address=emailaddr, template_id=settings.EMAIL_COMPLETED_UUID, personalisation={ 'who_got_access': 'You have', 'name': attention_for, 'services': services } ) if confirmation_requestor != confirmation_user: attention_for = get_username(confirmation_requestor) emailaddr = get_test_email_addreess(confirmation_requestor) user_given_access = get_username(confirmation_user) notifications_client.send_email_notification( email_address=emailaddr, template_id=settings.EMAIL_COMPLETED_UUID, personalisation={ 'who_got_access': user_given_access + ' has', 'name': attention_for, 'services': services})
def send_mail(self, language): notifications_client = NotificationsAPIClient( settings.NOTIFY_API_KEY, base_url=settings.NOTIFY_ENDPOINT) try: notifications_client.send_email_notification( email_address=self.admin.email, template_id=settings.BACKUP_CODE_ADMIN_EMAIL_TEMPLATE_ID.get( language or "en"), personalisation={ "name": self.admin.name, "user_email": self.user.email, "user_name": self.user.name, }, ) except HTTPError as e: raise Exception(e)
def send_accounts_creator_close_email(creator, offboard, services): print('Sending mail to', creator) notifications_client = NotificationsAPIClient(settings.GOV_NOTIFY_API_KEY) attention_for = get_username(creator) offboard = get_username(offboard) emailaddr = get_test_email_addreess(creator) notifications_client.send_email_notification( email_address=emailaddr, template_id=settings.EMAIL_OFFBOARD_UUID, personalisation={ 'creator': attention_for, 'offboard': offboard, 'services': services } )
def notify(self, django_user, barrier): barrier_obj = Barrier.objects.get(id=barrier) client = NotificationsAPIClient(settings.NOTIFY_API_KEY) barrier_url = urllib.parse.urljoin( settings.FRONTEND_DOMAIN, f"/barriers/{barrier}/action_plan" ) client.send_email_notification( email_address=django_user.email, template_id=settings.NOTIFY_ACTION_PLAN_USER_SET_AS_OWNER_ID, personalisation={ "first_name": django_user.first_name, "mentioned_by": f"{django_user.first_name} {django_user.last_name}", "barrier_number": barrier_obj.code, "barrier_name": barrier_obj.title, "barrier_url": barrier_url, }, )
def send_accounts_creator_email(request_id): print('Sending mail') request_approve = RequestItem.objects.values_list('services_id').filter( request_id__in=request_id) creators_id = AccountsCreator.objects.values_list('email', flat=True).filter( services__in=request_approve) notifications_client = NotificationsAPIClient(settings.GOV_NOTIFY_API_KEY) ras_url = 'https://' + settings.DOMAIN_NAME + '/action-requests/' for creator in set(creators_id): print('emailing: ') print(creator) attention_for = get_username(creator) emailaddr = get_test_email_addreess(creator) notifications_client.send_email_notification( email_address=emailaddr, template_id=settings.EMAIL_ACTIVATE_UUID, personalisation={ 'name': attention_for, 'ras_url': ras_url } )
def send_end_user_email(request_id): print('Sending mail') approver, requestor, user, reason, team_name, items_to_approve, sc = get_approval_details( request_id) ras_url = 'https://' + settings.DOMAIN_NAME + '/request-status/' attention_for = get_username(user) requestor = get_username(requestor) approver = get_username(approver) emailaddr = get_test_email_addreess(user) notifications_client = NotificationsAPIClient(settings.GOV_NOTIFY_API_KEY) notifications_client.send_email_notification( email_address=emailaddr, template_id=settings.EMAIL_ENDUSER_UUID, personalisation={ 'name': attention_for, 'requester': requestor, 'approver': approver, 'request_id': request_id, 'ras_url': ras_url, 'services': items_to_approve } )
def left_dit(self, request: HttpRequest, person: Person, reported_by: Person, comment: str) -> None: """Submit that the given person has left the DIT. Args: request: The associated HTTP request. person: The person who has left the DIT. reported_by: Who reported that the person has left. comment: A comment from the reporter about the request. """ context = { "profile_name": person.full_name, "profile_url": request.build_absolute_uri( reverse("profile-view", kwargs={"profile_slug": person.slug})), "reporter_name": reported_by.full_name, "reporter_email": reported_by.preferred_email, "comment": comment, } if settings.APP_ENV in ("local", "test"): logger.info(LEFT_DIT_LOG_MESSAGE.format(**context)) return notification_client = NotificationsAPIClient( settings.GOVUK_NOTIFY_API_KEY) notification_client.send_email_notification( settings.PROFILE_DELETION_REQUEST_EMAIL, settings.PROFILE_DELETION_REQUEST_EMAIL_TEMPLATE_ID, personalisation=context, )
def send_email(to, subject, name, body, template): personalisation = { 'subject': subject, 'name': name, 'body': body } notify_client = NotificationsAPIClient(current_app.config['NOTIFY_API_KEY']) response = notify_client.send_email_notification( email_address=to, template_id=templates[template], personalisation=personalisation, reference=None )
def _send(): notifications_client = NotificationsAPIClient(api_key) submission_date = datetime.now() read_close_date = submission_date + relativedelta(months=6) response = notifications_client.send_email_notification( email_address=email_address, template_id=email_template_id, personalisation={ "first_name": form.cleaned_data["name"], "registration_mark": form.cleaned_data["reg"], "submission_date": submission_date.strftime("%d %B %Y"), "read_close_date": read_close_date.strftime("%d %B %Y"), "survey_url": "https://example.com/xyz" }) return response["id"]
def send_email(template_id, email_address, personalisation=None, reference=None): client = NotificationsAPIClient(settings.NOTIFY_API_KEY) response = client.send_email_notification( template_id=template_id, email_address=email_address, personalisation=personalisation, reference=reference, ) # pylint: disable=unsupported-membership-test if "id" in response: # pylint: disable=unsubscriptable-object return response["id"] else: raise EmailSendFailureException(response)