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

portal/views/organisation.py

@@ -1,220 +1,51 @@
-import json
-
-from common.models import School, Teacher, Class
+import common.permissions as permissions
+from common.models import Class, School, Teacher
 from django.contrib import messages as messages
 from django.contrib.auth.decorators import login_required, user_passes_test
+from django.http import Http404, HttpResponseRedirect
+from django.shortcuts import get_object_or_404, render
 from django.urls import reverse_lazy
-from django.db.models import Q
-from django.http import Http404, HttpResponse, HttpResponseRedirect
-from django.shortcuts import render, get_object_or_404
-from rest_framework.authentication import SessionAuthentication
-from rest_framework.views import APIView
-
-import common.permissions as permissions
-from common import email_messages
-from portal.forms.organisation import OrganisationJoinForm, OrganisationForm
-from common.helpers.emails import send_email, NOTIFICATION_EMAIL
-
-
-class OrganisationFuzzyLookup(APIView):
-    authentication_classes = (SessionAuthentication,)
-    permission_classes = (permissions.LoggedInAsTeacher,)
-
-    def get(self, request):
-        fuzzy_name = request.GET.get("fuzzy_name", None)
-        school_data = []
-
-        # The idea here is to return all schools that satisfy that each
-        # part of the fuzzy_name (separated by spaces) occurs in either
-        # school.name or school.postcode.
-        # So it is an intersection of unions.
-
-        if fuzzy_name and len(fuzzy_name) > 2:
-            schools = School.objects.all()
-            for part in fuzzy_name.split():
-                schools = schools.filter(
-                    Q(name__icontains=part) | Q(postcode__icontains=part)
-                )
-
-            self._search_schools(schools, school_data)
 
-        return HttpResponse(json.dumps(school_data), content_type="application/json")
-
-    def _search_schools(self, schools, school_data):
-        for school in schools:
-            admins = Teacher.objects.filter(school=school, is_admin=True)
-            admin = admins.first()
-            if admin:
-                email = admin.new_user.email
-                admin_domain = "*********" + email[email.find("@") :]
-                school_data.append(
-                    {
-                        "id": school.id,
-                        "name": school.name,
-                        "postcode": school.postcode,
-                        "admin_domain": admin_domain,
-                    }
-                )
+from portal.forms.organisation import OrganisationForm
 
 
 @login_required(login_url=reverse_lazy("teacher_login"))
-@user_passes_test(
-    permissions.logged_in_as_teacher, login_url=reverse_lazy("teacher_login")
-)
+@user_passes_test(permissions.logged_in_as_teacher, login_url=reverse_lazy("teacher_login"))
 def organisation_create(request):
-
     teacher = request.user.new_teacher
 
     create_form = OrganisationForm(user=request.user)
-    join_form = OrganisationJoinForm()
 
     if request.method == "POST":
-        if "create_organisation" in request.POST:
-            create_form = OrganisationForm(request.POST, user=request.user)
-            if create_form.is_valid():
-                data = create_form.cleaned_data
-                name = data.get("name", "")
-                postcode = data.get("postcode", "").upper()
-                country = data.get("country", "")
-
-                error, town, lat, lng = (
-                    "",
-                    "0",
-                    "0",
-                    "0",
-                )  # lookup_coord(postcode, country)
+        create_form = OrganisationForm(request.POST, user=request.user)
+        if create_form.is_valid():
+            data = create_form.cleaned_data
+            name = data.get("name", "")
+            country = data.get("country")
 
-                school = School.objects.create(
-                    name=name,
-                    postcode=postcode,
-                    town=town,
-                    latitude=lat,
-                    longitude=lng,
-                    country=country,
-                )
+            school = School.objects.create(name=name, country=country)
 
-                teacher.school = school
-                teacher.is_admin = True
-                teacher.save()
+            teacher.school = school
+            teacher.is_admin = True
+            teacher.save()
 
-                messages.success(
-                    request,
-                    "The school or club '"
-                    + teacher.school.name
-                    + "' has been successfully added.",
-                )
+            messages.success(request, "The school or club '" + teacher.school.name + "' has been successfully added.")
 
-                return HttpResponseRedirect(reverse_lazy("onboarding-classes"))
-
-        elif "join_organisation" in request.POST:
-            process_join_form(
-                request, teacher, OrganisationJoinForm, OrganisationJoinForm
-            )
+            return HttpResponseRedirect(reverse_lazy("onboarding-classes"))
 
-        else:
-            return process_revoke_request(request, teacher)
-
-    res = render(
-        request,
-        "portal/teach/onboarding_school.html",
-        {"create_form": create_form, "join_form": join_form, "teacher": teacher},
-    )
+    res = render(request, "portal/teach/onboarding_school.html", {"create_form": create_form, "teacher": teacher})
 
     return res
 
 
-def compute_input_join_form(
-    OrganisationJoinFormWithCaptcha, OrganisationJoinForm, using_captcha
-):
-    InputOrganisationJoinForm = (
-        OrganisationJoinFormWithCaptcha if using_captcha else OrganisationJoinForm
-    )
-    return InputOrganisationJoinForm
-
-
-def compute_output_join_form(
-    OrganisationJoinFormWithCaptcha, OrganisationJoinForm, should_use_captcha
-):
-    OutputOrganisationJoinForm = (
-        OrganisationJoinFormWithCaptcha if should_use_captcha else OrganisationJoinForm
-    )
-    return OutputOrganisationJoinForm
-
-
-def send_pending_requests_emails(school, email_message):
-    for admin in Teacher.objects.filter(school=school, is_admin=True):
-        send_email(
-            NOTIFICATION_EMAIL,
-            [admin.new_user.email],
-            email_message["subject"],
-            email_message["message"],
-        )
-
-
-def process_join_form(
-    request, teacher, InputOrganisationJoinForm, OutputOrganisationJoinForm
-):
-    join_form = InputOrganisationJoinForm(request.POST)
-    if join_form.is_valid():
-        school = get_object_or_404(School, id=join_form.cleaned_data["chosen_org"])
-
-        teacher.pending_join_request = school
-        teacher.save()
-
-        email_message = email_messages.joinRequestPendingEmail(
-            request, teacher.new_user.email
-        )
-
-        send_pending_requests_emails(school, email_message)
-
-        email_message = email_messages.joinRequestSentEmail(request, school.name)
-        send_email(
-            NOTIFICATION_EMAIL,
-            [teacher.new_user.email],
-            email_message["subject"],
-            email_message["message"],
-        )
-
-        messages.success(
-            request,
-            "Your request to join a school or club has been sent.",
-        )
-
-        return render(
-            request,
-            "portal/teach/onboarding_school.html",
-            {"school": school, "teacher": teacher},
-        )
-
-    else:
-        join_form = OutputOrganisationJoinForm(request.POST)
-
-
-def process_revoke_request(request, teacher):
-    if "revoke_join_request" in request.POST:
-        teacher.pending_join_request = None
-        teacher.save()
-
-        messages.success(
-            request,
-            "Your request to join the school or club has been revoked successfully.",
-        )
-
-        return HttpResponseRedirect(reverse_lazy("onboarding-organisation"))
-
-
 @login_required(login_url=reverse_lazy("teacher_login"))
-@user_passes_test(
-    permissions.logged_in_as_teacher, login_url=reverse_lazy("teacher_login")
-)
+@user_passes_test(permissions.logged_in_as_teacher, login_url=reverse_lazy("teacher_login"))
 def organisation_manage(request):
     return organisation_create(request)
 
 
 @login_required(login_url=reverse_lazy("teacher_login"))
-@user_passes_test(
-    permissions.logged_in_as_teacher, login_url=reverse_lazy("teacher_login")
-)
+@user_passes_test(permissions.logged_in_as_teacher, login_url=reverse_lazy("teacher_login"))
 def organisation_leave(request):
     teacher = request.user.new_teacher
 

portal/views/registration.py

@@ -1,30 +1,46 @@
-from common.helpers.emails import PASSWORD_RESET_EMAIL
-from common.models import Teacher, Student
-from common.permissions import not_logged_in, not_fully_logged_in
+import ast
+import re
+from datetime import datetime
+
+from common.helpers.emails import (
+    NOTIFICATION_EMAIL,
+    PASSWORD_RESET_EMAIL,
+    delete_contact,
+    send_email,
+)
+from common.mail import campaign_ids, send_dotdigital_email
+from common.models import DailyActivity, Student, Teacher
+from common.permissions import not_fully_logged_in, not_logged_in
+from django.contrib import messages as messages
 from django.contrib.auth import get_user_model
-from django.contrib.auth.decorators import user_passes_test
+from django.contrib.auth.decorators import login_required, user_passes_test
 from django.contrib.auth.forms import PasswordResetForm, SetPasswordForm
+from django.contrib.auth.models import User
 from django.contrib.auth.tokens import default_token_generator
+from django.http import HttpResponseRedirect
 from django.shortcuts import render
 from django.template.response import TemplateResponse
 from django.urls import reverse_lazy
-from django.utils.encoding import force_text
+from django.utils.encoding import force_bytes
 from django.utils.http import urlsafe_base64_decode
-from django.utils.translation import ugettext as _
+from django.utils.translation import gettext as _
 from django.views.decorators.cache import never_cache
 from django.views.decorators.csrf import csrf_protect
 from django.views.decorators.debug import sensitive_post_parameters
+from django.views.decorators.http import require_POST
 
 from deploy import captcha
 from portal import app_settings
 from portal.forms.registration import (
-    TeacherPasswordResetForm,
-    TeacherPasswordResetSetPasswordForm,
     StudentPasswordResetForm,
     StudentPasswordResetSetPasswordForm,
+    TeacherPasswordResetForm,
+    TeacherPasswordResetSetPasswordForm,
 )
 from portal.helpers.captcha import remove_captcha_from_form
 from portal.helpers.ratelimit import clear_ratelimit_cache_for_user
+from portal.views.api import anonymise
+from portal.views.login import has_user_lockout_expired
 
 
 @user_passes_test(not_logged_in, login_url=reverse_lazy("home"))
@@ -39,6 +55,48 @@ def student_password_reset(request):
     )
 
 
+def blocked_and_not_expired(user: Student or Teacher):
+    return user.blocked_time and not has_user_lockout_expired(user)
+
+
+def school_student_reset_password_tracker(request, activity_today):
+    if "transfer_students" in request.POST:
+        student_list = ast.literal_eval(request.POST.get("transfer_students", []))
+        for student_id in student_list:
+            current_student = Student.objects.get(id=student_id)
+            if blocked_and_not_expired(current_student):
+                activity_today.school_student_lockout_resets += 1
+    elif "set_password" in request.POST:
+        student_id = re.search("/(\d+)/", request.path).group(1)
+        current_student = Student.objects.get(id=student_id)
+        if blocked_and_not_expired(current_student):
+            activity_today.school_student_lockout_resets += 1
+    activity_today.save()
+
+
+def teacher_or_indy_reset_password_tracker(request, activity_today, email):
+    get_user = Teacher.objects.filter(new_user__email=email) or Student.objects.filter(new_user__email=email)
+    if get_user.exists():
+        user = get_user[0]
+        if blocked_and_not_expired(user):
+            if "teacher" in request.path:
+                activity_today.teacher_lockout_resets += 1
+            elif "student" in request.path:
+                activity_today.indy_lockout_resets += 1
+            activity_today.save()
+
+
+def handle_reset_password_tracking(request, user_type, access_code=None, student_id=None):
+    activity_today = DailyActivity.objects.get_or_create(date=datetime.now().date())[0]
+    # school student has 2 different ways of resetting password
+    # hence the function is extended
+    # check for indy student or teacher account
+    if user_type == "SCHOOL_STUDENT":
+        school_student_reset_password_tracker(request, activity_today)
+    elif "email" in request.POST:
+        teacher_or_indy_reset_password_tracker(request, activity_today, request.POST.get("email", ""))
+
+
 @user_passes_test(not_fully_logged_in, login_url=reverse_lazy("teacher_login"))
 def teacher_password_reset(request):
     usertype = "TEACHER"
@@ -66,6 +124,7 @@ def password_reset(
     html_email_template_name=None,
 ):
     if request.method == "POST":
+        handle_reset_password_tracking(request, usertype)
         form = password_reset_form(request.POST)
         if not captcha.CAPTCHA_ENABLED:
             remove_captcha_from_form(form)
@@ -81,9 +140,7 @@ def password_reset(
             }
             form.save(**opts)
 
-            return render(
-                request, "portal/reset_password_email_sent.html", {"usertype": usertype}
-            )
+            return render(request, "portal/reset_password_email_sent.html", {"usertype": usertype})
     else:
         form = password_reset_form()
 
@@ -145,7 +202,7 @@ def password_reset_confirm(
     check_uidb64(uidb64, token)
 
     try:
-        uid = force_text(urlsafe_base64_decode(uidb64))
+        uid = force_bytes(urlsafe_base64_decode(uidb64))
         user = UserModel._default_manager.get(pk=uid)
     except (TypeError, ValueError, OverflowError, UserModel.DoesNotExist):
         user = None
@@ -163,9 +220,7 @@ def password_reset_confirm(
 
                 _check_and_unblock_user(user.username, usertype)
 
-                return render(
-                    request, "portal/reset_password_done.html", {"usertype": usertype}
-                )
+                return render(request, "portal/reset_password_done.html", {"usertype": usertype})
         else:
             form = set_password_form(user)
     else:
@@ -180,11 +235,13 @@ def password_reset_confirm(
     return TemplateResponse(request, template_name, context)
 
 
-def _check_and_unblock_user(username, usertype):
+def _check_and_unblock_user(username, usertype, access_code=None):
     if usertype == "TEACHER":
         user = Teacher.objects.get(new_user__username=username)
-    else:
+    elif usertype == "INDEP_STUDENT":
         user = Student.objects.get(new_user__username=username)
+    elif usertype == "SCHOOL_STUDENT":
+        user = Student.objects.get(new_user__first_name=username, class_field__access_code=access_code)
 
     if user.blocked_time is not None:
         user.blocked_time = None
@@ -230,3 +287,26 @@ def password_reset_check_and_confirm(request, uidb64=None, token=None):
             token=token,
             extra_context={"usertype": usertype},
         )
+
+
+@require_POST
+@login_required(login_url=reverse_lazy("teacher_login"))
+def delete_account(request):
+    user = request.user
+    password = request.POST.get("password")
+
+    if not user.check_password(password):
+        messages.error(request, "Your account was not deleted due to incorrect password.")
+        return HttpResponseRedirect(reverse_lazy("dashboard"))
+
+    email = user.email
+    anonymise(user)
+
+    # remove from dotmailer
+    if bool(request.POST.get("unsubscribe_newsletter")):
+        delete_contact(email)
+
+    # send confirmation email
+    send_dotdigital_email(campaign_ids["delete_account"], [email])
+
+    return HttpResponseRedirect(reverse_lazy("home"))

portal/views/student/edit_account_details.py

@@ -1,4 +1,9 @@
-from common.helpers.emails import update_email
+from common.helpers.emails import (
+    NOTIFICATION_EMAIL,
+    delete_contact,
+    send_email,
+    update_indy_email,
+)
 from common.models import Student
 from common.permissions import logged_in_as_student
 from django.contrib import messages as messages
@@ -6,12 +11,15 @@ from django.contrib.auth import logout
 from django.contrib.auth.decorators import login_required, user_passes_test
 from django.contrib.auth.mixins import LoginRequiredMixin
 from django.http import HttpResponseRedirect
+from django.shortcuts import render
 from django.urls import reverse_lazy
 from django.views.generic.edit import FormView
 
-from portal.forms.play import StudentEditAccountForm, IndependentStudentEditAccountForm
+from portal.forms.play import IndependentStudentEditAccountForm, StudentEditAccountForm
+from portal.forms.registration import DeleteAccountForm
 from portal.helpers.password import check_update_password
 from portal.helpers.ratelimit import clear_ratelimit_cache_for_user
+from portal.views.api import anonymise
 
 
 def _get_form(self, form_class):
@@ -68,9 +76,7 @@ class SchoolStudentEditAccountView(LoginRequiredMixin, FormView):
         # check not default value for CharField
         changing_password = check_update_password(form, student.new_user, request, data)
 
-        messages.success(
-            request, "Your account details have been changed successfully."
-        )
+        messages.success(request, "Your account details have been changed successfully.")
 
         if changing_password:
             logout(request)
@@ -84,86 +90,107 @@ class SchoolStudentEditAccountView(LoginRequiredMixin, FormView):
         return _get_form(self, form_class)
 
 
-class IndependentStudentEditAccountView(LoginRequiredMixin, FormView):
+def independentStudentEditAccountView(request):
     """
     A FormView for editing an independent student's account details. This forms enables
     an independent student to change their name, their email and / or their password.
-    """
+    Additionally it also deletes the independent students account with its second form
 
-    login_url = reverse_lazy("independent_student_login")
-    form_class = IndependentStudentEditAccountForm
+    Django class based views makes it very difficult to have multiple forms in one view,
+    hence using the functional based view
+    """
+    user = request.user
+    change_email_password_form = IndependentStudentEditAccountForm(user, initial={"name": user.first_name})
+    delete_account_form = DeleteAccountForm(user)
     template_name = "../templates/portal/play/student_edit_account.html"
-    model = Student
-    initial = {"name": "Could not find name"}
-    changing_email = False
-    changing_password = False
-
-    def get_form_kwargs(self):
-        kwargs = super(IndependentStudentEditAccountView, self).get_form_kwargs()
-        kwargs["initial"]["name"] = "{}{}".format(
-            self.request.user.first_name, self.request.user.last_name
-        )
-        return kwargs
-
-    def get_form(self, form_class=None):
-        return _get_form(self, form_class)
-
-    def get_success_url(self):
-        if self.changing_email:
-            return reverse_lazy("email_verification")
-        elif self.changing_password:
-            return reverse_lazy("independent_student_login")
-        else:
-            return reverse_lazy("independent_student_details")
-
-    def form_valid(self, form):
-        return _process_form(
-            self,
-            self.process_independent_student_edit_account_form,
-            form,
-            IndependentStudentEditAccountView,
-        )
+    delete_account_confirm = False
 
-    def process_independent_student_edit_account_form(self, form, student, request):
-        data = form.cleaned_data
-
-        # check not default value for CharField
-        self.changing_password = check_update_password(
-            form, student.new_user, request, data
-        )
+    def process_change_email_password_form(request, student, old_anchor):
+        change_email_password_form = IndependentStudentEditAccountForm(request.user, request.POST)
+        changing_email = False
+        changing_password = False
+        new_email = ""
+        if change_email_password_form.is_valid():
+            data = change_email_password_form.cleaned_data
+            # check not default value for CharField
+            changing_password = check_update_password(change_email_password_form, student, request, data)
 
-        # allow individual students to update more
-        self.changing_email, new_email = update_email(student, request, data)
+            changing_email, new_email = update_indy_email(student, request, data)
+            changing_first_name = False if request.POST["name"] == student.first_name else True
+            student.first_name = request.POST["name"]
 
-        self.update_name(student, data)
+            student.save()
 
-        # Reset ratelimit cache after successful account details update
-        clear_ratelimit_cache_for_user(student.new_user.username)
+            anchor = ""
 
-        messages.success(
-            request, "Your account details have been changed successfully."
-        )
+            # Reset ratelimit cache after successful account details update
+            clear_ratelimit_cache_for_user(student.username)
 
-        if self.changing_email:
-            logout(request)
-            messages.success(
-                request,
-                "Your email will be changed once you have verified it, until then "
-                "you can still log in with your old email.",
-            )
+            messages.success(request, "Your account details have been successfully changed.")
+        else:
+            anchor = old_anchor
 
-        if self.changing_password:
-            logout(request)
-            messages.success(
-                request,
-                "Please login using your new password.",
-            )
+        return changing_email, new_email, changing_password, changing_first_name, anchor
 
-    def update_name(self, student, data):
-        student.new_user.first_name = data["name"]
-        # save all tables
-        student.save()
-        student.new_user.save()
+    if request.method == "POST":
+        if "delete_account" in request.POST:
+            delete_account_form = DeleteAccountForm(user, request.POST)
+            if not delete_account_form.is_valid():
+                messages.warning(request, "Your account was not deleted due to incorrect password.")
+            else:
+                delete_account_confirm = True
+        else:
+            change_email_password_form = IndependentStudentEditAccountForm(request.user, request.POST)
+            if not change_email_password_form.is_valid():
+                messages.warning(request, "Your account was not updated do to incorrect details")
+                return render(
+                    request,
+                    template_name,
+                    {
+                        "form": change_email_password_form,
+                        "delete_account_form": delete_account_form,
+                    },
+                )
+            else:
+                (
+                    changing_email,
+                    new_email,
+                    changing_password,
+                    changing_first_name,
+                    anchor,
+                ) = process_change_email_password_form(request, request.user, "")
+                if changing_email:
+                    logout(request)
+                    messages.success(request, "Your account details have been changed successfully.")
+                    messages.success(
+                        request,
+                        "Your email will be changed once you have verified it, until then "
+                        "you can still log in with your old email.",
+                    )
+                    return render(
+                        request,
+                        "portal/email_verification_needed.html",
+                        {"usertype": "INDEP_STUDENT"},
+                    )
+                if changing_password:
+                    logout(request)
+                    messages.success(request, "Your account details have been changed successfully.")
+                    messages.success(request, "Please login using your new password.")
+                    return HttpResponseRedirect(reverse_lazy("independent_student_login"))
+
+                if changing_first_name:
+                    messages.success(request, "Your account details have been changed successfully.")
+                    return HttpResponseRedirect(reverse_lazy("independent_student_details"))
+
+    return render(
+        request,
+        template_name,
+        {
+            "form": change_email_password_form,
+            "delete_account_form": delete_account_form,
+            "delete_account_confirm": delete_account_confirm,
+        },
+    )
 
 
 @login_required(login_url=reverse_lazy("home"))