views.py

from __future__ import annotations
from django import forms
from django.utils.timezone import now
from django.views.generic import TemplateView
from django.views.generic.edit import UpdateView, FormView
from django.core.exceptions import PermissionDenied
from django.urls import reverse
from backend.mixins import VisitPersonMixin
from nm2.lib.forms import BootstrapAttrsMixin
import backend.models as bmodels
import dsa.models as dmodels
import legacy.models as lmodels
from backend import const
import datetime
import markdown
import json


class Person(VisitPersonMixin, TemplateView):
    template_name = "person/person.html"

    def get_context_data(self, **kw):
        from django.db.models import Min, Max
        ctx = super().get_context_data(**kw)

        processes = lmodels.Process.objects \
                           .filter(person=self.person) \
                           .annotate(started=Min("log__logdate"), ended=Max("log__logdate")) \
                           .order_by("is_active", "ended")

        import process.models as pmodels
        processes2 = pmodels.Process.objects.filter(person=self.person).order_by("-closed_time")

        adv_processes2 = []
        for req in pmodels.Requirement.objects.filter(
                type="advocate", statements__uploaded_by=self.person).distinct().select_related("process"):
            adv_processes2.append(req.process)

        try:
            am = bmodels.AM.objects.get(person=self.person)
        except bmodels.AM.DoesNotExist:
            am = None

        if am is not None:
            am_processes = lmodels.Process.objects.filter(manager=am) \
                    .annotate(started=Min("log__logdate"), ended=Max("log__logdate")) \
                    .order_by("is_active", "ended")

            am_processes2 = pmodels.Process.objects.filter(ams__am=am).distinct()
            count_processed = len(am_processes) + len(am_processes2)
        else:
            am_processes = []
            am_processes2 = []
            count_processed = 0

        audit_log = []
        if "view_person_audit_log" in self.visit_perms:
            for e in self.person.audit_log.order_by("-logdate"):
                if self.request.user.is_superuser:
                    changes = sorted((k, v[0], v[1]) for k, v in list(json.loads(e.changes).items()))
                else:
                    changes = sorted((k, v[0], v[1]) for k, v in list(json.loads(e.changes).items())
                                     if k not in ("fd_comment", "pending"))
                audit_log.append({
                    "logdate": e.logdate,
                    "author": e.author,
                    "notes": e.notes,
                    "changes": changes,
                })

        show_new_change_warning = (
                self.person.status in (const.STATUS_DD_U, const.STATUS_DD_NU)
                and self.person.status_changed + datetime.timedelta(days=15) > now())

        ctx.update(
            am=am,
            processes=processes,
            processes2=processes2,
            am_processes=am_processes,
            am_processes2=am_processes2,
            adv_processes=(lmodels.Process.objects.filter(advocates=self.person)
                           .annotate(started=Min("log__logdate"), ended=Max("log__logdate"))
                           .order_by("is_active", "ended")),
            adv_processes2=adv_processes2,
            audit_log=audit_log,
            show_new_change_warning=show_new_change_warning,
            count_processed=count_processed,
            picture=self.person.get_picture_url(),
        )

        if self.person.bio:
            ctx["bio_html"] = markdown.markdown(self.person.bio, safe_mode="escape")
        else:
            ctx["bio_html"] = ""

        return ctx


class EditLDAP(VisitPersonMixin, UpdateView):
    """
    Edit a person's information
    """
    require_visit_perms = "edit_ldap"
    model = dmodels.LDAPFields
    fields = ("cn", "mn", "sn", "email", "uid")
    template_name = "person/edit_ldap.html"

    def get_form_class(self):
        class Form(BootstrapAttrsMixin, super().get_form_class()):
            pass
        return Form

    def get_object(self):
        return self.person.ldap_fields

    def form_valid(self, form):
        """
        If the form is valid, save the associated model.
        """
        self.object = form.save(commit=False)
        self.object.save(audit_author=self.request.user, audit_notes="edited LDAP information")
        return super(EditLDAP, self).form_valid(form)


class EditBio(VisitPersonMixin, UpdateView):
    """
    Edit a person's information
    """
    require_visit_perms = "edit_bio"
    model = bmodels.Person
    fields = ("fullname", "bio")
    template_name = "person/edit_bio.html"

    def get_form_class(self):
        class Form(BootstrapAttrsMixin, super().get_form_class()):
            pass
        return Form

    def get_object(self):
        return self.person

    def form_valid(self, form):
        """
        If the form is valid, save the associated model.
        """
        self.object = form.save(commit=False)
        self.object.save(audit_author=self.request.user, audit_notes="edited bio information")
        return super(EditBio, self).form_valid(form)


class EditEmail(VisitPersonMixin, UpdateView):
    """
    Edit a person's information
    """
    require_visit_perms = "edit_email"
    model = bmodels.Person
    fields = ("email",)
    template_name = "person/edit_email.html"

    def get_form_class(self):
        class Form(BootstrapAttrsMixin, super().get_form_class()):
            pass
        return Form

    def get_object(self):
        return self.person

    def form_valid(self, form):
        """
        If the form is valid, save the associated model.
        """
        self.object = form.save(commit=False)
        self.object.save(audit_author=self.request.user, audit_notes="edited email")
        return super(EditEmail, self).form_valid(form)


class AMProfile(VisitPersonMixin, FormView):
    # Require DD instead of AM to give access to inactive AMs
    require_visitor = "dd"
    template_name = "person/amprofile.html"

    def load_objects(self):
        super().load_objects()
        try:
            self.am = bmodels.AM.objects.get(person=self.person)
        except bmodels.AM.DoesNotExist:
            self.am = None

        if self.request.user.is_authenticated:
            try:
                self.visitor_am = bmodels.AM.objects.get(person=self.request.user)
            except bmodels.AM.DoesNotExist:
                self.visitor_am = None
        else:
            self.visitor_am = None

    def check_permissions(self):
        super().check_permissions()
        if self.am is None:
            raise PermissionDenied
        if self.visitor_am is None:
            raise PermissionDenied
        if self.person.pk != self.request.user.pk and not self.request.user.is_superuser:
            raise PermissionDenied

    def get_form_class(self):
        includes = ["slots", "is_am"]

        if self.visitor_am.is_fd:
            includes.append("is_fd")
        if self.visitor_am.is_dam:
            includes.append("is_dam")
        if self.request.user.is_superuser:
            includes.append("fd_comment")

        class AMForm(BootstrapAttrsMixin, forms.ModelForm):
            class Meta:
                model = bmodels.AM
                fields = includes
        return AMForm

    def get_form_kwargs(self):
        res = super().get_form_kwargs()
        res["instance"] = self.am
        return res

    def get_context_data(self, **kw):
        ctx = super().get_context_data(**kw)
        ctx["am"] = self.am
        return ctx

    def form_valid(self, form):
        form.save()
        return self.render_to_response(self.get_context_data(form=form))


class Identities(VisitPersonMixin, TemplateView):
    template_name = "person/identities.html"
    require_visit_perms = "view_person_audit_log"

    def get_context_data(self, **kw):
        ctx = super().get_context_data(**kw)
        ctx["identities"] = self.person.identities.all()
        return ctx


class Certificate(VisitPersonMixin, TemplateView):
    template_name = "person/certificate.html"
    require_visit_perms = "view_certificate"

    def check_permissions(self):
        super().check_permissions()

        if not self.person.is_dd:
            raise PermissionDenied

    def get_context_data(self, **kw):
        ctx = super().get_context_data(**kw)

        ctx.update(
            upload_rights=self.person.status == const.STATUS_DD_U,
            today=datetime.date.today(),
            check_url=self.request.build_absolute_uri(
                reverse("person:show", kwargs={"key": self.person.lookup_key})),
        )

        return ctx