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

portal/views/admin.py

@@ -1,25 +1,13 @@
-from builtins import str
-from datetime import timedelta
-from time import sleep
-
-from common.models import Teacher, School, Class, Student
 from django.contrib import messages as messages
 from django.contrib.auth import logout
-from django.contrib.auth.decorators import permission_required, login_required
-from django.contrib.auth.models import User
 from django.contrib.auth.views import (
     PasswordChangeView,
     PasswordChangeDoneView,
 )
-from django.db.models import Avg, Count, Q
 from django.http import HttpResponseRedirect
-from django.shortcuts import render
-from django.utils import timezone
-from django_otp import device_classes
 from rest_framework.reverse import reverse_lazy
 
 from portal.forms.admin import AdminChangeOwnPasswordForm
-from portal.helpers.location import lookup_coord
 
 block_limit = 5
 
@@ -40,323 +28,3 @@ class AdminChangePasswordDoneView(PasswordChangeDoneView):
             "Password updated successfully. Please login using your new password.",
         )
         return HttpResponseRedirect(reverse_lazy("teacher_login"))
-
-
-@login_required(login_url=reverse_lazy("teacher_login"))
-@permission_required("common.view_aggregated_data", raise_exception=True)
-def aggregated_data(request):
-
-    tables = []
-
-    table_head = ["Data description", "Value", "More info"]
-    table_data = []
-
-    """
-    Overall statistics
-    """
-
-    teacher_count = Teacher.objects.count()
-    student_count = Student.objects.count()
-    new_profiles_count = User.objects.filter(
-        date_joined__gte=timezone.now() - timedelta(days=7)
-    ).count()
-
-    table_data.append(
-        [
-            "Number of users",
-            teacher_count + student_count,
-            "Number of teachers + Number of students",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Number of new users (past week)",
-            new_profiles_count,
-            "Number of user profiles",
-        ]
-    )
-
-    tables.append(
-        {
-            "title": "Overall Statistics",
-            "description": "CFL site overall statistics",
-            "header": table_head,
-            "data": table_data,
-        }
-    )
-
-    """
-    School statistics
-    """
-    table_data = []
-    table_data.append(["Number of schools signed up", School.objects.count(), ""])
-    num_of_teachers_per_school = School.objects.annotate(
-        num_teachers=Count("teacher_school")
-    )
-    stats_teachers_per_school = num_of_teachers_per_school.aggregate(
-        Avg("num_teachers")
-    )
-
-    table_data.append(
-        [
-            "Average number of teachers per school",
-            stats_teachers_per_school["num_teachers__avg"],
-            "",
-        ]
-    )
-
-    tables.append(
-        {
-            "title": "Schools or Clubs",
-            "description": "",
-            "header": table_head,
-            "data": table_data,
-        }
-    )
-
-    """
-    Teacher statistics
-    """
-    table_data = []
-    table_data.append(["Number of teachers signed up", teacher_count, ""])
-
-    table_data.append(
-        [
-            "Number of teachers not in a school",
-            Teacher.objects.filter(school=None).count(),
-            "",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Number of teachers with request pending to join a school",
-            Teacher.objects.exclude(pending_join_request=None).count(),
-            "",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Number of teachers with unverified email address",
-            Teacher.objects.exclude(
-                new_user__email_verifications__verified=True
-            ).count(),
-            "",
-        ]
-    )
-
-    otp_model_names = [model._meta.model_name for model in device_classes()]
-    otp_query = Q()
-    for model_name in otp_model_names:
-        otp_query = otp_query | Q(**{"new_user__%s__name" % model_name: "default"})
-    two_factor_teachers = Teacher.objects.filter(otp_query).distinct().count()
-    table_data.append(["Number of teachers setup with 2FA", two_factor_teachers, ""])
-    num_of_classes_per_teacher = Teacher.objects.annotate(
-        num_classes=Count("class_teacher")
-    )
-    stats_classes_per_teacher = num_of_classes_per_teacher.aggregate(Avg("num_classes"))
-    num_of_classes_per_active_teacher = num_of_classes_per_teacher.exclude(school=None)
-    stats_classes_per_active_teacher = num_of_classes_per_active_teacher.aggregate(
-        Avg("num_classes")
-    )
-
-    table_data.append(
-        [
-            "Average number of classes per teacher",
-            stats_classes_per_teacher["num_classes__avg"],
-            "",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Average number of classes per active teacher",
-            stats_classes_per_active_teacher["num_classes__avg"],
-            "Excludes teachers without a school",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Number of of teachers with no classes",
-            num_of_classes_per_teacher.filter(num_classes=0).count(),
-            "",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Number of of active teachers with no classes",
-            num_of_classes_per_active_teacher.filter(num_classes=0).count(),
-            "Excludes teachers without a school",
-        ]
-    )
-
-    tables.append(
-        {
-            "title": "Teachers",
-            "description": "",
-            "header": table_head,
-            "data": table_data,
-        }
-    )
-
-    """
-    Class statistics
-    """
-    table_data = []
-    table_data.append(["Number of classes", Class.objects.count(), ""])
-
-    num_students_per_class = Class.objects.annotate(num_students=Count("students"))
-    stats_students_per_class = num_students_per_class.aggregate(Avg("num_students"))
-    stats_students_per_active_class = num_students_per_class.exclude(
-        num_students=0
-    ).aggregate(Avg("num_students"))
-
-    table_data.append(
-        [
-            "Average number of students per class",
-            stats_students_per_class["num_students__avg"],
-            "",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Average number of students per active class",
-            stats_students_per_active_class["num_students__avg"],
-            "Excludes classes which are empty",
-        ]
-    )
-
-    tables.append(
-        {
-            "title": "Classes",
-            "description": "",
-            "header": table_head,
-            "data": table_data,
-        }
-    )
-
-    """
-    Student statistics
-    """
-    table_data = []
-    table_data.append(["Number of students", student_count, ""])
-
-    independent_students = Student.objects.filter(class_field=None)
-
-    table_data.append(
-        ["Number of independent students", independent_students.count(), ""]
-    )
-
-    table_data.append(
-        [
-            "Number of independent students with unverified email address",
-            Student.objects.exclude(
-                new_user__email_verifications__verified=True
-            ).count(),
-            "",
-        ]
-    )
-
-    table_data.append(
-        [
-            "Number of school students",
-            Student.objects.exclude(class_field=None).count(),
-            "",
-        ]
-    )
-
-    tables.append(
-        {
-            "title": "Students",
-            "description": "",
-            "header": table_head,
-            "data": table_data,
-        }
-    )
-
-    """
-    Rapid Router Student Progress statistics
-    """
-    table_data = []
-
-    students_with_attempts = Student.objects.annotate(
-        num_attempts=Count("attempts")
-    ).exclude(num_attempts=0)
-    table_data.append(
-        ["Number of students who have started RR", students_with_attempts.count(), ""]
-    )
-
-    school_students_with_attempts = students_with_attempts.exclude(class_field=None)
-    table_data.append(
-        [
-            "Number of school students who have started RR",
-            school_students_with_attempts.count(),
-            "",
-        ]
-    )
-
-    independent_students_with_attempts = students_with_attempts.filter(class_field=None)
-    table_data.append(
-        [
-            "Number of independent students who have started RR",
-            independent_students_with_attempts.count(),
-            "",
-        ]
-    )
-
-    tables.append(
-        {
-            "title": "Rapid Router Student Progress",
-            "description": "",
-            "header": table_head,
-            "data": table_data,
-        }
-    )
-
-    return render(request, "portal/admin/aggregated_data.html", {"tables": tables})
-
-
-def fill_in_missing_school_locations(request):
-    schools = School.objects.filter(latitude="0", longitude="0")
-
-    requests = 0
-    failures = []
-    town0 = 0
-
-    for school in schools:
-        requests += 1
-        sleep(0.2)  # so we execute a bit less than 5/sec
-
-        (
-            error,
-            school.country,
-            school.town,
-            school.latitude,
-            school.longitude,
-        ) = lookup_coord(school.postcode, school.country.code)
-
-        if error is None:
-            school.save()
-
-        if error is not None:
-            failures += [(school.id, school.postcode, error)]
-
-        if school.town == "0":
-            town0 += 1
-
-    messages.info(request, "Made %d requests" % requests)
-    messages.info(request, "There were %d errors: %s" % (len(failures), str(failures)))
-    messages.info(request, "%d school have no town" % town0)
-
-
-@login_required(login_url=reverse_lazy("teacher_login"))
-@permission_required("common.view_map_data", raise_exception=True)
-def schools_map(request):
-    fill_in_missing_school_locations(request)
-
-    return render(request, "portal/admin/map.html", {"schools": School.objects.all()})

portal/views/api.py

@@ -1,18 +1,19 @@
 import datetime
 import uuid
 
-from common.models import Student, Teacher
+from common.models import Class, School, Student, Teacher, UserProfile
 from django.contrib.auth.decorators import login_required
 from django.contrib.auth.models import User
 from django.http import HttpRequest, HttpResponse
 from django.utils import timezone
-from portal.app_settings import IS_CLOUD_SCHEDULER_FUNCTION
 from rest_framework import generics, permissions, serializers, status
 from rest_framework.authentication import SessionAuthentication
 from rest_framework.decorators import api_view
 from rest_framework.response import Response
 from rest_framework.reverse import reverse_lazy
 
+from portal.app_settings import IS_CLOUD_SCHEDULER_FUNCTION
+
 THREE_YEARS_IN_DAYS = 1095
 
 
@@ -21,7 +22,9 @@ THREE_YEARS_IN_DAYS = 1095
 def registered_users(request, year, month, day):
     try:
         nbr_reg = User.objects.filter(
-            date_joined__startswith=datetime.date(int(year), int(month), int(day))
+            date_joined__startswith=datetime.date(
+                int(year), int(month), int(day)
+            )
         ).count()
         return Response(nbr_reg)
     except ValueError:
@@ -70,11 +73,14 @@ class IsAdminOrGoogleAppEngine(permissions.IsAdminUser):
     """Checks whether the request is from a Google App Engine cron job."""
 
     def has_permission(self, request: HttpRequest, view):
-        is_admin = super(IsAdminOrGoogleAppEngine, self).has_permission(request, view)
+        is_admin = super(IsAdminOrGoogleAppEngine, self).has_permission(
+            request, view
+        )
         return IS_CLOUD_SCHEDULER_FUNCTION(request) or is_admin
 
 
-def _anonymise(user):
+def __anonymise_user(user):
+    # the actual user anonymisation
     user.username = uuid.uuid4().hex
     user.first_name = "Deleted"
     user.last_name = "User"
@@ -83,6 +89,52 @@ def _anonymise(user):
     user.save()
 
 
+def anonymise(user):
+    """Anonymise user. If admin teacher, pass the admin role to another teacher (if exists).
+    If the only teacher, anonymise the school.
+    """
+    is_admin = False
+    teacher = None
+    # Find the teacher even if they're anonymised
+    teacher_set = Teacher._base_manager.filter(new_user=user)
+    if teacher_set:
+        is_admin = teacher_set[0].is_admin
+        school = teacher_set[0].school
+        teacher = teacher_set[0]
+
+    __anonymise_user(user)
+
+    # if teacher, anonymise classes and students
+    if teacher:
+        classes = Class.objects.filter(teacher=teacher)
+        for klass in classes:
+            students = Student.objects.filter(class_field=klass)
+            for student in students:
+                __anonymise_user(student.new_user)
+            klass.anonymise()
+
+    # if user is admin and the school does not have another admin, appoint another teacher as admin
+    if is_admin:
+        teachers = Teacher.objects.filter(school=school).order_by(
+            "new_user__last_name", "new_user__first_name"
+        )
+        if not teachers:
+            # no other teacher, anonymise the school
+            school.anonymise()
+            return
+
+        admin_exists = False
+        for teacher in teachers:
+            if teacher.is_admin:
+                admin_exists = True
+                break
+
+        # if no admin, appoint the first teacher as admin
+        if not admin_exists:
+            teachers[0].is_admin = True
+            teachers[0].save()
+
+
 class InactiveUsersView(generics.ListAPIView):
     """
     This API view endpoint allows us to see our inactive users.
@@ -110,62 +162,44 @@ class InactiveUsersView(generics.ListAPIView):
         """Delete all personal data from inactive users and mark them as inactive."""
         inactive_users = self.get_queryset()
         for user in inactive_users:
-            _anonymise(user)
+            anonymise(user)
         return Response(status=status.HTTP_204_NO_CONTENT)
 
 
-class DuplicateIndyTeacherView(generics.ListAPIView):
+class RemoveFakeAccounts(generics.ListAPIView):
     """
-    This API endpoint deletes teacher or independent student accounts with duplicate emails.
+    This API endpoint will delete suspicious accounts that have the same first and last name and who are not verified
     """
 
-    queryset = Student.objects.filter(
-        class_field__isnull=True, new_user__is_active=True
-    ).select_related("new_user")
-
     authentication_classes = (SessionAuthentication,)
+    serializer_class = InactiveUserSerializer
     permission_classes = (IsAdminOrGoogleAppEngine,)
 
-    def delete(self, request, *args, **kwargs):
-        def _tidyup(usrone, usrtwo):
-            # if there's no login at all, keep the one with the most recent date_joined
-            if not usrone.last_login and not usrtwo.last_login:
-                if usrone.date_joined > usrtwo.date_joined:
-                    _anonymise(usrtwo)
-                elif usrone.date_joined < usrtwo.date_joined:
-                    _anonymise(usrone)
-                # else: should not happen, but if it does, leave them
-            # if there's one with login, keep that one
-            elif usrone.last_login and not usrtwo.last_login:
-                _anonymise(usrtwo)
-            elif not usrone.last_login and usrtwo.last_login:
-                _anonymise(usrone)
-            # else: both have logged in, we don't want to automatically choose for teacher+indy duplicates
-
-        def _tidyup_students(students):
-            for student in students:
-                email = student.new_user.email
-                assert email != ""
+    def get(self, request):
+        userprofiles = UserProfile.objects.filter(is_verified=False)
+        [
+            userprofile.user.delete()
+            for userprofile in userprofiles
+            if userprofile.user.first_name == userprofile.user.last_name
+        ]
 
-                teachers = Teacher.objects.filter(
-                    new_user__is_active=True, new_user__email=email
-                ).select_related("new_user")
+        return HttpResponse(status=204)
 
-                if not teachers.exists():
-                    continue  # no duplicate
 
-                # else there's a duplicate
-                assert len(teachers) == 1
-                _tidyup(student.new_user, teachers[0].new_user)
+class AnonymiseOrphanSchoolsView(generics.ListAPIView):
+    authentication_classes = (SessionAuthentication,)
+    serializer_class = InactiveUserSerializer
+    permission_classes = (IsAdminOrGoogleAppEngine,)
 
-        # do it in batches
-        offset = 0
-        LIMIT = 1000
+    def get(self, request: HttpRequest, start_id):
+        # Re-anonymise all inactive teachers so their schools (if necessary) and classes/students are anonymised
+        for teacher in Teacher._base_manager.filter(
+            pk__gte=start_id, new_user__is_active=False
+        ):
+            anonymise(teacher.new_user)
 
-        indystudents = self.get_queryset()[offset : (offset + LIMIT)]
-        while indystudents.exists():
-            _tidyup_students(indystudents)
-            offset += LIMIT
-            indystudents = self.get_queryset()[offset : (offset + LIMIT)]
+        # Anonymise schools without any teachers
+        for school in School.objects.filter(teacher_school__isnull=True):
+            school.anonymise()
 
         return Response(status=status.HTTP_204_NO_CONTENT)

portal/views/cron/__init__.py

@@ -0,0 +1 @@
+from .user import *