codeforlife-portal 5.33.5__py2.py3-none-any.whl → 8.9.9__py2.py3-none-any.whl

cfl_common/common/__init__.py

@@ -0,0 +1 @@
+default_app_config = "common.apps.CommonConfig"

cfl_common/common/app_settings.py

@@ -0,0 +1,66 @@
+from django.conf import settings
+
+# Email address to source notifications from
+EMAIL_ADDRESS = getattr(settings, "EMAIL_ADDRESS", "no-reply@codeforlife.education")
+
+# Dotdigital authorization details
+DOTDIGITAL_AUTH = getattr(settings, "DOTDIGITAL_AUTH", "")
+
+# Dotmailer URLs for adding users to the newsletter address book
+DOTMAILER_CREATE_CONTACT_URL = getattr(settings, "DOTMAILER_CREATE_CONTACT_URL", "")
+DOTMAILER_TEACHER_ADDRESS_BOOK_URL = getattr(settings, "DOTMAILER_TEACHER_ADDRESS_BOOK_URL", "")
+DOTMAILER_STUDENT_ADDRESS_BOOK_URL = getattr(settings, "DOTMAILER_STUDENT_ADDRESS_BOOK_URL", "")
+DOTMAILER_NO_ACCOUNT_ADDRESS_BOOK_URL = getattr(settings, "DOTMAILER_NO_ACCOUNT_ADDRESS_BOOK_URL", "")
+
+# Dotmailer username for API authentication
+DOTMAILER_USER = getattr(settings, "DOTMAILER_USER", "")
+
+# Dotmailer password for API authentication
+DOTMAILER_PASSWORD = getattr(settings, "DOTMAILER_PASSWORD", "")
+
+# Dotmailer default preferences to what users are signed up to
+DOTMAILER_DEFAULT_PREFERENCES = getattr(settings, "DOTMAILER_DEFAULT_PREFERENCES", [])
+
+# Dotmailer URL for getting a user by email
+DOTMAILER_GET_USER_BY_EMAIL_URL = getattr(
+    settings,
+    "DOTMAILER_GET_USER_BY_EMAIL_URL",
+    "",
+)
+
+# Dotmailer URL for deleting a contact by id
+DOTMAILER_DELETE_USER_BY_ID_URL = getattr(
+    settings,
+    "DOTMAILER_DELETE_USER_BY_ID_URL",
+    "",
+)
+
+# Dotmailer URL for adding consent data to a user
+DOTMAILER_PUT_CONSENT_DATA_URL = getattr(settings, "DOTMAILER_PUT_CONSENT_DATA_URL", "")
+
+# Dotmailer URL for sending a triggered campaign to a users
+DOTMAILER_SEND_CAMPAIGN_URL = getattr(settings, "DOTMAILER_SEND_CAMPAIGN_URL", "")
+
+# ID of the "Thanks for staying!" campaign in Dotmailer
+DOTMAILER_THANKS_FOR_STAYING_CAMPAIGN_ID = getattr(settings, "DOTMAILER_THANKS_FOR_STAYING_CAMPAIGN_ID", "")
+
+# Fernet encryption for OAuth2 sign in
+ENCRYPTION_KEY = getattr(settings, "ENCRYPTION_KEY", "")
+
+# The name of the google app engine service the application is running on, local otherwise
+MODULE_NAME = getattr(settings, "MODULE_NAME", "local")
+
+# Boolean indicating if OneTrust cookie management is enabled or not
+COOKIE_MANAGEMENT_ENABLED = getattr(settings, "COOKIE_MANAGEMENT_ENABLED", True)
+
+
+def domain():
+    """Returns the full domain depending on whether it's local, dev, staging or prod."""
+    domain = "https://www.codeforlife.education"
+
+    if MODULE_NAME == "local":
+        domain = "localhost:8000"
+    elif MODULE_NAME == "staging" or MODULE_NAME == "dev":
+        domain = f"https://{MODULE_NAME}-dot-decent-digit-629.appspot.com"
+
+    return domain

cfl_common/common/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class CommonConfig(AppConfig):
+    name = "common"
+    verbose_name = "Code for Life Common"

cfl_common/common/context_processors.py

@@ -0,0 +1,9 @@
+from common import app_settings
+
+
+def module_name(request):
+    return {"module_name": app_settings.MODULE_NAME}
+
+
+def cookie_management_enabled(request):
+    return {"cookie_management_enabled": app_settings.COOKIE_MANAGEMENT_ENABLED}

cfl_common/common/csp_config.py

@@ -0,0 +1,85 @@
+"""CSP Config"""
+
+from .app_settings import domain, MODULE_NAME
+
+CSP_DEFAULT_SRC = ("self",)
+CSP_CONNECT_SRC = (
+    "'self'",
+    "https://*.onetrust.com/",
+    "https://api.pwnedpasswords.com",
+    "https://euc-widget.freshworks.com/",
+    "https://codeforlife.freshdesk.com/",
+    "https://api.iconify.design/",
+    "https://api.simplesvg.com/",
+    "https://api.unisvg.com/",
+    "https://www.google-analytics.com/",
+    "https://pyodide-cdn2.iodide.io/v0.15.0/full/",
+    "https://crowdin.com/",
+)
+CSP_FONT_SRC = ("'self'", "https://fonts.gstatic.com/", "https://fonts.googleapis.com/", "https://use.typekit.net/")
+CSP_SCRIPT_SRC = (
+    "'self'",
+    "'unsafe-inline'",
+    "'unsafe-eval'",
+    "https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.0.0/crypto-js.min.js",
+    "https://cdn.crowdin.com/",
+    "https://*.onetrust.com/",
+    "https://code.jquery.com/",
+    "https://euc-widget.freshworks.com/",
+    "https://cdn-ukwest.onetrust.com/",
+    "https://code.iconify.design/2/2.0.3/iconify.min.js",
+    "https://www.googletagmanager.com/",
+    "https://www.recaptcha.net/",
+    "https://www.google.com/recaptcha/",
+    "https://www.gstatic.com/recaptcha/",
+    "https://use.typekit.net/mrl4ieu.js",
+    "https://pyodide-cdn2.iodide.io/v0.15.0/full/",
+    f"{domain()}/static/portal/",
+    f"{domain()}/static/common/",
+)
+CSP_STYLE_SRC = (
+    "'self'",
+    "'unsafe-inline'",
+    "https://euc-widget.freshworks.com/",
+    "https://cdn-ukwest.onetrust.com/",
+    "https://fonts.googleapis.com/",
+    "https://code.jquery.com/ui/1.13.1/themes/base/jquery-ui.css",
+    "https://cdn.crowdin.com/",
+    f"{domain()}/static/portal/",
+)
+CSP_FRAME_SRC = (
+    "https://storage.googleapis.com/",
+    "https://2662351606-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/",
+    "https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/",
+    "https://www.recaptcha.net/",
+    "https://www.google.com/recaptcha/",
+    "https://crowdin.com/",
+    f"{domain()}/static/common/img/",
+    f"{domain()}/static/game/image/",
+)
+CSP_IMG_SRC = (
+    "'self'",
+    "https://storage.googleapis.com/codeforlife-assets/images/",
+    "https://cdn-ukwest.onetrust.com/",
+    "https://p.typekit.net/",
+    "https://cdn.crowdin.com/",
+    "https://crowdin-static.downloads.crowdin.com/",
+    "data:",
+    f"{domain()}/static/portal/img/",
+    f"{domain()}/static/portal/static/portal/img/",
+    f"{domain()}/static/portal/img/",
+    f"{domain()}/favicon.ico",
+    f"{domain()}/img/",
+    f"{domain()}/account/two_factor/qrcode/",
+    f"{domain()}/static/",
+    f"{domain()}/static/game/image/",
+    f"{domain()}/static/game/raphael_image/",
+    f"{domain()}/static/game/js/blockly/media/",
+    f"{domain()}/static/icons/",
+)
+CSP_OBJECT_SRC = (f"{domain()}/static/common/img/", f"{domain()}/static/game/image/")
+CSP_MEDIA_SRC = (
+    "https://files.gitbook.com/v0/b/gitbook-x-prod.appspot.com/",
+    f"{domain()}/static/game/sound/",
+    f"{domain()}/static/game/js/blockly/media/",
+)

cfl_common/common/helpers/data_migration_loader.py

@@ -0,0 +1,42 @@
+from pathlib import Path
+from typing import Callable
+
+from django.core.management import call_command
+from django.core.serializers import base, python
+
+
+def load_data_from_file(file_name) -> Callable:
+    """Returns a migration function that loads a json file produced by `manage.py dumpdata` into the database.
+    For use with migrations.RunPython
+
+    Args:
+        file_name (str): The name of the file containing the data you want to load. Include `.json` at the end.
+        The file must be in the fixtures directory.
+    """
+    absolute_file_path = Path(__file__).resolve().parent.parent / "fixtures" / file_name
+
+    def _load_fixture(apps, schema_editor):
+        # Save the default _get_model() function
+        default_get_model = python._get_model
+
+        # Define new _get_model() function here, which utilizes the apps argument to
+        # get the historical version of a model. This piece of code is directly taken
+        # from django.core.serializers.python._get_model, unchanged. However, here it
+        # has a different context, specifically, the apps variable.
+        def _get_model(model_identifier):
+            try:
+                return apps.get_model(model_identifier)
+            except (LookupError, TypeError):
+                raise base.DeserializationError("Invalid model identifier: '%s'" % model_identifier)
+
+        # Replace the _get_model() function on the module, so loaddata can utilize it.
+        python._get_model = _get_model
+
+        try:
+            # Call loaddata command
+            call_command("loaddata", absolute_file_path, app_label="common")
+        finally:
+            # Restore default _get_model() function
+            python._get_model = default_get_model
+
+    return _load_fixture

cfl_common/common/helpers/emails.py

@@ -0,0 +1,393 @@
+import datetime
+import json
+from enum import Enum, auto
+from uuid import uuid4
+
+import jwt
+from common import app_settings
+from common.mail import (
+    address_book_ids,
+    campaign_ids,
+    django_send_email,
+    send_dotdigital_email,
+)
+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.urls import reverse
+from django.utils import timezone
+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 + ">"
+)
+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,
+    title,
+    replace_url=None,
+    plaintext_template="email.txt",
+    html_template="email.html",
+):
+    django_send_email(
+        sender,
+        recipients,
+        subject,
+        text_content,
+        title,
+        replace_url,
+        plaintext_template,
+        html_template,
+    )
+
+
+def send_verification_email(
+    request, user, data, new_email=None, age=None, school=None
+):
+    """
+    Sends emails relating to email address verification.
+
+    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
+
+    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
+
+    :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)
+    """
+
+    # verifying first email address (registration or unverified login attempt)
+    if not new_email:
+        verification = generate_token(user)
+
+        if age is None:
+            # if the user is a released student
+            if hasattr(user, "new_student") and school is not None:
+                url = f"{request.build_absolute_uri(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"{request.build_absolute_uri(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"{request.build_absolute_uri(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"{request.build_absolute_uri(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"{request.build_absolute_uri(reverse('verify_email', kwargs={'token': verification}))}"
+        send_dotdigital_email(
+            campaign_ids["email_change_verification"],
+            [new_email],
+            personalization_values={"VERIFICATION_LINK": url},
+        )
+
+
+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, address_book_id, user_type
+        )
+    except RequestException:
+        return HttpResponse(status=404)
+
+
+def create_contact(first_name, last_name, email):
+    url = app_settings.DOTMAILER_CREATE_CONTACT_URL
+    body = {
+        "contact": {
+            "email": email,
+            "optInType": "VerifiedDouble",
+            "emailType": "Html",
+            "dataFields": [
+                {"key": "FIRSTNAME", "value": first_name},
+                {"key": "LASTNAME", "value": last_name},
+                {"key": "FULLNAME", "value": f"{first_name} {last_name}"},
+            ],
+        },
+        "consentFields": [
+            {
+                "fields": [
+                    {
+                        "key": "DATETIMECONSENTED",
+                        "value": datetime.datetime.now().__str__(),
+                    }
+                ]
+            }
+        ],
+        "preferences": app_settings.DOTMAILER_DEFAULT_PREFERENCES,
+    }
+
+    post(
+        url,
+        json=body,
+        auth=(app_settings.DOTMAILER_USER, app_settings.DOTMAILER_PASSWORD),
+    )
+
+
+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",
+        "emailType": "Html",
+        "dataFields": [
+            {"key": "FIRSTNAME", "value": first_name},
+            {"key": "LASTNAME", "value": last_name},
+            {"key": "FULLNAME", "value": f"{first_name} {last_name}"},
+        ],
+    }
+
+    post(
+        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)
+    )
+
+    return json.loads(response.content)
+
+
+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"])
+    )
+    body = {
+        "contact": {
+            "email": user["email"],
+            "optInType": user["optInType"],
+            "emailType": user["emailType"],
+            "dataFields": user["dataFields"],
+        },
+        "consentFields": [
+            {
+                "fields": [
+                    {"key": "DATETIMECONSENTED", "value": consent_date_time}
+                ]
+            }
+        ],
+    }
+
+    put(
+        url,
+        json=body,
+        auth=(app_settings.DOTMAILER_USER, app_settings.DOTMAILER_PASSWORD),
+    )
+
+
+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"])]}
+
+    post(
+        url,
+        json=body,
+        auth=(app_settings.DOTMAILER_USER, app_settings.DOTMAILER_PASSWORD),
+    )
+
+
+def update_indy_email(user, request, data):
+    changing_email = False
+    new_email = data["email"]
+
+    if new_email != "" and new_email != user.email:
+        changing_email = True
+        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, data, new_email)
+    return changing_email, new_email
+
+
+def update_email(user: Teacher or Student, request, data):
+    changing_email = False
+    new_email = data["email"]
+
+    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

cfl_common/common/helpers/generators.py

@@ -0,0 +1,52 @@
+import hashlib
+import random
+import string
+from builtins import range, str
+from uuid import uuid4
+
+from common.models import Class, Student
+from django.contrib.auth.models import User
+
+
+def get_random_username():
+    while True:
+        random_username = uuid4().hex[:30]  # generate a random username
+        if not User.objects.filter(username=random_username).exists():
+            return random_username
+
+
+def generate_new_student_name(orig_name):
+    if not Student.objects.filter(new_user__username=orig_name).exists():
+        return orig_name
+
+    i = 1
+    while True:
+        new_name = orig_name + str(i)
+        if not Student.objects.filter(new_user__username=new_name).exists():
+            return new_name
+        i += 1
+
+
+def generate_access_code():
+    while True:
+        access_code = "".join(random.choice(string.ascii_uppercase) for _ in range(5))
+
+        if not Class.objects.filter(access_code=access_code).exists():
+            return access_code
+
+
+def generate_password(length):
+    return "".join(random.choice(string.ascii_lowercase) for _ in range(length))
+
+
+def generate_login_id():
+    """Returns the uuid string and its hashed.
+    The string is used for URL, and the hashed is stored in the DB."""
+    login_id = uuid4().hex
+    hashed_login_id = get_hashed_login_id(login_id)
+    return login_id, hashed_login_id
+
+
+def get_hashed_login_id(login_id):
+    """Returns the hash of a given string used for login url"""
+    return hashlib.sha256(login_id.encode()).hexdigest()

cfl_common/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