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

cfl_common/common/models.py

@@ -0,0 +1,557 @@
+import re
+import typing as t
+from datetime import timedelta
+from uuid import uuid4
+
+from cryptography.fernet import Fernet
+from django.conf import settings
+from django.contrib.auth.models import User
+from django.db import models
+from django.utils import timezone
+from django_countries.fields import CountryField
+
+if t.TYPE_CHECKING:
+    from django.db.models import ManyToManyField
+    from game.models import Worksheet
+
+
+class EncryptedCharField(models.CharField):
+    """
+    A custom CharField that encrypts data before saving and decrypts it when
+    retrieved.
+    """
+
+    _fernet = Fernet(settings.ENCRYPTION_KEY)
+    _prefix = "ENC:"
+
+    # pylint: disable-next=unused-argument
+    def from_db_value(self, value: t.Optional[str], expression, connection):
+        """
+        Converts a value as returned by the database to a Python object. It is
+        the reverse of get_prep_value().
+
+        https://docs.djangoproject.com/en/5.1/howto/custom-model-fields/#converting-values-to-python-objects
+        """
+        if isinstance(value, str):
+            return self.decrypt_value(value)
+        return value
+
+    def to_python(self, value: t.Optional[str]):
+        """
+        Converts the value into the correct Python object. It acts as the
+        reverse of value_to_string(), and is also called in clean().
+
+        https://docs.djangoproject.com/en/5.1/howto/custom-model-fields/#converting-values-to-python-objects
+        """
+        if isinstance(value, str):
+            return self.decrypt_value(value)
+        return value
+
+    def get_prep_value(self, value: t.Optional[str]):
+        """
+        'value' is the current value of the model's attribute, and the method
+        should return data in a format that has been prepared for use as a
+        parameter in a query.
+
+        https://docs.djangoproject.com/en/5.1/howto/custom-model-fields/#converting-python-objects-to-query-values
+        """
+        if isinstance(value, str):
+            return self.encrypt_value(value)
+        return value
+
+    def encrypt_value(self, value: str):
+        """Encrypt the value if it's not encrypted."""
+        if not value.startswith(self._prefix):
+            return self._prefix + self._fernet.encrypt(value.encode()).decode()
+        return value
+
+    def decrypt_value(self, value: str):
+        """Decrpyt the value if it's encrypted.."""
+        if value.startswith(self._prefix):
+            value = value[len(self._prefix) :]
+            return self._fernet.decrypt(value).decode()
+        return value
+
+
+class UserProfile(models.Model):
+    user = models.OneToOneField(User, on_delete=models.CASCADE)
+
+    otp_secret = models.CharField(max_length=40, null=True, blank=True)
+    last_otp_for_time = models.DateTimeField(null=True, blank=True)
+    developer = models.BooleanField(default=False)
+    is_verified = models.BooleanField(default=False)
+
+    # TODO: Make not nullable once data has been transferred
+    first_name = models.CharField(max_length=200, null=True, blank=True)
+    _first_name = models.BinaryField(null=True, blank=True)
+    last_name = models.CharField(max_length=200, null=True, blank=True)
+    _last_name = models.BinaryField(null=True, blank=True)
+    email = models.CharField(max_length=200, null=True, blank=True)
+    _email = models.BinaryField(null=True, blank=True)
+    # TODO: Make not nullable once data has been transferred
+    username = models.CharField(max_length=200, null=True, blank=True)
+    _username = models.BinaryField(null=True, blank=True)
+
+    # Google.
+    google_refresh_token = EncryptedCharField(
+        max_length=1000 + len(EncryptedCharField._prefix), null=True, blank=True
+    )
+    google_sub = models.CharField(max_length=255, null=True, blank=True)
+
+    def __str__(self):
+        return f"{self.user.first_name} {self.user.last_name}"
+
+    def joined_recently(self):
+        now = timezone.now()
+        return now - timedelta(days=7) <= self.user.date_joined
+
+
+class SchoolModelManager(models.Manager):
+    def get_original_queryset(self):
+        return super().get_queryset()
+
+    # Filter out inactive schools by default
+    def get_queryset(self):
+        return super().get_queryset().filter(is_active=True)
+
+
+class School(models.Model):
+    name = models.CharField(max_length=200, unique=True)
+    country = CountryField(
+        blank_label="(select country)", null=True, blank=True
+    )
+    # TODO: Create an Address model to house address details
+    county = models.CharField(max_length=50, blank=True, null=True)
+    creation_time = models.DateTimeField(default=timezone.now, null=True)
+    is_active = models.BooleanField(default=True)
+
+    objects = SchoolModelManager()
+
+    def __str__(self):
+        return self.name
+
+    def classes(self):
+        teachers = self.teacher_school.all()
+        if teachers:
+            classes = []
+            for teacher in teachers:
+                if teacher.class_teacher.all():
+                    classes.extend(list(teacher.class_teacher.all()))
+            return classes
+        return None
+
+    def admins(self):
+        teachers = self.teacher_school.all()
+        return (
+            [teacher for teacher in teachers if teacher.is_admin]
+            if teachers
+            else None
+        )
+
+    def anonymise(self):
+        self.name = uuid4().hex
+        self.is_active = False
+        self.save()
+
+
+class TeacherModelManager(models.Manager):
+    def factory(self, first_name, last_name, email, password):
+        user = User.objects.create_user(
+            username=email,
+            email=email,
+            password=password,
+            first_name=first_name,
+            last_name=last_name,
+        )
+
+        user_profile = UserProfile.objects.create(user=user)
+
+        return Teacher.objects.create(user=user_profile, new_user=user)
+
+    def get_original_queryset(self):
+        return super().get_queryset()
+
+    # Filter out non active teachers by default
+    def get_queryset(self):
+        return super().get_queryset().filter(new_user__is_active=True)
+
+
+class Teacher(models.Model):
+    user = models.OneToOneField(UserProfile, on_delete=models.CASCADE)
+    new_user = models.OneToOneField(
+        User,
+        related_name="new_teacher",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+    )
+    school = models.ForeignKey(
+        School,
+        related_name="teacher_school",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    is_admin = models.BooleanField(default=False)
+    blocked_time = models.DateTimeField(null=True, blank=True)
+    invited_by = models.ForeignKey(
+        "self",
+        related_name="invited_teachers",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+
+    objects = TeacherModelManager()
+
+    class Meta:
+        constraints = [
+            models.CheckConstraint(
+                check=~models.Q(
+                    school__isnull=True,
+                    is_admin=True,
+                ),
+                name="teacher__is_admin",
+            )
+        ]
+
+    def teaches(self, userprofile):
+        if hasattr(userprofile, "student"):
+            student = userprofile.student
+            return (
+                not student.is_independent()
+                and student.class_field.teacher == self
+            )
+
+    def has_school(self):
+        return self.school is not (None or "")
+
+    def has_class(self):
+        return self.class_teacher.exists()
+
+    def __str__(self):
+        return f"{self.new_user.first_name} {self.new_user.last_name}"
+
+
+class SchoolTeacherInvitationModelManager(models.Manager):
+    def get_original_queryset(self):
+        return super().get_queryset()
+
+    # Filter out inactive invitations by default
+    def get_queryset(self):
+        return super().get_queryset().filter(is_active=True)
+
+
+class SchoolTeacherInvitation(models.Model):
+    token = models.CharField(max_length=88)
+    school = models.ForeignKey(
+        School,
+        related_name="teacher_invitations",
+        null=True,
+        on_delete=models.SET_NULL,
+    )
+    from_teacher = models.ForeignKey(
+        Teacher,
+        related_name="school_invitations",
+        null=True,
+        on_delete=models.SET_NULL,
+    )
+    invited_teacher_first_name = models.CharField(
+        max_length=150
+    )  # Same as User model
+    # TODO: Make not nullable once data has been transferred
+    _invited_teacher_first_name = models.BinaryField(null=True, blank=True)
+    invited_teacher_last_name = models.CharField(
+        max_length=150
+    )  # Same as User model
+    # TODO: Make not nullable once data has been transferred
+    _invited_teacher_last_name = models.BinaryField(null=True, blank=True)
+    # TODO: Switch to a CharField to be able to hold hashed value
+    invited_teacher_email = models.EmailField()  # Same as User model
+    # TODO: Make not nullable once data has been transferred
+    _invited_teacher_email = models.BinaryField(null=True, blank=True)
+    invited_teacher_is_admin = models.BooleanField(default=False)
+    expiry = models.DateTimeField()
+    creation_time = models.DateTimeField(default=timezone.now, null=True)
+    is_active = models.BooleanField(default=True)
+
+    objects = SchoolTeacherInvitationModelManager()
+
+    @property
+    def is_expired(self):
+        return self.expiry < timezone.now()
+
+    def __str__(self):
+        return f"School teacher invitation for {self.invited_teacher_email} to {self.school.name}"
+
+    def anonymise(self):
+        self.invited_teacher_first_name = uuid4().hex
+        self.invited_teacher_last_name = uuid4().hex
+        self.invited_teacher_email = uuid4().hex
+        self.is_active = False
+        self.save()
+
+
+class ClassModelManager(models.Manager):
+    def all_members(self, user):
+        members = []
+        if hasattr(user, "teacher"):
+            members.append(user.teacher)
+            if user.teacher.has_school():
+                classes = user.teacher.class_teacher.all()
+                for c in classes:
+                    members.extend(c.students.all())
+        else:
+            c = user.student.class_field
+            members.append(c.teacher)
+            members.extend(c.students.all())
+        return members
+
+    def get_original_queryset(self):
+        return super().get_queryset()
+
+    # Filter out non active classes by default
+    def get_queryset(self):
+        return super().get_queryset().filter(is_active=True)
+
+
+class Class(models.Model):
+    locked_worksheets: "ManyToManyField[Worksheet]"
+
+    name = models.CharField(max_length=200)
+    teacher = models.ForeignKey(
+        Teacher, related_name="class_teacher", on_delete=models.CASCADE
+    )
+    access_code = models.CharField(max_length=5, null=True)
+    classmates_data_viewable = models.BooleanField(default=False)
+    always_accept_requests = models.BooleanField(default=False)
+    accept_requests_until = models.DateTimeField(null=True)
+    creation_time = models.DateTimeField(default=timezone.now, null=True)
+    is_active = models.BooleanField(default=True)
+    created_by = models.ForeignKey(
+        Teacher,
+        null=True,
+        blank=True,
+        related_name="created_classes",
+        on_delete=models.SET_NULL,
+    )
+
+    objects = ClassModelManager()
+
+    def __str__(self):
+        return self.name
+
+    @property
+    def active_game(self):
+        games = self.game_set.filter(game_class=self, is_archived=False)
+        if len(games) >= 1:
+            assert (
+                len(games) == 1
+            )  # there should NOT be more than one active game
+            return games[0]
+        return None
+
+    def has_students(self):
+        students = self.students.all()
+        return students.count() != 0
+
+    def get_requests_message(self):
+        if self.always_accept_requests:
+            external_requests_message = (
+                "This class is currently set to always accept requests."
+            )
+        elif (
+            self.accept_requests_until is not None
+            and (self.accept_requests_until - timezone.now()) >= timedelta()
+        ):
+            external_requests_message = (
+                "This class is accepting external requests until "
+                + self.accept_requests_until.strftime("%d-%m-%Y %H:%M")
+                + " "
+                + timezone.get_current_timezone_name()
+            )
+        else:
+            external_requests_message = (
+                "This class is not currently accepting external requests."
+            )
+
+        return external_requests_message
+
+    def anonymise(self):
+        self.name = uuid4().hex
+        self.access_code = ""
+        self.is_active = False
+        self.save()
+
+        # Remove independent students' requests to join this class
+        self.class_request.clear()
+
+    class Meta(object):
+        verbose_name_plural = "classes"
+
+
+class UserSession(models.Model):
+    user = models.ForeignKey(User, on_delete=models.CASCADE)
+    login_time = models.DateTimeField(default=timezone.now)
+    school = models.ForeignKey(School, null=True, on_delete=models.SET_NULL)
+    class_field = models.ForeignKey(Class, null=True, on_delete=models.SET_NULL)
+    login_type = models.CharField(
+        max_length=100, null=True
+    )  # for student login
+
+    def __str__(self):
+        return f"{self.user} login: {self.login_time} type: {self.login_type}"
+
+
+class StudentModelManager(models.Manager):
+    def get_random_username(self):
+        while True:
+            random_username = uuid4().hex[:30]  # generate a random username
+            if not User.objects.filter(username=random_username).exists():
+                return random_username
+
+    def schoolFactory(self, klass, name, password, login_id=None):
+        user = User.objects.create_user(
+            username=self.get_random_username(),
+            password=password,
+            first_name=name,
+        )
+        user_profile = UserProfile.objects.create(user=user)
+
+        return Student.objects.create(
+            class_field=klass,
+            user=user_profile,
+            new_user=user,
+            login_id=login_id,
+        )
+
+    def independentStudentFactory(self, name, email, password):
+        user = User.objects.create_user(
+            username=email, email=email, password=password, first_name=name
+        )
+
+        user_profile = UserProfile.objects.create(user=user)
+
+        return Student.objects.create(user=user_profile, new_user=user)
+
+
+class Student(models.Model):
+    class_field = models.ForeignKey(
+        Class,
+        related_name="students",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+    )
+    # hashed uuid used for the unique direct login url
+    login_id = models.CharField(max_length=64, null=True)
+    user = models.OneToOneField(UserProfile, on_delete=models.CASCADE)
+    new_user = models.OneToOneField(
+        User,
+        related_name="new_student",
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+    )
+    pending_class_request = models.ForeignKey(
+        Class,
+        related_name="class_request",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    blocked_time = models.DateTimeField(null=True, blank=True)
+
+    objects = StudentModelManager()
+
+    def is_independent(self):
+        return not self.class_field
+
+    def __str__(self):
+        return f"{self.new_user.first_name} {self.new_user.last_name}"
+
+
+def stripStudentName(name):
+    return re.sub("[ \t]+", " ", name.strip())
+
+
+# -----------------------------------------------------------------------
+# Below are models used for data tracking and maintenance
+# -----------------------------------------------------------------------
+class JoinReleaseStudent(models.Model):
+    """
+    To keep track when a student is released to be independent student or
+    joins a class to be a school student.
+    """
+
+    JOIN = "join"
+    RELEASE = "release"
+
+    student = models.ForeignKey(
+        Student, related_name="student", on_delete=models.CASCADE
+    )
+    # either "release" or "join"
+    action_type = models.CharField(max_length=64)
+    action_time = models.DateTimeField(default=timezone.now)
+
+
+class DailyActivity(models.Model):
+    """
+    A model to record sets of daily activity. Currently used to record the
+    amount of student details download clicks, through the CSV and login
+    cards methods, per day.
+    """
+
+    date = models.DateField(default=timezone.now)
+    csv_click_count = models.PositiveIntegerField(default=0)
+    login_cards_click_count = models.PositiveIntegerField(default=0)
+    primary_coding_club_downloads = models.PositiveIntegerField(default=0)
+    python_coding_club_downloads = models.PositiveIntegerField(default=0)
+    level_control_submits = models.PositiveBigIntegerField(default=0)
+    teacher_lockout_resets = models.PositiveIntegerField(default=0)
+    indy_lockout_resets = models.PositiveIntegerField(default=0)
+    school_student_lockout_resets = models.PositiveIntegerField(default=0)
+    anonymised_unverified_teachers = models.PositiveIntegerField(default=0)
+    anonymised_unverified_independents = models.PositiveIntegerField(default=0)
+
+    class Meta:
+        verbose_name_plural = "Daily activities"
+
+    def __str__(self):
+        return f"Activity on {self.date}: CSV clicks: {self.csv_click_count}, login cards clicks: {self.login_cards_click_count}, primary pack downloads: {self.primary_coding_club_downloads}, python pack downloads: {self.python_coding_club_downloads}, level control submits: {self.level_control_submits}, teacher lockout resets: {self.teacher_lockout_resets}, indy lockout resets: {self.indy_lockout_resets}, school student lockout resets: {self.school_student_lockout_resets}, unverified teachers anonymised: {self.anonymised_unverified_teachers}, unverified independents anonymised: {self.anonymised_unverified_independents}"
+
+
+class TotalActivity(models.Model):
+    """
+    A model to record total activity. Meant to only have one entry which
+    records all total activity. An example of this is total ever registrations.
+    """
+
+    teacher_registrations = models.PositiveIntegerField(default=0)
+    student_registrations = models.PositiveIntegerField(default=0)
+    independent_registrations = models.PositiveIntegerField(default=0)
+    anonymised_unverified_teachers = models.PositiveIntegerField(default=0)
+    anonymised_unverified_independents = models.PositiveIntegerField(default=0)
+
+    class Meta:
+        verbose_name_plural = "Total activity"
+
+    def __str__(self):
+        return "Total activity"
+
+
+class DynamicElement(models.Model):
+    """
+    This model is meant to allow us to quickly update some elements
+    dynamically on the website without having to redeploy everytime. For
+    example, if a maintenance banner needs to be added, we check the box in
+    the Django admin panel, edit the text and it'll show immediately on the
+    website.
+    """
+
+    name = models.CharField(max_length=64, unique=True, editable=False)
+    active = models.BooleanField(default=False)
+    text = models.TextField(null=True, blank=True)
+
+    def __str__(self) -> str:
+        return self.name

cfl_common/common/permissions.py

@@ -0,0 +1,84 @@
+from functools import wraps
+
+from common.utils import using_two_factor
+from django.http import Http404
+from django.http import HttpResponseRedirect
+from django.urls import reverse_lazy
+from rest_framework import permissions
+
+
+def has_completed_auth_setup(user):
+    return (not using_two_factor(user)) or (user.userprofile.is_verified and using_two_factor(user))
+
+
+class LoggedInAsTeacher(permissions.BasePermission):
+    def has_permission(self, request, view):
+        return logged_in_as_teacher(request.user)
+
+
+def logged_in_as_teacher(user):
+    try:
+        return user.userprofile.teacher and has_completed_auth_setup(user)
+    except AttributeError:
+        return False
+
+
+def logged_in_as_student(u):
+    try:
+        if u.userprofile.student:
+            return True
+    except AttributeError:
+        return False
+
+
+def logged_in_as_independent_student(u):
+    return logged_in_as_student(u) and u.userprofile.student.is_independent()
+
+
+def logged_in_as_school_student(u):
+    return logged_in_as_student(u) and not u.userprofile.student.is_independent()
+
+
+def check_teacher_authorised(request, class_teacher):
+    current_teacher_owns_the_class = class_teacher == request.user.new_teacher
+    is_current_teacher_school_admin = (
+        class_teacher.school == request.user.new_teacher.school and request.user.new_teacher.is_admin
+    )
+
+    if not (current_teacher_owns_the_class or is_current_teacher_school_admin):
+        raise Http404
+
+
+def not_logged_in(u):
+    try:
+        if u.userprofile:
+            return False
+    except AttributeError:
+        return True
+
+
+def not_fully_logged_in(u):
+    return not_logged_in(u) or (not logged_in_as_student(u) and not logged_in_as_teacher(u))
+
+
+def teacher_verified(view_func):
+    @wraps(view_func)
+    def wrapped(request, *args, **kwargs):
+        u = request.user
+        try:
+            if not u.userprofile.teacher or not has_completed_auth_setup(u):
+                return HttpResponseRedirect(reverse_lazy("teach"))
+        except AttributeError:
+            return HttpResponseRedirect(reverse_lazy("teach"))
+        return view_func(request, *args, **kwargs)
+
+    return wrapped
+
+
+class CanDeleteGame(permissions.BasePermission):
+    def has_permission(self, request, view):
+        u = request.user
+        try:
+            return u.userprofile.teacher and has_completed_auth_setup(u)
+        except AttributeError:
+            return False

cfl_common/common/tests/test_migration_anonymise_orphan_schools.py

@@ -0,0 +1,30 @@
+import pytest
+from django_test_migrations.migrator import Migrator
+
+
+@pytest.mark.django_db
+def test_migration_anonymise_orphan_schools(migrator: Migrator):
+    state = migrator.apply_initial_migration(
+        ("common", "0049_anonymise_orphan_users")
+    )
+    User = state.apps.get_model("auth", "User")
+    UserProfile = state.apps.get_model("common", "UserProfile")
+    Teacher = state.apps.get_model("common", "Teacher")
+    School = state.apps.get_model("common", "School")
+
+    orphan_school = School.objects.create(name="OrphanSchool")
+    teacher_school = School.objects.create(name="TeacherSchool")
+
+    teacher_user = User.objects.create_user("TeacherUser", password="password")
+    teacher_userprofile = UserProfile.objects.create(user=teacher_user)
+    Teacher.objects.create(
+        user=teacher_userprofile, new_user=teacher_user, school=teacher_school
+    )
+
+    migrator.apply_tested_migration(("common", "0050_anonymise_orphan_schools"))
+
+    def assert_school_anonymised(pk: int, anonymised: bool):
+        assert School.objects.get(pk=pk).is_active != anonymised
+
+    assert_school_anonymised(orphan_school.pk, True)
+    assert_school_anonymised(teacher_school.pk, False)

cfl_common/common/tests/test_migration_anonymise_orphan_users.py

@@ -0,0 +1,30 @@
+import pytest
+from django_test_migrations.migrator import Migrator
+
+
+@pytest.mark.django_db
+def test_migration_anonymise_orphan_users(migrator: Migrator):
+    state = migrator.apply_initial_migration(
+        ("common", "0048_unique_school_names")
+    )
+    User = state.apps.get_model("auth", "User")
+    UserProfile = state.apps.get_model("common", "UserProfile")
+    Teacher = state.apps.get_model("common", "Teacher")
+    Student = state.apps.get_model("common", "Student")
+
+    orphan_user = User.objects.create_user("OrphanUser", password="password")
+    teacher_user = User.objects.create_user("TeacherUser", password="password")
+    student_user = User.objects.create_user("StudentUser", password="password")
+    teacher_userprofile = UserProfile.objects.create(user=teacher_user)
+    student_userprofile = UserProfile.objects.create(user=student_user)
+    Teacher.objects.create(user=teacher_userprofile, new_user=teacher_user)
+    Student.objects.create(user=student_userprofile, new_user=student_user)
+
+    migrator.apply_tested_migration(("common", "0049_anonymise_orphan_users"))
+
+    def assert_user_anonymised(pk: int, anonymised: bool):
+        assert User.objects.get(pk=pk).is_active != anonymised
+
+    assert_user_anonymised(orphan_user.pk, True)
+    assert_user_anonymised(teacher_user.pk, False)
+    assert_user_anonymised(student_user.pk, False)