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

portal/views/cron/user.py

@@ -0,0 +1,322 @@
+import logging
+from datetime import datetime, timedelta
+
+from common.helpers.emails import generate_token_for_email
+from common.mail import campaign_ids, send_dotdigital_email
+from common.models import DailyActivity, TotalActivity
+from django.contrib.auth.models import User
+from django.db.models import F, Q
+from django.db.models.query import QuerySet
+from django.urls import reverse
+from django.utils import timezone
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from ...mixins import CronMixin
+from ...views.api import anonymise
+
+USER_1ST_VERIFY_EMAIL_REMINDER_DAYS = 7
+USER_2ND_VERIFY_EMAIL_REMINDER_DAYS = 14
+USER_DELETE_UNVERIFIED_ACCOUNT_DAYS = 19
+
+USER_1ST_INACTIVE_REMINDER_DAYS = 730  # 2 years
+USER_2ND_INACTIVE_REMINDER_DAYS = 973  # roughly 2 years and 8 months
+USER_FINAL_INACTIVE_REMINDER_DAYS = 1065  # 2 years and 11 months
+USER_RETENTION_PERIOD = 1096  # 3 years
+
+
+def get_unverified_users(
+    days: int, same_day: bool
+) -> (QuerySet[User], QuerySet[User]):
+    now = timezone.now()
+
+    # All expired unverified users.
+    user_queryset = User.objects.filter(
+        date_joined__lte=now - timedelta(days=days),
+        userprofile__is_verified=False,
+    )
+    if same_day:
+        user_queryset = user_queryset.filter(
+            date_joined__gt=now - timedelta(days=days + 1)
+        )
+
+    teacher_queryset = user_queryset.filter(
+        new_teacher__isnull=False,
+        new_student__isnull=True,
+    )
+    independent_student_queryset = user_queryset.filter(
+        new_teacher__isnull=True,
+        new_student__class_field__isnull=True,
+    )
+
+    return teacher_queryset, independent_student_queryset
+
+
+def get_inactive_users(days: int) -> QuerySet[User]:
+    now = timezone.now()
+
+    # All users who haven't logged in in X days OR who've never logged in and
+    # registered over X days ago.
+    user_queryset = User.objects.filter(
+        Q(
+            last_login__isnull=False,
+            last_login__lte=now - timedelta(days=days),
+            last_login__gt=now - timedelta(days=days + 1),
+        )
+        | Q(
+            last_login__isnull=True,
+            date_joined__lte=now - timedelta(days=days),
+            date_joined__gt=now - timedelta(days=days + 1),
+        )
+    )
+
+    return user_queryset.exclude(email__isnull=True).exclude(email="")
+
+
+def build_absolute_google_uri(request, location: str) -> str:
+    """
+    This is needed specifically for emails sent by cron jobs as the protocol for
+    cron jobs is HTTP and the service name is wrongly parsed.
+    """
+    url = request.build_absolute_uri(location)
+    url = url.replace("http", "https")
+    url = url.replace(".decent", "-dot-decent")
+
+    return url
+
+
+class FirstVerifyEmailReminderView(CronMixin, APIView):
+    def get(self, request):
+        teacher_queryset, independent_student_queryset = get_unverified_users(
+            USER_1ST_VERIFY_EMAIL_REMINDER_DAYS,
+            same_day=True,
+        )
+        user_queryset = teacher_queryset.union(independent_student_queryset)
+        user_count = user_queryset.count()
+
+        logging.info(f"{user_count} emails unverified.")
+
+        if user_count > 0:
+            sent_email_count = 0
+            for email in user_queryset.values_list("email", flat=True).iterator(
+                chunk_size=500
+            ):
+                email_verification_url = build_absolute_google_uri(
+                    request,
+                    reverse(
+                        "verify_email",
+                        kwargs={"token": generate_token_for_email(email)},
+                    ),
+                )
+
+                try:
+                    send_dotdigital_email(
+                        campaign_ids["verify_new_user_first_reminder"],
+                        [email],
+                        personalization_values={
+                            "VERIFICATION_LINK": email_verification_url
+                        },
+                    )
+
+                    sent_email_count += 1
+                except Exception as ex:
+                    logging.exception(ex)
+
+            logging.info(f"Sent {sent_email_count}/{user_count} emails.")
+
+        return Response()
+
+
+class SecondVerifyEmailReminderView(CronMixin, APIView):
+    def get(self, request):
+        teacher_queryset, independent_student_queryset = get_unverified_users(
+            USER_2ND_VERIFY_EMAIL_REMINDER_DAYS,
+            same_day=True,
+        )
+        user_queryset = teacher_queryset.union(independent_student_queryset)
+        user_count = user_queryset.count()
+
+        logging.info(f"{user_count} emails unverified.")
+
+        if user_count > 0:
+
+            sent_email_count = 0
+            for email in user_queryset.values_list("email", flat=True).iterator(
+                chunk_size=500
+            ):
+                email_verification_url = build_absolute_google_uri(
+                    request,
+                    reverse(
+                        "verify_email",
+                        kwargs={"token": generate_token_for_email(email)},
+                    ),
+                )
+
+                try:
+                    send_dotdigital_email(
+                        campaign_ids["verify_new_user_second_reminder"],
+                        [email],
+                        personalization_values={
+                            "VERIFICATION_LINK": email_verification_url
+                        },
+                    )
+
+                    sent_email_count += 1
+                except Exception as ex:
+                    logging.exception(ex)
+
+            logging.info(f"Sent {sent_email_count}/{user_count} emails.")
+
+        return Response()
+
+
+class AnonymiseUnverifiedAccounts(CronMixin, APIView):
+    def get(self, request):
+        user_count = User.objects.filter(is_active=True).count()
+
+        teacher_queryset, independent_student_queryset = get_unverified_users(
+            USER_DELETE_UNVERIFIED_ACCOUNT_DAYS,
+            same_day=False,
+        )
+        teacher_count = teacher_queryset.count()
+        indy_count = independent_student_queryset.count()
+
+        user_queryset = teacher_queryset.union(independent_student_queryset)
+
+        for user in user_queryset.iterator(chunk_size=100):
+            try:
+                anonymise(user)
+            except Exception as ex:
+                logging.error(f"Failed to anonymise user with id: {user.id}")
+                logging.exception(ex)
+
+        user_count -= User.objects.filter(is_active=True).count()
+        logging.info(f"{user_count} unverified users anonymised.")
+
+        activity_today = DailyActivity.objects.get_or_create(
+            date=datetime.now().date()
+        )[0]
+        activity_today.anonymised_unverified_teachers = teacher_count
+        activity_today.anonymised_unverified_independents = indy_count
+        activity_today.save()
+
+        TotalActivity.objects.update(
+            anonymised_unverified_teachers=F("anonymised_unverified_teachers")
+            + teacher_count,
+            anonymised_unverified_independents=F(
+                "anonymised_unverified_independents"
+            )
+            + indy_count,
+        )
+
+        return Response()
+
+
+class FirstInactivityReminderView(CronMixin, APIView):
+    def get(self, request):
+        user_queryset = get_inactive_users(USER_1ST_INACTIVE_REMINDER_DAYS)
+        user_count = user_queryset.count()
+
+        logging.info(
+            f"{user_count} inactive users after "
+            f"{USER_1ST_INACTIVE_REMINDER_DAYS} days."
+        )
+
+        if user_count > 0:
+            sent_email_count = 0
+            for email in user_queryset.values_list("email", flat=True).iterator(
+                chunk_size=500
+            ):
+                try:
+                    send_dotdigital_email(
+                        campaign_ids[
+                            "inactive_users_on_website_first_reminder"
+                        ],
+                        [email],
+                    )
+
+                    sent_email_count += 1
+                except Exception as ex:
+                    logging.exception(ex)
+
+            logging.info(
+                f"Reminded {sent_email_count}/{user_count} inactive users."
+            )
+
+        return Response()
+
+
+class SecondInactivityReminderView(CronMixin, APIView):
+    def get(self, request):
+        user_queryset = get_inactive_users(USER_2ND_INACTIVE_REMINDER_DAYS)
+        user_count = user_queryset.count()
+
+        logging.info(
+            f"{user_count} inactive users after "
+            f"{USER_2ND_INACTIVE_REMINDER_DAYS} days."
+        )
+
+        if user_count > 0:
+            sent_email_count = 0
+            for email in user_queryset.values_list("email", flat=True).iterator(
+                chunk_size=500
+            ):
+                try:
+                    send_dotdigital_email(
+                        campaign_ids[
+                            "inactive_users_on_website_second_reminder"
+                        ],
+                        [email],
+                        personalization_values={
+                            "DAYS_LEFT": USER_RETENTION_PERIOD
+                            - USER_2ND_INACTIVE_REMINDER_DAYS
+                        },
+                    )
+
+                    sent_email_count += 1
+                except Exception as ex:
+                    logging.exception(ex)
+
+            logging.info(
+                f"Reminded {sent_email_count}/{user_count} inactive users."
+            )
+
+        return Response()
+
+
+class FinalInactivityReminderView(CronMixin, APIView):
+    def get(self, request):
+        user_queryset = get_inactive_users(USER_FINAL_INACTIVE_REMINDER_DAYS)
+        user_count = user_queryset.count()
+
+        logging.info(
+            f"{user_count} inactive users after "
+            f"{USER_FINAL_INACTIVE_REMINDER_DAYS} days."
+        )
+
+        if user_count > 0:
+            sent_email_count = 0
+            for email in user_queryset.values_list("email", flat=True).iterator(
+                chunk_size=500
+            ):
+                try:
+                    send_dotdigital_email(
+                        campaign_ids[
+                            "inactive_users_on_website_final_reminder"
+                        ],
+                        [email],
+                        personalization_values={
+                            "DAYS_LEFT": USER_RETENTION_PERIOD
+                            - USER_FINAL_INACTIVE_REMINDER_DAYS
+                        },
+                    )
+
+                    sent_email_count += 1
+                except Exception as ex:
+                    logging.exception(ex)
+
+            logging.info(
+                f"Reminded {sent_email_count}/{user_count} inactive users."
+            )
+
+        return Response()

portal/views/dotmailer.py

@@ -3,7 +3,9 @@ from common.helpers.emails import (
     get_dotmailer_user_by_email,
     send_dotmailer_consent_confirmation_email_to_user,
     add_consent_record_to_dotmailer_user,
+    DotmailerUserType,
 )
+from common.mail import address_book_ids
 from django.contrib import messages as messages
 from django.http import HttpResponseRedirect, HttpResponse
 from django.shortcuts import render
@@ -19,7 +21,13 @@ def process_newsletter_form(request):
         newsletter_form = NewsletterForm(data=request.POST)
         if newsletter_form.is_valid():
             user_email = newsletter_form.cleaned_data["email"]
-            add_to_dotmailer("", "", user_email)
+            add_to_dotmailer(
+                "",
+                "",
+                user_email,
+                address_book_ids["newsletter"],
+                DotmailerUserType.NO_ACCOUNT,
+            )
             messages.success(request, "Thank you for signing up! 🎉")
             return HttpResponseRedirect(reverse_lazy("home"))
         messages.error(

portal/views/email.py

@@ -1,58 +1,60 @@
 from datetime import timedelta
 
-from common.helpers.emails import NOTIFICATION_EMAIL, send_email
-from common.models import EmailVerification, School, Student, Teacher
-from common.permissions import logged_in_as_independent_student, logged_in_as_teacher
+import jwt
+from common.models import Teacher
+from common.permissions import logged_in_as_independent_student
+from django.conf import settings
 from django.contrib import messages as messages
 from django.contrib.auth.models import User
-from django.db.models import Count
-from django.http import HttpResponse, HttpResponseRedirect
+from django.http import HttpResponseRedirect
 from django.shortcuts import render
 from django.urls import reverse_lazy
 from django.utils import timezone
-from django_countries import countries
-
-from portal.app_settings import CONTACT_FORM_EMAILS
 
 
 def verify_email(request, token):
-    verifications = EmailVerification.objects.filter(token=token)
+    decoded_jwt = jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
+
+    user_found = User.objects.filter(email=decoded_jwt["email"]).first()
+    usertype = (
+        "TEACHER"
+        if Teacher.objects.filter(new_user=user_found).exists()
+        else "INDEP_STUDENT"
+    )
+    is_expired = decoded_jwt["expires"] < timezone.now().timestamp()
+
+    is_changing_email = decoded_jwt["new_email"] != ""
+    updated_email = (
+        decoded_jwt["new_email"] if is_changing_email else decoded_jwt["email"]
+    )
 
-    if not verifications.exists():
+    if not user_found or is_expired:
         return render(
             request,
             "portal/email_verification_failed.html",
-            {"usertype": "INDEP_STUDENT"},
+            {"usertype": usertype},
         )
 
-    verification = verifications[0]
-    user = verification.user
-
-    usertype = (
-        "TEACHER" if Teacher.objects.filter(new_user=user).exists() else "INDEP_STUDENT"
-    )
-
-    if has_verification_failed(verifications):
+    is_user_verified = user_found.userprofile.is_verified
+    if is_user_verified and not is_changing_email:
         return render(
-            request, "portal/email_verification_failed.html", {"usertype": usertype}
+            request,
+            "portal/email_verification_failed.html",
+            {"usertype": usertype},
         )
 
-    verification.verified = True
-    verification.save()
-
-    if verification.email:  # verifying change of email address
-        user.email = verification.email
-        if logged_in_as_teacher(user):
-            user.username = verification.email
-        user.save()
-
-        user.email_verifications.exclude(email=user.email).delete()
+    if not is_user_verified or is_changing_email:
+        user_found.email = updated_email
+        user_found.username = updated_email
+        user_found.userprofile.is_verified = True
+        user_found.userprofile.save()
+        user_found.save()
 
     messages.success(
         request, "Your email address was successfully verified, please log in."
     )
 
-    if logged_in_as_independent_student(user):
+    if logged_in_as_independent_student(user_found):
         login_url = "independent_student_login"
     else:
         login_url = "teacher_login"
@@ -66,49 +68,3 @@ def has_verification_failed(verifications):
         or verifications[0].verified
         or (verifications[0].expiry - timezone.now()) < timedelta()
     )
-
-
-def send_new_users_report(request):
-    new_users_count = User.objects.filter(
-        date_joined__gte=timezone.now() - timedelta(days=7)
-    ).count()
-    users_count = User.objects.count()
-    active_users = User.objects.filter(
-        last_login__gte=timezone.now() - timedelta(days=7)
-    ).count()
-    school_count = School.objects.count()
-    teacher_count = Teacher.objects.count()
-    student_count = Student.objects.count()
-    schools_countries = (
-        School.objects.values("country")
-        .annotate(nb_countries=Count("id"))
-        .order_by("-nb_countries")
-    )
-    nb_countries = schools_countries.count()
-    countries_count = "\n".join(
-        "{}: {}".format(dict(countries)[k["country"]], k["nb_countries"])
-        for k in schools_countries[:3]
-    )
-    send_email(
-        NOTIFICATION_EMAIL,
-        CONTACT_FORM_EMAILS,
-        "new users",
-        "There are {new_users} new users this week!\n"
-        "The total number of registered users is now: {users}\n"
-        "Current number of schools: {schools}\n"
-        "Current number of teachers: {teachers}\n"
-        "Current number of students: {students}\n"
-        "Number of users that last logged in during the last week: {active_users}\n"
-        "Number of countries with registered schools: {countries}\n"
-        "Top 3 - schools per country:\n{countries_counter}".format(
-            new_users=new_users_count,
-            users=users_count,
-            schools=school_count,
-            teachers=teacher_count,
-            students=student_count,
-            countries=nb_countries,
-            active_users=active_users,
-            countries_counter=countries_count,
-        ),
-    )
-    return HttpResponse("success")

portal/views/google_analytics.py

@@ -0,0 +1,28 @@
+import json
+
+import requests
+from django.http import HttpRequest, JsonResponse
+from django.views.decorators.csrf import csrf_exempt
+
+
+@csrf_exempt
+def collect(request: HttpRequest):
+    body: dict = json.loads(request.body)
+    measurement_id = body["measurement_id"]
+    api_secret = body["api_secret"]
+    debug = body.get("debug", False)
+
+    response = requests.post(
+        url=(
+            "https://www.google-analytics.com/debug/mp/collect"
+            if debug
+            else "https://www.google-analytics.com/mp/collect"
+        )
+        + f"?measurement_id=${measurement_id}&api_secret=${api_secret}",
+        json=body["payload"],
+    )
+
+    return JsonResponse(
+        data=response.json() if debug else {},
+        status=response.status_code,
+    )