cfl-common 5.3.0__py3-none-any.whl → 8.9.15__py3-none-any.whl

common/helpers/emails.py

@@ -1,107 +1,190 @@
 import datetime
 import json
+from enum import Enum, auto
 from uuid import uuid4
 
+import jwt
 from common import app_settings
-from common.email_messages import (
-    emailChangeNotificationEmail,
-    emailChangeVerificationEmail,
-    emailChangeDuplicateNotificationEmail,
-    emailVerificationNeededEmail,
+from common.mail import (
+    address_book_ids,
+    campaign_ids,
+    django_send_email,
+    send_dotdigital_email,
 )
-from common.models import EmailVerification, Teacher, Student
-from django.core.mail import EmailMultiAlternatives
+from common.models import Student, Teacher
+from django.conf import settings
+from django.contrib.auth.models import User
 from django.http import HttpResponse
-from django.template import loader
+from django.urls import reverse
 from django.utils import timezone
-from requests import post, get, put
+from requests import delete, get, post, put
 from requests.exceptions import RequestException
 
 NOTIFICATION_EMAIL = "Code For Life Notification <" + app_settings.EMAIL_ADDRESS + ">"
 VERIFICATION_EMAIL = "Code For Life Verification <" + app_settings.EMAIL_ADDRESS + ">"
-PASSWORD_RESET_EMAIL = (
-    "Code For Life Password Reset <" + app_settings.EMAIL_ADDRESS + ">"
-)
+PASSWORD_RESET_EMAIL = "Code For Life Password Reset <" + app_settings.EMAIL_ADDRESS + ">"
 INVITE_FROM = "Code For Life Invitation <" + app_settings.EMAIL_ADDRESS + ">"
 
 
+class DotmailerUserType(Enum):
+    TEACHER = auto()
+    STUDENT = auto()
+    NO_ACCOUNT = auto()
+
+
+def generate_token(user, new_email="", preverified=False):
+    if preverified:
+        user.userprofile.is_verified = preverified
+        user.userprofile.save()
+
+    return generate_token_for_email(user.email, new_email)
+
+
+def generate_token_for_email(email: str, new_email: str = ""):
+    return jwt.encode(
+        {
+            "email": email,
+            "new_email": new_email,
+            "email_verification_token": uuid4().hex[:30],
+            "expires": (timezone.now() + datetime.timedelta(hours=1)).timestamp(),
+        },
+        settings.SECRET_KEY,
+        algorithm="HS256",
+    )
+
+
+def _newsletter_ticked(data):
+    return "newsletter_ticked" in data and data["newsletter_ticked"]
+
+
 def send_email(
     sender,
     recipients,
     subject,
     text_content,
-    html_content=None,
+    title,
+    replace_url=None,
     plaintext_template="email.txt",
     html_template="email.html",
 ):
-    # add in template for templates to message
-
-    # setup templates
-    plaintext = loader.get_template(plaintext_template)
-    html = loader.get_template(html_template)
-    plaintext_email_context = {"content": text_content}
-    html_email_context = {"content": text_content}
-    if html_content:
-        html_email_context = {"content": html_content}
-
-    # render templates
-    plaintext_body = plaintext.render(plaintext_email_context)
-    html_body = html.render(html_email_context)
-
-    # make message using templates
-    message = EmailMultiAlternatives(subject, plaintext_body, sender, recipients)
-    message.attach_alternative(html_body, "text/html")
-
-    message.send()
-
-
-def generate_token(user, email="", preverified=False):
-    return EmailVerification.objects.create(
-        user=user,
-        email=email,
-        token=uuid4().hex[:30],
-        expiry=timezone.now() + datetime.timedelta(hours=1),
-        verified=preverified,
+    django_send_email(
+        sender,
+        recipients,
+        subject,
+        text_content,
+        title,
+        replace_url,
+        plaintext_template,
+        html_template,
     )
 
 
-def send_verification_email(request, user, new_email=None):
-    """Send an email prompting the user to verify their email address."""
+def send_verification_email(request, user, data, new_email=None, age=None, school=None):
+    """
+    Sends emails relating to email address verification.
 
-    if not new_email:  # verifying first email address
-        user.email_verifications.all().delete()
+    On registration:
+    - if the user is under 13, send a verification email addressed to the parent / guardian
+    - if the user is over 13, send a regular verification email
+    - if the user is a student who just got released, send a verification email explaining the situation
+    - if the user is a student who has requested to sign up to the newsletter, handle their Dotmailer subscription
 
-        verification = generate_token(user)
+    On email address update:
+    - sends an email to the old address alerting the user that an email change request has occurred
+    - sends an email to the new address requesting email address verification
 
-        message = emailVerificationNeededEmail(request, verification.token)
-        send_email(
-            VERIFICATION_EMAIL, [user.email], message["subject"], message["message"]
-        )
-
-    else:  # verifying change of email address.
-        verification = generate_token(user, new_email)
+    :param request: The Django form request
+    :param user: The user object concerned with the email verification
+    :param data: The data inputted by the user in the Django form.
+    :param new_email: New email the user wants to associate to their account - if not provided, it means the user is
+    registering a new account
+    :param age: The user's age (collected only for the purposes of this function and if the user is an independent
+    student)
+    """
 
-        message = emailChangeVerificationEmail(request, verification.token)
-        send_email(
-            VERIFICATION_EMAIL, [new_email], message["subject"], message["message"]
-        )
+    # verifying first email address (registration or unverified login attempt)
+    if not new_email:
+        verification = generate_token(user)
 
-        message = emailChangeNotificationEmail(request)
-        send_email(
-            VERIFICATION_EMAIL, [user.email], message["subject"], message["message"]
+        if age is None:
+            # if the user is a released student
+            if hasattr(user, "new_student") and school is not None:
+                url = f"{app_settings.domain(request)}{reverse('verify_email', kwargs={'token': verification})}"
+
+                send_dotdigital_email(
+                    campaign_ids["verify_released_student"],
+                    [user.email],
+                    personalization_values={
+                        "VERIFICATION_LINK": url,
+                        "SCHOOL_NAME": school.name,
+                    },
+                )
+            else:
+                url = f"{app_settings.domain(request)}{reverse('verify_email', kwargs={'token': verification})}"
+
+                send_dotdigital_email(
+                    campaign_ids["verify_new_user"],
+                    [user.email],
+                    personalization_values={"VERIFICATION_LINK": url},
+                )
+
+                if _newsletter_ticked(data):
+                    add_to_dotmailer(
+                        user.first_name,
+                        user.last_name,
+                        user.email,
+                        address_book_ids["newsletter"],
+                        DotmailerUserType.TEACHER,
+                    )
+        # if the user is an independent student
+        else:
+            if age < 13:
+                url = f"{app_settings.domain(request)}{reverse('verify_email', kwargs={'token': verification})}"
+                send_dotdigital_email(
+                    campaign_ids["verify_new_user_via_parent"],
+                    [user.email],
+                    personalization_values={
+                        "FIRST_NAME": user.first_name,
+                        "ACTIVATION_LINK": url,
+                    },
+                )
+            else:
+                url = f"{app_settings.domain(request)}{reverse('verify_email', kwargs={'token': verification})}"
+                send_dotdigital_email(
+                    campaign_ids["verify_new_user"],
+                    [user.email],
+                    personalization_values={"VERIFICATION_LINK": url},
+                )
+
+            if _newsletter_ticked(data):
+                add_to_dotmailer(
+                    user.first_name,
+                    user.last_name,
+                    user.email,
+                    address_book_ids["newsletter"],
+                    DotmailerUserType.STUDENT,
+                )
+    # verifying change of email address.
+    else:
+        verification = generate_token(user, new_email)
+        url = f"{app_settings.domain(request)}{reverse('verify_email', kwargs={'token': verification})}"
+        send_dotdigital_email(
+            campaign_ids["email_change_verification"],
+            [new_email],
+            personalization_values={"VERIFICATION_LINK": url},
         )
 
 
-def is_verified(user):
-    """Check that a user has verified their email address."""
-    verifications = user.email_verifications.filter(verified=True)
-    return len(verifications) != 0
-
-
-def add_to_dotmailer(first_name: str, last_name: str, email: str):
+def add_to_dotmailer(
+    first_name: str,
+    last_name: str,
+    email: str,
+    address_book_id: int,
+    user_type: DotmailerUserType = None,
+):
     try:
         create_contact(first_name, last_name, email)
-        add_contact_to_address_book(first_name, last_name, email)
+        add_contact_to_address_book(first_name, last_name, email, address_book_id, user_type)
     except RequestException:
         return HttpResponse(status=404)
 
@@ -125,7 +208,7 @@ def create_contact(first_name, last_name, email):
                     {
                         "key": "DATETIMECONSENTED",
                         "value": datetime.datetime.now().__str__(),
-                    },
+                    }
                 ]
             }
         ],
@@ -139,8 +222,15 @@ def create_contact(first_name, last_name, email):
     )
 
 
-def add_contact_to_address_book(first_name, last_name, email):
-    url = app_settings.DOTMAILER_ADDRESS_BOOK_URL
+def add_contact_to_address_book(
+    first_name: str,
+    last_name: str,
+    email: str,
+    address_book_id: int,
+    user_type: DotmailerUserType = None,
+):
+    main_address_book_url = f"https://r1-api.dotmailer.com/v2/address-books/{address_book_id}/contacts"
+
     body = {
         "email": email,
         "optInType": "VerifiedDouble",
@@ -153,19 +243,47 @@ def add_contact_to_address_book(first_name, last_name, email):
     }
 
     post(
-        url,
+        main_address_book_url,
         json=body,
         auth=(app_settings.DOTMAILER_USER, app_settings.DOTMAILER_PASSWORD),
     )
 
+    if user_type is not None:
+        specific_address_book_url = app_settings.DOTMAILER_NO_ACCOUNT_ADDRESS_BOOK_URL
+
+        if user_type == DotmailerUserType.TEACHER:
+            specific_address_book_url = app_settings.DOTMAILER_TEACHER_ADDRESS_BOOK_URL
+        elif user_type == DotmailerUserType.STUDENT:
+            specific_address_book_url = app_settings.DOTMAILER_STUDENT_ADDRESS_BOOK_URL
+
+        post(
+            specific_address_book_url,
+            json=body,
+            auth=(app_settings.DOTMAILER_USER, app_settings.DOTMAILER_PASSWORD),
+        )
+
+
+def delete_contact(email: str):
+    try:
+        user = get_dotmailer_user_by_email(email)
+        user_id = user.get("id")
+        if user_id:
+            url = app_settings.DOTMAILER_DELETE_USER_BY_ID_URL.replace("ID", str(user_id))
+            delete(
+                url,
+                auth=(
+                    app_settings.DOTMAILER_USER,
+                    app_settings.DOTMAILER_PASSWORD,
+                ),
+            )
+    except RequestException:
+        return HttpResponse(status=404)
+
 
 def get_dotmailer_user_by_email(email):
     url = app_settings.DOTMAILER_GET_USER_BY_EMAIL_URL.replace("EMAIL", email)
 
-    response = get(
-        url,
-        auth=(app_settings.DOTMAILER_USER, app_settings.DOTMAILER_PASSWORD),
-    )
+    response = get(url, auth=(app_settings.DOTMAILER_USER, app_settings.DOTMAILER_PASSWORD))
 
     return json.loads(response.content)
 
@@ -173,9 +291,7 @@ def get_dotmailer_user_by_email(email):
 def add_consent_record_to_dotmailer_user(user):
     consent_date_time = datetime.datetime.now().__str__()
 
-    url = app_settings.DOTMAILER_PUT_CONSENT_DATA_URL.replace(
-        "USER_ID", str(user["id"])
-    )
+    url = app_settings.DOTMAILER_PUT_CONSENT_DATA_URL.replace("USER_ID", str(user["id"]))
     body = {
         "contact": {
             "email": user["email"],
@@ -183,13 +299,7 @@ def add_consent_record_to_dotmailer_user(user):
             "emailType": user["emailType"],
             "dataFields": user["dataFields"],
         },
-        "consentFields": [
-            {
-                "fields": [
-                    {"key": "DATETIMECONSENTED", "value": consent_date_time},
-                ]
-            }
-        ],
+        "consentFields": [{"fields": [{"key": "DATETIMECONSENTED", "value": consent_date_time}]}],
     }
 
     put(
@@ -202,10 +312,7 @@ def add_consent_record_to_dotmailer_user(user):
 def send_dotmailer_consent_confirmation_email_to_user(user):
     url = app_settings.DOTMAILER_SEND_CAMPAIGN_URL
     campaign_id = app_settings.DOTMAILER_THANKS_FOR_STAYING_CAMPAIGN_ID
-    body = {
-        "campaignID": campaign_id,
-        "contactIds": [str(user["id"])],
-    }
+    body = {"campaignID": campaign_id, "contactIds": [str(user["id"])]}
 
     post(
         url,
@@ -214,30 +321,43 @@ def send_dotmailer_consent_confirmation_email_to_user(user):
     )
 
 
-def update_email(user: Teacher or Student, request, data):
+def update_indy_email(user, request, data):
     changing_email = False
     new_email = data["email"]
 
-    if new_email != "" and new_email != user.new_user.email:
+    if new_email != "" and new_email != user.email:
         changing_email = True
-        if _is_email_already_taken(new_email, user):
-            email_message = emailChangeDuplicateNotificationEmail(request, new_email)
-            send_email(
-                NOTIFICATION_EMAIL,
-                [user.new_user.email],
-                email_message["subject"],
-                email_message["message"],
-            )
-        else:
+        users_with_email = User.objects.filter(email=new_email)
+
+        send_dotdigital_email(
+            campaign_ids["email_change_notification"],
+            [user.email],
+            personalization_values={"NEW_EMAIL_ADDRESS": new_email},
+        )
+
+        # email is available
+        if not users_with_email.exists():
             # new email to set and verify
-            send_verification_email(request, user.new_user, new_email)
+            send_verification_email(request, user, data, new_email)
     return changing_email, new_email
 
 
-def _is_email_already_taken(new_email, user):
-    teachers_with_email = Teacher.objects.filter(new_user__email=new_email)
-    students_with_email = Student.objects.filter(new_user__email=new_email)
+def update_email(user: Teacher or Student, request, data):
+    changing_email = False
+    new_email = data["email"]
 
-    return (teachers_with_email.exists() and teachers_with_email[0] != user) or (
-        students_with_email.exists() and students_with_email[0] != user
-    )
+    if new_email != "" and new_email != user.new_user.email:
+        changing_email = True
+        users_with_email = User.objects.filter(email=new_email)
+
+        send_dotdigital_email(
+            campaign_ids["email_change_notification"],
+            [user.new_user.email],
+            personalization_values={"NEW_EMAIL_ADDRESS": new_email},
+        )
+
+        # email is available
+        if not users_with_email.exists():
+            # new email to set and verify
+            send_verification_email(request, user.new_user, data, new_email)
+    return changing_email, new_email

common/helpers/generators.py

@@ -1,6 +1,6 @@
+import hashlib
 import random
 import string
-import hashlib
 from builtins import range, str
 from uuid import uuid4
 

common/helpers/organisation.py

@@ -0,0 +1,10 @@
+# TODO: Move to Address model once we create it
+def sanitise_uk_postcode(postcode):
+    if len(postcode) >= 5:  # Valid UK postcodes are at least 5 chars long
+        outcode = postcode[:-3]  # UK incodes are always 3 characters
+
+        # Insert a space between outcode and incode if there isn't already one
+        if not outcode.endswith(" "):
+            postcode = postcode[:-3] + " " + postcode[-3:]
+
+    return postcode

common/mail.py

@@ -0,0 +1,201 @@
+import typing as t
+from dataclasses import dataclass
+
+import requests
+from common import app_settings
+from common.app_settings import MODULE_NAME, domain
+from django.core.mail import EmailMultiAlternatives
+from django.template import loader
+
+campaign_ids = {
+    "admin_given": 1569057,
+    "admin_revoked": 1569071,
+    "delete_account": 1567477,
+    "email_change_notification": 1551600,
+    "email_change_verification": 1551594,
+    "invite_teacher_with_account": 1569599,
+    "invite_teacher_without_account": 1569607,
+    "level_creation": 1570259,
+    "reset_password": 1557153,
+    "student_join_request_notification": 1569486,
+    "student_join_request_rejected": 1569470,
+    "student_join_request_sent": 1569477,
+    "teacher_released": 1569537,
+    "user_already_registered": 1569539,
+    "verify_new_user": 1551577,
+    "verify_new_user_first_reminder": 1557170,
+    "verify_new_user_second_reminder": 1557173,
+    "verify_new_user_via_parent": 1551587,
+    "verify_released_student": 1580574,
+    "inactive_users_on_website_first_reminder": 1604381,
+    "inactive_users_on_website_second_reminder": 1606208,
+    "inactive_users_on_website_final_reminder": 1606215,
+}
+
+address_book_ids = {
+    "newsletter": 9705772,
+    "donors": 37649245,
+}
+
+
+def add_contact(email: str):
+    """Add a new contact to Dotdigital."""
+    # TODO: implement
+
+
+def remove_contact(email: str):
+    """Remove an existing contact from Dotdigital."""
+    # TODO: implement
+
+
+@dataclass
+class EmailAttachment:
+    """An email attachment for a Dotdigital triggered campaign."""
+
+    file_name: str
+    mime_type: str
+    content: str
+
+
+def django_send_email(
+    sender,
+    recipients,
+    subject,
+    text_content,
+    title,
+    replace_url=None,
+    plaintext_template="email.txt",
+    html_template="email.html",
+):
+    # add in template for templates to message
+
+    # setup templates
+    plaintext = loader.get_template(plaintext_template)
+    html = loader.get_template(html_template)
+    plaintext_email_context = {"content": text_content}
+    html_email_context = {
+        "content": text_content,
+        "title": title,
+        "url_prefix": domain(),
+    }
+
+    # render templates
+    plaintext_body = plaintext.render(plaintext_email_context)
+    original_html_body = html.render(html_email_context)
+    html_body = original_html_body
+
+    if replace_url:
+        verify_url = replace_url["verify_url"]
+        verify_replace_url = re.sub(
+            f"(.*/verify_email/)(.*)", f"\\1", verify_url
+        )
+        html_body = re.sub(
+            f"({verify_url})(.*){verify_url}",
+            f"\\1\\2{verify_replace_url}",
+            original_html_body,
+        )
+
+    # make message using templates
+    message = EmailMultiAlternatives(
+        subject, plaintext_body, sender, recipients
+    )
+    message.attach_alternative(html_body, "text/html")
+
+    message.send()
+
+
+# pylint: disable-next=too-many-arguments
+def send_dotdigital_email(
+    campaign_id: int,
+    to_addresses: t.List[str],
+    cc_addresses: t.Optional[t.List[str]] = None,
+    bcc_addresses: t.Optional[t.List[str]] = None,
+    from_address: t.Optional[str] = None,
+    personalization_values: t.Optional[t.Dict[str, str]] = None,
+    metadata: t.Optional[str] = None,
+    attachments: t.Optional[t.List[EmailAttachment]] = None,
+    region: str = "r1",
+    auth: t.Optional[str] = None,
+    timeout: int = 30,
+):
+    # pylint: disable=line-too-long
+    """Send a triggered email campaign using DotDigital's API.
+
+    https://developer.dotdigital.com/reference/send-transactional-email-using-a-triggered-campaign
+
+    Args:
+        campaign_id: The ID of the triggered campaign, which needs to be included within the request body.
+        to_addresses: The email address(es) to send to.
+        cc_addresses: The CC email address or address to to send to. separate email addresses with a comma. Maximum: 100.
+        bcc_addresses: The BCC email address or address to to send to. separate email addresses with a comma. Maximum: 100.
+        from_address: The From address for your email. Note: The From address must already be added to your account. Otherwise, your account's default From address is used.
+        personalization_values: Each personalisation value is a key-value pair; the placeholder name of the personalization value needs to be included in the request body.
+        metadata: The metadata for your email. It can be either a single value or a series of values in a JSON object.
+        attachments: A Base64 encoded string. All attachment types are supported. Maximum file size: 15 MB.
+        region: The Dotdigital region id your account belongs to e.g. r1, r2 or r3.
+        auth: The authorization header used to enable API access. If None, the value will be retrieved from the DOTDIGITAL_AUTH environment variable.
+        timeout: Send timeout to avoid hanging.
+
+    Raises:
+        AssertionError: If failed to send email.
+    """
+    # pylint: enable=line-too-long
+
+    # Dotdigital emails don't work locally, so if testing emails locally use Django to send a dummy email instead
+    if MODULE_NAME == "local":
+        django_send_email(
+            from_address,
+            to_addresses,
+            "dummy_subject",
+            "dummy_text_content",
+            "dummy_title",
+        )
+    else:
+        if auth is None:
+            auth = app_settings.DOTDIGITAL_AUTH
+
+        body = {
+            "campaignId": campaign_id,
+            "toAddresses": to_addresses,
+        }
+        if cc_addresses is not None:
+            body["ccAddresses"] = cc_addresses
+        if bcc_addresses is not None:
+            body["bccAddresses"] = bcc_addresses
+        if from_address is not None:
+            body["fromAddress"] = from_address
+        if personalization_values is not None:
+            body["personalizationValues"] = [
+                {
+                    "name": key,
+                    "value": value,
+                }
+                for key, value in personalization_values.items()
+            ]
+        if metadata is not None:
+            body["metadata"] = metadata
+        if attachments is not None:
+            body["attachments"] = [
+                {
+                    "fileName": attachment.file_name,
+                    "mimeType": attachment.mime_type,
+                    "content": attachment.content,
+                }
+                for attachment in attachments
+            ]
+
+        response = requests.post(
+            url=f"https://{region}-api.dotdigital.com/v2/email/triggered-campaign",
+            json=body,
+            headers={
+                "accept": "text/plain",
+                "authorization": auth,
+            },
+            timeout=timeout,
+        )
+
+        assert response.ok, (
+            "Failed to send email."
+            f" Reason: {response.reason}."
+            f" Text: {response.text}."
+        )

common/migrations/0002_emailverification.py

@@ -32,9 +32,7 @@ class Migration(migrations.Migration):
                         ("token", models.CharField(max_length=30)),
                         (
                             "email",
-                            models.CharField(
-                                blank=True, default=None, max_length=200, null=True
-                            ),
+                            models.CharField(blank=True, default=None, max_length=200, null=True),
                         ),
                         ("expiry", models.DateTimeField()),
                         ("verified", models.BooleanField(default=False)),