Merge pull request 'master' (#499) from master into Docker

Reviewed-on: #499

Dockerfile

@@ -0,0 +1,36 @@
+# Nutze ein schlankes Python-Image
+FROM python:3.11-slim-bullseye
+
+ENV PYTHONUNBUFFERED 1
+
+WORKDIR /konova
+
+# Installiere System-Abhängigkeiten
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gdal-bin redis-server nginx \
+    && rm -rf /var/lib/apt/lists/*  # Platz sparen
+
+# Erstelle benötigte Verzeichnisse & setze Berechtigungen
+RUN mkdir -p /var/log/nginx /var/log/gunicorn /var/lib/nginx /tmp/nginx_client_body \
+    && touch /var/log/nginx/access.log /var/log/nginx/error.log \
+    && chown -R root:root /var/log/nginx /var/lib/nginx /tmp/nginx_client_body
+
+# Kopiere und installiere Python-Abhängigkeiten
+COPY ./requirements.txt /konova/
+RUN pip install --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+# Entferne Standard-Nginx-Site und ersetze sie durch eigene Config
+RUN rm -rf /etc/nginx/sites-enabled/default
+COPY ./nginx.conf /etc/nginx/conf.d
+
+# Kopiere restliche Projektdateien
+COPY . /konova/
+
+# Sammle statische Dateien
+RUN python manage.py collectstatic --noinput
+
+# Exponiere Ports
+#EXPOSE 80 6379 8000
+
+# Setze Entrypoint
+ENTRYPOINT ["/konova/docker-entrypoint.sh"]

README.md

@@ -4,6 +4,7 @@ the database postgresql and the css library bootstrap as well as the icon packag
 fontawesome for a modern look, following best practices from the industry.
 
 ## Background processes
+### !!! For non-docker run
 Konova uses celery for background processing. To start the worker you need to run
 ```shell
 $ celery -A konova worker -l INFO
@@ -18,3 +19,58 @@ Technical documention is provided in the projects git wiki.
 A user documentation is not available (and not needed, yet). 
 
 
+# Docker 
+To run the docker-compose as expected, you need to take the following steps:
+
+1. Create a database containing docker, using an appropriate Dockerfile, e.g. the following
+```
+version: '3.3'
+services:
+  postgis:
+    image: postgis/postgis
+    restart: always
+    container_name: postgis-docker
+    ports: 
+      - 5433:5432
+    volumes:
+      - db-volume:/var/lib/postgresql/data
+    environment:
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_USER=postgres
+    networks:
+      - db-network-bridge
+
+networks:
+  db-network-bridge:
+    driver: "bridge"
+
+volumes:
+  db-volume:
+```
+This Dockerfile creates a Docker container running postgresql and postgis, creates the default superuser postgres, 
+creates a named volume for persisting the database and creates a new network bridge, which **must be used by any other
+container, which wants to write/read on this database**. 
+
+2. Make sure the name of the network bridge above matches the network in the konova docker-compose.yml  
+3. Get into the running postgis container (`docker exec -it postgis-docker bash`) and create new databases, users and so on. Make sure the database `konova` exists now!
+4. Replace all `CHANGE_ME_xy` values inside of konova/docker-compose.yml for your installation. Make sure the `SSO_HOST` holds the proper SSO host, e.g. for the arnova project `arnova.example.org` (Arnova must be installed and the webserver configured as well, of course)
+5. Take a look on konova/settings.py and konova/sub_settings/django_settings.py. Again: Replace all occurences of `CHANGE_ME` with proper values for your installation.
+   1. Make sure you have the proper host strings added to `ALLOWED_HOSTS` inside of django_settings.py.  
+6. Build and run the docker setup using `docker-compose build` and `docker-compose start` from the main directory of this project (where the docker-compose.yml lives)
+7. Run migrations! To do so, get into the konova service container (`docker exec -it konova-docker bash`) and run the needed commands (`python manage.py makemigrations LIST_OF_ALL_MIGRATABLE_APPS`, then `python manage.py migrate`)
+8. Run the setup command `python manage.py setup` and follow the instructions on the CLI
+9. To enable **SMTP** mail support, make sure your host machine (the one where the docker container run) has the postfix service configured properly. Make sure the `mynetworks` variable is xtended using the docker network bridge ip, created in the postgis container and used by the konova services.
+   1. **Hint**: You can find out this easily by trying to perform a test mail in the running konova web application (which will fail, of course). Then take a look to the latest entries in `/var/log/mail.log` on your host machine. The failed IP will be displayed there.
+   2. **Please note**: This installation guide is based on SMTP using postfix! 
+   3. Restart the postfix service on your host machine to reload the new configuration (`service postfix restart`)
+10. Finally, make sure your host machine webserver passes incoming requests properly to the docker nginx webserver of konova. A proper nginx config for the host machine may look like this:
+```
+server {
+    server_name konova.domain.org;
+
+    location / {
+        proxy_pass http://localhost:KONOVA_NGINX_DOCKER_PORT/;
+        proxy_set_header Host $host;
+    }
+}
+```

compensation/admin.py

@@ -45,14 +45,6 @@ class AbstractCompensationAdmin(BaseObjectAdmin):
         states = "\n".join(states)
         return states
 
-    def get_actions(self, request):
-        DELETE_ACTION_IDENTIFIER = "delete_selected"
-        actions = super().get_actions(request)
-
-        if DELETE_ACTION_IDENTIFIER in actions:
-            del actions[DELETE_ACTION_IDENTIFIER]
-
-        return actions
 
 class CompensationAdmin(AbstractCompensationAdmin):
     autocomplete_fields = [

compensation/forms/eco_account.py

@@ -15,7 +15,6 @@ from compensation.models import EcoAccount
 from intervention.models import Handler, Responsibility, Legal
 from konova.forms import SimpleGeomForm
 from konova.forms.modals import RemoveModalForm
-from konova.settings import ETS_GROUP
 from konova.utils import validators
 from user.models import User, UserActionLogEntry
 
@@ -247,13 +246,4 @@ class RemoveEcoAccountModalForm(RemoveModalForm):
                 "confirm",
                 _("The account can not be removed, since there are still deductions.")
             )
-
-            # If there are deductions but the performing user is not part of an ETS group, we assume this poor
-            # fella does not know what he/she does -> give a hint that they should contact someone in charge...
-            user_is_ets_user = self.user.in_group(ETS_GROUP)
-            if not user_is_ets_user:
-                self.add_error(
-                    "confirm",
-                    _("Please contact the responsible conservation office to find a solution!")
-                )
         return super_valid and not has_deductions

compensation/templates/compensation/detail/eco_account/includes/deductions.html

@@ -53,7 +53,7 @@
                 </td>
                 <td class="align-middle">
                     {% if deduction.intervention.recorded %}
-                        <em title="{% trans 'Recorded on' %} {{deduction.intervention.recorded.timestamp}} {% trans 'by' %} {{deduction.intervention.recorded.user}}" class='fas fa-bookmark registered-bookmark'></em>
+                        <em title="{% trans 'Recorded on' %} {{obj.recorded.timestamp}} {% trans 'by' %} {{obj.recorded.user}}" class='fas fa-bookmark registered-bookmark'></em>
                     {% else %}
                         <em title="{% trans 'Not recorded yet' %}" class='far fa-bookmark'></em>
                     {% endif %}

compensation/urls/compensation.py

@@ -7,32 +7,30 @@ Created on: 24.08.21
 """
 from django.urls import path
 
-from compensation.views.compensation.detail import DetailCompensationView
 from compensation.views.compensation.document import EditCompensationDocumentView, NewCompensationDocumentView, \
     GetCompensationDocumentView, RemoveCompensationDocumentView
-from compensation.views.compensation.remove import RemoveCompensationView
 from compensation.views.compensation.resubmission import CompensationResubmissionView
-from compensation.views.compensation.report import CompensationPublicReportView
+from compensation.views.compensation.report import report_view
 from compensation.views.compensation.deadline import NewCompensationDeadlineView, EditCompensationDeadlineView, \
     RemoveCompensationDeadlineView
 from compensation.views.compensation.action import NewCompensationActionView, EditCompensationActionView, \
     RemoveCompensationActionView
 from compensation.views.compensation.state import NewCompensationStateView, EditCompensationStateView, \
     RemoveCompensationStateView
-from compensation.views.compensation.compensation import IndexCompensationView, CompensationIdentifierGeneratorView, \
+from compensation.views.compensation.compensation import index_view, new_view, new_id_view, detail_view, edit_view, \
-    EditCompensationView, NewCompensationView
+    remove_view
 from compensation.views.compensation.log import CompensationLogView
 
 urlpatterns = [
     # Main compensation
-    path("", IndexCompensationView.as_view(), name="index"),
+    path("", index_view, name="index"),
-    path('new/id', CompensationIdentifierGeneratorView.as_view(), name='new-id'),
+    path('new/id', new_id_view, name='new-id'),
-    path('new/<intervention_id>', NewCompensationView.as_view(), name='new'),
+    path('new/<intervention_id>', new_view, name='new'),
-    path('new', NewCompensationView.as_view(), name='new'),
+    path('new', new_view, name='new'),
-    path('<id>', DetailCompensationView.as_view(), name='detail'),
+    path('<id>', detail_view, name='detail'),
     path('<id>/log', CompensationLogView.as_view(), name='log'),
-    path('<id>/edit', EditCompensationView.as_view(), name='edit'),
+    path('<id>/edit', edit_view, name='edit'),
-    path('<id>/remove', RemoveCompensationView.as_view(), name='remove'),
+    path('<id>/remove', remove_view, name='remove'),
 
     path('<id>/state/new', NewCompensationStateView.as_view(), name='new-state'),
     path('<id>/state/<state_id>/edit', EditCompensationStateView.as_view(), name='state-edit'),
@@ -45,7 +43,7 @@ urlpatterns = [
     path('<id>/deadline/new', NewCompensationDeadlineView.as_view(), name="new-deadline"),
     path('<id>/deadline/<deadline_id>/edit', EditCompensationDeadlineView.as_view(), name='deadline-edit'),
     path('<id>/deadline/<deadline_id>/remove', RemoveCompensationDeadlineView.as_view(), name='deadline-remove'),
-    path('<id>/report', CompensationPublicReportView.as_view(), name='report'),
+    path('<id>/report', report_view, name='report'),
     path('<id>/resub', CompensationResubmissionView.as_view(), name='resubmission-create'),
 
     # Documents

compensation/urls/eco_account.py

@@ -8,13 +8,11 @@ Created on: 24.08.21
 from django.urls import path
 
 from compensation.autocomplete.eco_account import EcoAccountAutocomplete
-from compensation.views.eco_account.detail import DetailEcoAccountView
+from compensation.views.eco_account.eco_account import index_view, new_view, new_id_view, edit_view, remove_view, \
-from compensation.views.eco_account.eco_account import IndexEcoAccountView, EcoAccountIdentifierGeneratorView, \
+    detail_view
-    NewEcoAccountView, EditEcoAccountView
 from compensation.views.eco_account.log import EcoAccountLogView
 from compensation.views.eco_account.record import EcoAccountRecordView
-from compensation.views.eco_account.remove import RemoveEcoAccountView
+from compensation.views.eco_account.report import report_view
-from compensation.views.eco_account.report import EcoAccountPublicReportView
 from compensation.views.eco_account.resubmission import EcoAccountResubmissionView
 from compensation.views.eco_account.state import NewEcoAccountStateView, EditEcoAccountStateView, \
     RemoveEcoAccountStateView
@@ -30,15 +28,15 @@ from compensation.views.eco_account.deduction import NewEcoAccountDeductionView,
 
 app_name = "acc"
 urlpatterns = [
-    path("", IndexEcoAccountView.as_view(), name="index"),
+    path("", index_view, name="index"),
-    path('new/', NewEcoAccountView.as_view(), name='new'),
+    path('new/', new_view, name='new'),
-    path('new/id', EcoAccountIdentifierGeneratorView.as_view(), name='new-id'),
+    path('new/id', new_id_view, name='new-id'),
-    path('<id>', DetailEcoAccountView.as_view(), name='detail'),
+    path('<id>', detail_view, name='detail'),
     path('<id>/log', EcoAccountLogView.as_view(), name='log'),
     path('<id>/record', EcoAccountRecordView.as_view(), name='record'),
-    path('<id>/report', EcoAccountPublicReportView.as_view(), name='report'),
+    path('<id>/report', report_view, name='report'),
-    path('<id>/edit', EditEcoAccountView.as_view(), name='edit'),
+    path('<id>/edit', edit_view, name='edit'),
-    path('<id>/remove', RemoveEcoAccountView.as_view(), name='remove'),
+    path('<id>/remove', remove_view, name='remove'),
     path('<id>/resub', EcoAccountResubmissionView.as_view(), name='resubmission-create'),
 
     path('<id>/state/new', NewEcoAccountStateView.as_view(), name='new-state'),

compensation/views/compensation/compensation.py

@@ -6,127 +6,91 @@ Created on: 19.08.22
 
 """
 from django.contrib import messages
-from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.auth.decorators import login_required
-from django.http import HttpRequest, HttpResponse
+from django.core.exceptions import ObjectDoesNotExist
+from django.db.models import Sum
+from django.http import HttpRequest, JsonResponse
 from django.shortcuts import get_object_or_404, render, redirect
-from django.utils.decorators import method_decorator
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
-from django.views import View
 
 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.contexts import BaseContext
-from konova.decorators import shared_access_required, default_group_required
+from konova.decorators import shared_access_required, default_group_required, any_group_check, login_required_modal, \
+    uuid_required
 from konova.forms import SimpleGeomForm
+from konova.forms.modals import RemoveModalForm
+from konova.settings import DEFAULT_GROUP, ZB_GROUP, ETS_GROUP
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.message_templates import RECORDED_BLOCKS_EDIT, CHECK_STATE_RESET, FORM_INVALID, PARAMS_INVALID, \
+from konova.utils.message_templates import COMPENSATION_REMOVED_TEMPLATE, DATA_CHECKED_PREVIOUSLY_TEMPLATE, \
-    IDENTIFIER_REPLACED, COMPENSATION_ADDED_TEMPLATE, GEOMETRY_SIMPLIFIED, GEOMETRIES_IGNORED_TEMPLATE
+    RECORDED_BLOCKS_EDIT, CHECK_STATE_RESET, FORM_INVALID, PARAMS_INVALID, IDENTIFIER_REPLACED, \
-from konova.views.identifier import AbstractIdentifierGeneratorView
+    COMPENSATION_ADDED_TEMPLATE, DO_NOT_FORGET_TO_SHARE, GEOMETRY_SIMPLIFIED, GEOMETRIES_IGNORED_TEMPLATE
-from konova.views.index import AbstractIndexView
 
 
-class IndexCompensationView(AbstractIndexView):
+@login_required
-    def get(self, request, *args, **kwargs) -> HttpResponse:
+@any_group_check
-        """
+def index_view(request: HttpRequest):
-        Renders the index view for compensation
+    """
+    Renders the index view for compensation
 
-        Args:
+    Args:
-            request (HttpRequest): The incoming request
+        request (HttpRequest): The incoming request
 
-        Returns:
+    Returns:
-            A rendered view
+        A rendered view
-        """
+    """
-        compensations = Compensation.objects.filter(
+    template = "generic_index.html"
-            deleted=None,  # only show those which are not deleted individually
+    compensations = Compensation.objects.filter(
-            intervention__deleted=None,  # and don't show the ones whose intervention has been deleted
+        deleted=None,  # only show those which are not deleted individually
-        ).order_by(
+        intervention__deleted=None,  # and don't show the ones whose intervention has been deleted
-            "-modified__timestamp"
+    ).order_by(
-        )
+        "-modified__timestamp"
-        table = CompensationTable(
+    )
-            request=request,
+    table = CompensationTable(
-            queryset=compensations
+        request=request,
-        )
+        queryset=compensations
-        context = {
+    )
-            "table": table,
+    context = {
-            TAB_TITLE_IDENTIFIER: _("Compensations - Overview"),
+        "table": table,
-        }
+        TAB_TITLE_IDENTIFIER: _("Compensations - Overview"),
-        context = BaseContext(request, context).context
+    }
-        return render(request, self._TEMPLATE, context)
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
 
-class NewCompensationView(LoginRequiredMixin, View):
+@login_required
-    _TEMPLATE = "compensation/form/view.html"
+@default_group_required
+@shared_access_required(Intervention, "intervention_id")
+def new_view(request: HttpRequest, intervention_id: str = None):
+    """
+    Renders a view for a new compensation creation
 
-    @method_decorator(default_group_required)
+    Args:
-    @method_decorator(shared_access_required(Intervention, "intervention_id"))
+        request (HttpRequest): The incoming request
-    def get(self, request: HttpRequest, intervention_id: str = None, *args, **kwargs) -> HttpResponse:
-        """
-        Renders a view for new compensation
 
-        A compensation creation may be called directly from the parent-intervention object. If so - we may take
+    Returns:
-        the intervention's id and directly link the compensation to it.
 
-        Args:
+    """
-            request (HttpRequest): The incoming request
+    template = "compensation/form/view.html"
-            intervention_id (str): The intervention identifier
+    if intervention_id is not None:
-
+        try:
-        Returns:
+            intervention = Intervention.objects.get(id=intervention_id)
-
+        except ObjectDoesNotExist:
-        """
+            messages.error(request, PARAMS_INVALID)
-        if intervention_id:
+            return redirect("home")
-            # If the parent-intervention is recorded, we are not allowed to change anything on it's data.
+        if intervention.is_recorded:
-            # Not even adding new child elements like compensations!
+            messages.info(
-            intervention = get_object_or_404(Intervention, id=intervention_id)
+                request,
-            recording_state_blocks_actions = intervention.is_recorded
+                RECORDED_BLOCKS_EDIT
-            if recording_state_blocks_actions:
+            )
-                messages.info(
+            return redirect("intervention:detail", id=intervention_id)
-                    request,
-                    RECORDED_BLOCKS_EDIT
-                )
-                return redirect("intervention:detail", id=intervention_id)
-
-        data_form = NewCompensationForm(request.POST or None, intervention_id=intervention_id)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False)
-
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("New compensation"),
-        }
-        context = BaseContext(request, context).context
-
-        return render(request, self._TEMPLATE, context)
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Intervention, "intervention_id"))
-    def post(self, request: HttpRequest, intervention_id: str = None, *args, **kwargs) -> HttpResponse:
-
-        """
-        Renders a view for a new compensation creation
-
-        Args:
-            request (HttpRequest): The incoming request
-
-        Returns:
-
-        """
-        if intervention_id:
-            # If the parent-intervention is recorded, we are not allowed to change anything on it's data.
-            # Not even adding new child elements like compensations!
-            intervention = get_object_or_404(Intervention, id=intervention_id)
-            recording_state_blocks_actions = intervention.is_recorded
-            if recording_state_blocks_actions:
-                messages.info(
-                    request,
-                    RECORDED_BLOCKS_EDIT
-                )
-                return redirect("intervention:detail", id=intervention_id)
-
-        data_form = NewCompensationForm(request.POST or None, intervention_id=intervention_id)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False)
 
+    data_form = NewCompensationForm(request.POST or None, intervention_id=intervention_id)
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False)
+    if request.method == "POST":
         if data_form.is_valid() and geom_form.is_valid():
             generated_identifier = data_form.cleaned_data.get("identifier", None)
             comp = data_form.save(request.user, geom_form)
@@ -144,97 +108,80 @@ class NewCompensationView(LoginRequiredMixin, View):
                     request,
                     GEOMETRY_SIMPLIFIED
                 )
+
             num_ignored_geometries = geom_form.get_num_geometries_ignored()
             if num_ignored_geometries > 0:
                 messages.info(
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("compensation:detail", id=comp.id)
         else:
-            messages.error(request, FORM_INVALID, extra_tags="danger", )
+            messages.error(request, FORM_INVALID, extra_tags="danger",)
+    else:
+        # For clarification: nothing in this case
+        pass
+    context = {
+        "form": data_form,
+        "geom_form": geom_form,
+        TAB_TITLE_IDENTIFIER: _("New compensation"),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
-        context = {
+
-            "form": data_form,
+@login_required
-            "geom_form": geom_form,
+@default_group_required
-            TAB_TITLE_IDENTIFIER: _("New compensation"),
+def new_id_view(request: HttpRequest):
+    """ JSON endpoint
+
+    Provides fetching of free identifiers for e.g. AJAX calls
+
+    """
+    tmp = Compensation()
+    identifier = tmp.generate_new_identifier()
+    while Compensation.objects.filter(identifier=identifier).exists():
+        identifier = tmp.generate_new_identifier()
+    return JsonResponse(
+        data={
+            "gen_data": identifier
         }
-        context = BaseContext(request, context).context
+    )
-
-        return render(request, self._TEMPLATE, context)
 
 
-class CompensationIdentifierGeneratorView(AbstractIdentifierGeneratorView):
+@login_required
-    _MODEL = Compensation
+@default_group_required
+@shared_access_required(Compensation, "id")
+def edit_view(request: HttpRequest, id: str):
+    """
+    Renders a view for editing compensations
 
+    Args:
+        request (HttpRequest): The incoming request
 
-class EditCompensationView(LoginRequiredMixin, View):
+    Returns:
-    _TEMPLATE = "compensation/form/view.html"
 
-    @method_decorator(default_group_required)
+    """
-    @method_decorator(shared_access_required(Compensation, "id"))
+    template = "compensation/form/view.html"
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
+    # Get object from db
+    comp = get_object_or_404(Compensation, id=id)
+    if comp.is_recorded:
+        messages.info(
+            request,
+            RECORDED_BLOCKS_EDIT
+        )
+        return redirect("compensation:detail", id=id)
 
-        """
+    # Create forms, initialize with values from db/from POST request
-        Renders a view for editing compensations
+    data_form = EditCompensationForm(request.POST or None, instance=comp)
-
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=comp)
-        Args:
+    if request.method == "POST":
-            request (HttpRequest): The incoming request
-
-        Returns:
-
-        """
-        # Get object from db
-        comp = get_object_or_404(Compensation, id=id)
-        if comp.is_recorded:
-            messages.info(
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("compensation:detail", id=id)
-
-        # Create forms, initialize with values from db/from POST request
-        data_form = EditCompensationForm(request.POST or None, instance=comp)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=comp)
-
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(comp.identifier),
-        }
-        context = BaseContext(request, context).context
-
-        return render(request, self._TEMPLATE, context)
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Compensation, "id"))
-    def post(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-
-        """
-        Renders a view for editing compensations
-
-        Args:
-            request (HttpRequest): The incoming request
-
-        Returns:
-
-        """
-        # Get object from db
-        comp = get_object_or_404(Compensation, id=id)
-        if comp.is_recorded:
-            messages.info(
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("compensation:detail", id=id)
-
-        # Create forms, initialize with values from db/from POST request
-        data_form = EditCompensationForm(request.POST or None, instance=comp)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=comp)
         if data_form.is_valid() and geom_form.is_valid():
             # Preserve state of intervention checked to determine whether the user must be informed or not
             # about a change of the check state
             intervention_is_checked = comp.intervention.checked is not None
+
             # The data form takes the geom form for processing, as well as the performing user
             comp = data_form.save(request.user, geom_form)
             if intervention_is_checked:
@@ -245,21 +192,126 @@ class EditCompensationView(LoginRequiredMixin, View):
                     request,
                     GEOMETRY_SIMPLIFIED
                 )
+
             num_ignored_geometries = geom_form.get_num_geometries_ignored()
             if num_ignored_geometries > 0:
                 messages.info(
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("compensation:detail", id=comp.id)
         else:
-            messages.error(request, FORM_INVALID, extra_tags="danger", )
+            messages.error(request, FORM_INVALID, extra_tags="danger",)
+    else:
+        # For clarification: nothing in this case
+        pass
+    context = {
+        "form": data_form,
+        "geom_form": geom_form,
+        TAB_TITLE_IDENTIFIER: _("Edit {}").format(comp.identifier),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(comp.identifier),
-        }
-        context = BaseContext(request, context).context
 
-        return render(request, self._TEMPLATE, context)
+@login_required
+@any_group_check
+@uuid_required
+def detail_view(request: HttpRequest, id: str):
+    """ Renders a detail view for a compensation
+
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The compensation's id
+
+    Returns:
+
+    """
+    template = "compensation/detail/compensation/view.html"
+    comp = get_object_or_404(
+        Compensation.objects.select_related(
+            "modified",
+            "created",
+            "geometry"
+        ),
+        id=id,
+        deleted=None,
+        intervention__deleted=None,
+    )
+    geom_form = SimpleGeomForm(instance=comp)
+    parcels = comp.get_underlying_parcels()
+    _user = request.user
+    is_data_shared = comp.intervention.is_shared_with(_user)
+
+    # Order states according to surface
+    before_states = comp.before_states.all().prefetch_related("biotope_type").order_by("-surface")
+    after_states = comp.after_states.all().prefetch_related("biotope_type").order_by("-surface")
+    actions = comp.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 = comp.get_surface_before_states()
+    sum_after_states = comp.get_surface_after_states()
+    diff_states = abs(sum_before_states - sum_after_states)
+
+    request = comp.set_status_messages(request)
+
+    last_checked = comp.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)
+
+    requesting_user_is_only_shared_user = comp.is_only_shared_with(_user)
+    if requesting_user_is_only_shared_user:
+        messages.info(
+            request,
+            DO_NOT_FORGET_TO_SHARE
+        )
+
+    context = {
+        "obj": comp,
+        "last_checked": last_checked,
+        "last_checked_tooltip": last_checked_tooltip,
+        "geom_form": geom_form,
+        "parcels": parcels,
+        "is_entry_shared": is_data_shared,
+        "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,
+        "is_default_member": _user.in_group(DEFAULT_GROUP),
+        "is_zb_member": _user.in_group(ZB_GROUP),
+        "is_ets_member": _user.in_group(ETS_GROUP),
+        "LANIS_LINK": comp.get_LANIS_link(),
+        TAB_TITLE_IDENTIFIER: f"{comp.identifier} - {comp.title}",
+        "has_finished_deadlines": comp.get_finished_deadlines().exists(),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
+
+
+@login_required_modal
+@login_required
+@default_group_required
+@shared_access_required(Compensation, "id")
+def remove_view(request: HttpRequest, id: str):
+    """ Renders a modal view for removing the compensation
+
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The compensation's id
+
+    Returns:
+
+    """
+    comp = get_object_or_404(Compensation, id=id)
+    form = RemoveModalForm(request.POST or None, instance=comp, request=request)
+    return form.process_request(
+        request=request,
+        msg_success=COMPENSATION_REMOVED_TEMPLATE.format(comp.identifier),
+        redirect_url=reverse("compensation:index"),
+    )
+

compensation/views/compensation/detail.py

@@ -1,97 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.contrib import messages
-from django.http import HttpRequest, HttpResponse
-from django.shortcuts import render, get_object_or_404
-
-from compensation.models import Compensation
-from konova.contexts import BaseContext
-from konova.forms import SimpleGeomForm
-from konova.settings import ETS_GROUP, ZB_GROUP, DEFAULT_GROUP
-from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.message_templates import DO_NOT_FORGET_TO_SHARE, DATA_CHECKED_PREVIOUSLY_TEMPLATE
-from konova.views.detail import AbstractDetailView
-
-
-class DetailCompensationView(AbstractDetailView):
-    _TEMPLATE = "compensation/detail/compensation/view.html"
-
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-
-        """ Renders a detail view for a compensation
-
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The compensation's id
-
-        Returns:
-
-        """
-        comp = get_object_or_404(
-            Compensation.objects.select_related(
-                "modified",
-                "created",
-                "geometry"
-            ),
-            id=id,
-            deleted=None,
-            intervention__deleted=None,
-        )
-        geom_form = SimpleGeomForm(instance=comp)
-        parcels = comp.get_underlying_parcels()
-        _user = request.user
-        is_data_shared = comp.intervention.is_shared_with(_user)
-
-        # Order states according to surface
-        before_states = comp.before_states.all().prefetch_related("biotope_type").order_by("-surface")
-        after_states = comp.after_states.all().prefetch_related("biotope_type").order_by("-surface")
-        actions = comp.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 = comp.get_surface_before_states()
-        sum_after_states = comp.get_surface_after_states()
-        diff_states = abs(sum_before_states - sum_after_states)
-
-        request = comp.set_status_messages(request)
-
-        last_checked = comp.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
-            )
-
-        requesting_user_is_only_shared_user = comp.is_only_shared_with(_user)
-        if requesting_user_is_only_shared_user:
-            messages.info(
-                request,
-                DO_NOT_FORGET_TO_SHARE
-            )
-
-        context = {
-            "obj": comp,
-            "last_checked": last_checked,
-            "last_checked_tooltip": last_checked_tooltip,
-            "geom_form": geom_form,
-            "parcels": parcels,
-            "is_entry_shared": is_data_shared,
-            "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,
-            "is_default_member": _user.in_group(DEFAULT_GROUP),
-            "is_zb_member": _user.in_group(ZB_GROUP),
-            "is_ets_member": _user.in_group(ETS_GROUP),
-            "LANIS_LINK": comp.get_LANIS_link(),
-            TAB_TITLE_IDENTIFIER: f"{comp.identifier} - {comp.title}",
-            "has_finished_deadlines": comp.get_finished_deadlines().exists(),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)

compensation/views/compensation/remove.py

@@ -1,20 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.http import HttpRequest, HttpResponse
-from django.utils.decorators import method_decorator
-
-from compensation.models import Compensation
-from konova.decorators import shared_access_required
-from konova.views.remove import AbstractRemoveView
-
-
-class RemoveCompensationView(AbstractRemoveView):
-    _MODEL = Compensation
-    _REDIRECT_URL = "compensation:index"
-
-    @method_decorator(shared_access_required(Compensation, "id"))
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-        return super().get(request, *args, **kwargs)

compensation/views/compensation/report.py

@@ -5,81 +5,77 @@ Contact: ksp-servicestelle@sgdnord.rlp.de
 Created on: 19.08.22
 
 """
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest
 from django.shortcuts import get_object_or_404, render
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from compensation.models import Compensation
 from konova.contexts import BaseContext
+from konova.decorators import uuid_required
 from konova.forms import SimpleGeomForm
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.qrcode import QrCode
+from konova.utils.generators import generate_qr_code
-from konova.views.report import AbstractPublicReportView
 
+@uuid_required
+def report_view(request: HttpRequest, id: str):
+    """ Renders the public report view
 
-class CompensationPublicReportView(AbstractPublicReportView):
+    Args:
-    _TEMPLATE = "compensation/report/compensation/report.html"
+        request (HttpRequest): The incoming request
+        id (str): The id of the intervention
 
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
+    Returns:
-        """ Renders the public report view
 
-        Args:
+    """
-            request (HttpRequest): The incoming request
+    # Reuse the compensation report template since compensations are structurally identical
-            id (str): The id of the intervention
+    template = "compensation/report/compensation/report.html"
-
+    comp = get_object_or_404(Compensation, id=id)
-        Returns:
-
-        """
-        comp = get_object_or_404(Compensation, id=id)
-        tab_title = _("Report {}").format(comp.identifier)
-        # If intervention is not recorded (yet or currently) we need to render another template without any data
-        if not comp.is_ready_for_publish():
-            template = "report/unavailable.html"
-            context = {
-                TAB_TITLE_IDENTIFIER: tab_title,
-            }
-            context = BaseContext(request, context).context
-            return render(request, template, context)
-
-        # Prepare data for map viewer
-        geom_form = SimpleGeomForm(
-            instance=comp
-        )
-        parcels = comp.get_underlying_parcels()
-
-        qrcode = QrCode(
-            content=request.build_absolute_uri(reverse("compensation:report", args=(id,))),
-            size=10
-        )
-        qrcode_lanis = QrCode(
-            content=comp.get_LANIS_link(),
-            size=7
-        )
-
-        # Order states by surface
-        before_states = comp.before_states.all().order_by("-surface").prefetch_related("biotope_type")
-        after_states = comp.after_states.all().order_by("-surface").prefetch_related("biotope_type")
-        actions = comp.actions.all().prefetch_related("action_type")
 
+    tab_title = _("Report {}").format(comp.identifier)
+    # If intervention is not recorded (yet or currently) we need to render another template without any data
+    if not comp.is_ready_for_publish():
+        template = "report/unavailable.html"
         context = {
-            "obj": comp,
-            "qrcode": {
-                "img": qrcode.get_img(),
-                "url": qrcode.get_content(),
-            },
-            "qrcode_lanis": {
-                "img": qrcode_lanis.get_img(),
-                "url": qrcode_lanis.get_content(),
-            },
-            "is_entry_shared": False,  # disables action buttons during rendering
-            "before_states": before_states,
-            "after_states": after_states,
-            "geom_form": geom_form,
-            "parcels": parcels,
-            "actions": actions,
-            "tables_scrollable": False,
             TAB_TITLE_IDENTIFIER: tab_title,
         }
         context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
+        return render(request, template, context)
+
+    # Prepare data for map viewer
+    geom_form = SimpleGeomForm(
+        instance=comp
+    )
+    parcels = comp.get_underlying_parcels()
+
+    qrcode_url = request.build_absolute_uri(reverse("compensation:report", args=(id,)))
+    qrcode_img = generate_qr_code(qrcode_url, 10)
+    qrcode_lanis_url = comp.get_LANIS_link()
+    qrcode_img_lanis = generate_qr_code(qrcode_lanis_url, 7)
+
+    # Order states by surface
+    before_states = comp.before_states.all().order_by("-surface").prefetch_related("biotope_type")
+    after_states = comp.after_states.all().order_by("-surface").prefetch_related("biotope_type")
+    actions = comp.actions.all().prefetch_related("action_type")
+
+    context = {
+        "obj": comp,
+        "qrcode": {
+            "img": qrcode_img,
+            "url": qrcode_url,
+        },
+        "qrcode_lanis": {
+            "img": qrcode_img_lanis,
+            "url": qrcode_lanis_url,
+        },
+        "is_entry_shared": False,  # disables action buttons during rendering
+        "before_states": before_states,
+        "after_states": after_states,
+        "geom_form": geom_form,
+        "parcels": parcels,
+        "actions": actions,
+        "tables_scrollable": False,
+        TAB_TITLE_IDENTIFIER: tab_title,
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)

compensation/views/eco_account/detail.py

@@ -1,97 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.contrib import messages
-from django.http import HttpRequest, HttpResponse
-from django.shortcuts import render, get_object_or_404
-
-from compensation.models import EcoAccount
-from konova.contexts import BaseContext
-from konova.forms import SimpleGeomForm
-from konova.settings import ETS_GROUP, ZB_GROUP, DEFAULT_GROUP
-from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.message_templates import DO_NOT_FORGET_TO_SHARE
-from konova.views.detail import AbstractDetailView
-
-
-class DetailEcoAccountView(AbstractDetailView):
-    _TEMPLATE = "compensation/detail/eco_account/view.html"
-
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        """ Renders a detail view for a compensation
-
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The compensation's id
-
-        Returns:
-
-        """
-        acc = get_object_or_404(
-            EcoAccount.objects.prefetch_related(
-                "deadlines",
-            ).select_related(
-                'geometry',
-                'responsible',
-            ),
-            id=id,
-            deleted=None,
-        )
-        geom_form = SimpleGeomForm(instance=acc)
-        parcels = acc.get_underlying_parcels()
-        _user = request.user
-        is_data_shared = acc.is_shared_with(_user)
-
-        # Order states according to surface
-        before_states = acc.before_states.order_by("-surface")
-        after_states = acc.after_states.order_by("-surface")
-
-        # 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 = acc.get_surface_before_states()
-        sum_after_states = acc.get_surface_after_states()
-        diff_states = abs(sum_before_states - sum_after_states)
-        # Calculate rest of available surface for deductions
-        available_total = acc.deductable_rest
-        available_relative = acc.get_deductable_rest_relative()
-
-        # Prefetch related data to decrease the amount of db connections
-        deductions = acc.deductions.filter(
-            intervention__deleted=None,
-        )
-        actions = acc.actions.all()
-
-        request = acc.set_status_messages(request)
-
-        requesting_user_is_only_shared_user = acc.is_only_shared_with(_user)
-        if requesting_user_is_only_shared_user:
-            messages.info(
-                request,
-                DO_NOT_FORGET_TO_SHARE
-            )
-
-        context = {
-            "obj": acc,
-            "geom_form": geom_form,
-            "parcels": parcels,
-            "is_entry_shared": is_data_shared,
-            "before_states": before_states,
-            "after_states": after_states,
-            "sum_before_states": sum_before_states,
-            "sum_after_states": sum_after_states,
-            "diff_states": diff_states,
-            "available": available_relative,
-            "available_total": available_total,
-            "is_default_member": _user.in_group(DEFAULT_GROUP),
-            "is_zb_member": _user.in_group(ZB_GROUP),
-            "is_ets_member": _user.in_group(ETS_GROUP),
-            "LANIS_LINK": acc.get_LANIS_link(),
-            "deductions": deductions,
-            "actions": actions,
-            TAB_TITLE_IDENTIFIER: f"{acc.identifier} - {acc.title}",
-            "has_finished_deadlines": acc.get_finished_deadlines().exists(),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)

compensation/views/eco_account/eco_account.py

@@ -6,94 +6,72 @@ Created on: 19.08.22
 
 """
 from django.contrib import messages
-from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.auth.decorators import login_required
-from django.http import HttpRequest, HttpResponse
+from django.db.models import Sum
+from django.http import HttpRequest, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render
-from django.utils.decorators import method_decorator
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
-from django.views import View
 
-from compensation.forms.eco_account import EditEcoAccountForm, NewEcoAccountForm
+from compensation.forms.eco_account import EditEcoAccountForm, NewEcoAccountForm, RemoveEcoAccountModalForm
 from compensation.models import EcoAccount
 from compensation.tables.eco_account import EcoAccountTable
 from konova.contexts import BaseContext
-from konova.decorators import shared_access_required, default_group_required
+from konova.decorators import shared_access_required, default_group_required, any_group_check, login_required_modal, \
+    uuid_required
 from konova.forms import SimpleGeomForm
+from konova.settings import ETS_GROUP, DEFAULT_GROUP, ZB_GROUP
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.message_templates import RECORDED_BLOCKS_EDIT, FORM_INVALID, \
+from konova.utils.message_templates import CANCEL_ACC_RECORDED_OR_DEDUCTED, RECORDED_BLOCKS_EDIT, FORM_INVALID, \
-    IDENTIFIER_REPLACED, GEOMETRY_SIMPLIFIED, GEOMETRIES_IGNORED_TEMPLATE
+    IDENTIFIER_REPLACED, DO_NOT_FORGET_TO_SHARE, GEOMETRY_SIMPLIFIED, GEOMETRIES_IGNORED_TEMPLATE
-from konova.views.identifier import AbstractIdentifierGeneratorView
-from konova.views.index import AbstractIndexView
 
 
-class IndexEcoAccountView(AbstractIndexView):
+@login_required
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
+@any_group_check
-        """
+def index_view(request: HttpRequest):
-        Renders the index view for eco accounts
+    """
+    Renders the index view for eco accounts
 
-        Args:
+    Args:
-            request (HttpRequest): The incoming request
+        request (HttpRequest): The incoming request
 
-        Returns:
+    Returns:
-            A rendered view
+        A rendered view
-        """
+    """
-        eco_accounts = EcoAccount.objects.filter(
+    template = "generic_index.html"
-            deleted=None,
+    eco_accounts = EcoAccount.objects.filter(
-        ).order_by(
+        deleted=None,
-            "-modified__timestamp"
+    ).order_by(
-        )
+        "-modified__timestamp"
-        table = EcoAccountTable(
+    )
-            request=request,
+    table = EcoAccountTable(
-            queryset=eco_accounts
+        request=request,
-        )
+        queryset=eco_accounts
-        context = {
+    )
-            "table": table,
+    context = {
-            TAB_TITLE_IDENTIFIER: _("Eco-account - Overview"),
+        "table": table,
-        }
+        TAB_TITLE_IDENTIFIER: _("Eco-account - Overview"),
-        context = BaseContext(request, context).context
+    }
-        return render(request, self._TEMPLATE, context)
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
 
-class NewEcoAccountView(LoginRequiredMixin, View):
+@login_required
-    _TEMPLATE = "compensation/form/view.html"
+@default_group_required
+def new_view(request: HttpRequest):
+    """
+    Renders a view for a new eco account creation
 
-    @method_decorator(default_group_required)
+    Args:
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
+        request (HttpRequest): The incoming request
-        """
-        Renders a view for a new eco account creation
 
-        Args:
+    Returns:
-            request (HttpRequest): The incoming request
 
-        Returns:
+    """
-
+    template = "compensation/form/view.html"
-        """
+    data_form = NewEcoAccountForm(request.POST or None)
-        data_form = NewEcoAccountForm(request.POST or None)
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False)
+    if request.method == "POST":
-
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("New Eco-Account"),
-        }
-        context = BaseContext(request, context).context
-
-        return render(request, self._TEMPLATE, context)
-
-    @method_decorator(default_group_required)
-    def post(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-
-        """
-        Renders a view for a new eco account creation
-
-        Args:
-            request (HttpRequest): The incoming request
-
-        Returns:
-
-        """
-        data_form = NewEcoAccountForm(request.POST or None)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False)
         if data_form.is_valid() and geom_form.is_valid():
             generated_identifier = data_form.cleaned_data.get("identifier", None)
             acc = data_form.save(request.user, geom_form)
@@ -111,92 +89,75 @@ class NewEcoAccountView(LoginRequiredMixin, View):
                     request,
                     GEOMETRY_SIMPLIFIED
                 )
+
             num_ignored_geometries = geom_form.get_num_geometries_ignored()
             if num_ignored_geometries > 0:
                 messages.info(
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("compensation:acc:detail", id=acc.id)
         else:
-            messages.error(request, FORM_INVALID, extra_tags="danger", )
+            messages.error(request, FORM_INVALID, extra_tags="danger",)
+    else:
+        # For clarification: nothing in this case
+        pass
+    context = {
+        "form": data_form,
+        "geom_form": geom_form,
+        TAB_TITLE_IDENTIFIER: _("New Eco-Account"),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
-        context = {
+
-            "form": data_form,
+@login_required
-            "geom_form": geom_form,
+@default_group_required
-            TAB_TITLE_IDENTIFIER: _("New Eco-Account"),
+def new_id_view(request: HttpRequest):
+    """ JSON endpoint
+
+    Provides fetching of free identifiers for e.g. AJAX calls
+
+    """
+    tmp = EcoAccount()
+    identifier = tmp.generate_new_identifier()
+    while EcoAccount.objects.filter(identifier=identifier).exists():
+        identifier = tmp.generate_new_identifier()
+    return JsonResponse(
+        data={
+            "gen_data": identifier
         }
-        context = BaseContext(request, context).context
+    )
-
-        return render(request, self._TEMPLATE, context)
-
-class EcoAccountIdentifierGeneratorView(AbstractIdentifierGeneratorView):
-    _MODEL = EcoAccount
 
 
-class EditEcoAccountView(LoginRequiredMixin, View):
+@login_required
-    _TEMPLATE = "compensation/form/view.html"
+@default_group_required
+@shared_access_required(EcoAccount, "id")
+def edit_view(request: HttpRequest, id: str):
+    """
+    Renders a view for editing compensations
 
-    @method_decorator(default_group_required)
+    Args:
-    @method_decorator(shared_access_required(EcoAccount, "id"))
+        request (HttpRequest): The incoming request
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
 
-        """
+    Returns:
-        Renders a view for editing compensations
 
-        Args:
+    """
-            request (HttpRequest): The incoming request
+    template = "compensation/form/view.html"
-
+    # Get object from db
-        Returns:
+    acc = get_object_or_404(EcoAccount, id=id)
-
+    if acc.is_recorded:
-        """
+        messages.info(
-        # Get object from db
+            request,
-        acc = get_object_or_404(EcoAccount, id=id)
+            RECORDED_BLOCKS_EDIT
-        if acc.is_recorded:
+        )
-            messages.info(
+        return redirect("compensation:acc:detail", id=id)
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("compensation:acc:detail", id=id)
-
-        # Create forms, initialize with values from db/from POST request
-        data_form = EditEcoAccountForm(request.POST or None, instance=acc)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=acc)
-
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(acc.identifier),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(EcoAccount, "id"))
-    def post(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-
-        """
-        Renders a view for editing compensations
-
-        Args:
-            request (HttpRequest): The incoming request
-
-        Returns:
-
-        """
-        # Get object from db
-        acc = get_object_or_404(EcoAccount, id=id)
-        if acc.is_recorded:
-            messages.info(
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("compensation:acc:detail", id=id)
-
-        # Create forms, initialize with values from db/from POST request
-        data_form = EditEcoAccountForm(request.POST or None, instance=acc)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=acc)
 
+    # Create forms, initialize with values from db/from POST request
+    data_form = EditEcoAccountForm(request.POST or None, instance=acc)
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=acc)
+    if request.method == "POST":
         data_form_valid = data_form.is_valid()
         geom_form_valid = geom_form.is_valid()
         if data_form_valid and geom_form_valid:
@@ -208,21 +169,139 @@ class EditEcoAccountView(LoginRequiredMixin, View):
                     request,
                     GEOMETRY_SIMPLIFIED
                 )
+
             num_ignored_geometries = geom_form.get_num_geometries_ignored()
             if num_ignored_geometries > 0:
                 messages.info(
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("compensation:acc:detail", id=acc.id)
         else:
-            messages.error(request, FORM_INVALID, extra_tags="danger", )
+            messages.error(request, FORM_INVALID, extra_tags="danger",)
+    else:
+        # For clarification: nothing in this case
+        pass
+    context = {
+        "form": data_form,
+        "geom_form": geom_form,
+        TAB_TITLE_IDENTIFIER: _("Edit {}").format(acc.identifier),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(acc.identifier),
-        }
-        context = BaseContext(request, context).context
 
-        return render(request, self._TEMPLATE, context)
+@login_required
+@any_group_check
+@uuid_required
+def detail_view(request: HttpRequest, id: str):
+    """ Renders a detail view for a compensation
+
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The compensation's id
+
+    Returns:
+
+    """
+    template = "compensation/detail/eco_account/view.html"
+    acc = get_object_or_404(
+        EcoAccount.objects.prefetch_related(
+            "deadlines",
+        ).select_related(
+            'geometry',
+            'responsible',
+        ),
+        id=id,
+        deleted=None,
+    )
+    geom_form = SimpleGeomForm(instance=acc)
+    parcels = acc.get_underlying_parcels()
+    _user = request.user
+    is_data_shared = acc.is_shared_with(_user)
+
+    # Order states according to surface
+    before_states = acc.before_states.order_by("-surface")
+    after_states = acc.after_states.order_by("-surface")
+
+    # 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 = acc.get_surface_before_states()
+    sum_after_states = acc.get_surface_after_states()
+    diff_states = abs(sum_before_states - sum_after_states)
+    # Calculate rest of available surface for deductions
+    available_total = acc.deductable_rest
+    available_relative = acc.get_deductable_rest_relative()
+
+    # Prefetch related data to decrease the amount of db connections
+    deductions = acc.deductions.filter(
+        intervention__deleted=None,
+    )
+    actions = acc.actions.all()
+
+    request = acc.set_status_messages(request)
+
+    requesting_user_is_only_shared_user = acc.is_only_shared_with(_user)
+    if requesting_user_is_only_shared_user:
+        messages.info(
+            request,
+            DO_NOT_FORGET_TO_SHARE
+        )
+
+    context = {
+        "obj": acc,
+        "geom_form": geom_form,
+        "parcels": parcels,
+        "is_entry_shared": is_data_shared,
+        "before_states": before_states,
+        "after_states": after_states,
+        "sum_before_states": sum_before_states,
+        "sum_after_states": sum_after_states,
+        "diff_states": diff_states,
+        "available": available_relative,
+        "available_total": available_total,
+        "is_default_member": _user.in_group(DEFAULT_GROUP),
+        "is_zb_member": _user.in_group(ZB_GROUP),
+        "is_ets_member": _user.in_group(ETS_GROUP),
+        "LANIS_LINK": acc.get_LANIS_link(),
+        "deductions": deductions,
+        "actions": actions,
+        TAB_TITLE_IDENTIFIER: f"{acc.identifier} - {acc.title}",
+        "has_finished_deadlines": acc.get_finished_deadlines().exists(),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
+
+
+@login_required_modal
+@login_required
+@default_group_required
+@shared_access_required(EcoAccount, "id")
+def remove_view(request: HttpRequest, id: str):
+    """ Renders a modal view for removing the eco account
+
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The account's id
+
+    Returns:
+
+    """
+    acc = get_object_or_404(EcoAccount, id=id)
+
+    # If the eco account has already been recorded OR there are already deductions, it can not be deleted by a regular
+    # default group user
+    if acc.recorded is not None or acc.deductions.exists():
+        user = request.user
+        if not user.in_group(ETS_GROUP):
+            messages.info(request, CANCEL_ACC_RECORDED_OR_DEDUCTED)
+            return redirect("compensation:acc:detail", id=id)
+
+    form = RemoveEcoAccountModalForm(request.POST or None, instance=acc, request=request)
+    return form.process_request(
+        request=request,
+        msg_success=_("Eco-account removed"),
+        redirect_url=reverse("compensation:acc:index"),
+    )
+

compensation/views/eco_account/remove.py

@@ -1,22 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.http import HttpRequest, HttpResponse
-from django.utils.decorators import method_decorator
-
-from compensation.forms.eco_account import RemoveEcoAccountModalForm
-from compensation.models import EcoAccount
-from konova.decorators import shared_access_required
-from konova.views.remove import AbstractRemoveView
-
-
-class RemoveEcoAccountView(AbstractRemoveView):
-    _MODEL = EcoAccount
-    _REDIRECT_URL = "compensation:acc:index"
-    _FORM = RemoveEcoAccountModalForm
-
-    @method_decorator(shared_access_required(EcoAccount, "id"))
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-        return super().get(request, *args, **kwargs)

compensation/views/eco_account/report.py

@@ -5,88 +5,85 @@ Contact: ksp-servicestelle@sgdnord.rlp.de
 Created on: 19.08.22
 
 """
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest
 from django.shortcuts import get_object_or_404, render
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from compensation.models import EcoAccount
 from konova.contexts import BaseContext
+from konova.decorators import uuid_required
 from konova.forms import SimpleGeomForm
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.qrcode import QrCode
+from konova.utils.generators import generate_qr_code
-from konova.views.report import AbstractPublicReportView
 
 
-class EcoAccountPublicReportView(AbstractPublicReportView):
+@uuid_required
-    _TEMPLATE = "compensation/report/eco_account/report.html"
+def report_view(request: HttpRequest, id: str):
+    """ Renders the public report view
 
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
+    Args:
-        """ Renders the public report view
+        request (HttpRequest): The incoming request
+        id (str): The id of the intervention
 
-        Args:
+    Returns:
-            request (HttpRequest): The incoming request
-            id (str): The id of the intervention
 
-        Returns:
+    """
-
+    # Reuse the compensation report template since EcoAccounts are structurally identical
-        """
+    template = "compensation/report/eco_account/report.html"
-        acc = get_object_or_404(EcoAccount, id=id)
+    acc = get_object_or_404(EcoAccount, id=id)
-        tab_title = _("Report {}").format(acc.identifier)
-        # If intervention is not recorded (yet or currently) we need to render another template without any data
-        if not acc.is_ready_for_publish():
-            template = "report/unavailable.html"
-            context = {
-                TAB_TITLE_IDENTIFIER: tab_title,
-            }
-            context = BaseContext(request, context).context
-            return render(request, template, context)
-
-        # Prepare data for map viewer
-        geom_form = SimpleGeomForm(
-            instance=acc
-        )
-        parcels = acc.get_underlying_parcels()
-
-        qrcode = QrCode(
-            content=request.build_absolute_uri(reverse("compensation:acc:report", args=(id,))),
-            size=10
-        )
-        qrcode_lanis = QrCode(
-            content=acc.get_LANIS_link(),
-            size=7
-        )
-
-        # Order states by surface
-        before_states = acc.before_states.all().order_by("-surface").select_related("biotope_type__parent")
-        after_states = acc.after_states.all().order_by("-surface").select_related("biotope_type__parent")
-        actions = acc.actions.all().prefetch_related("action_type__parent")
-
-        # Reduce amount of db fetched data to the bare minimum we need in the template (deduction's intervention id and identifier)
-        deductions = acc.deductions.all() \
-            .distinct("intervention") \
-            .select_related("intervention") \
-            .values_list("intervention__id", "intervention__identifier", "intervention__title", named=True)
 
+    tab_title = _("Report {}").format(acc.identifier)
+    # If intervention is not recorded (yet or currently) we need to render another template without any data
+    if not acc.is_ready_for_publish():
+        template = "report/unavailable.html"
         context = {
-            "obj": acc,
-            "qrcode": {
-                "img": qrcode.get_img(),
-                "url": qrcode.get_content(),
-            },
-            "qrcode_lanis": {
-                "img": qrcode_lanis.get_img(),
-                "url": qrcode_lanis.get_content(),
-            },
-            "is_entry_shared": False,  # disables action buttons during rendering
-            "before_states": before_states,
-            "after_states": after_states,
-            "geom_form": geom_form,
-            "parcels": parcels,
-            "actions": actions,
-            "deductions": deductions,
-            "tables_scrollable": False,
             TAB_TITLE_IDENTIFIER: tab_title,
         }
         context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
+        return render(request, template, context)
+
+    # Prepare data for map viewer
+    geom_form = SimpleGeomForm(
+        instance=acc
+    )
+    parcels = acc.get_underlying_parcels()
+
+    qrcode_url = request.build_absolute_uri(reverse("compensation:acc:report", args=(id,)))
+    qrcode_img = generate_qr_code(qrcode_url, 10)
+    qrcode_lanis_url = acc.get_LANIS_link()
+    qrcode_img_lanis = generate_qr_code(qrcode_lanis_url, 7)
+
+    # Order states by surface
+    before_states = acc.before_states.all().order_by("-surface").select_related("biotope_type__parent")
+    after_states = acc.after_states.all().order_by("-surface").select_related("biotope_type__parent")
+    actions = acc.actions.all().prefetch_related("action_type__parent")
+
+    # Reduce amount of db fetched data to the bare minimum we need in the template (deduction's intervention id and identifier)
+    deductions = acc.deductions.all()\
+        .distinct("intervention")\
+        .select_related("intervention")\
+        .values_list("intervention__id", "intervention__identifier", "intervention__title", named=True)
+
+    context = {
+        "obj": acc,
+        "qrcode": {
+            "img": qrcode_img,
+            "url": qrcode_url,
+        },
+        "qrcode_lanis": {
+            "img": qrcode_img_lanis,
+            "url": qrcode_lanis_url,
+        },
+        "is_entry_shared": False,  # disables action buttons during rendering
+        "before_states": before_states,
+        "after_states": after_states,
+        "geom_form": geom_form,
+        "parcels": parcels,
+        "actions": actions,
+        "deductions": deductions,
+        "tables_scrollable": False,
+        TAB_TITLE_IDENTIFIER: tab_title,
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)

docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3.3'
+
+services:
+  konova:
+    external_links:
+      - postgis:db
+      - arnova-nginx-server:arnova
+    build: .
+    image: "ksp/konova:1.8"
+    container_name: "konova-docker"
+    command: ./docker-entrypoint.sh
+    restart: always
+    volumes:
+      - /data/apps/konova/uploaded_files:/konova_uploaded_files
+    ports:
+      - "1337:80"
+
+# Instead of an own, new network, we need to connect to the existing one, which is provided by the postgis container
+# NOTE: THIS NETWORK MUST EXIST
+networks:
+  default:
+    external:
+      name: postgis_nat_it_backend

docker-entrypoint.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -e  # Beende Skript bei Fehlern
+set -o pipefail  # Fehler in Pipelines nicht ignorieren
+
+# Starte Redis
+redis-server --daemonize yes
+
+# Starte Celery Worker im Hintergrund
+celery -A konova worker --loglevel=info &
+
+# Starte Nginx als Hintergrundprozess
+nginx -g "daemon off;" &
+
+# Setze Gunicorn Worker-Anzahl (Standard: (2*CPUs)+1)
+WORKERS=${GUNICORN_WORKERS:-$((2 * $(nproc) + 1))}
+
+# Stelle sicher, dass Logs existieren
+mkdir -p /var/log/gunicorn
+touch /var/log/gunicorn/access.log /var/log/gunicorn/error.log
+
+# Starte Gunicorn als Hauptprozess
+exec gunicorn --workers="$WORKERS" konova.wsgi:application \
+    --bind=0.0.0.0:8000 \
+    --access-logfile /var/log/gunicorn/access.log \
+    --error-logfile /var/log/gunicorn/error.log \
+    --access-logformat '%({x-real-ip}i)s via %(h)s %(l)s %(u)s %(t)s "%(r)s" %(s)s %(b)s "%(f)s" "%(a)s"'

ema/templates/ema/detail/includes/controls.html

@@ -15,10 +15,10 @@
         <button class="btn btn-default btn-modal mr-2" title="{% trans 'Resubmission' %}" data-form-url="{% url 'ema:resubmission-create' obj.id %}">
             {% fa5_icon 'bell' %}
         </button>
+        <button class="btn btn-default btn-modal mr-2" title="{% trans 'Share' %}" data-form-url="{% url 'ema:share-form' obj.id %}">
+            {% fa5_icon 'share-alt' %}
+        </button>
         {% if is_ets_member %}
-            <button class="btn btn-default btn-modal mr-2" title="{% trans 'Share' %}" data-form-url="{% url 'ema:share-form' obj.id %}">
-                {% fa5_icon 'share-alt' %}
-            </button>
             {% if obj.recorded %}
                 <button class="btn btn-default btn-modal mr-2" title="{% trans 'Unrecord' %}" data-form-url="{% url 'ema:record' obj.id %}">
                     {% fa5_icon 'bookmark' 'far' %}
@@ -28,21 +28,19 @@
                     {% fa5_icon 'bookmark' %}
                 </button>
             {% endif %}
-            <a href="{% url 'ema:edit' obj.id %}" class="mr-2">
-                <button class="btn btn-default" title="{% trans 'Edit' %}">
-                    {% fa5_icon 'edit' %}
-                </button>
-            </a>
         {% endif %}
         {% if is_default_member %}
-            <button class="btn btn-default btn-modal mr-2" data-form-url="{% url 'ema:log' obj.id %}" title="{% trans 'Show log' %}">
+        <a href="{% url 'ema:edit' obj.id %}" class="mr-2">
-                {% fa5_icon 'history' %}
+            <button class="btn btn-default" title="{% trans 'Edit' %}">
-            </button>
+                {% fa5_icon 'edit' %}
-        {% endif %}
-        {% if is_ets_member %}
-            <button class="btn btn-default btn-modal" data-form-url="{% url 'ema:remove' obj.id %}" title="{% trans 'Delete' %}">
-                {% fa5_icon 'trash' %}
             </button>
+        </a>
+        <button class="btn btn-default btn-modal mr-2" data-form-url="{% url 'ema:log' obj.id %}" title="{% trans 'Show log' %}">
+            {% fa5_icon 'history' %}
+        </button>
+        <button class="btn btn-default btn-modal" data-form-url="{% url 'ema:remove' obj.id %}" title="{% trans 'Delete' %}">
+            {% fa5_icon 'trash' %}
+        </button>
         {% endif %}
     {% endif %}
 </div>

ema/tests/test_views.py

@@ -118,7 +118,6 @@ class EmaViewTestCase(CompensationViewTestCase):
             self.index_url,
             self.detail_url,
             self.report_url,
-            self.log_url,
         ]
         fail_urls = [
             self.new_url,
@@ -134,6 +133,7 @@ class EmaViewTestCase(CompensationViewTestCase):
             self.action_remove_url,
             self.action_new_url,
             self.new_doc_url,
+            self.log_url,
             self.remove_url,
         ]
         self.assert_url_fail(client, fail_urls)

ema/urls.py

@@ -9,28 +9,26 @@ from django.urls import path
 
 from ema.views.action import NewEmaActionView, EditEmaActionView, RemoveEmaActionView
 from ema.views.deadline import NewEmaDeadlineView, EditEmaDeadlineView, RemoveEmaDeadlineView
-from ema.views.detail import DetailEmaView
 from ema.views.document import NewEmaDocumentView, EditEmaDocumentView, RemoveEmaDocumentView, GetEmaDocumentView
-from ema.views.ema import IndexEmaView, EmaIdentifierGeneratorView, EditEmaView, NewEmaView
+from ema.views.ema import index_view, new_view, new_id_view, detail_view, edit_view, remove_view
 from ema.views.log import EmaLogView
 from ema.views.record import EmaRecordView
-from ema.views.remove import RemoveEmaView
+from ema.views.report import report_view
-from ema.views.report import EmaPublicReportView
 from ema.views.resubmission import EmaResubmissionView
 from ema.views.share import EmaShareFormView, EmaShareByTokenView
 from ema.views.state import NewEmaStateView, EditEmaStateView, RemoveEmaStateView
 
 app_name = "ema"
 urlpatterns = [
-    path("", IndexEmaView.as_view(), name="index"),
+    path("", index_view, name="index"),
-    path("new/", NewEmaView.as_view(), name="new"),
+    path("new/", new_view, name="new"),
-    path("new/id", EmaIdentifierGeneratorView.as_view(), name="new-id"),
+    path("new/id", new_id_view, name="new-id"),
-    path("<id>", DetailEmaView.as_view(), name="detail"),
+    path("<id>", detail_view, name="detail"),
     path('<id>/log', EmaLogView.as_view(), name='log'),
-    path('<id>/edit', EditEmaView.as_view(), name='edit'),
+    path('<id>/edit', edit_view, name='edit'),
-    path('<id>/remove', RemoveEmaView.as_view(), name='remove'),
+    path('<id>/remove', remove_view, name='remove'),
     path('<id>/record', EmaRecordView.as_view(), name='record'),
-    path('<id>/report', EmaPublicReportView.as_view(), name='report'),
+    path('<id>/report', report_view, name='report'),
     path('<id>/resub', EmaResubmissionView.as_view(), name='resubmission-create'),
 
     path('<id>/state/new', NewEmaStateView.as_view(), name='new-state'),

ema/views/detail.py

@@ -1,76 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.contrib import messages
-from django.http import HttpResponse, HttpRequest
-from django.shortcuts import get_object_or_404, render
-
-from ema.models import Ema
-from konova.contexts import BaseContext
-from konova.forms import SimpleGeomForm
-from konova.settings import DEFAULT_GROUP, ZB_GROUP, ETS_GROUP
-from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.message_templates import DO_NOT_FORGET_TO_SHARE
-from konova.views.detail import AbstractDetailView
-
-
-class DetailEmaView(AbstractDetailView):
-    _TEMPLATE = "ema/detail/view.html"
-
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        """ Renders the detail view of an EMA
-
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The EMA id
-
-        Returns:
-
-        """
-        ema = get_object_or_404(Ema, id=id, deleted=None)
-
-        geom_form = SimpleGeomForm(instance=ema)
-        parcels = ema.get_underlying_parcels()
-        _user = request.user
-        is_entry_shared = ema.is_shared_with(_user)
-
-        # Order states according to surface
-        before_states = ema.before_states.all().order_by("-surface")
-        after_states = ema.after_states.all().order_by("-surface")
-
-        # 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 = ema.get_surface_before_states()
-        sum_after_states = ema.get_surface_after_states()
-        diff_states = abs(sum_before_states - sum_after_states)
-
-        ema.set_status_messages(request)
-
-        requesting_user_is_only_shared_user = ema.is_only_shared_with(_user)
-        if requesting_user_is_only_shared_user:
-            messages.info(
-                request,
-                DO_NOT_FORGET_TO_SHARE
-            )
-
-        context = {
-            "obj": ema,
-            "geom_form": geom_form,
-            "parcels": parcels,
-            "is_entry_shared": is_entry_shared,
-            "before_states": before_states,
-            "after_states": after_states,
-            "sum_before_states": sum_before_states,
-            "sum_after_states": sum_after_states,
-            "diff_states": diff_states,
-            "is_default_member": _user.in_group(DEFAULT_GROUP),
-            "is_zb_member": _user.in_group(ZB_GROUP),
-            "is_ets_member": _user.in_group(ETS_GROUP),
-            "LANIS_LINK": ema.get_LANIS_link(),
-            TAB_TITLE_IDENTIFIER: f"{ema.identifier} - {ema.title}",
-            "has_finished_deadlines": ema.get_finished_deadlines().exists(),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)

ema/views/ema.py

@@ -7,96 +7,71 @@ 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.db.models import Sum
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render
-from django.utils.decorators import method_decorator
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
-from django.views.generic.base import View
 
 from ema.forms import NewEmaForm, EditEmaForm
 from ema.models import Ema
 from ema.tables import EmaTable
 from konova.contexts import BaseContext
-from konova.decorators import shared_access_required, conservation_office_group_required
+from konova.decorators import shared_access_required, conservation_office_group_required, login_required_modal, \
+    uuid_required
 from konova.forms import SimpleGeomForm
+from konova.forms.modals import RemoveModalForm
+from konova.settings import DEFAULT_GROUP, ZB_GROUP, ETS_GROUP
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
 from konova.utils.message_templates import RECORDED_BLOCKS_EDIT, IDENTIFIER_REPLACED, FORM_INVALID, \
-    GEOMETRY_SIMPLIFIED, GEOMETRIES_IGNORED_TEMPLATE
+    DO_NOT_FORGET_TO_SHARE, GEOMETRY_SIMPLIFIED, GEOMETRIES_IGNORED_TEMPLATE
-from konova.views.identifier import AbstractIdentifierGeneratorView
-from konova.views.index import AbstractIndexView
 
 
-class IndexEmaView(AbstractIndexView):
+@login_required
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
+def index_view(request: HttpRequest):
-        """ Renders the index view for EMAs
+    """ Renders the index view for EMAs
 
-        Args:
+    Args:
-            request (HttpRequest): The incoming request
+        request (HttpRequest): The incoming request
 
-        Returns:
+    Returns:
 
-        """
+    """
-        emas = Ema.objects.filter(
+    template = "generic_index.html"
-            deleted=None,
+    emas = Ema.objects.filter(
-        ).order_by(
+        deleted=None,
-            "-modified__timestamp"
+    ).order_by(
-        )
+        "-modified__timestamp"
+    )
 
-        table = EmaTable(
+    table = EmaTable(
-            request,
+        request,
-            queryset=emas
+        queryset=emas
-        )
+    )
-        context = {
+    context = {
-            "table": table,
+        "table": table,
-            TAB_TITLE_IDENTIFIER: _("EMAs - Overview"),
+        TAB_TITLE_IDENTIFIER: _("EMAs - Overview"),
-        }
+    }
-        context = BaseContext(request, context).context
+    context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
+    return render(request, template, context)
 
-class NewEmaView(LoginRequiredMixin, View):
-    _TEMPLATE = "ema/form/view.html"
 
-    @method_decorator(conservation_office_group_required)
+@login_required
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
+@conservation_office_group_required
-        """ GET endpoint
+def new_view(request: HttpRequest):
+    """
+    Renders a view for a new eco account creation
 
-        Renders form for new EMA
+    Args:
+        request (HttpRequest): The incoming request
 
-        Args:
+    Returns:
-            request (HttpRequest): The incoming request
-            *args ():
-            **kwargs ():
 
-        Returns:
+    """
-
+    template = "ema/form/view.html"
-        """
+    data_form = NewEmaForm(request.POST or None)
-        data_form = NewEmaForm(request.POST or None)
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False)
+    if request.method == "POST":
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("New EMA"),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
-
-    @method_decorator(conservation_office_group_required)
-    def post(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-        """ POST endpoint
-
-        Processes submitted form
-
-        Args:
-            request (HttpRequest): The incoming request
-            *args ():
-            **kwargs ():
-
-        Returns:
-
-        """
-        data_form = NewEmaForm(request.POST or None)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False)
         if data_form.is_valid() and geom_form.is_valid():
             generated_identifier = data_form.cleaned_data.get("identifier", None)
             ema = data_form.save(request.user, geom_form)
@@ -120,91 +95,128 @@ class NewEmaView(LoginRequiredMixin, View):
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("ema:detail", id=ema.id)
         else:
             messages.error(request, FORM_INVALID, extra_tags="danger",)
-        context = {
+    else:
-            "form": data_form,
+        # For clarification: nothing in this case
-            "geom_form": geom_form,
+        pass
-            TAB_TITLE_IDENTIFIER: _("New EMA"),
+    context = {
+        "form": data_form,
+        "geom_form": geom_form,
+        TAB_TITLE_IDENTIFIER: _("New EMA"),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
+
+
+@login_required
+@conservation_office_group_required
+def new_id_view(request: HttpRequest):
+    """ JSON endpoint
+
+    Provides fetching of free identifiers for e.g. AJAX calls
+
+    """
+    tmp = Ema()
+    identifier = tmp.generate_new_identifier()
+    while Ema.objects.filter(identifier=identifier).exists():
+        identifier = tmp.generate_new_identifier()
+    return JsonResponse(
+        data={
+            "gen_data": identifier
         }
-        context = BaseContext(request, context).context
+    )
-        return render(request, self._TEMPLATE, context)
 
-class EmaIdentifierGeneratorView(AbstractIdentifierGeneratorView):
-    _MODEL = Ema
 
-    @method_decorator(conservation_office_group_required)
+@login_required
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
+@uuid_required
-        return super().get(request, *args, **kwargs)
+def detail_view(request: HttpRequest, id: str):
+    """ Renders the detail view of an EMA
 
-class EditEmaView(LoginRequiredMixin, View):
+    Args:
-    _TEMPLATE = "compensation/form/view.html"
+        request (HttpRequest): The incoming request
+        id (str): The EMA id
 
-    @method_decorator(conservation_office_group_required)
+    Returns:
-    @method_decorator(shared_access_required(Ema, "id"))
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        """ GET endpoint
 
-        Renders form
+    """
+    template = "ema/detail/view.html"
+    ema = get_object_or_404(Ema, id=id, deleted=None)
 
-        Args:
+    geom_form = SimpleGeomForm(instance=ema)
-            request (HttpRequest): The incoming request
+    parcels = ema.get_underlying_parcels()
-            id (str): The ema identifier
+    _user = request.user
-            *args ():
+    is_entry_shared = ema.is_shared_with(_user)
-            **kwargs ():
 
-        Returns:
+    # Order states according to surface
+    before_states = ema.before_states.all().order_by("-surface")
+    after_states = ema.after_states.all().order_by("-surface")
 
-        """
+    # Precalculate logical errors between before- and after-states
-        # Get object from db
+    # Sum() returns None in case of no states, so we catch that and replace it with 0 for easier handling
-        ema = get_object_or_404(Ema, id=id)
+    sum_before_states = ema.get_surface_before_states()
-        if ema.is_recorded:
+    sum_after_states = ema.get_surface_after_states()
-            messages.info(
+    diff_states = abs(sum_before_states - sum_after_states)
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("ema:detail", id=id)
 
-        # Create forms, initialize with values from db/from POST request
+    ema.set_status_messages(request)
-        data_form = EditEmaForm(instance=ema)
-        geom_form = SimpleGeomForm(read_only=False, instance=ema)
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(ema.identifier),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
 
-    @method_decorator(conservation_office_group_required)
+    requesting_user_is_only_shared_user = ema.is_only_shared_with(_user)
-    @method_decorator(shared_access_required(Ema, "id"))
+    if requesting_user_is_only_shared_user:
-    def post(self, request: HttpRequest, id:str, *args, **kwargs) -> HttpResponse:
+        messages.info(
-        """ POST endpoint
+            request,
+            DO_NOT_FORGET_TO_SHARE
+        )
 
-        Process submitted forms
+    context = {
+        "obj": ema,
+        "geom_form": geom_form,
+        "parcels": parcels,
+        "is_entry_shared": is_entry_shared,
+        "before_states": before_states,
+        "after_states": after_states,
+        "sum_before_states": sum_before_states,
+        "sum_after_states": sum_after_states,
+        "diff_states": diff_states,
+        "is_default_member": _user.in_group(DEFAULT_GROUP),
+        "is_zb_member": _user.in_group(ZB_GROUP),
+        "is_ets_member": _user.in_group(ETS_GROUP),
+        "LANIS_LINK": ema.get_LANIS_link(),
+        TAB_TITLE_IDENTIFIER: f"{ema.identifier} - {ema.title}",
+        "has_finished_deadlines": ema.get_finished_deadlines().exists(),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The id of the ema
-            *args ():
-            **kwargs ():
 
-        Returns:
+@login_required
+@conservation_office_group_required
+@shared_access_required(Ema, "id")
+def edit_view(request: HttpRequest, id: str):
+    """
+    Renders a view for editing compensations
 
-        """
+    Args:
-        # Get object from db
+        request (HttpRequest): The incoming request
-        ema = get_object_or_404(Ema, id=id)
-        if ema.is_recorded:
-            messages.info(
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("ema:detail", id=id)
 
-        # Create forms, initialize with values from db/from POST request
+    Returns:
-        data_form = EditEmaForm(request.POST or None, instance=ema)
+
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=ema)
+    """
+    template = "compensation/form/view.html"
+    # Get object from db
+    ema = get_object_or_404(Ema, id=id)
+    if ema.is_recorded:
+        messages.info(
+            request,
+            RECORDED_BLOCKS_EDIT
+        )
+        return redirect("ema:detail", id=id)
+
+    # Create forms, initialize with values from db/from POST request
+    data_form = EditEmaForm(request.POST or None, instance=ema)
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=ema)
+    if request.method == "POST":
         if data_form.is_valid() and geom_form.is_valid():
             # The data form takes the geom form for processing, as well as the performing user
             ema = data_form.save(request.user, geom_form)
@@ -214,19 +226,48 @@ class EditEmaView(LoginRequiredMixin, View):
                     request,
                     GEOMETRY_SIMPLIFIED
                 )
+
             num_ignored_geometries = geom_form.get_num_geometries_ignored()
             if num_ignored_geometries > 0:
                 messages.info(
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("ema:detail", id=ema.id)
         else:
-            messages.error(request, FORM_INVALID, extra_tags="danger", )
+            messages.error(request, FORM_INVALID, extra_tags="danger",)
-        context = {
+    else:
-            "form": data_form,
+        # For clarification: nothing in this case
-            "geom_form": geom_form,
+        pass
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(ema.identifier),
+    context = {
-        }
+        "form": data_form,
-        context = BaseContext(request, context).context
+        "geom_form": geom_form,
-        return render(request, self._TEMPLATE, context)
+        TAB_TITLE_IDENTIFIER: _("Edit {}").format(ema.identifier),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
+
+
+@login_required_modal
+@login_required
+@conservation_office_group_required
+@shared_access_required(Ema, "id")
+def remove_view(request: HttpRequest, id: str):
+    """ Renders a modal view for removing the EMA
+
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The EMA's id
+
+    Returns:
+
+    """
+    ema = get_object_or_404(Ema, id=id)
+    form = RemoveModalForm(request.POST or None, instance=ema, request=request)
+    return form.process_request(
+        request=request,
+        msg_success=_("EMA removed"),
+        redirect_url=reverse("ema:index"),
+    )
+

ema/views/log.py

@@ -18,6 +18,7 @@ class EmaLogView(AbstractLogView):
 
     @method_decorator(login_required_modal)
     @method_decorator(login_required)
+    @method_decorator(conservation_office_group_required)
     @method_decorator(shared_access_required(Ema, "id"))
     def dispatch(self, request, *args, **kwargs):
         return super().dispatch(request, *args, **kwargs)

ema/views/remove.py

@@ -1,21 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.http import HttpRequest, HttpResponse
-from django.utils.decorators import method_decorator
-
-from ema.models import Ema
-from konova.decorators import shared_access_required, conservation_office_group_required
-from konova.views.remove import AbstractRemoveView
-
-
-class RemoveEmaView(AbstractRemoveView):
-    _MODEL = Ema
-    _REDIRECT_URL = "ema:index"
-
-    @method_decorator(conservation_office_group_required)
-    @method_decorator(shared_access_required(Ema, "id"))
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-        return super().get(request, *args, **kwargs)

ema/views/report.py

@@ -5,81 +5,77 @@ Contact: ksp-servicestelle@sgdnord.rlp.de
 Created on: 19.08.22
 
 """
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest
 from django.shortcuts import get_object_or_404, render
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from ema.models import Ema
 from konova.contexts import BaseContext
+from konova.decorators import uuid_required
 from konova.forms import SimpleGeomForm
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.qrcode import QrCode
+from konova.utils.generators import generate_qr_code
-from konova.views.report import AbstractPublicReportView
 
+@uuid_required
+def report_view(request:HttpRequest, id: str):
+    """ Renders the public report view
 
-class EmaPublicReportView(AbstractPublicReportView):
+    Args:
-    _TEMPLATE = "ema/report/report.html"
+        request (HttpRequest): The incoming request
+        id (str): The id of the intervention
 
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
+    Returns:
-        """ Renders the public report view
 
-        Args:
+    """
-            request (HttpRequest): The incoming request
+    # Reuse the compensation report template since EMAs are structurally identical
-            id (str): The id of the intervention
+    template = "ema/report/report.html"
-
+    ema = get_object_or_404(Ema, id=id)
-        Returns:
-
-        """
-        ema = get_object_or_404(Ema, id=id)
-        tab_title = _("Report {}").format(ema.identifier)
-        # If intervention is not recorded (yet or currently) we need to render another template without any data
-        if not ema.is_ready_for_publish():
-            template = "report/unavailable.html"
-            context = {
-                TAB_TITLE_IDENTIFIER: tab_title,
-            }
-            context = BaseContext(request, context).context
-            return render(request, template, context)
-
-        # Prepare data for map viewer
-        geom_form = SimpleGeomForm(
-            instance=ema,
-        )
-        parcels = ema.get_underlying_parcels()
-
-        qrcode = QrCode(
-            content=request.build_absolute_uri(reverse("ema:report", args=(id,))),
-            size=10
-        )
-        qrcode_lanis = QrCode(
-            content=ema.get_LANIS_link(),
-            size=7
-        )
-
-        # Order states by surface
-        before_states = ema.before_states.all().order_by("-surface").prefetch_related("biotope_type")
-        after_states = ema.after_states.all().order_by("-surface").prefetch_related("biotope_type")
-        actions = ema.actions.all().prefetch_related("action_type")
 
+    tab_title = _("Report {}").format(ema.identifier)
+    # If intervention is not recorded (yet or currently) we need to render another template without any data
+    if not ema.is_ready_for_publish():
+        template = "report/unavailable.html"
         context = {
-            "obj": ema,
-            "qrcode": {
-                "img": qrcode.get_img(),
-                "url": qrcode.get_content(),
-            },
-            "qrcode_lanis": {
-                "img": qrcode_lanis.get_img(),
-                "url": qrcode_lanis.get_content(),
-            },
-            "is_entry_shared": False,  # disables action buttons during rendering
-            "before_states": before_states,
-            "after_states": after_states,
-            "geom_form": geom_form,
-            "parcels": parcels,
-            "actions": actions,
-            "tables_scrollable": False,
             TAB_TITLE_IDENTIFIER: tab_title,
         }
         context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
+        return render(request, template, context)
+
+    # Prepare data for map viewer
+    geom_form = SimpleGeomForm(
+        instance=ema,
+    )
+    parcels = ema.get_underlying_parcels()
+
+    qrcode_url = request.build_absolute_uri(reverse("ema:report", args=(id,)))
+    qrcode_img = generate_qr_code(qrcode_url, 10)
+    qrcode_lanis_url = ema.get_LANIS_link()
+    qrcode_img_lanis = generate_qr_code(qrcode_lanis_url, 7)
+
+    # Order states by surface
+    before_states = ema.before_states.all().order_by("-surface").prefetch_related("biotope_type")
+    after_states = ema.after_states.all().order_by("-surface").prefetch_related("biotope_type")
+    actions = ema.actions.all().prefetch_related("action_type")
+
+    context = {
+        "obj": ema,
+        "qrcode": {
+            "img": qrcode_img,
+            "url": qrcode_url
+        },
+        "qrcode_lanis": {
+            "img": qrcode_img_lanis,
+            "url": qrcode_lanis_url
+        },
+        "is_entry_shared": False,  # disables action buttons during rendering
+        "before_states": before_states,
+        "after_states": after_states,
+        "geom_form": geom_form,
+        "parcels": parcels,
+        "actions": actions,
+        "tables_scrollable": False,
+        TAB_TITLE_IDENTIFIER: tab_title,
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)

intervention/admin.py

@@ -37,14 +37,6 @@ class InterventionAdmin(BaseObjectAdmin):
             "geometry",
         ]
 
-    def get_actions(self, request):
-        DELETE_ACTION_IDENTIFIER = "delete_selected"
-        actions = super().get_actions(request)
-
-        if DELETE_ACTION_IDENTIFIER in actions:
-            del actions[DELETE_ACTION_IDENTIFIER]
-
-        return actions
 
 class InterventionDocumentAdmin(AbstractDocumentAdmin):
     pass

intervention/urls.py

@@ -8,42 +8,39 @@ Created on: 30.11.20
 from django.urls import path
 
 from intervention.autocomplete.intervention import InterventionAutocomplete
-from intervention.views.check import InterventionCheckView
+from intervention.views.check import check_view
-from intervention.views.compensation import RemoveCompensationFromInterventionView
+from intervention.views.compensation import remove_compensation_view
 from intervention.views.deduction import NewInterventionDeductionView, EditInterventionDeductionView, \
     RemoveInterventionDeductionView
 from intervention.views.document import NewInterventionDocumentView, GetInterventionDocumentView, \
     RemoveInterventionDocumentView, EditInterventionDocumentView
-from intervention.views.intervention import IndexInterventionView, InterventionIdentifierGeneratorView, \
+from intervention.views.intervention import index_view, new_view, new_id_view, detail_view, edit_view, remove_view
-    NewInterventionView, EditInterventionView
-from intervention.views.remove import RemoveInterventionView
-from intervention.views.detail import DetailInterventionView
 from intervention.views.log import InterventionLogView
 from intervention.views.record import InterventionRecordView
-from intervention.views.report import InterventionPublicReportView
+from intervention.views.report import report_view
 from intervention.views.resubmission import InterventionResubmissionView
-from intervention.views.revocation import NewInterventionRevocationView, GetInterventionRevocationView, \
+from intervention.views.revocation import new_revocation_view, edit_revocation_view, remove_revocation_view, \
-    EditInterventionRevocationView, RemoveInterventionRevocationView
+    get_revocation_view
 from intervention.views.share import InterventionShareFormView, InterventionShareByTokenView
 
 app_name = "intervention"
 urlpatterns = [
-    path("", IndexInterventionView.as_view(), name="index"),
+    path("", index_view, name="index"),
-    path('new/', NewInterventionView.as_view(), name='new'),
+    path('new/', new_view, name='new'),
-    path('new/id', InterventionIdentifierGeneratorView.as_view(), name='new-id'),
+    path('new/id', new_id_view, name='new-id'),
-    path('<id>', DetailInterventionView.as_view(), name='detail'),
+    path('<id>', detail_view, name='detail'),
     path('<id>/log', InterventionLogView.as_view(), name='log'),
-    path('<id>/edit', EditInterventionView.as_view(), name='edit'),
+    path('<id>/edit', edit_view, name='edit'),
-    path('<id>/remove', RemoveInterventionView.as_view(), name='remove'),
+    path('<id>/remove', remove_view, name='remove'),
     path('<id>/share/<token>', InterventionShareByTokenView.as_view(), name='share-token'),
     path('<id>/share', InterventionShareFormView.as_view(), name='share-form'),
-    path('<id>/check', InterventionCheckView.as_view(), name='check'),
+    path('<id>/check', check_view, name='check'),
     path('<id>/record', InterventionRecordView.as_view(), name='record'),
-    path('<id>/report', InterventionPublicReportView.as_view(), name='report'),
+    path('<id>/report', report_view, name='report'),
     path('<id>/resub', InterventionResubmissionView.as_view(), name='resubmission-create'),
 
     # Compensations
-    path('<id>/compensation/<comp_id>/remove', RemoveCompensationFromInterventionView.as_view(), name='remove-compensation'),
+    path('<id>/compensation/<comp_id>/remove', remove_compensation_view, name='remove-compensation'),
 
     # Documents
     path('<id>/document/new/', NewInterventionDocumentView.as_view(), name='new-doc'),
@@ -57,10 +54,10 @@ urlpatterns = [
     path('<id>/deduction/<deduction_id>/remove', RemoveInterventionDeductionView.as_view(), name='remove-deduction'),
 
     # Revocation routes
-    path('<id>/revocation/new', NewInterventionRevocationView.as_view(), name='new-revocation'),
+    path('<id>/revocation/new', new_revocation_view, name='new-revocation'),
-    path('<id>/revocation/<revocation_id>/edit', EditInterventionRevocationView.as_view(), name='edit-revocation'),
+    path('<id>/revocation/<revocation_id>/edit', edit_revocation_view, name='edit-revocation'),
-    path('<id>/revocation/<revocation_id>/remove', RemoveInterventionRevocationView.as_view(), name='remove-revocation'),
+    path('<id>/revocation/<revocation_id>/remove', remove_revocation_view, name='remove-revocation'),
-    path('revocation/<doc_id>', GetInterventionRevocationView.as_view(), name='get-doc-revocation'),
+    path('revocation/<doc_id>', get_revocation_view, name='get-doc-revocation'),
 
     # Autocomplete
     path("atcmplt/interventions", InterventionAutocomplete.as_view(), name="autocomplete"),

intervention/views/check.py

@@ -5,44 +5,35 @@ Contact: ksp-servicestelle@sgdnord.rlp.de
 Created on: 19.08.22
 
 """
-from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.auth.decorators import login_required
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest
 from django.shortcuts import get_object_or_404
-from django.utils.decorators import method_decorator
 from django.utils.translation import gettext_lazy as _
-from django.views import View
 
 from intervention.forms.modals.check import CheckModalForm
 from intervention.models import Intervention
 from konova.decorators import registration_office_group_required, shared_access_required
 from konova.utils.message_templates import INTERVENTION_INVALID
 
-class InterventionCheckView(LoginRequiredMixin, View):
 
-    def __process_request(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
+@login_required
-        """ Renders check form for an intervention
+@registration_office_group_required
+@shared_access_required(Intervention, "id")
+def check_view(request: HttpRequest, id: str):
+    """ Renders check form for an intervention
 
-        Args:
+    Args:
-            request (HttpRequest): The incoming request
+        request (HttpRequest): The incoming request
-            id (str): Intervention's id
+        id (str): Intervention's id
 
-        Returns:
+    Returns:
 
-        """
+    """
-        intervention = get_object_or_404(Intervention, id=id)
+    intervention = get_object_or_404(Intervention, id=id)
-        form = CheckModalForm(request.POST or None, instance=intervention, request=request)
+    form = CheckModalForm(request.POST or None, instance=intervention, request=request)
-        return form.process_request(
+    return form.process_request(
-            request,
+        request,
-            msg_success=_("Check performed"),
+        msg_success=_("Check performed"),
-            msg_error=INTERVENTION_INVALID
+        msg_error=INTERVENTION_INVALID
-        )
+    )
 
-    @method_decorator(registration_office_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, *args, **kwargs)
-
-    @method_decorator(registration_office_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def post(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, *args, **kwargs)

intervention/views/compensation.py

@@ -5,50 +5,42 @@ Contact: ksp-servicestelle@sgdnord.rlp.de
 Created on: 19.08.22
 
 """
-from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.auth.decorators import login_required
 from django.core.exceptions import ObjectDoesNotExist
-from django.http import HttpRequest, Http404, HttpResponse
+from django.http import HttpRequest, Http404
 from django.shortcuts import get_object_or_404
 from django.urls import reverse
-from django.utils.decorators import method_decorator
-from django.views import View
 
 from intervention.models import Intervention
-from konova.decorators import shared_access_required
+from konova.decorators import shared_access_required, login_required_modal
 from konova.forms.modals import RemoveModalForm
 from konova.utils.message_templates import COMPENSATION_REMOVED_TEMPLATE
 
 
-class RemoveCompensationFromInterventionView(LoginRequiredMixin, View):
+@login_required_modal
+@login_required
+@shared_access_required(Intervention, "id")
+def remove_compensation_view(request: HttpRequest, id: str, comp_id: str):
+    """ Renders a modal view for removing the compensation
 
-    def __process_request(self, request: HttpRequest, id: str, comp_id: str, *args, **kwargs) -> HttpResponse:
+    Args:
-        """ Renders a modal view for removing the compensation
+        request (HttpRequest): The incoming request
+        id (str): The compensation's id
 
-        Args:
+    Returns:
-            request (HttpRequest): The incoming request
-            id (str): The compensation's id
 
-        Returns:
+    """
-
+    intervention = get_object_or_404(Intervention, id=id)
-        """
+    try:
-        intervention = get_object_or_404(Intervention, id=id)
+        comp = intervention.compensations.get(
-        try:
+            id=comp_id
-            comp = intervention.compensations.get(
-                id=comp_id
-            )
-        except ObjectDoesNotExist:
-            raise Http404("Unknown compensation")
-        form = RemoveModalForm(request.POST or None, instance=comp, request=request)
-        return form.process_request(
-            request=request,
-            msg_success=COMPENSATION_REMOVED_TEMPLATE.format(comp.identifier),
-            redirect_url=reverse("intervention:detail", args=(id,)) + "#related_data",
         )
+    except ObjectDoesNotExist:
+        raise Http404("Unknown compensation")
+    form = RemoveModalForm(request.POST or None, instance=comp, request=request)
+    return form.process_request(
+        request=request,
+        msg_success=COMPENSATION_REMOVED_TEMPLATE.format(comp.identifier),
+        redirect_url=reverse("intervention:detail", args=(id,)) + "#related_data",
+    )
 
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def get(self, request, id: str, comp_id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, comp_id, *args, **kwargs)
-
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def post(self, request, id: str, comp_id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, comp_id, *args, **kwargs)

intervention/views/detail.py

@@ -1,79 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.contrib import messages
-from django.http import HttpResponse
-from django.shortcuts import get_object_or_404, render
-
-from intervention.models import Intervention
-from konova.contexts import BaseContext
-from konova.forms import SimpleGeomForm
-from konova.settings import DEFAULT_GROUP, ZB_GROUP, ETS_GROUP
-from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.message_templates import DATA_CHECKED_PREVIOUSLY_TEMPLATE, DO_NOT_FORGET_TO_SHARE
-from konova.views.detail import AbstractDetailView
-
-
-class DetailInterventionView(AbstractDetailView):
-    _TEMPLATE = "intervention/detail/view.html"
-
-    def get(self, request, id: str, *args, **kwargs) -> HttpResponse:
-        # Fetch data, filter out deleted related data
-        intervention = get_object_or_404(
-            Intervention.objects.select_related(
-                "geometry",
-                "legal",
-                "responsible",
-            ).prefetch_related(
-                "legal__revocations",
-            ),
-            id=id,
-            deleted=None
-        )
-        compensations = intervention.compensations.filter(
-            deleted=None,
-        )
-        _user = request.user
-        is_data_shared = intervention.is_shared_with(user=_user)
-
-        geom_form = SimpleGeomForm(
-            instance=intervention,
-        )
-        last_checked = 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
-            )
-
-        has_payment_without_document = intervention.payments.exists() and not intervention.get_documents()[1].exists()
-
-        requesting_user_is_only_shared_user = intervention.is_only_shared_with(_user)
-        if requesting_user_is_only_shared_user:
-            messages.info(
-                request,
-                DO_NOT_FORGET_TO_SHARE
-            )
-
-        context = {
-            "obj": intervention,
-            "last_checked": last_checked,
-            "last_checked_tooltip": last_checked_tooltip,
-            "compensations": compensations,
-            "is_entry_shared": is_data_shared,
-            "geom_form": geom_form,
-            "is_default_member": _user.in_group(DEFAULT_GROUP),
-            "is_zb_member": _user.in_group(ZB_GROUP),
-            "is_ets_member": _user.in_group(ETS_GROUP),
-            "LANIS_LINK": intervention.get_LANIS_link(),
-            "has_payment_without_document": has_payment_without_document,
-            TAB_TITLE_IDENTIFIER: f"{intervention.identifier} - {intervention.title}",
-        }
-
-        request = intervention.set_status_messages(request)
-
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)

intervention/views/intervention.py

@@ -7,98 +7,76 @@ 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.http import JsonResponse, HttpRequest
-from django.http import HttpRequest, HttpResponse
 from django.shortcuts import get_object_or_404, render, redirect
-from django.utils.decorators import method_decorator
+from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
-from django.views import View
 
 from intervention.forms.intervention import EditInterventionForm, NewInterventionForm
 from intervention.models import Intervention
 from intervention.tables import InterventionTable
 from konova.contexts import BaseContext
-from konova.decorators import default_group_required, shared_access_required
+from konova.decorators import default_group_required, shared_access_required, any_group_check, login_required_modal, \
+    uuid_required
 from konova.forms import SimpleGeomForm
+from konova.forms.modals import RemoveModalForm
+from konova.settings import DEFAULT_GROUP, ZB_GROUP, ETS_GROUP
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.message_templates import RECORDED_BLOCKS_EDIT, \
+from konova.utils.message_templates import DATA_CHECKED_PREVIOUSLY_TEMPLATE, RECORDED_BLOCKS_EDIT, \
-    CHECK_STATE_RESET, FORM_INVALID, IDENTIFIER_REPLACED, GEOMETRY_SIMPLIFIED, \
+    CHECK_STATE_RESET, FORM_INVALID, IDENTIFIER_REPLACED, DO_NOT_FORGET_TO_SHARE, GEOMETRY_SIMPLIFIED, \
     GEOMETRIES_IGNORED_TEMPLATE
-from konova.views.identifier import AbstractIdentifierGeneratorView
-from konova.views.index import AbstractIndexView
 
 
-class IndexInterventionView(AbstractIndexView):
+@login_required
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
+@any_group_check
-        """
+def index_view(request: HttpRequest):
-        Renders the index view for Interventions
+    """
+    Renders the index view for Interventions
 
-        Args:
+    Args:
-            request (HttpRequest): The incoming request
+        request (HttpRequest): The incoming request
 
-        Returns:
+    Returns:
-            A rendered view
+        A rendered view
-        """
+    """
-        # Filtering by user access is performed in table filter inside InterventionTableFilter class
+    template = "generic_index.html"
-        interventions = Intervention.objects.filter(
+
-            deleted=None,  # not deleted
+    # Filtering by user access is performed in table filter inside InterventionTableFilter class
-        ).select_related(
+    interventions = Intervention.objects.filter(
-            "legal"
+        deleted=None,  # not deleted
-        ).order_by(
+    ).select_related(
-            "-modified__timestamp"
+        "legal"
-        )
+    ).order_by(
-        table = InterventionTable(
+        "-modified__timestamp"
-            request=request,
+    )
-            queryset=interventions
+    table = InterventionTable(
-        )
+        request=request,
-        context = {
+        queryset=interventions
-            "table": table,
+    )
-            TAB_TITLE_IDENTIFIER: _("Interventions - Overview"),
+    context = {
-        }
+        "table": table,
-        context = BaseContext(request, context).context
+        TAB_TITLE_IDENTIFIER: _("Interventions - Overview"),
-        return render(request, self._TEMPLATE, context)
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
 
-class NewInterventionView(LoginRequiredMixin, View):
+@login_required
-    _TEMPLATE = "intervention/form/view.html"
+@default_group_required
+def new_view(request: HttpRequest):
+    """
+    Renders a view for a new intervention creation
 
-    @method_decorator(default_group_required)
+    Args:
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
+        request (HttpRequest): The incoming request
 
-        """
+    Returns:
-        Renders a view for a new intervention creation
-
-        Args:
-            request (HttpRequest): The incoming request
-
-        Returns:
-
-        """
-        data_form = NewInterventionForm()
-        geom_form = SimpleGeomForm(read_only=False)
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("New intervention"),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
-
-    @method_decorator(default_group_required)
-    def post(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-
-        """
-        Renders a view for a new intervention creation
-
-        Args:
-            request (HttpRequest): The incoming request
-
-        Returns:
-
-        """
-        data_form = NewInterventionForm(request.POST or None)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False)
 
+    """
+    template = "intervention/form/view.html"
+    data_form = NewInterventionForm(request.POST or None)
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False)
+    if request.method == "POST":
         if data_form.is_valid() and geom_form.is_valid():
             generated_identifier = data_form.cleaned_data.get("identifier", None)
             intervention = data_form.save(request.user, geom_form)
@@ -110,7 +88,6 @@ class NewInterventionView(LoginRequiredMixin, View):
                         intervention.identifier
                     )
                 )
-
             messages.success(request, _("Intervention {} added").format(intervention.identifier))
             if geom_form.has_geometry_simplified():
                 messages.info(
@@ -124,86 +101,142 @@ class NewInterventionView(LoginRequiredMixin, View):
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("intervention:detail", id=intervention.id)
-
         else:
-            messages.error(request, FORM_INVALID, extra_tags="danger", )
+            messages.error(request, FORM_INVALID, extra_tags="danger",)
-        context = {
+    else:
-            "form": data_form,
+        # For clarification: nothing in this case
-            "geom_form": geom_form,
+        pass
-            TAB_TITLE_IDENTIFIER: _("New intervention"),
+    context = {
+        "form": data_form,
+        "geom_form": geom_form,
+        TAB_TITLE_IDENTIFIER: _("New intervention"),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
+
+
+@login_required
+@default_group_required
+def new_id_view(request: HttpRequest):
+    """ JSON endpoint
+
+    Provides fetching of free identifiers for e.g. AJAX calls
+
+    """
+    tmp_intervention = Intervention()
+    identifier = tmp_intervention.generate_new_identifier()
+    while Intervention.objects.filter(identifier=identifier).exists():
+        identifier = tmp_intervention.generate_new_identifier()
+    return JsonResponse(
+        data={
+            "gen_data": identifier
         }
-        context = BaseContext(request, context).context
+    )
-        return render(request, self._TEMPLATE, context)
 
 
-class InterventionIdentifierGeneratorView(AbstractIdentifierGeneratorView):
+@login_required
-    _MODEL = Intervention
+@any_group_check
+@uuid_required
+def detail_view(request: HttpRequest, id: str):
+    """ Renders a detail view for viewing an intervention's data
+
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The intervention's id
+
+    Returns:
+
+    """
+    template = "intervention/detail/view.html"
+
+    # Fetch data, filter out deleted related data
+    intervention = get_object_or_404(
+        Intervention.objects.select_related(
+            "geometry",
+            "legal",
+            "responsible",
+        ).prefetch_related(
+            "legal__revocations",
+        ),
+        id=id,
+        deleted=None
+    )
+    compensations = intervention.compensations.filter(
+        deleted=None,
+    )
+    _user = request.user
+    is_data_shared = intervention.is_shared_with(user=_user)
+
+    geom_form = SimpleGeomForm(
+        instance=intervention,
+    )
+    last_checked = 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
+        )
+
+    has_payment_without_document = intervention.payments.exists() and not intervention.get_documents()[1].exists()
+
+    requesting_user_is_only_shared_user = intervention.is_only_shared_with(_user)
+    if requesting_user_is_only_shared_user:
+        messages.info(
+            request,
+            DO_NOT_FORGET_TO_SHARE
+        )
+
+    context = {
+        "obj": intervention,
+        "last_checked": last_checked,
+        "last_checked_tooltip": last_checked_tooltip,
+        "compensations": compensations,
+        "is_entry_shared": is_data_shared,
+        "geom_form": geom_form,
+        "is_default_member": _user.in_group(DEFAULT_GROUP),
+        "is_zb_member": _user.in_group(ZB_GROUP),
+        "is_ets_member": _user.in_group(ETS_GROUP),
+        "LANIS_LINK": intervention.get_LANIS_link(),
+        "has_payment_without_document": has_payment_without_document,
+        TAB_TITLE_IDENTIFIER: f"{intervention.identifier} - {intervention.title}",
+    }
+
+    request = intervention.set_status_messages(request)
+
+    context = BaseContext(request, context).context
+    return render(request, template, context)
 
 
-class EditInterventionView(LoginRequiredMixin, View):
+@login_required
-    _TEMPLATE = "intervention/form/view.html"
+@default_group_required
+@shared_access_required(Intervention, "id")
+def edit_view(request: HttpRequest, id: str):
+    """
+    Renders a view for editing interventions
 
-    @method_decorator(default_group_required)
+    Args:
-    @method_decorator(shared_access_required(Intervention, "id"))
+        request (HttpRequest): The incoming request
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        """
-        Renders a view for editing interventions
 
-        Args:
+    Returns:
-            request (HttpRequest): The incoming request
-            id (str): The intervention identifier
 
-        Returns:
+    """
-            HttpResponse: The rendered view
+    template = "intervention/form/view.html"
-        """
+    # Get object from db
+    intervention = get_object_or_404(Intervention, id=id)
+    if intervention.is_recorded:
+        messages.info(
+            request,
+            RECORDED_BLOCKS_EDIT
+        )
+        return redirect("intervention:detail", id=id)
 
-        # Get object from db
+    # Create forms, initialize with values from db/from POST request
-        intervention = get_object_or_404(Intervention, id=id)
+    data_form = EditInterventionForm(request.POST or None, instance=intervention)
-        if intervention.is_recorded:
+    geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=intervention)
-            messages.info(
+    if request.method == "POST":
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("intervention:detail", id=id)
-
-        # Create forms, initialize with values from db/from POST request
-        data_form = EditInterventionForm(request.POST or None, instance=intervention)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=intervention)
-        context = {
-            "form": data_form,
-            "geom_form": geom_form,
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(intervention.identifier),
-        }
-        context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
-
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def post(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        """
-        Process saved form content
-
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The intervention id
-
-        Returns:
-            HttpResponse:
-        """
-        # Get object from db
-        intervention = get_object_or_404(Intervention, id=id)
-        if intervention.is_recorded:
-            messages.info(
-                request,
-                RECORDED_BLOCKS_EDIT
-            )
-            return redirect("intervention:detail", id=id)
-
-        # Create forms, initialize with values from db/from POST request
-        data_form = EditInterventionForm(request.POST or None, instance=intervention)
-        geom_form = SimpleGeomForm(request.POST or None, read_only=False, instance=intervention)
         if data_form.is_valid() and geom_form.is_valid():
             # The data form takes the geom form for processing, as well as the performing user
             # Save the current state of recorded|checked to inform the user in case of a status reset due to editing
@@ -217,17 +250,48 @@ class EditInterventionView(LoginRequiredMixin, View):
                     request,
                     GEOMETRY_SIMPLIFIED
                 )
+
             num_ignored_geometries = geom_form.get_num_geometries_ignored()
             if num_ignored_geometries > 0:
                 messages.info(
                     request,
                     GEOMETRIES_IGNORED_TEMPLATE.format(num_ignored_geometries)
                 )
+
             return redirect("intervention:detail", id=intervention.id)
-        context = {
+        else:
-            "form": data_form,
+            messages.error(request, FORM_INVALID, extra_tags="danger",)
-            "geom_form": geom_form,
+    else:
-            TAB_TITLE_IDENTIFIER: _("Edit {}").format(intervention.identifier),
+        # For clarification: nothing in this case
-        }
+        pass
-        context = BaseContext(request, context).context
+    context = {
-        return render(request, self._TEMPLATE, context)
+        "form": data_form,
+        "geom_form": geom_form,
+        TAB_TITLE_IDENTIFIER: _("Edit {}").format(intervention.identifier),
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)
+
+
+@login_required_modal
+@login_required
+@default_group_required
+@shared_access_required(Intervention, "id")
+def remove_view(request: HttpRequest, id: str):
+    """ Renders a remove view for this intervention
+
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The uuid id as string
+
+    Returns:
+
+    """
+    obj = Intervention.objects.get(id=id)
+    identifier = obj.identifier
+    form = RemoveModalForm(request.POST or None, instance=obj, request=request)
+    return form.process_request(
+        request,
+        _("{} removed").format(identifier),
+        redirect_url=reverse("intervention:index")
+    )

intervention/views/remove.py

@@ -1,20 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from django.http import HttpRequest, HttpResponse
-from django.utils.decorators import method_decorator
-
-from intervention.models import Intervention
-from konova.decorators import shared_access_required
-from konova.views.remove import AbstractRemoveView
-
-
-class RemoveInterventionView(AbstractRemoveView):
-    _MODEL = Intervention
-    _REDIRECT_URL = "intervention:index"
-
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-        return super().get(request, *args, **kwargs)

intervention/views/report.py

@@ -5,78 +5,72 @@ Contact: ksp-servicestelle@sgdnord.rlp.de
 Created on: 19.08.22
 
 """
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest
 from django.shortcuts import get_object_or_404, render
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from intervention.models import Intervention
 from konova.contexts import BaseContext
+from konova.decorators import uuid_required
 from konova.forms import SimpleGeomForm
 from konova.sub_settings.context_settings import TAB_TITLE_IDENTIFIER
-from konova.utils.qrcode import QrCode
+from konova.utils.generators import generate_qr_code
-from konova.views.report import AbstractPublicReportView
 
 
-class InterventionPublicReportView(AbstractPublicReportView):
+@uuid_required
-    _TEMPLATE = "intervention/report/report.html"
+def report_view(request: HttpRequest, id: str):
+    """ Renders the public report view
 
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
+    Args:
-        """ Renders the public report view
+        request (HttpRequest): The incoming request
+        id (str): The id of the intervention
 
-        Args:
+    Returns:
-            request (HttpRequest): The incoming request
-            id (str): The id of the intervention
 
-        Returns:
+    """
-
+    template = "intervention/report/report.html"
-        """
+    intervention = get_object_or_404(Intervention, id=id)
-        intervention = get_object_or_404(Intervention, id=id)
-
-        tab_title = _("Report {}").format(intervention.identifier)
-        # If intervention is not recorded (yet or currently) we need to render another template without any data
-        if not intervention.is_ready_for_publish():
-            template = "report/unavailable.html"
-            context = {
-                TAB_TITLE_IDENTIFIER: tab_title,
-            }
-            context = BaseContext(request, context).context
-            return render(request, template, context)
-
-        # Prepare data for map viewer
-        geom_form = SimpleGeomForm(
-            instance=intervention
-        )
-        parcels = intervention.get_underlying_parcels()
-
-        distinct_deductions = intervention.deductions.all().distinct(
-            "account"
-        )
-
-        qrcode = QrCode(
-            content=request.build_absolute_uri(reverse("intervention:report", args=(id,))),
-            size=10
-        )
-        qrcode_lanis = QrCode(
-            content=intervention.get_LANIS_link(),
-            size=7
-        )
 
+    tab_title = _("Report {}").format(intervention.identifier)
+    # If intervention is not recorded (yet or currently) we need to render another template without any data
+    if not intervention.is_ready_for_publish():
+        template = "report/unavailable.html"
         context = {
-            "obj": intervention,
-            "deductions": distinct_deductions,
-            "qrcode": {
-                "img": qrcode.get_img(),
-                "url": qrcode.get_content(),
-            },
-            "qrcode_lanis": {
-                "img": qrcode_lanis.get_img(),
-                "url": qrcode_lanis.get_content(),
-            },
-            "geom_form": geom_form,
-            "parcels": parcels,
-            "tables_scrollable": False,
             TAB_TITLE_IDENTIFIER: tab_title,
         }
         context = BaseContext(request, context).context
-        return render(request, self._TEMPLATE, context)
+        return render(request, template, context)
+
+    # Prepare data for map viewer
+    geom_form = SimpleGeomForm(
+        instance=intervention
+    )
+    parcels = intervention.get_underlying_parcels()
+
+    distinct_deductions = intervention.deductions.all().distinct(
+        "account"
+    )
+    qrcode_url = request.build_absolute_uri(reverse("intervention:report", args=(id,)))
+    qrcode_img = generate_qr_code(qrcode_url, 10)
+    qrcode_lanis_url = intervention.get_LANIS_link()
+    qrcode_img_lanis = generate_qr_code(qrcode_lanis_url, 7)
+
+    context = {
+        "obj": intervention,
+        "deductions": distinct_deductions,
+        "qrcode": {
+            "img": qrcode_img,
+            "url": qrcode_url,
+        },
+        "qrcode_lanis": {
+            "img": qrcode_img_lanis,
+            "url": qrcode_lanis_url,
+        },
+        "geom_form": geom_form,
+        "parcels": parcels,
+        "tables_scrollable": False,
+        TAB_TITLE_IDENTIFIER: tab_title,
+    }
+    context = BaseContext(request, context).context
+    return render(request, template, context)

intervention/views/revocation.py

@@ -6,12 +6,10 @@ Created on: 19.08.22
 
 """
 from django.contrib import messages
-from django.contrib.auth.mixins import LoginRequiredMixin
+from django.contrib.auth.decorators import login_required
-from django.http import HttpRequest, HttpResponse
+from django.http import HttpRequest
 from django.shortcuts import get_object_or_404, redirect
 from django.urls import reverse
-from django.utils.decorators import method_decorator
-from django.views import View
 
 from intervention.forms.modals.revocation import NewRevocationModalForm, EditRevocationModalForm, \
     RemoveRevocationModalForm
@@ -21,125 +19,100 @@ from konova.utils.documents import get_document
 from konova.utils.message_templates import REVOCATION_ADDED, DATA_UNSHARED, REVOCATION_EDITED, REVOCATION_REMOVED
 
 
-class NewInterventionRevocationView(LoginRequiredMixin, View):
+@login_required
-    def __process_request(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
+@default_group_required
-        """ Renders sharing form for an intervention
+@shared_access_required(Intervention, "id")
+def new_revocation_view(request: HttpRequest, id: str):
+    """ Renders sharing form for an intervention
 
-        Args:
+    Args:
-            request (HttpRequest): The incoming request
+        request (HttpRequest): The incoming request
-            id (str): Intervention's id
+        id (str): Intervention's id
 
-        Returns:
+    Returns:
 
-        """
+    """
-        intervention = get_object_or_404(Intervention, id=id)
+    intervention = get_object_or_404(Intervention, id=id)
-        form = NewRevocationModalForm(request.POST or None, request.FILES or None, instance=intervention,
+    form = NewRevocationModalForm(request.POST or None, request.FILES or None, instance=intervention, request=request)
-                                      request=request)
+    return form.process_request(
-        return form.process_request(
+        request,
+        msg_success=REVOCATION_ADDED,
+        redirect_url=reverse("intervention:detail", args=(id,)) + "#related_data"
+    )
+
+
+@login_required
+@default_group_required
+def get_revocation_view(request: HttpRequest, doc_id: str):
+    """ Returns the revocation document as downloadable file
+
+    Wraps the generic document fetcher function from konova.utils.
+
+    Args:
+        request (HttpRequest): The incoming request
+        doc_id (str): The document id
+
+    Returns:
+
+    """
+    doc = get_object_or_404(RevocationDocument, id=doc_id)
+    # File download only possible if related instance is shared with user
+    if not doc.instance.legal.intervention.users.filter(id=request.user.id):
+        messages.info(
             request,
-            msg_success=REVOCATION_ADDED,
+            DATA_UNSHARED
-            redirect_url=reverse("intervention:detail", args=(id,)) + "#related_data"
         )
-
+        return redirect("intervention:detail", id=doc.instance.id)
-    @method_decorator(default_group_required)
+    return get_document(doc)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, *args, **kwargs)
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def post(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, *args, **kwargs)
 
 
-class GetInterventionRevocationView(LoginRequiredMixin, View):
+@login_required
-    @method_decorator(default_group_required)
+@default_group_required
-    def get(self, request: HttpRequest, doc_id: str, *args, **kwargs) -> HttpResponse:
+@shared_access_required(Intervention, "id")
-        """ Returns the revocation document as downloadable file
+def edit_revocation_view(request: HttpRequest, id: str, revocation_id: str):
+    """ Renders a edit view for a revocation
 
-        Wraps the generic document fetcher function from konova.utils.
+    Args:
+        request (HttpRequest): The incoming request
+        id (str): The intervention's id as string
+        revocation_id (str): The revocation's id as string
 
-        Args:
+    Returns:
-            request (HttpRequest): The incoming request
-            doc_id (str): The document id
 
-        Returns:
+    """
+    intervention = get_object_or_404(Intervention, id=id)
+    revocation = get_object_or_404(Revocation, id=revocation_id)
 
-        """
+    form = EditRevocationModalForm(request.POST or None, request.FILES or None, instance=intervention, revocation=revocation, request=request)
-        doc = get_object_or_404(RevocationDocument, id=doc_id)
+    return form.process_request(
-        # File download only possible if related instance is shared with user
+        request,
-        if not doc.instance.legal.intervention.users.filter(id=request.user.id):
+        REVOCATION_EDITED,
-            messages.info(
+        redirect_url=reverse("intervention:detail", args=(intervention.id,)) + "#related_data"
-                request,
+    )
-                DATA_UNSHARED
-            )
-            return redirect("intervention:detail", id=doc.instance.id)
-        return get_document(doc)
 
 
-class EditInterventionRevocationView(LoginRequiredMixin, View):
+@login_required_modal
-    def __process_request(self, request: HttpRequest, id: str, revocation_id: str, *args, **kwargs) -> HttpResponse:
+@login_required
-        """ Renders a edit view for a revocation
+@default_group_required
+@shared_access_required(Intervention, "id")
+def remove_revocation_view(request: HttpRequest, id: str, revocation_id: str):
+    """ Renders a remove view for a revocation
 
-        Args:
+    Args:
-            request (HttpRequest): The incoming request
+        request (HttpRequest): The incoming request
-            id (str): The intervention's id as string
+        id (str): The intervention's id as string
-            revocation_id (str): The revocation's id as string
+        revocation_id (str): The revocation's id as string
 
-        Returns:
+    Returns:
 
-        """
+    """
-        intervention = get_object_or_404(Intervention, id=id)
+    intervention = get_object_or_404(Intervention, id=id)
-        revocation = get_object_or_404(Revocation, id=revocation_id)
+    revocation = get_object_or_404(Revocation, id=revocation_id)
 
-        form = EditRevocationModalForm(request.POST or None, request.FILES or None, instance=intervention,
+    form = RemoveRevocationModalForm(request.POST or None, instance=intervention, revocation=revocation, request=request)
-                                       revocation=revocation, request=request)
+    return form.process_request(
-        return form.process_request(
+        request,
-            request,
+        REVOCATION_REMOVED,
-            REVOCATION_EDITED,
+        redirect_url=reverse("intervention:detail", args=(intervention.id,)) + "#related_data"
-            redirect_url=reverse("intervention:detail", args=(intervention.id,)) + "#related_data"
+    )
-        )
 
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def get(self, request: HttpRequest, id: str, revocation_id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, revocation_id, *args, **kwargs)
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def post(self, request: HttpRequest, id: str, revocation_id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, revocation_id, *args, **kwargs)
-
-
-class RemoveInterventionRevocationView(LoginRequiredMixin, View):
-    def __process_request(self, request, id: str, revocation_id: str, *args, **kwargs) -> HttpResponse:
-        """ Renders a remove view for a revocation
-
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The intervention's id as string
-            revocation_id (str): The revocation's id as string
-
-        Returns:
-
-        """
-        intervention = get_object_or_404(Intervention, id=id)
-        revocation = get_object_or_404(Revocation, id=revocation_id)
-
-        form = RemoveRevocationModalForm(request.POST or None, instance=intervention, revocation=revocation,
-                                         request=request)
-        return form.process_request(
-            request,
-            REVOCATION_REMOVED,
-            redirect_url=reverse("intervention:detail", args=(intervention.id,)) + "#related_data"
-        )
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def get(self, request: HttpRequest, id: str, revocation_id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, revocation_id, *args, **kwargs)
-
-    @method_decorator(default_group_required)
-    @method_decorator(shared_access_required(Intervention, "id"))
-    def post(self, request, id: str, revocation_id: str, *args, **kwargs) -> HttpResponse:
-        return self.__process_request(request, id, revocation_id, *args, **kwargs)

konova/forms/geometry_form.py

@@ -35,7 +35,6 @@ class SimpleGeomForm(BaseForm):
         disabled=False,
     )
     _num_geometries_ignored: int = 0
-    empty = False
 
     def __init__(self, *args, **kwargs):
         self.read_only = kwargs.pop("read_only", True)
@@ -50,11 +49,11 @@ class SimpleGeomForm(BaseForm):
                 raise AttributeError
 
             geojson = self.instance.geometry.as_feature_collection(srid=DEFAULT_SRID_RLP)
-            geojson = self._set_geojson_properties(geojson, title=self.instance.identifier or None)
+            self._set_geojson_properties(geojson, title=self.instance.identifier or None)
             geom = json.dumps(geojson)
         except AttributeError:
             # If no geometry exists for this form, we simply set the value to None and zoom to the maximum level
-            geom = json.dumps({})
+            geom = ""
             self.empty = True
 
         self.initialize_form_field("output", geom)
@@ -63,18 +62,18 @@ class SimpleGeomForm(BaseForm):
         super().is_valid()
         is_valid = True
 
-        # Make sure invalid geometry is properly rendered again to the user
+        # Get geojson from form
-        # Therefore: write submitted data back into form field
+        geom = self.data.get("output", None)
-        # (does not matter whether we know if it is valid or invalid)
+        if geom is None or len(geom) == 0:
-        submitted_data = self.data["output"]
+            # empty geometry is a valid geometry
-        submitted_data = json.loads(submitted_data)
+            self.cleaned_data["output"] = MultiPolygon(srid=DEFAULT_SRID_RLP).ewkt
-        submitted_data = self._set_geojson_properties(submitted_data)
+            return is_valid
-        self.initialize_form_field("output", json.dumps(submitted_data))
-
-        # Get geojson from form for validity checking
-        geom = self.data.get("output", json.dumps({}))
         geom = json.loads(geom)
 
+        # Write submitted data back into form field to make sure invalid geometry
+        # will be rendered again on failed submit
+        self.initialize_form_field("output", self.data["output"])
+
         # Initialize features list with empty MultiPolygon, so that an empty input will result in a
         # proper empty MultiPolygon object
         features = []
@@ -85,23 +84,20 @@ class SimpleGeomForm(BaseForm):
             "MultiPolygon",
             "MultiPolygon25D",
         ]
-        # Check validity for each feature of the geometry
         for feature in features_json:
             feature_geom = feature.get("geometry", feature)
             if feature_geom is None:
                 # Fallback for rare cases where a feature does not contain any geometry
                 continue
 
-            # Try to create a geometry object from the single feature
             feature_geom = json.dumps(feature_geom)
             g = gdal.OGRGeometry(feature_geom, srs=DEFAULT_SRID_RLP)
 
-            geometry_has_unwanted_dimensions = g.coord_dim > 2
+            flatten_geometry = g.coord_dim > 2
-            if geometry_has_unwanted_dimensions:
+            if flatten_geometry:
                 g = self.__flatten_geom_to_2D(g)
 
-            geometry_type_is_accepted = g.geom_type not in accepted_ogr_types
+            if g.geom_type not in accepted_ogr_types:
-            if geometry_type_is_accepted:
                 self.add_error("output", _("Only surfaces allowed. Points or lines must be buffered."))
                 is_valid &= False
                 return is_valid
@@ -113,33 +109,27 @@ class SimpleGeomForm(BaseForm):
                 self._num_geometries_ignored += 1
                 continue
 
-            # Whatever this geometry object is -> try to create a Polygon from it
-            # The resulting polygon object automatically detects whether a valid polygon has been created or not
             g = Polygon.from_ewkt(g.ewkt)
             is_valid &= g.valid
             if not g.valid:
                 self.add_error("output", g.valid_reason)
                 return is_valid
 
-            # If the resulting polygon is just a single polygon, we add it to the list of properly casted features
             if isinstance(g, Polygon):
                 features.append(g)
             elif isinstance(g, MultiPolygon):
-                # The resulting polygon could be of type MultiPolygon (due to multiple surfaces)
-                # If so, we extract all polygons from the MultiPolygon and extend the casted features list
                 features.extend(list(g))
 
-        # Unionize all polygon features into one new MultiPolygon
+        # Unionize all geometry features into one new MultiPolygon
         if features:
             form_geom = MultiPolygon(*features, srid=DEFAULT_SRID_RLP).unary_union
         else:
-            # If no features have been processed, this indicates an empty geometry - so we store an empty geometry
             form_geom = MultiPolygon(srid=DEFAULT_SRID_RLP)
 
         # Make sure to convert into a MultiPolygon. Relevant if a single Polygon is provided.
         form_geom = Geometry.cast_to_multipolygon(form_geom)
 
-        # Write unionized Multipolygon back into cleaned data
+        # Write unioned Multipolygon into cleaned data
         if self.cleaned_data is None:
             self.cleaned_data = {}
         self.cleaned_data["output"] = form_geom.ewkt
@@ -262,8 +252,6 @@ class SimpleGeomForm(BaseForm):
         """
         features = geojson.get("features", [])
         for feature in features:
-            if not feature.get("properties", None):
-                feature["properties"] = {}
             feature["properties"]["editable"] = not self.read_only
             if title:
                 feature["properties"]["title"] = title

konova/models/geometry.py

@@ -10,7 +10,6 @@ import json
 from django.contrib.gis.db.models import MultiPolygonField
 from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
 from django.db import models, transaction
-from django.db.models import Q
 from django.utils import timezone
 from django.contrib.gis.geos import MultiPolygon
 
@@ -110,26 +109,17 @@ class Geometry(BaseResource):
             objs (list): The list of objects
         """
         objs = []
-
+        sets = [
-        # Some related data sets can be processed rather easily
-        regular_sets = [
             self.intervention_set,
+            self.compensation_set,
             self.ema_set,
             self.ecoaccount_set,
         ]
-        for _set in regular_sets:
+        for _set in sets:
             set_objs = _set.filter(
                 deleted=None
             )
             objs += set_objs
-
-        # ... but we need a special treatment for compensations, since they can be deleted directly OR inherit their
-        # de-facto-deleted status from their deleted parent intervention
-        comp_objs = self.compensation_set.filter(
-            Q(deleted=None) & Q(intervention__deleted=None)
-        )
-        objs += comp_objs
-
         return objs
 
     def get_data_object(self):

konova/models/object.py

@@ -677,12 +677,12 @@ class GeoReferencedMixin(models.Model):
             return request
 
         instance_objs = []
-        conflicts = self.geometry.conflicts_geometries.iterator()
+        conflicts = self.geometry.conflicts_geometries.all()
 
         for conflict in conflicts:
             instance_objs += conflict.affected_geometry.get_data_objects()
 
-        conflicts = self.geometry.conflicted_by_geometries.iterator()
+        conflicts = self.geometry.conflicted_by_geometries.all()
         for conflict in conflicts:
             instance_objs += conflict.conflicting_geometry.get_data_objects()
 

konova/sub_settings/context_settings.py

@@ -11,4 +11,4 @@ BASE_TITLE = "KSP - Kompensationsverzeichnis Service Portal"
 BASE_FRONTEND_TITLE = "Kompensationsverzeichnis Service Portal"
 TAB_TITLE_IDENTIFIER = "tab_title"
 HELP_LINK = "https://dienste.naturschutz.rlp.de/doku/doku.php?id=ksp2:start"
-IMPRESSUM_LINK = "https://naturschutz.rlp.de/ueber-uns/impressum"
+IMPRESSUM_LINK = "https://naturschutz.rlp.de/index.php?q=impressum"

konova/sub_settings/django_settings.py

@@ -191,11 +191,10 @@ STATICFILES_DIRS = [
 ]
 
 # EMAIL (see https://docs.djangoproject.com/en/dev/topics/email/)
-
-# CHANGE_ME !!! ONLY FOR DEVELOPMENT !!!
 if DEBUG:
+    # ONLY FOR DEVELOPMENT NEEDED
     EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend'
-    EMAIL_FILE_PATH = '/tmp/app-messages' # change this to a proper location
+    EMAIL_FILE_PATH = '/tmp/app-messages'
 
 DEFAULT_FROM_EMAIL = env("DEFAULT_FROM_EMAIL")  # The default email address for the 'from' element
 SERVER_EMAIL = DEFAULT_FROM_EMAIL  # The default email sender address, which is used by Django to send errors via mail

konova/utils/generators.py

@@ -42,24 +42,23 @@ def generate_random_string(length: int, use_numbers: bool = False, use_letters_l
     ret_val = "".join(random.choice(elements) for i in range(length))
     return ret_val
 
-class IdentifierGenerator:
-    _MODEL = None
 
-    def __init__(self, model):
+def generate_qr_code(content: str, size: int = 20) -> str:
-        from konova.models import BaseObject
+    """ Generates a qr code from given content
-        if not issubclass(model, BaseObject):
-            raise AssertionError("Model must be a subclass of BaseObject!")
 
-        self._MODEL = model
+    Args:
+        content (str): The content for the qr code
+        size (int): The image size
 
-    def generate_id(self) -> str:
+    Returns:
-        """ Generates a unique identifier
+        qrcode_svg (str): The qr code as svg
-
+    """
-        Returns:
+    qrcode_factory = qrcode.image.svg.SvgImage
-
+    qrcode_img = qrcode.make(
-        """
+        content,
-        unpersisted_object = self._MODEL()
+        image_factory=qrcode_factory,
-        identifier = unpersisted_object.generate_new_identifier()
+        box_size=size
-        while self._MODEL.objects.filter(identifier=identifier).exists():
+    )
-            identifier = unpersisted_object.generate_new_identifier()
+    stream = BytesIO()
-        return identifier
+    qrcode_img.save(stream)
+    return stream.getvalue().decode()

konova/utils/qrcode.py

@@ -1,47 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from io import BytesIO
-
-import qrcode
-import qrcode.image.svg as svg
-
-
-class QrCode:
-    """ A wrapping class for creating a qr code with content
-
-    """
-    _content = None
-    _img = None
-
-    def __init__(self, content: str, size: int):
-        self._content = content
-        self._img = self._generate_qr_code(content, size)
-
-    def _generate_qr_code(self, content: str, size: int = 20) -> str:
-        """ Generates a qr code from given content
-
-        Args:
-            content (str): The content for the qr code
-            size (int): The image size
-
-        Returns:
-            qrcode_svg (str): The qr code as svg
-        """
-        img_factory = svg.SvgImage
-        qrcode_img = qrcode.make(
-            content,
-            image_factory=img_factory,
-            box_size=size
-        )
-        stream = BytesIO()
-        qrcode_img.save(stream)
-        return stream.getvalue().decode()
-
-    def get_img(self):
-        return self._img
-
-    def get_content(self):
-        return self._content

konova/views/detail.py

@@ -1,25 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from abc import ABC
-
-from django.contrib.auth.mixins import LoginRequiredMixin
-from django.http import HttpRequest, HttpResponse
-from django.utils.decorators import method_decorator
-from django.views import View
-
-from konova.decorators import uuid_required, any_group_check
-
-
-class AbstractDetailView(LoginRequiredMixin, View, ABC):
-    _TEMPLATE = None
-
-    @method_decorator(uuid_required)
-    def dispatch(self, request, *args, **kwargs):
-        return super().dispatch(request, *args, **kwargs)
-
-    @method_decorator(any_group_check)
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        raise NotImplementedError()

konova/views/identifier.py

@@ -1,28 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from abc import ABC
-
-from django.contrib.auth.mixins import LoginRequiredMixin
-from django.http import HttpRequest, JsonResponse
-from django.utils.decorators import method_decorator
-from django.views import View
-
-from konova.decorators import default_group_required
-from konova.utils.generators import IdentifierGenerator
-
-
-class AbstractIdentifierGeneratorView(LoginRequiredMixin, View, ABC):
-    _MODEL = None
-
-    @method_decorator(default_group_required)
-    def get(self, request: HttpRequest, *args, **kwargs):
-        generator = IdentifierGenerator(model=self._MODEL)
-        identifier = generator.generate_id()
-        return JsonResponse(
-            data={
-                "gen_data": identifier
-            }
-        )

konova/views/index.py

@@ -1,21 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from abc import ABC
-
-from django.contrib.auth.mixins import LoginRequiredMixin
-from django.http import HttpRequest, HttpResponse
-from django.utils.decorators import method_decorator
-from django.views import View
-
-from konova.decorators import any_group_check
-
-
-class AbstractIndexView(LoginRequiredMixin, View, ABC):
-    _TEMPLATE = "generic_index.html"
-
-    @method_decorator(any_group_check)
-    def get(self, request: HttpRequest, *args, **kwargs) -> HttpResponse:
-        raise NotImplementedError()

konova/views/remove.py

@@ -1,64 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from abc import ABC
-
-from django.contrib.auth.mixins import LoginRequiredMixin
-from django.http import HttpRequest, HttpResponse
-from django.urls import reverse
-from django.utils.decorators import method_decorator
-from django.views import View
-from django.utils.translation import gettext_lazy as _
-
-from konova.decorators import default_group_required
-from konova.forms.modals import RemoveModalForm
-
-
-class AbstractRemoveView(LoginRequiredMixin, View, ABC):
-    _MODEL = None
-    _REDIRECT_URL = None
-    _FORM = RemoveModalForm
-
-    def dispatch(self, request, *args, **kwargs):
-        return super().dispatch(request, *args, **kwargs)
-
-    @method_decorator(default_group_required)
-    def __process_request(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        obj = self._MODEL.objects.get(id=id)
-        identifier = obj.identifier
-        form = self._FORM(request.POST or None, instance=obj, request=request)
-        return form.process_request(
-            request,
-            _("{} removed").format(identifier),
-            redirect_url=reverse(self._REDIRECT_URL)
-        )
-
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        """ GET endpoint for removing via modal form
-
-        Due to the legacy logic of the form (which processes get and post requests directly), we simply need to pipe
-        the request from GET and POST endpoints directly into the same method.
-
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The uuid id as string
-
-        Returns:
-        """
-        return self.__process_request(request, id, *args, **kwargs)
-
-    def post(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        """  POST endpoint for removing via modal form
-
-        Due to the legacy logic of the form (which processes get and post requests directly), we simply need to pipe
-        the request from GET and POST endpoints directly into the same method.
-
-        Args:
-            request (HttpRequest): The incoming request
-            id (str): The uuid id as string
-
-        Returns:
-        """
-        return self.__process_request(request, id, *args, **kwargs)

konova/views/report.py

@@ -1,24 +0,0 @@
-"""
-Author: Michel Peltriaux
-Created on: 14.12.25
-
-"""
-from abc import abstractmethod, ABC
-
-from django.http import HttpRequest, HttpResponse
-from django.utils.decorators import method_decorator
-from django.views import View
-
-from konova.decorators import uuid_required
-
-
-class AbstractPublicReportView(View, ABC):
-    _TEMPLATE = None
-
-    @method_decorator(uuid_required)
-    def dispatch(self, request, *args, **kwargs):
-        return super().dispatch(request, *args, **kwargs)
-
-    @abstractmethod
-    def get(self, request: HttpRequest, id: str, *args, **kwargs) -> HttpResponse:
-        raise NotImplementedError()

locale/de/LC_MESSAGES/django.po

@@ -45,7 +45,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-12-14 17:23+0100\n"
+"POT-Creation-Date: 2025-10-15 09:11+0200\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -448,7 +448,7 @@ msgid "Select the intervention for which this compensation compensates"
 msgstr "Wählen Sie den Eingriff, für den diese Kompensation bestimmt ist"
 
 #: compensation/forms/compensation.py:114
-#: compensation/views/compensation/compensation.py:121
+#: compensation/views/compensation/compensation.py:120
 msgid "New compensation"
 msgstr "Neue Kompensation"
 
@@ -456,38 +456,38 @@ msgstr "Neue Kompensation"
 msgid "Edit compensation"
 msgstr "Bearbeite Kompensation"
 
-#: compensation/forms/eco_account.py:32 compensation/utils/quality.py:97
+#: compensation/forms/eco_account.py:31 compensation/utils/quality.py:97
 msgid "Available Surface"
 msgstr "Verfügbare Fläche"
 
-#: compensation/forms/eco_account.py:35
+#: compensation/forms/eco_account.py:34
 msgid "The amount that can be used for deductions"
 msgstr "Die für Abbuchungen zur Verfügung stehende Menge"
 
-#: compensation/forms/eco_account.py:44
+#: compensation/forms/eco_account.py:43
 #: compensation/templates/compensation/detail/eco_account/view.html:67
 #: compensation/utils/quality.py:84
 msgid "Agreement date"
 msgstr "Vereinbarungsdatum"
 
-#: compensation/forms/eco_account.py:46
+#: compensation/forms/eco_account.py:45
 msgid "When did the parties agree on this?"
 msgstr "Wann wurde dieses Ökokonto offiziell vereinbart?"
 
-#: compensation/forms/eco_account.py:73
+#: compensation/forms/eco_account.py:72
-#: compensation/views/eco_account/eco_account.py:105
+#: compensation/views/eco_account/eco_account.py:101
 msgid "New Eco-Account"
 msgstr "Neues Ökokonto"
 
-#: compensation/forms/eco_account.py:82
+#: compensation/forms/eco_account.py:81
 msgid "Eco-Account XY; Location ABC"
 msgstr "Ökokonto XY; Flur ABC"
 
-#: compensation/forms/eco_account.py:148
+#: compensation/forms/eco_account.py:147
 msgid "Edit Eco-Account"
 msgstr "Ökokonto bearbeiten"
 
-#: compensation/forms/eco_account.py:184
+#: compensation/forms/eco_account.py:183
 msgid ""
 "{}m² have been deducted from this eco account so far. The given value of {} "
 "would be too low."
@@ -495,16 +495,12 @@ msgstr ""
 "{}n² wurden bereits von diesem Ökokonto abgebucht. Der eingegebene Wert von "
 "{} wäre daher zu klein."
 
-#: compensation/forms/eco_account.py:248
+#: compensation/forms/eco_account.py:247
 msgid "The account can not be removed, since there are still deductions."
 msgstr ""
 "Das Ökokonto kann nicht entfernt werden, da hierzu noch Abbuchungen "
 "vorliegen."
 
-#: compensation/forms/eco_account.py:257
-msgid "Please contact the responsible conservation office to find a solution!"
-msgstr "Kontaktieren Sie die zuständige Naturschutzbehörde um eine Lösung zu finden!"
-
 #: compensation/forms/mixins.py:37
 #: compensation/templates/compensation/detail/eco_account/view.html:63
 #: compensation/templates/compensation/report/eco_account/report.html:20
@@ -1292,40 +1288,44 @@ msgstr ""
 msgid "Responsible data"
 msgstr "Daten zu den verantwortlichen Stellen"
 
-#: compensation/views/compensation/compensation.py:52
+#: compensation/views/compensation/compensation.py:58
 msgid "Compensations - Overview"
 msgstr "Kompensationen - Übersicht"
 
-#: compensation/views/compensation/compensation.py:167
+#: compensation/views/compensation/compensation.py:181
 #: konova/utils/message_templates.py:40
 msgid "Compensation {} edited"
 msgstr "Kompensation {} bearbeitet"
 
-#: compensation/views/compensation/compensation.py:190
+#: compensation/views/compensation/compensation.py:196
-#: compensation/views/eco_account/eco_account.py:168 ema/views/ema.py:173
+#: compensation/views/eco_account/eco_account.py:173 ema/views/ema.py:238
-#: intervention/views/intervention.py:175
+#: intervention/views/intervention.py:253
 msgid "Edit {}"
 msgstr "Bearbeite {}"
 
 #: compensation/views/compensation/report.py:35
-#: compensation/views/eco_account/report.py:35 ema/views/report.py:35
+#: compensation/views/eco_account/report.py:36 ema/views/report.py:35
-#: intervention/views/report.py:36
+#: intervention/views/report.py:35
 msgid "Report {}"
 msgstr "Bericht {}"
 
-#: compensation/views/eco_account/eco_account.py:49
+#: compensation/views/eco_account/eco_account.py:53
 msgid "Eco-account - Overview"
 msgstr "Ökokonten - Übersicht"
 
-#: compensation/views/eco_account/eco_account.py:82
+#: compensation/views/eco_account/eco_account.py:86
 msgid "Eco-Account {} added"
 msgstr "Ökokonto {} hinzugefügt"
 
-#: compensation/views/eco_account/eco_account.py:145
+#: compensation/views/eco_account/eco_account.py:158
 msgid "Eco-Account {} edited"
 msgstr "Ökokonto {} bearbeitet"
 
-#: ema/forms.py:42 ema/tests/unit/test_forms.py:27 ema/views/ema.py:107
+#: compensation/views/eco_account/eco_account.py:288
+msgid "Eco-account removed"
+msgstr "Ökokonto entfernt"
+
+#: ema/forms.py:42 ema/tests/unit/test_forms.py:27 ema/views/ema.py:108
 msgid "New EMA"
 msgstr "Neue EMA hinzufügen"
 
@@ -1353,18 +1353,22 @@ msgstr ""
 msgid "Payment funded compensation"
 msgstr "Ersatzzahlungsmaßnahme"
 
-#: ema/views/ema.py:52
+#: ema/views/ema.py:53
 msgid "EMAs - Overview"
 msgstr "EMAs - Übersicht"
 
-#: ema/views/ema.py:85
+#: ema/views/ema.py:86
 msgid "EMA {} added"
 msgstr "EMA {} hinzugefügt"
 
-#: ema/views/ema.py:150
+#: ema/views/ema.py:223
 msgid "EMA {} edited"
 msgstr "EMA {} bearbeitet"
 
+#: ema/views/ema.py:262
+msgid "EMA removed"
+msgstr "EMA entfernt"
+
 #: intervention/forms/intervention.py:49
 msgid "Construction XY; Location ABC"
 msgstr "Bauvorhaben XY; Flur ABC"
@@ -1425,7 +1429,7 @@ msgstr "Datum Bestandskraft bzw. Rechtskraft"
 
 #: intervention/forms/intervention.py:216
 #: intervention/tests/unit/test_forms.py:36
-#: intervention/views/intervention.py:109
+#: intervention/views/intervention.py:105
 msgid "New intervention"
 msgstr "Neuer Eingriff"
 
@@ -1661,18 +1665,22 @@ msgstr ""
 msgid "Check performed"
 msgstr "Prüfung durchgeführt"
 
-#: intervention/views/intervention.py:53
+#: intervention/views/intervention.py:57
 msgid "Interventions - Overview"
 msgstr "Eingriffe - Übersicht"
 
-#: intervention/views/intervention.py:86
+#: intervention/views/intervention.py:90
 msgid "Intervention {} added"
 msgstr "Eingriff {} hinzugefügt"
 
-#: intervention/views/intervention.py:150
+#: intervention/views/intervention.py:236
 msgid "Intervention {} edited"
 msgstr "Eingriff {} bearbeitet"
 
+#: intervention/views/intervention.py:278
+msgid "{} removed"
+msgstr "{} entfernt"
+
 #: konova/decorators.py:32
 msgid "You need to be staff to perform this action!"
 msgstr "Hierfür müssen Sie Mitarbeiter sein!"
@@ -1802,7 +1810,7 @@ msgstr "Nicht editierbar"
 msgid "Geometry"
 msgstr "Geometrie"
 
-#: konova/forms/geometry_form.py:105
+#: konova/forms/geometry_form.py:100
 msgid "Only surfaces allowed. Points or lines must be buffered."
 msgstr ""
 "Nur Flächen erlaubt. Punkte oder Linien müssen zu Flächen gepuffert werden."
@@ -2260,9 +2268,8 @@ msgid ""
 "too small to be valid). These parts have been removed. Please check the "
 "stored geometry."
 msgstr ""
-"Die Geometrie enthielt {} invalide Bestandteile (z.B. unaussagekräftige "
+"Die Geometrie enthielt {} invalide Bestandteile (z.B. unaussagekräftige Kleinstflächen)."
-"Kleinstflächen).Diese Bestandteile wurden automatisch entfernt. Bitte "
+"Diese Bestandteile wurden automatisch entfernt. Bitte überprüfen Sie die angepasste Geometrie."
-"überprüfen Sie die angepasste Geometrie."
 
 #: konova/utils/message_templates.py:89
 msgid "This intervention has {} revocations"
@@ -2323,10 +2330,6 @@ msgstr "{} verzeichnet"
 msgid "Errors found:"
 msgstr "Fehler gefunden:"
 
-#: konova/views/remove.py:35
-msgid "{} removed"
-msgstr "{} entfernt"
-
 #: konova/views/resubmission.py:39
 msgid "Resubmission set"
 msgstr "Wiedervorlage gesetzt"

nginx.conf

@@ -0,0 +1,25 @@
+server {
+    listen 80;
+    client_max_body_size 25M;
+
+    location / {
+        proxy_pass http://127.0.0.1:8000;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header Host $host;
+        proxy_redirect off;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    location /static/ {
+        alias /konova/static/;
+        access_log /var/log/nginx/access.log;
+        autoindex off;
+        types {
+            text/css css;
+            application/javascript js;
+        }
+    }
+
+    error_log /var/log/nginx/error.log;
+}

requirements.txt

@@ -48,7 +48,7 @@ pytz==2024.2
 PyYAML==6.0.2
 qrcode==7.3.1
 redis==5.1.0b6
-requests==2.32.3
+requests<2.32.0
 six==1.16.0
 soupsieve==2.5
 sqlparse==0.5.1

templates/map/geom_form.html

@@ -13,9 +13,9 @@
     </div>
 {% endif %}
 
-{% if geom_form.output.errors %}
+{% if geom_form.geom.errors %}
     <div class="alert-danger p-2">
-    {% for error in geom_form.output.errors %}
+    {% for error in geom_form.geom.errors %}
             <strong class="invalid">{{ error }}</strong>
             <br>
     {% endfor %}