konova/compensation/views/compensation/compensation.py

"""
Author: Michel Peltriaux
Organization: Struktur- und Genehmigungsdirektion Nord, Rhineland-Palatinate, Germany
Contact: ksp-servicestelle@sgdnord.rlp.de
Created on: 19.08.22

"""
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin
from django.core.exceptions import ObjectDoesNotExist
from django.http import HttpRequest, JsonResponse
from django.shortcuts import get_object_or_404, render, redirect
from django.urls import reverse
from django.utils.translation import gettext_lazy as _

from compensation.forms.compensation import EditCompensationForm, NewCompensationForm
from compensation.models import Compensation
from compensation.tables.compensation import CompensationTable
from intervention.models import Intervention
from konova.decorators import shared_access_required, default_group_required, login_required_modal
from konova.forms.modals import RemoveModalForm
from konova.utils.message_templates import COMPENSATION_REMOVED_TEMPLATE, DATA_CHECKED_PREVIOUSLY_TEMPLATE, \
    RECORDED_BLOCKS_EDIT, PARAMS_INVALID
from konova.views.base import BaseIndexView, BaseIdentifierGeneratorView, BaseNewSpatialLocatedObjectFormView, \
    BaseEditSpatialLocatedObjectFormView
from konova.views.detail import BaseDetailView
from konova.views.remove import BaseRemoveModalFormView


class CompensationIndexView(LoginRequiredMixin, BaseIndexView):
    _TAB_TITLE = _("Compensations - Overview")
    _INDEX_TABLE_CLS = CompensationTable

    def _get_queryset(self):
        qs = Compensation.objects.filter(
            deleted=None,  # only show those which are not deleted individually
            intervention__deleted=None,  # and don't show the ones whose intervention has been deleted
        ).order_by(
            "-modified__timestamp"
        )
        return qs


class NewCompensationFormView(BaseNewSpatialLocatedObjectFormView):
    _FORM_CLS = NewCompensationForm
    _MODEL_CLS = Compensation
    _TEMPLATE = "compensation/form/view.html"
    _TAB_TITLE = _("New Compensation")
    _REDIRECT_URL = "compensation:detail"

    def _user_has_shared_access(self, user, **kwargs):
        # On a new compensation make sure the intervention (if call came directly through an intervention's detail
        # view) is shared with the user
        intervention_id = kwargs.get("intervention_id", None)
        if not intervention_id:
            return True
        else:
            intervention = get_object_or_404(Intervention, id=intervention_id)
            return intervention.is_shared_with(user)

    def _user_has_permission(self, user, **kwargs):
        # User has to be an ets user
        return user.is_default_user()

    def dispatch(self, request, *args, **kwargs):
        # Make sure there is an existing intervention based on the given id
        # Compensations can not exist without an intervention
        intervention_id = kwargs.get("intervention_id", None)
        if intervention_id:
            try:
                intervention = Intervention.objects.get(id=intervention_id)
                if intervention.is_recorded:
                    messages.info(
                        request,
                        RECORDED_BLOCKS_EDIT
                    )
                    return redirect("intervention:detail", id=intervention_id)
            except ObjectDoesNotExist:
                messages.error(request, PARAMS_INVALID, extra_tags="danger")
                return redirect("home")
        return super().dispatch(request, *args, **kwargs)


class EditCompensationFormView(BaseEditSpatialLocatedObjectFormView):
    _MODEL_CLS = Compensation
    _FORM_CLS = EditCompensationForm
    _TEMPLATE = "compensation/form/view.html"
    _REDIRECT_URL = "compensation:detail"

    def _user_has_permission(self, user, **kwargs):
        # User has to be a default user
        return user.is_default_user()


class CompensationIdentifierGeneratorView(LoginRequiredMixin, BaseIdentifierGeneratorView):
    _MODEL_CLS = Compensation
    _REDIRECT_URL = "compensation:index"


class CompensationDetailView(BaseDetailView):
    _MODEL_CLS = Compensation
    _TEMPLATE = "compensation/detail/compensation/view.html"

    def _get_object(self, id: str):
        """ Returns the compensation

        Args:
            id (str): The compensation's id

        Returns:
            obj (Compensation): The compensation
        """
        comp = get_object_or_404(
            Compensation.objects.select_related(
                "modified",
                "created",
                "geometry"
            ),
            id=id,
            deleted=None,
            intervention__deleted=None,
        )
        return comp

    def _get_detail_context(self, obj: Compensation):
        """ Generate object specific detail context for  view

        Args:
            obj (): The record

        Returns:

        """
        # Order states according to surface
        before_states = obj.before_states.all().prefetch_related("biotope_type").order_by("-surface")
        after_states = obj.after_states.all().prefetch_related("biotope_type").order_by("-surface")
        actions = obj.actions.all().prefetch_related("action_type")

        # Precalculate logical errors between before- and after-states
        # Sum() returns None in case of no states, so we catch that and replace it with 0 for easier handling
        sum_before_states = obj.get_surface_before_states()
        sum_after_states = obj.get_surface_after_states()
        diff_states = abs(sum_before_states - sum_after_states)

        last_checked = obj.intervention.get_last_checked_action()
        last_checked_tooltip = ""
        if last_checked:
            last_checked_tooltip = DATA_CHECKED_PREVIOUSLY_TEMPLATE.format(
                last_checked.get_timestamp_str_formatted(),
                last_checked.user
            )

        context = {
            "last_checked": last_checked,
            "last_checked_tooltip": last_checked_tooltip,
            "actions": actions,
            "before_states": before_states,
            "after_states": after_states,
            "sum_before_states": sum_before_states,
            "sum_after_states": sum_after_states,
            "diff_states": diff_states,
            "has_finished_deadlines": obj.get_finished_deadlines().exists(),
        }
        return context


class RemoveCompensationView(LoginRequiredMixin, BaseRemoveModalFormView):
    _MODEL_CLS = Compensation
    _FORM_CLS = RemoveModalForm
    _REDIRECT_URL = "compensation:index"

    def _user_has_permission(self, user, **kwargs):
        return user.is_default_user()