views.py

from contextlib import nullcontext
from copy import deepcopy
from datetime import date, datetime, timedelta
from typing import Any, Dict, Optional

from django.apps import apps
from django.core.exceptions import PermissionDenied
from django.db.models import Count, Exists, FilteredRelation, OuterRef, Prefetch, Q, Sum
from django.db.models.expressions import Case, When
from django.db.models.functions import Extract
from django.http import Http404, HttpRequest, HttpResponse, HttpResponseNotFound
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse, reverse_lazy
from django.utils import timezone
from django.utils.decorators import method_decorator
from django.utils.http import url_has_allowed_host_and_scheme
from django.utils.translation import ugettext as _
from django.views import View
from django.views.decorators.cache import never_cache
from django.views.generic import DetailView, TemplateView

import reversion
from calendarweek import CalendarWeek
from django_tables2 import RequestConfig, SingleTableView
from guardian.core import ObjectPermissionChecker
from guardian.shortcuts import get_objects_for_user
from reversion.views import RevisionMixin
from rules.contrib.views import PermissionRequiredMixin, permission_required

from aleksis.apps.chronos.managers import TimetableType
from aleksis.apps.chronos.models import (
    Event,
    ExtraLesson,
    Holiday,
    Lesson,
    LessonPeriod,
    TimePeriod,
)
from aleksis.apps.chronos.util.build import build_weekdays
from aleksis.apps.chronos.util.date import (
    get_current_year,
    get_weeks_for_year,
    week_weekday_to_date,
)
from aleksis.core.mixins import (
    AdvancedCreateView,
    AdvancedDeleteView,
    AdvancedEditView,
    SuccessNextMixin,
)
from aleksis.core.models import Group, Person, SchoolTerm
from aleksis.core.util import messages
from aleksis.core.util.core_helpers import get_site_preferences, objectgetter_optional
from aleksis.core.util.pdf import render_pdf
from aleksis.core.util.predicates import check_global_permission

from .filters import PersonalNoteFilter
from .forms import (
    AssignGroupRoleForm,
    ExcuseTypeForm,
    ExtraMarkForm,
    FilterRegisterObjectForm,
    GroupRoleAssignmentEditForm,
    GroupRoleForm,
    LessonDocumentationForm,
    PersonalNoteFormSet,
    PersonOverviewForm,
    RegisterAbsenceForm,
    RegisterObjectActionForm,
    SelectForm,
)
from .models import (
    ExcuseType,
    ExtraMark,
    GroupRole,
    GroupRoleAssignment,
    LessonDocumentation,
    PersonalNote,
)
from .tables import (
    ExcuseTypeTable,
    ExtraMarkTable,
    GroupRoleTable,
    PersonalNoteTable,
    RegisterObjectSelectTable,
    RegisterObjectTable,
)
from .util.alsijil_helpers import (
    annotate_documentations,
    generate_list_of_all_register_objects,
    get_register_object_by_pk,
    get_timetable_instance_by_pk,
    register_objects_sorter,
)


@permission_required("alsijil.view_register_object_rule", fn=get_register_object_by_pk)  # FIXME
def register_object(
    request: HttpRequest,
    model: Optional[str] = None,
    year: Optional[int] = None,
    week: Optional[int] = None,
    id_: Optional[int] = None,
) -> HttpResponse:
    context = {}

    register_object = get_register_object_by_pk(request, model, year, week, id_)

    if id_ and model == "lesson":
        wanted_week = CalendarWeek(year=year, week=week)
    elif id_ and model == "extra_lesson":
        wanted_week = register_object.calendar_week
    elif hasattr(request, "user") and hasattr(request.user, "person"):
        wanted_week = CalendarWeek()
    else:
        wanted_week = None

    if not all((year, week, id_)):
        if register_object and model == "lesson":
            return redirect(
                "lesson_period",
                wanted_week.year,
                wanted_week.week,
                register_object.pk,
            )
        elif not register_object:
            raise Http404(
                _(
                    "You either selected an invalid lesson or "
                    "there is currently no lesson in progress."
                )
            )

    date_of_lesson = (
        week_weekday_to_date(wanted_week, register_object.period.weekday)
        if not isinstance(register_object, Event)
        else register_object.date_start
    )
    start_time = (
        register_object.period.time_start
        if not isinstance(register_object, Event)
        else register_object.period_from.time_start
    )

    if isinstance(register_object, Event):
        register_object.annotate_day(date_of_lesson)
    if isinstance(register_object, LessonPeriod) and (
        date_of_lesson < register_object.lesson.validity.date_start
        or date_of_lesson > register_object.lesson.validity.date_end
    ):
        return HttpResponseNotFound()

    if (
        datetime.combine(date_of_lesson, start_time) > datetime.now()
        and not (
            get_site_preferences()["alsijil__open_periods_same_day"]
            and date_of_lesson <= datetime.now().date()
        )
        and not request.user.is_superuser
    ):
        raise PermissionDenied(
            _("You are not allowed to create a lesson documentation for a lesson in the future.")
        )

    holiday = Holiday.on_day(date_of_lesson)
    blocked_because_holidays = (
        holiday is not None and not get_site_preferences()["alsijil__allow_entries_in_holidays"]
    )
    context["blocked_because_holidays"] = blocked_because_holidays
    context["holiday"] = holiday

    next_lesson = (
        request.user.person.next_lesson(register_object, date_of_lesson)
        if isinstance(register_object, LessonPeriod)
        else None
    )
    prev_lesson = (
        request.user.person.previous_lesson(register_object, date_of_lesson)
        if isinstance(register_object, LessonPeriod)
        else None
    )
    back_url = reverse(
        "lesson_period", args=[wanted_week.year, wanted_week.week, register_object.pk]
    )
    context["back_url"] = back_url

    context["register_object"] = register_object
    context["week"] = wanted_week
    context["day"] = date_of_lesson
    context["next_lesson_person"] = next_lesson
    context["prev_lesson_person"] = prev_lesson
    context["prev_lesson"] = (
        register_object.prev if isinstance(register_object, LessonPeriod) else None
    )
    context["next_lesson"] = (
        register_object.next if isinstance(register_object, LessonPeriod) else None
    )

    if not blocked_because_holidays:
        groups = register_object.get_groups().all()