Merge pull request 'Master' (#587) from master into Docker

Reviewed-on: #587

Dockerfile

@@ -0,0 +1,36 @@
+# Nutze ein schlankes Python-Image
+FROM python:3.13-slim-trixie
+
+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;
+    }
+}
+```

api/admin.py

@@ -1,5 +1,6 @@
 from django.contrib import admin
 
+from api.models import ExternalIdentifier
 from api.models.token import APIUserToken, OAuthToken
 
 
@@ -28,6 +29,17 @@ class OAuthTokenAdmin(admin.ModelAdmin):
         "refresh_token",
     ]
 
+class ExternalIdentifierAdmin(admin.ModelAdmin):
+    list_display = [
+        "external_id",
+        "internal_id",
+        "created",
+    ]
+    search_fields = [
+        "external_id",
+        "internal_id",
+    ]
 
 admin.site.register(APIUserToken, APITokenAdmin)
 admin.site.register(OAuthToken, OAuthTokenAdmin)
+admin.site.register(ExternalIdentifier, ExternalIdentifierAdmin)

api/tests/v1/create/compensation_create_post_body.json

@@ -1,5 +1,5 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
     ],
     "properties": {

api/tests/v1/create/ecoaccount_create_post_body.json

@@ -1,5 +1,5 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
     ],
     "properties": {

api/tests/v1/create/ema_create_post_body.json

@@ -1,5 +1,5 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
     ],
     "properties": {

api/tests/v1/create/intervention_create_post_body.json

@@ -1,5 +1,5 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
     ],
     "properties": {

api/tests/v1/update/compensation_update_put_body.json

@@ -1,44 +1,26 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
           [
             [
-                    [
+              7.489245186249832,
-                        7.845568656921382,
+              50.29519575559556
-                        50.79829702304368
             ],
             [
-                        7.837371826171871,
+              7.5244137991026605,
-                        50.80155187891526
+              50.29519575559556
             ],
             [
-                        7.835698127746578,
+              7.5244137991026605,
-                        50.805267562209806
+              50.275124048323875
             ],
             [
-                        7.841062545776364,
+              7.489245186249832,
-                        50.806623577403386
+              50.275124048323875
             ],
             [
-                        7.848916053771969,
+              7.489245186249832,
-                        50.808359219420474
+              50.29519575559556
-                    ],
-                    [
-                        7.855696678161618,
-                        50.807057493952975
-                    ],
-                    [
-                        7.854666709899899,
-                        50.80423696434001
-                    ],
-                    [
-                        7.850461006164548,
-                        50.80217570040005
-                    ],
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ]
             ]
           ]
         ],

api/tests/v1/update/ecoaccount_update_put_body.json

@@ -1,44 +1,26 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
           [
             [
-                    [
+              7.489245186249832,
-                        7.845568656921382,
+              50.29519575559556
-                        50.79829702304368
             ],
             [
-                        7.837371826171871,
+              7.5244137991026605,
-                        50.80155187891526
+              50.29519575559556
             ],
             [
-                        7.835698127746578,
+              7.5244137991026605,
-                        50.805267562209806
+              50.275124048323875
             ],
             [
-                        7.841062545776364,
+              7.489245186249832,
-                        50.806623577403386
+              50.275124048323875
             ],
             [
-                        7.848916053771969,
+              7.489245186249832,
-                        50.808359219420474
+              50.29519575559556
-                    ],
-                    [
-                        7.855696678161618,
-                        50.807057493952975
-                    ],
-                    [
-                        7.854666709899899,
-                        50.80423696434001
-                    ],
-                    [
-                        7.850461006164548,
-                        50.80217570040005
-                    ],
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ]
             ]
           ]
         ],

api/tests/v1/update/ema_update_put_body.json

@@ -1,44 +1,26 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
           [
             [
-                    [
+              7.489245186249832,
-                        7.845568656921382,
+              50.29519575559556
-                        50.79829702304368
             ],
             [
-                        7.837371826171871,
+              7.5244137991026605,
-                        50.80155187891526
+              50.29519575559556
             ],
             [
-                        7.835698127746578,
+              7.5244137991026605,
-                        50.805267562209806
+              50.275124048323875
             ],
             [
-                        7.841062545776364,
+              7.489245186249832,
-                        50.806623577403386
+              50.275124048323875
             ],
             [
-                        7.848916053771969,
+              7.489245186249832,
-                        50.808359219420474
+              50.29519575559556
-                    ],
-                    [
-                        7.855696678161618,
-                        50.807057493952975
-                    ],
-                    [
-                        7.854666709899899,
-                        50.80423696434001
-                    ],
-                    [
-                        7.850461006164548,
-                        50.80217570040005
-                    ],
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ]
             ]
           ]
         ],

api/tests/v1/update/intervention_update_put_body.json

@@ -1,44 +1,26 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
           [
             [
-                    [
+              7.489245186249832,
-                        7.845568656921382,
+              50.29519575559556
-                        50.79829702304368
             ],
             [
-                        7.837371826171871,
+              7.5244137991026605,
-                        50.80155187891526
+              50.29519575559556
             ],
             [
-                        7.835698127746578,
+              7.5244137991026605,
-                        50.805267562209806
+              50.275124048323875
             ],
             [
-                        7.841062545776364,
+              7.489245186249832,
-                        50.806623577403386
+              50.275124048323875
             ],
             [
-                        7.848916053771969,
+              7.489245186249832,
-                        50.808359219420474
+              50.29519575559556
-                    ],
-                    [
-                        7.855696678161618,
-                        50.807057493952975
-                    ],
-                    [
-                        7.854666709899899,
-                        50.80423696434001
-                    ],
-                    [
-                        7.850461006164548,
-                        50.80217570040005
-                    ],
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ]
             ]
           ]
         ],

api/tests/v1/update/test_api_update.py

@@ -9,10 +9,11 @@ Created on: 28.01.22
 import json
 
 from django.contrib.gis import geos
+from django.contrib.gis.geos import MultiPolygon
 from django.urls import reverse
 
 from api.tests.v1.share.test_api_sharing import BaseAPIV1TestCase
-from konova.models import Geometry
+from konova.utils.geometry.geometry_validator import GeometryProcessor
 
 
 class APIV1UpdateTestCase(BaseAPIV1TestCase):
@@ -64,8 +65,8 @@ class APIV1UpdateTestCase(BaseAPIV1TestCase):
 
         put_props = put_body["properties"]
         put_geom = geos.fromstr(json.dumps(put_body))
-        put_geom = Geometry.cast_to_rlp_srid(put_geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_geom))
-        self.assertEqual(put_geom, self.intervention.geometry.geom)
+        self.assertTrue(put_geom.equals_exact(self.intervention.geometry.geom,0.00001))
         self.assertEqual(put_props["title"], self.intervention.title)
         self.assertNotEqual(modified_on, self.intervention.modified)
         self.assertEqual(put_props["responsible"]["registration_file_number"], self.intervention.responsible.registration_file_number)
@@ -94,8 +95,8 @@ class APIV1UpdateTestCase(BaseAPIV1TestCase):
 
         put_props = put_body["properties"]
         put_geom = geos.fromstr(json.dumps(put_body))
-        put_geom = Geometry.cast_to_rlp_srid(put_geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_geom))
-        self.assertEqual(put_geom, self.compensation.geometry.geom)
+        self.assertTrue(put_geom.equals_exact(self.compensation.geometry.geom, 0.00001))
         self.assertEqual(put_props["title"], self.compensation.title)
         self.assertNotEqual(modified_on, self.compensation.modified)
         self.assertEqual(put_props["is_cef"], self.compensation.is_cef)
@@ -124,8 +125,8 @@ class APIV1UpdateTestCase(BaseAPIV1TestCase):
 
         put_props = put_body["properties"]
         put_geom = geos.fromstr(json.dumps(put_body))
-        put_geom = Geometry.cast_to_rlp_srid(put_geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_geom))
-        self.assertEqual(put_geom, self.eco_account.geometry.geom)
+        self.assertTrue(put_geom.equals_exact(self.eco_account.geometry.geom, 0.00001))
         self.assertEqual(put_props["title"], self.eco_account.title)
         self.assertNotEqual(modified_on, self.eco_account.modified)
         self.assertEqual(put_props["deductable_surface"], str(self.eco_account.deductable_surface))
@@ -156,8 +157,8 @@ class APIV1UpdateTestCase(BaseAPIV1TestCase):
 
         put_props = put_body["properties"]
         put_geom = geos.fromstr(json.dumps(put_body))
-        put_geom = Geometry.cast_to_rlp_srid(put_geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_geom))
-        self.assertEqual(put_geom, self.ema.geometry.geom)
+        self.assertTrue(put_geom.equals_exact(self.ema.geometry.geom,0.00001))
         self.assertEqual(put_props["title"], self.ema.title)
         self.assertNotEqual(modified_on, self.ema.modified)
         self.assertEqual(put_props["responsible"]["conservation_office"], self.ema.responsible.conservation_office)

api/utils/serializer/serializer.py

@@ -6,16 +6,19 @@ Created on: 24.01.22
 
 """
 import json
+import uuid
 from abc import abstractmethod
 
 from django.contrib.gis import geos
 from django.contrib.gis.geos import GEOSGeometry
-from django.core.exceptions import ObjectDoesNotExist
+from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.core.paginator import Paginator
 from django.db.models import Q
 
 from api.models import ExternalIdentifier
 from konova.models import Geometry
+from konova.sub_settings.lanis_settings import DEFAULT_SRID
+from konova.utils.geometry.geometry_validator import GeoJsonValidator
 from konova.utils.message_templates import DATA_UNSHARED
 
 
@@ -101,6 +104,7 @@ class AbstractModelAPISerializer:
         Returns:
             serialized_data (dict)
         """
+        try:
             entries = self.model.objects.filter(
                 **self.lookup
             ).filter(
@@ -108,6 +112,8 @@ class AbstractModelAPISerializer:
             ).order_by(
                 "id"
             ).distinct()
+        except ValidationError:
+            raise AssertionError("ID expected to be of UUID4 for internal lookup.")
         self.paginator = Paginator(entries, self.rpp)
         requested_entries = self.paginator.page(self.page_number)
 
@@ -152,11 +158,20 @@ class AbstractModelAPISerializer:
         Returns:
             geometry (GEOSGeometry)
         """
-        if isinstance(geojson, dict):
+        if isinstance(geojson, str):
-            geojson = json.dumps(geojson)
+            geojson = json.loads(geojson)
-        geometry = geos.fromstr(geojson)
+
-        geometry = Geometry.cast_to_rlp_srid(geometry)
+        geojson_validator = GeoJsonValidator(geojson, DEFAULT_SRID)
-        geometry = Geometry.cast_to_multipolygon(geometry)
+        geojson_validator.validate()
+
+        if geojson_validator.errors:
+            raise ValueError(geojson_validator.errors)
+
+        geometry = geojson_validator.validated_geometry
+        is_input_geometry_too_small = geometry.area == 0.0 and geojson_validator.num_ignored_geometries > 0
+        if is_input_geometry_too_small:
+            raise ValueError(f"Your area was too small to be processed! Must be > 1m²!")
+
         return geometry
 
     def _get_obj_from_db(self, id, user):
@@ -171,13 +186,20 @@ class AbstractModelAPISerializer:
         Returns:
 
         """
+        if not id:
+            raise ValueError("No id provided. The id is expected to live in the URL!")
+
         # First if there is an external identifier linked to an internal one, so we can continue with the internal
         try:
             ext_id = ExternalIdentifier.objects.get(external_id=id)
             id = ext_id.internal_id
         except ObjectDoesNotExist:
-            # No external id found - let's hope the given id exists internally
+            # Not found as external id - let's check whether this is a valid uuid and therefore
-            pass
+            # potentially an internal id
+            try:
+                uuid.UUID(id)
+            except ValueError:
+                raise AssertionError(f"'{id}' is neither a known external identifier nor a valid uuid.")
 
         obj = self.model.objects.get(
             id=id,
@@ -217,7 +239,11 @@ class AbstractModelAPISerializer:
         conflict_geometries = geometry.get_conflict_geometries()
         for geom in conflict_geometries:
             try:
-                data = geom.get_data_objects(["identifier", "id"])[0]
+                data = geom.get_data_objects(["identifier", "id"])
+                if len(data) == 0:
+                    # expected behaviour in case of deleted data object
+                    continue
+                data = data[0]
             except KeyError:
                 raise AssertionError(f"Geometry {geom.id} is not attached to any entries. Contact an admin!")
             ids.append(

api/views/v1/views.py

@@ -10,6 +10,7 @@ from json import JSONDecodeError
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import JsonResponse, HttpRequest
+from django.views.decorators.csrf import csrf_exempt
 
 from api.utils.serializer.v1.compensation import CompensationAPISerializerV1
 from api.utils.serializer.v1.deduction import DeductionAPISerializerV1
@@ -28,6 +29,20 @@ class AbstractAPIViewV1(AbstractAPIView):
         super().__init__(*args, **kwargs)
         self.serializer = self.serializer()
 
+    @csrf_exempt
+    def dispatch(self, request, *args, **kwargs):
+        try:
+            return super().dispatch(request, *args, **kwargs)
+        except (JSONDecodeError,
+                AssertionError,
+                ValueError,
+                PermissionError) as e:
+            return self._return_error_response(e, 400)
+        except ObjectDoesNotExist as e:
+            return self._return_error_response(e, 404)
+        except Exception as e:
+            return self._return_error_response(e, 500)
+
     def get(self, request: HttpRequest, id=None):
         """ Handles the GET request
 
@@ -40,17 +55,12 @@ class AbstractAPIViewV1(AbstractAPIView):
         Returns:
             response (JsonResponse)
         """
-        try:
         self.rpp = int(request.GET.get("rpp", self.rpp))
         self.page_number = int(request.GET.get("p", self.page_number))
-
         self.serializer.rpp = self.rpp
         self.serializer.page_number = self.page_number
-
         self.serializer.prepare_lookup(id, self.user)
         data = self.serializer.fetch_and_serialize()
-        except Exception as e:
-            return self._return_error_response(e, 500)
         return self._return_response(request, data)
 
     def post(self, request: HttpRequest):
@@ -64,16 +74,9 @@ class AbstractAPIViewV1(AbstractAPIView):
         Returns:
             response (JsonResponse)
         """
-        try:
         body = request.body.decode("utf-8")
         body = json.loads(body)
         created_id = self.serializer.create_model_from_json(body, self.user)
-        except (JSONDecodeError,
-                AssertionError,
-                ValueError,
-                PermissionError,
-                ObjectDoesNotExist) as e:
-            return self._return_error_response(e, 400)
         return JsonResponse({"id": created_id})
 
     def put(self, request: HttpRequest, id=None):
@@ -88,12 +91,9 @@ class AbstractAPIViewV1(AbstractAPIView):
         Returns:
             response (JsonResponse)
         """
-        try:
         body = request.body.decode("utf-8")
         body = json.loads(body)
         updated_id = self.serializer.update_model_from_json(id, body, self.user)
-        except Exception as e:
-            return self._return_error_response(e, 500)
         return JsonResponse({"id": updated_id})
 
     def delete(self, request: HttpRequest, id=None):
@@ -107,10 +107,7 @@ class AbstractAPIViewV1(AbstractAPIView):
             response (JsonResponse)
         """
 
-        try:
         success = self.serializer.delete_entry(id, self.user)
-        except Exception as e:
-            return self._return_error_response(e, 500)
         return JsonResponse(
             {
                 "success": success,

compensation/models/compensation.py

@@ -325,8 +325,8 @@ class Compensation(AbstractCompensation, CEFMixin, CoherenceMixin, PikMixin):
             self.identifier = self.generate_new_identifier()
         super().save(*args, **kwargs)
 
-    def mark_as_deleted(self, user, send_mail: bool = True):
+    def mark_as_deleted(self, user, send_mail: bool = True, comment: str|None = None):
-        super().mark_as_deleted(user, send_mail)
+        super().mark_as_deleted(user, send_mail, comment)
         if user is not None:
             self.intervention.mark_as_edited(user, edit_comment=COMPENSATION_REMOVED_TEMPLATE.format(self.identifier))
 

compensation/templates/compensation/report/eco_account/report.html

@@ -30,17 +30,45 @@
                             {% endif %}
                         </td>
                     </tr>
+                    <tr>
+                        <th scope="row">{% trans 'Available' %}</th>
+                        <td>
+                            {{available_total|floatformat:2}} / {{obj.deductable_surface|default_if_none:0.00|floatformat:2}} m²
+                            {% with available as value %}
+                                {% include 'konova/widgets/progressbar.html' %}
+                            {% endwith %}
+                        </td>
+                    </tr>
                     <tr>
                         <th scope="row">{% trans 'Deductions for' %}</th>
                         <td class="align-middle">
+                            <table class="table table-hover">
+                                <th scope="col">
+                                    {% translate 'Intervention' %}
+                                </th>
+                                <th scope="col">
+                                    {% translate 'Amount' %}
+                                </th>
                                 {% for deduction in deductions %}
+                                <tr>
+                                    <td>
                                         <a href="{% url 'intervention:report' deduction.intervention__id %}">
                                         {{deduction.intervention__identifier}} - {{deduction.intervention__title}}
                                         </a>
-                                <br>
+                                    </td>
+                                    <td>{{ deduction.surface|floatformat:2 }} m²</td>
+                                </tr>
                                 {% empty %}
-                                {% trans 'None' %}
+                                <tr>
+                                    <td>
+                                        {% translate 'None' %}
+                                    </td>
+                                    <td>
+                                        /
+                                    </td>
+                                </tr>
                                 {% endfor %}
+                            </table>
                         </td>
                     </tr>
                     <tr>

compensation/views/eco_account/report.py

@@ -66,7 +66,15 @@ class EcoAccountPublicReportView(AbstractPublicReportView):
         deductions = acc.deductions.all() \
             .distinct("intervention") \
             .select_related("intervention") \
-            .values_list("intervention__id", "intervention__identifier", "intervention__title", named=True)
+            .values_list("intervention__id",
+                         "intervention__identifier",
+                         "intervention__title",
+                         "surface",
+                         named=True)
+
+        # Calculate rest of available surface for deductions
+        available_total = acc.deductable_rest
+        available_relative = acc.get_deductable_rest_relative()
 
         context = {
             "obj": acc,
@@ -86,6 +94,8 @@ class EcoAccountPublicReportView(AbstractPublicReportView):
             "actions": actions,
             "deductions": deductions,
             "tables_scrollable": False,
+            "available": available_relative,
+            "available_total": available_total,
             TAB_TITLE_IDENTIFIER: tab_title,
         }
         context = BaseContext(request, context).context

docker-compose.yml

@@ -0,0 +1,21 @@
+services:
+  konova:
+    external_links:
+      - postgis:db
+      - arnova-nginx-server:arnova
+    build: .
+    image: "ksp/konova:x.y"
+    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:
+    name: postgis_nat_it_backend
+    external: true

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"'

intervention/admin.py

@@ -1,6 +1,6 @@
 from django.contrib import admin
 
-from intervention.models import Intervention, Responsibility, Legal, Revocation, InterventionDocument
+from intervention.models import Intervention
 from konova.admin import AbstractDocumentAdmin, BaseObjectAdmin
 
 

intervention/models/intervention.py

@@ -306,7 +306,7 @@ class Intervention(BaseObject,
             self.set_unchecked()
         return action
 
-    def mark_as_deleted(self, user, send_mail: bool = True):
+    def mark_as_deleted(self, user, send_mail: bool = True, comment: str|None = None):
         """ Extends base mark_as_delete functionality
 
         Removes related deductions from the database, which results in updating the deductable_rest of the
@@ -315,11 +315,12 @@ class Intervention(BaseObject,
         Args:
             user (User): The performing user
             send_mail (bool): Whether to send an info mail
+            comment (str|None): The delete comment
 
         Returns:
 
         """
-        super().mark_as_deleted(user, send_mail)
+        super().mark_as_deleted(user, send_mail, comment)
 
         # Remove pending deductions to free booked capacities
         deductions = self.deductions.all()

konova/admin.py

@@ -7,10 +7,7 @@ Created on: 22.07.21
 """
 from django.contrib import admin
 
-from konova.models import Geometry, Deadline, GeometryConflict, Parcel, District, Municipal, ParcelGroup, Resubmission
 from konova.sub_settings.lanis_settings import DEFAULT_SRID_RLP
-from konova.utils.message_templates import COMPENSATION_REMOVED_TEMPLATE
-from user.models import UserAction
 
 
 class GeometryAdmin(admin.ModelAdmin):
@@ -123,6 +120,7 @@ class BaseResourceAdmin(admin.ModelAdmin):
 
 class BaseObjectAdmin(BaseResourceAdmin, DeletableObjectMixinAdmin):
     search_fields = [
+        "id",
         "identifier",
         "title",
     ]

konova/forms/geometry_form.py

@@ -7,9 +7,7 @@ Created on: 15.08.22
 """
 import json
 
-from django.contrib.gis import gdal
+from django.contrib.gis.geos import MultiPolygon
-from django.contrib.gis.geos import MultiPolygon, Polygon
-from django.contrib.gis.geos.prototypes.io import WKTWriter
 from django.utils.translation import gettext_lazy as _
 from django.forms import JSONField
 
@@ -18,6 +16,7 @@ from konova.models import Geometry
 from konova.settings import GEOM_MAX_VERTICES
 from konova.tasks import celery_update_parcels, celery_check_for_geometry_conflicts
 from konova.sub_settings.lanis_settings import DEFAULT_SRID_RLP
+from konova.utils.geometry.geometry_validator import GeoJsonValidator, GeometryProcessor
 from user.models import UserActionLogEntry
 
 
@@ -60,6 +59,11 @@ class SimpleGeomForm(BaseForm):
         self.initialize_form_field("output", geom)
 
     def is_valid(self):
+        """ Custom is_valid method for SimpleGeomForm
+
+        Returns:
+
+        """
         super().is_valid()
         is_valid = True
 
@@ -75,118 +79,21 @@ class SimpleGeomForm(BaseForm):
         geom = self.data.get("output", json.dumps({}))
         geom = json.loads(geom)
 
-        # Initialize features list with empty MultiPolygon, so that an empty input will result in a
+        geojson_validator = GeoJsonValidator(geom, DEFAULT_SRID_RLP)
-        # proper empty MultiPolygon object
+        geojson_validator.validate()
-        features = []
-        features_json = geom.get("features", [])
-        accepted_ogr_types = [
-            "Polygon",
-            "Polygon25D",
-            "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
+        if geojson_validator.errors:
-            feature_geom = json.dumps(feature_geom)
+            self.add_error("output", geojson_validator.errors)
-            g = gdal.OGRGeometry(feature_geom, srs=DEFAULT_SRID_RLP)
+            return False
 
-            geometry_has_unwanted_dimensions = g.coord_dim > 2
+        # If cleaned_data is not proper empty dict, initialize one
-            if geometry_has_unwanted_dimensions:
-                g = self.__flatten_geom_to_2D(g)
-
-            geometry_type_is_accepted = 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
-
-            is_area_valid = self.__is_area_valid(g)
-            if not is_area_valid:
-                # Geometries with an invalid size will not be saved to the db
-                # We assume these are malicious snippets which are not supposed to be in the geometry in the first place
-                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
-        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
         if self.cleaned_data is None:
             self.cleaned_data = {}
-        self.cleaned_data["output"] = form_geom.ewkt
+        self.cleaned_data["output"] = geojson_validator.validated_geometry.ewkt
+        self._num_geometries_ignored = geojson_validator.num_ignored_geometries
 
         return is_valid
 
-    def __is_vertices_num_valid(self):
-        """ Checks whether the number of vertices in the geometry is not too high
-
-        Returns:
-
-        """
-        geom = self.cleaned_data.get("output")
-        g = gdal.OGRGeometry(geom, srs=DEFAULT_SRID_RLP)
-        num_vertices = g.num_coords
-
-        return num_vertices <= GEOM_MAX_VERTICES
-
-    def __is_area_valid(self, geom: gdal.OGRGeometry):
-        """ Checks whether the area is at least > 1m²
-
-        Returns:
-
-        """
-        is_area_valid = geom.area > 1  # > 1m² (SRID:25832)
-        return is_area_valid
-
-    def __simplify_geometry(self, geom, max_vert: int):
-        """ Simplifies a geometry
-
-        Geometry will be simplified until a threshold of max vertices has been reached.
-
-        Args:
-            geom (MultiPolygon): The geometry
-            max_vert (int): Threshold of maximum vertices in geometry
-
-        Returns:
-            geom (MultiPolygon): The simplified geometry
-        """
-        tolerance = 0.1
-        n = geom.num_coords
-        while(n > max_vert):
-            geom = geom.simplify(tolerance)
-            n = geom.num_coords
-            tolerance += 0.1
-        return geom
-
     def save(self, action: UserActionLogEntry):
         """ Saves the form's geometry
 
@@ -213,9 +120,9 @@ class SimpleGeomForm(BaseForm):
                 created=action,
             )
 
-        is_vertices_num_valid = self.__is_vertices_num_valid()
+        is_vertices_num_valid = GeometryProcessor.is_vertices_num_valid(geometry.geom)
         if not is_vertices_num_valid:
-            geometry.geom = self.__simplify_geometry(geometry.geom, max_vert=GEOM_MAX_VERTICES)
+            geometry.geom = GeometryProcessor.simplify_geometry(geometry.geom, max_vert=GEOM_MAX_VERTICES)
             geometry.save()
             self._geometry_simplified = True
 
@@ -240,16 +147,6 @@ class SimpleGeomForm(BaseForm):
         """
         return self._geometry_simplified
 
-    def __flatten_geom_to_2D(self, geom):
-        """
-        Enforces a given OGRGeometry from higher dimensions into 2D
-
-        """
-        wkt_w = WKTWriter(dim=2)
-        g_wkt = wkt_w.write(geom.geos).decode("utf-8")
-        geom = gdal.OGRGeometry(g_wkt)
-        return geom
-
     def _set_geojson_properties(self, geojson: dict, title: str = None):
         """ Toggles the editable property of the geojson for proper handling in map client
 

konova/management/commands/mass_delete_entries.py

@@ -0,0 +1,211 @@
+"""
+Author: Michel Peltriaux
+Created on: 16.07.26
+
+"""
+from django.db.models import QuerySet
+
+from compensation.models import Compensation, EcoAccount
+from ema.models import Ema
+from intervention.models import Intervention
+from konova.management.commands.setup import BaseKonovaCommand
+from user.models import User
+
+
+class Command(BaseKonovaCommand):
+    help = "Mass-deletes entries according to user input"
+
+    _DELETE_CLS = None
+    _DELETE_COMMENT = None
+    _DELETE_USER = None
+    _DELETE_FROM_DB = False
+
+    def handle(self, *args, **options):
+        self._get_delete_user()
+        self._get_object_type()
+        filter = self._get_filter()
+        self._get_delete_comment()
+        self._show_config(filter)
+        entries = self._collect_entries(filter)
+        self._process_delete(entries)
+
+    def _get_delete_user(self):
+        self._DELETE_USER = User.objects.filter(
+            is_superuser=True,
+            is_staff=True
+        ).order_by(
+            "id"
+        ).first()
+
+        if not self._DELETE_USER:
+            self._write_error("No admin-staff user could be found. Please check the admin users!")
+
+    def _get_object_type(self):
+        object_types = {
+            "eiv": Intervention,
+            "kom": Compensation,
+            "oek": EcoAccount,
+            "ema": Ema,
+        }
+        object_types_str = "|".join(object_types.keys())
+        object_type_select = input(f"Which object type shall be processed? ({object_types_str}): ").lower()
+        try:
+            self._DELETE_CLS = object_types[object_type_select]
+            if self._DELETE_CLS == EcoAccount:
+                oek_deduction_remove_understood = input(f"Please be aware that deleting OEKs will result in TOTAL REMOVING of their deductions without any chance to restore them. Do you want to continue? (y|n): ")
+                oek_deduction_remove_understood = oek_deduction_remove_understood.lower() == "y"
+                if not oek_deduction_remove_understood:
+                    self._write_error("Removing of OEK canceled. Abort.")
+                    exit(-1)
+
+        except KeyError:
+            self._write_error(f"'{object_type_select}' not a valid option of {object_types_str}. Abort.")
+            exit(-1)
+
+    def _get_filter(self):
+        filter_attribute = input("What do you want to filter entries by? (identifier|created_by_user): ").lower()
+        filter = {}
+        try:
+            assert filter_attribute in ["identifier", "created_by_user"]
+            if filter_attribute == "identifier":
+                filter_attribute = "identifier__contains"
+            elif filter_attribute == "created_by_user":
+                filter_attribute = "created__user__username"
+        except AssertionError:
+            self._write_error(f"'{filter_attribute}' unknown. Abort")
+            exit(-1)
+
+        filter_val = input("Use this value to search for: ")
+        try:
+            assert len(filter_val) > 0
+        except AssertionError:
+            self._write_error(f"'{filter_val}' is empty. Abort.")
+            exit(-1)
+
+        filter[filter_attribute] = filter_val
+        return filter
+
+    def _get_delete_comment(self):
+        self._DELETE_COMMENT = input("Comment to store in delete action: ")
+
+    def _show_config(self, filter: dict):
+        assert self._DELETE_CLS is not None
+        assert self._DELETE_COMMENT is not None
+
+        self._write_warning("You are about to delete entries with:")
+        self._write_warning(f"    Object type: {self._DELETE_CLS.__name__}")
+        self._write_warning(f"    Filter by: '{filter}'")
+        self._write_warning(f"    Delete performing user: '{self._DELETE_USER}'")
+
+    def _collect_entries(self, filter: dict):
+        return self._DELETE_CLS.objects.filter(
+            deleted__isnull=True
+        ).filter(
+            **filter
+        )
+
+    def _process_delete(self, entries: QuerySet):
+        """ Wrapping delete method. Forces user to decide whether entries will be marked as deleted or shall
+        be removed completely from database
+
+        Args:
+            entries (QuerySet): Entries to be processed
+
+        Returns:
+
+        """
+        delete_type = input("Do you want 1) mark entries as deleted or 2) remove them from the database? (1|2): ")
+        try:
+            delete_type = int(delete_type)
+            assert delete_type in (1, 2)
+            self._DELETE_FROM_DB = delete_type == 2
+        except (ValueError, AssertionError) as e:
+            self._write_error(f"Entered unknown '{delete_type}'. Abort.")
+            exit(-1)
+        if self._DELETE_FROM_DB:
+            self._process_delete_from_db(entries)
+        else:
+            self._process_mark_as_deleted(entries)
+
+
+    def _process_mark_as_deleted(self, entries: QuerySet):
+        """ Method do mark chosen entries as deleted
+
+        Args:
+            entries (QuerySet): Entries to be processed
+
+        Returns:
+
+        """
+        self._write_warning(f"    Comment for delete action: '{self._DELETE_COMMENT}'")
+
+        self._check_entries_sample(entries)
+
+        entries_count = entries.count()
+        i = 0
+        for element in entries:
+            if i % 10 == 0:
+                self._write_warning(f"    Deleted {i}/{entries_count}")
+            element.mark_as_deleted(user=self._DELETE_USER, send_mail=False, comment=self._DELETE_COMMENT)
+            i += 1
+        self._write_warning(f"    Deleted {entries_count}/{entries_count}")
+        self._write_success("Entries deleted. Bye.")
+
+    def _process_delete_from_db(self, entries: QuerySet):
+        """ Method do REMOVE entries from the database
+
+        Args:
+            entries (QuerySet): Entries to be processed
+
+        Returns:
+
+        """
+        self._check_entries_sample(entries)
+
+        entries_count = entries.count()
+        input_num_entries = input(f"THIS IS THE FINAL WARNING! {entries_count} ENTRIES WILL BE REMOVED FROM THE DATABASE! ENTER THE NUMBER OF ENTRIES TO BE DELETED TO CONTINUE: ")
+        try:
+            input_num_entries = int(input_num_entries)
+        except ValueError:
+            self._write_error(f"'{input_num_entries}' is not an integer. Abort.")
+            exit(-1)
+        if entries_count == input_num_entries:
+            i = 0
+            for element in entries:
+                if i % 10 == 0:
+                    self._write_warning(f"    Deleted {i}/{entries_count}")
+                element.delete()  # call individual delete routine to enforce custom delete logic (not called on bulk deleting!)
+                i += 1
+
+            self._write_warning(f"    Deleted {entries_count}/{entries_count}")
+            self._write_success("Entries deleted. Bye.")
+        else:
+            self._write_error(f"'{input_num_entries}' was not correct. Abort.")
+            exit(-1)
+
+    def _check_entries_sample(self, entries):
+        """ Shows a sample from the entries on the terminal, so the user can decide whether the results are as expected
+
+        Args:
+            entries (QuerySet): Entries to be processed
+
+        Returns:
+
+        """
+
+        entries_count = entries.count()
+        if entries_count == 0:
+            self._write_success(f"Found {entries_count} matches to delete. Nothing to do here. Bye.")
+            exit(0)
+
+        self._write_warning(
+            f"Found {entries_count} matches to delete. Please double-check whether these samples from the results are what you expected: ")
+        first_three_elements = entries[:3]
+        for element in first_three_elements:
+            self._write_warning(f"    {element.identifier} ({element.id})")
+
+        delete_input = input("Are you ready to delete them now? (y|n): ").lower()
+        delete_now = delete_input == "y"
+        if not delete_now:
+            self._write_error(f"Entered '{delete_input}'. Abort.")
+            exit(-1)

konova/models/geometry.py

@@ -113,7 +113,7 @@ class Geometry(BaseResource):
             objs (list): The list of objects
         """
         objs = []
-
+        stop_searching = False
         # Some related data sets can be processed rather easily
         regular_sets = [
             self.intervention_set,
@@ -129,10 +129,15 @@ class Geometry(BaseResource):
             else:
                 objs += set_objs
 
+            stop_searching = len(objs) > 0
+            if stop_searching:
+                break
+
+        if not stop_searching:
             # ... 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)
+                Q(deleted=None) | Q(intervention__deleted=None)
             )
             if limit_to_attrs:
                 objs += comp_objs.values(*limit_to_attrs)
@@ -142,11 +147,22 @@ class Geometry(BaseResource):
 
     def get_data_object(self, limit_to_attrs: list = None):
         """
-        Getter for the specific data object which is related to this geometry
+        Getter for the specific data object which is related to this geometry.
+
+        !!! Only returns undeleted entries !!!
+
+        Returns:
+            result (str|None): Returns the desired attributes or None if the data object is marked as deleted
+
         """
         objs = self.get_data_objects(limit_to_attrs)
         assert (len(objs) <= 1)
+        try:
             result = objs.pop()
+        except IndexError:
+            # If this happens, we just processed a GeometryConflict with an entry which is marked as deleted.
+            # Therefore we return None
+            result = None
         return result
 
     def update_parcels(self):
@@ -403,39 +419,6 @@ class Geometry(BaseResource):
 
         return complexity_factor
 
-    @staticmethod
-    def cast_to_multipolygon(input_geom):
-        """ If input_geom is not a MultiPolygon, cast to MultiPolygon
-
-        Args:
-            input_geom ():
-
-        Returns:
-            output_geom
-        """
-        output_geom = input_geom
-        if not isinstance(input_geom, MultiPolygon):
-            try:
-                output_geom = MultiPolygon(input_geom, srid=DEFAULT_SRID_RLP)
-            except TypeError as e:
-                raise AssertionError(f"Only (Multi)Polygon allowed! Could not convert {input_geom.geom_type} to MultiPolygon")
-        return output_geom
-
-    @staticmethod
-    def cast_to_rlp_srid(input_geom):
-        """ If input_geom is not of RLP SRID (25832), cast to RLP SRID
-
-        Args:
-            input_geom ():
-
-        Returns:
-            output_geom
-        """
-        output_geom = input_geom
-        if output_geom.srid != DEFAULT_SRID_RLP:
-            output_geom.transform(DEFAULT_SRID_RLP)
-        return output_geom
-
     def get_conflict_geometries(self):
         """ Getter for geometry ids which conflict with this geometry or are conflicted by this one
 

konova/models/object.py

@@ -92,13 +92,15 @@ class DeletableObjectMixin(models.Model):
     class Meta:
         abstract = True
 
-    def mark_as_deleted(self, user, send_mail: bool = True):
+    def mark_as_deleted(self, user, send_mail: bool = True, comment: str|None = None):
         """ Mark an entry as deleted
 
         Does not delete from database but sets a timestamp for being deleted on and which user deleted the object
 
         Args:
             user (User): The performing user
+            send_mail (bool): Whether to send mails to users and teams
+            comment (str|None): The comment for delete action
 
         Returns:
 
@@ -109,7 +111,7 @@ class DeletableObjectMixin(models.Model):
             return
 
         with transaction.atomic():
-            action = UserActionLogEntry.get_deleted_action(user)
+            action = UserActionLogEntry.get_deleted_action(user, comment)
             self.deleted = action
             self.log.add(action)
 
@@ -144,6 +146,33 @@ class BaseObject(BaseResource, DeletableObjectMixin):
     class Meta:
         abstract = True
 
+    def delete(self, using=None, keep_parents=False):
+        """ Base deleting of a BaseObject instance
+
+        Args:
+            using:
+            keep_parents:
+
+        Returns:
+
+        """
+        self.__delete_external_identifier()
+        super().delete(using, keep_parents)
+
+    def __delete_external_identifier(self):
+        """ Checks on existing external identifier linking and drops them
+
+        Returns:
+
+        """
+        from api.models import ExternalIdentifier
+        try:
+            external_identifier = ExternalIdentifier.objects.filter(internal_id=self.id)
+            external_identifier.delete()
+        except ObjectDoesNotExist:
+            pass
+
+
     @abstractmethod
     def set_status_messages(self, request: HttpRequest):
         raise NotImplementedError
@@ -679,7 +708,9 @@ class GeoReferencedMixin(models.Model):
         conflicting_geometries = self.geometry.get_conflict_geometries()
         data_object_identifiers = []
         for conflicting_geom in conflicting_geometries:
-            data_object_identifiers.append(conflicting_geom.get_data_object(["identifier"]))
+            data_obj_id = conflicting_geom.get_data_object(["identifier"])
+            if data_obj_id:
+                data_object_identifiers.append(data_obj_id)
 
         add_message = len(data_object_identifiers) > 0
         if add_message:

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/tests/test_geometries.py

@@ -85,12 +85,6 @@ class GeometryTestCase(BaseTestCase):
         )
 
     def test_get_data_objects(self):
-        num_objs_with_geom = 0
-        self.assertEqual(
-            len(self.geom_1.get_data_objects()),
-            num_objs_with_geom
-        )
-
         objs = [
             self.intervention,
             self.compensation,
@@ -98,16 +92,13 @@ class GeometryTestCase(BaseTestCase):
             self.ema,
         ]
         for obj in objs:
-            obj.geometry = self.geom_1
+            if not obj.geometry:
+                obj.geometry = Geometry.objects.create(geom=self.create_dummy_geometry())
                 obj.save()
 
-            num_objs_with_geom += 1
+            data_objs = obj.geometry.get_data_objects()
-            geom_objs = self.geom_1.get_data_objects()
+            self.assertEqual(len(data_objs), 1)
-            self.assertEqual(
+            self.assertIn(obj, data_objs)
-                len(geom_objs),
-                num_objs_with_geom
-            )
-            self.assertIn(obj, geom_objs)
 
     def test_as_feature_collection(self):
         geometry = self.geom_1.geom

konova/utils/__init__.py

@@ -0,0 +1,5 @@
+"""
+Author: Michel Peltriaux
+Created on: 16.07.26
+
+"""

konova/utils/geometry/__init__.py

@@ -0,0 +1,5 @@
+"""
+Author: Michel Peltriaux
+Created on: 12.09.26
+
+"""

konova/utils/geometry/geometry_validator.py

@@ -0,0 +1,353 @@
+"""
+Author: Michel Peltriaux
+Created on: 12.09.26
+
+"""
+import json
+
+from django.contrib.gis import gdal
+from django.contrib.gis.gdal.srs import SpatialReference
+from django.contrib.gis.geos import Polygon, MultiPolygon
+from django.contrib.gis.geos.prototypes.io import WKTWriter
+from django.utils.translation import gettext_lazy as _
+
+from konova.settings import GEOM_MAX_VERTICES
+from konova.sub_settings.lanis_settings import DEFAULT_SRID_RLP, DEFAULT_SRID
+
+
+class GeometryProcessor:
+    """ GeometryProcessor wraps methods for checking or processing geometry objects
+
+    """
+    @staticmethod
+    def simplify_geometry(geom: MultiPolygon, max_vert: int):
+        """ Simplifies a geometry
+
+        Geometry will be simplified until a threshold of max vertices has been reached.
+
+        Args:
+            geom (MultiPolygon): The geometry
+            max_vert (int): Threshold of maximum vertices in geometry
+
+        Returns:
+            geom (MultiPolygon): The simplified geometry
+        """
+        tolerance = 0.1
+        n = geom.num_coords
+        while(n > max_vert):
+            geom = geom.simplify(tolerance)
+            n = geom.num_coords
+            tolerance += 0.1
+        return geom
+
+    @staticmethod
+    def is_vertices_num_valid(geometry: MultiPolygon):
+        """ Checks whether the number of vertices in the geometry is not too high
+
+        Returns:
+
+        """
+        return geometry.num_coords <= GEOM_MAX_VERTICES
+
+    @staticmethod
+    def is_valid_4326(geometry: MultiPolygon) -> bool:
+        """ Checks whether a given geometry's coordinates are in a valid range to be of EPSG:4326
+
+        Args:
+            geometry: The geometry
+
+        Returns:
+            ret_val (bool): Whether the geometry is valid EPSG:4326
+        """
+        assert geometry.srid == DEFAULT_SRID
+        return GeometryProcessor.is_valid_coord_range(
+            geometry,
+            -90.0,
+            90.0,
+            -180.0,
+            180.0,
+        )
+
+    @staticmethod
+    def is_valid_25832(geometry: MultiPolygon) -> bool:
+        """ Checks whether a given geometry's coordinates are in a valid range to be of EPSG:25832
+
+        Args:
+            geometry: The geometry
+
+        Returns:
+            ret_val (bool): Whether the geometry is valid EPSG:25832
+        """
+        assert geometry.srid == DEFAULT_SRID_RLP
+        return GeometryProcessor.is_valid_coord_range(
+            geometry,
+            166_000,
+            834_000,
+            0,
+            9_329_000,
+        )
+
+    @staticmethod
+    def is_valid_coord_range(geometry: MultiPolygon,
+                             min_x:float|int,
+                             max_x:float|int,
+                             min_y:float|int,
+                             max_y: float|int) -> bool:
+        """ Checks whether a given geometry's coordinates are in a valid range defined by input parameters
+
+        Args:
+            geometry: The geometry
+            min_x (float|int): The min x value
+            max_x (float|int): The max x value
+            min_y (float|int): The min y value
+            max_y (float|int): The max y value
+
+        Returns:
+            ret_val (bool): Whether the geometry's coordinates stays inside the defined range
+        """
+        if not geometry.centroid.coords:
+            # No coordinates at all found, therefore technically proper 4326
+            return True
+
+        try:
+            env_min_x = geometry.envelope.min_x
+            env_max_x = geometry.envelope.max_x
+            env_min_y = geometry.envelope.min_y
+            env_max_y = geometry.envelope.max_x
+
+            valid = (
+                    min_x <= env_min_x and
+                    env_max_x <= max_x and
+                    min_y <= env_min_y and
+                    env_max_y <= max_y
+            )
+            return valid
+        except IndexError:
+            return False
+
+    @staticmethod
+    def cast_to_multipolygon(input_geom: MultiPolygon) -> MultiPolygon:
+        """ If input_geom is not a MultiPolygon, cast to MultiPolygon
+
+        Args:
+            input_geom ():
+
+        Returns:
+            output_geom
+        """
+        output_geom = input_geom
+        if not isinstance(input_geom, MultiPolygon):
+            try:
+                output_geom = MultiPolygon(input_geom, srid=DEFAULT_SRID_RLP)
+            except TypeError as e:
+                raise AssertionError(f"Only (Multi)Polygon allowed! Could not convert {input_geom.geom_type} to MultiPolygon")
+        return output_geom
+
+    @staticmethod
+    def cast_to_rlp_srid(input_geom: gdal.OGRGeometry) -> gdal.OGRGeometry:
+        """ If input_geom is not of RLP SRID (25832), cast to RLP SRID
+
+        Args:
+            input_geom ():
+
+        Returns:
+            output_geom
+        """
+        output_geom = input_geom
+        if output_geom.srid != DEFAULT_SRID_RLP:
+            output_geom.transform(DEFAULT_SRID_RLP)
+        return output_geom
+
+    @staticmethod
+    def flatten_geom_to_2D(geom: gdal.OGRGeometry) -> gdal.OGRGeometry:
+        """
+        Enforces a given OGRGeometry from higher dimensions into 2D
+
+        """
+        wkt_w = WKTWriter(dim=2)
+        g_wkt = wkt_w.write(geom.geos).decode("utf-8")
+        geom = gdal.OGRGeometry(g_wkt)
+        return geom
+
+    @staticmethod
+    def is_area_valid(geom: gdal.OGRGeometry) -> bool:
+        """ Checks whether the area is at least > 1m²
+
+        Returns:
+
+        """
+        assert geom.srid == DEFAULT_SRID_RLP
+        is_area_valid = geom.area > 1  # > 1m² (SRID:25832)
+        return is_area_valid
+
+
+class GeoJsonValidator:
+    """ GeoJson Validator validates geojson (e.g. from API or form input)
+
+    """
+    _errors: list
+    _input_geojson: dict
+    _validated_geometry: MultiPolygon
+    _num_ignored_geometries: int
+
+    _accepted_ogr_types = [
+        "Polygon",
+        "Polygon25D",
+        "MultiPolygon",
+        "MultiPolygon25D",
+    ]
+
+    def __init__(self, input_geojson: dict, srs: int) -> None:
+        assert input_geojson is not None
+        self._input_geojson = input_geojson
+        self._num_ignored_geometries = 0
+        self._errors = list()
+        self._srs = SpatialReference(srs)
+
+    @property
+    def num_ignored_geometries(self):
+        """ Getter
+
+        Returns:
+
+        """
+        return self._num_ignored_geometries
+
+    @property
+    def input_geojson(self):
+        """ Getter
+
+        Returns:
+
+        """
+        return self._input_geojson
+
+    @property
+    def validated_geometry(self):
+        """ Getter
+
+        Returns:
+
+        """
+        return self._validated_geometry
+
+    @property
+    def errors(self):
+        """ Getter
+
+        Returns:
+
+        """
+        return self._errors
+
+    def __add_error(self, text: str):
+        """ Wraps pushing new error into error list
+
+        Args:
+            text (str): The error text
+
+        Returns:
+
+        """
+        self._errors.append(text)
+
+    def validate(self):
+        """ Validates input geojson
+
+        Returns:
+
+        """
+        features = self._input_geojson.get("features", None)
+
+        is_input_geojson_empty = len(self._input_geojson) == 0
+        no_features_in_input_found = features is None
+
+        if not is_input_geojson_empty and no_features_in_input_found:
+            # check if _input_geojson is a feature itself
+            if self.__is_geojson_feature():
+                features = [
+                    {
+                        "geometry": self._input_geojson
+                    }
+                ]
+            else:
+                self.__add_error("Input does not seem to be geojson")
+                return
+
+        try:
+            validated_features = self.__validate_single_features(features)
+        except AssertionError as e:
+            self.__add_error(str(e))
+            return
+
+        # Unionize all polygon features into one new MultiPolygon
+        if validated_features:
+            multipolygon_geometry = MultiPolygon(*validated_features, srid=self._srs).unary_union
+        else:
+            # If no features have been processed, this indicates an empty geometry - so we store an empty geometry
+            multipolygon_geometry = MultiPolygon(srid=self._srs)
+
+        # Make sure to convert into a MultiPolygon. Relevant if a single Polygon is provided.
+        multipolygon_geometry = GeometryProcessor.cast_to_multipolygon(multipolygon_geometry)
+        self._validated_geometry = multipolygon_geometry
+
+    def __validate_single_features(self, features: list) -> list:
+        validated_features = []
+
+        # Check validity for each feature of the geometry
+        for feature in features:
+            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=self._srs)
+            if g.empty:
+                continue
+            g = GeometryProcessor.cast_to_rlp_srid(g)
+            if not GeometryProcessor.is_valid_25832(g):
+                raise AssertionError(_("This feature does not hold valid EPSG:25832 coordinates:\n {}".format(g.geojson)))
+
+            geometry_has_unwanted_dimensions = g.coord_dim > 2
+            if geometry_has_unwanted_dimensions:
+                g = GeometryProcessor.flatten_geom_to_2D(g)
+
+            geometry_type_is_accepted = g.geom_type not in self._accepted_ogr_types
+            if geometry_type_is_accepted:
+                raise AssertionError(_("Only surfaces allowed. Points or lines must be buffered."))
+
+            is_area_valid = GeometryProcessor.is_area_valid(g)
+            if not is_area_valid:
+                # Geometries with an invalid size will not be saved to the db
+                # We assume these are malicious snippets which are not supposed to be in the geometry in the first place
+                self._num_ignored_geometries += 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)
+            if not g.valid:
+                raise AssertionError(g.valid_reason)
+
+            # If the resulting polygon is just a single polygon, we add it to the list of properly created features
+            if isinstance(g, Polygon):
+                validated_features.append(g)
+            elif isinstance(g, MultiPolygon):
+                # The resulting polygon could be of type MultiPolygon (due to multiple surfaces)
+                # If so, we extract each single polygons from the MultiPolygon and add them to the created features list
+                validated_features.extend(list(g))
+
+        return validated_features
+
+    def __is_geojson_feature(self):
+        """ Checks whether _input_geojson is a proper geojson feature
+
+        Returns:
+
+        """
+        has_type = self._input_geojson.get("type", None) is not None
+        has_coordinates = self._input_geojson.get("coordinates", None) is not None
+        has_properties = self._input_geojson.get("properties", None) is not None
+        return has_type and has_coordinates and has_properties

konova/utils/schneider/__init__.py

@@ -0,0 +1,5 @@
+"""
+Author: Michel Peltriaux
+Created on: 16.07.26
+
+"""

konova/utils/schneider/fetcher.py

@@ -9,6 +9,7 @@ import json
 from json import JSONDecodeError
 
 import requests
+from django.contrib.gis import gdal
 
 from konova.sub_settings import schneider_settings
 from konova.sub_settings.lanis_settings import DEFAULT_SRID
@@ -35,7 +36,10 @@ class ParcelFetcher:
         if geom.area < buffer_threshold:
             # Fallback for malicious geometries which are way too small and would disappear on negative buffering
             geom = geometry.geom
+        try:
             geom.transform(DEFAULT_SRID)
+        except gdal.GDALException as e:
+            raise ValueError(f"{str(e)}\nCould not transform geometry (id: {geometry.id}) to {DEFAULT_SRID}:\n {geom.geojson}")
         self.geojson = geom.ewkt
         self.results = []
 

locale/de/LC_MESSAGES/django.po

@@ -30,7 +30,7 @@
 #: konova/filters/mixins/office.py:57 konova/filters/mixins/record.py:23
 #: konova/filters/mixins/self_created.py:24 konova/filters/mixins/share.py:23
 #: konova/filters/mixins/user_log.py:17 konova/filters/mixins/user_log.py:18
-#: konova/forms/geometry_form.py:32 konova/forms/modals/document_form.py:26
+#: konova/forms/geometry_form.py:31 konova/forms/modals/document_form.py:26
 #: konova/forms/modals/document_form.py:36
 #: konova/forms/modals/document_form.py:50
 #: konova/forms/modals/document_form.py:62
@@ -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: 2026-09-13 12:06+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"
@@ -129,6 +129,7 @@ msgstr ""
 #: analysis/templates/analysis/reports/includes/old_data/amount.html:3
 #: compensation/forms/modals/compensation_action.py:66
 #: compensation/templates/compensation/detail/eco_account/includes/deductions.html:34
+#: compensation/templates/compensation/report/eco_account/report.html:50
 #: intervention/templates/intervention/detail/includes/deductions.html:31
 msgid "Amount"
 msgstr "Menge"
@@ -334,6 +335,7 @@ msgstr "Typ"
 
 #: analysis/templates/analysis/reports/includes/old_data/amount.html:24
 #: compensation/tables/compensation.py:87
+#: compensation/templates/compensation/report/eco_account/report.html:47
 #: intervention/forms/modals/deduction.py:58
 #: intervention/forms/modals/deduction.py:65 intervention/tables.py:92
 #: intervention/templates/intervention/detail/view.html:19
@@ -448,7 +450,8 @@ 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:96
+#: compensation/views/compensation/compensation.py:160
 msgid "New compensation"
 msgstr "Neue Kompensation"
 
@@ -475,7 +478,8 @@ msgid "When did the parties agree on this?"
 msgstr "Wann wurde dieses Ökokonto offiziell vereinbart?"
 
 #: compensation/forms/eco_account.py:73
-#: compensation/views/eco_account/eco_account.py:105
+#: compensation/views/eco_account/eco_account.py:77
+#: compensation/views/eco_account/eco_account.py:127
 msgid "New Eco-Account"
 msgstr "Neues Ökokonto"
 
@@ -503,7 +507,8 @@ msgstr ""
 
 #: 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!"
+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
@@ -818,6 +823,7 @@ msgstr "Am {} von {} verzeichnet worden"
 
 #: compensation/tables/eco_account.py:39
 #: compensation/templates/compensation/detail/eco_account/view.html:36
+#: compensation/templates/compensation/report/eco_account/report.html:34
 #: konova/templates/konova/widgets/progressbar.html:3
 msgid "Available"
 msgstr "Verfügbar"
@@ -948,7 +954,7 @@ msgstr "Wiedervorlage"
 
 #: compensation/templates/compensation/detail/compensation/includes/controls.html:20
 #: compensation/templates/compensation/detail/eco_account/includes/controls.html:34
-#: ema/templates/ema/detail/includes/controls.html:34
+#: ema/templates/ema/detail/includes/controls.html:32
 #: intervention/templates/intervention/detail/includes/controls.html:39
 msgid "Edit"
 msgstr "Bearbeiten"
@@ -962,7 +968,7 @@ msgstr "Log anzeigen"
 
 #: compensation/templates/compensation/detail/compensation/includes/controls.html:27
 #: compensation/templates/compensation/detail/eco_account/includes/controls.html:41
-#: ema/templates/ema/detail/includes/controls.html:41
+#: ema/templates/ema/detail/includes/controls.html:43
 #: intervention/templates/intervention/detail/includes/controls.html:46
 msgid "Delete"
 msgstr "Löschen"
@@ -1154,7 +1160,7 @@ msgstr "Verzeichnet am"
 #: compensation/templates/compensation/detail/compensation/view.html:107
 #: compensation/templates/compensation/detail/eco_account/view.html:85
 #: compensation/templates/compensation/report/compensation/report.html:54
-#: compensation/templates/compensation/report/eco_account/report.html:47
+#: compensation/templates/compensation/report/eco_account/report.html:75
 #: ema/templates/ema/detail/view.html:71
 #: ema/templates/ema/report/report.html:34
 #: intervention/templates/intervention/detail/view.html:113
@@ -1188,7 +1194,7 @@ msgid "other users"
 msgstr "weitere Nutzer"
 
 #: compensation/templates/compensation/detail/eco_account/includes/controls.html:18
-#: ema/templates/ema/detail/includes/controls.html:18
+#: ema/templates/ema/detail/includes/controls.html:19
 #: intervention/forms/modals/share.py:62
 #: intervention/templates/intervention/detail/includes/controls.html:18
 #: intervention/tests/unit/test_forms.py:150
@@ -1258,11 +1264,11 @@ msgstr "Maßnahmenträger"
 msgid "Report"
 msgstr "Bericht"
 
-#: compensation/templates/compensation/report/eco_account/report.html:34
+#: compensation/templates/compensation/report/eco_account/report.html:43
 msgid "Deductions for"
 msgstr "Abbuchungen für"
 
-#: compensation/templates/compensation/report/eco_account/report.html:42
+#: compensation/templates/compensation/report/eco_account/report.html:64
 #: intervention/templates/intervention/report/report.html:53
 #: intervention/templates/intervention/report/report.html:66
 #: intervention/templates/intervention/report/report.html:76
@@ -1292,40 +1298,44 @@ msgstr ""
 msgid "Responsible data"
 msgstr "Daten zu den verantwortlichen Stellen"
 
-#: compensation/views/compensation/compensation.py:52
+#: compensation/views/compensation/compensation.py:53
 msgid "Compensations - Overview"
 msgstr "Kompensationen - Übersicht"
 
-#: compensation/views/compensation/compensation.py:167
+#: compensation/views/compensation/compensation.py:203
+#: compensation/views/compensation/compensation.py:261
+#: compensation/views/eco_account/eco_account.py:169
+#: compensation/views/eco_account/eco_account.py:224 ema/views/ema.py:175
+#: ema/views/ema.py:229 intervention/views/intervention.py:176
+#: intervention/views/intervention.py:230
+msgid "Edit {}"
+msgstr "Bearbeite {}"
+
+#: compensation/views/compensation/compensation.py:242
 #: konova/utils/message_templates.py:40
 msgid "Compensation {} edited"
 msgstr "Kompensation {} bearbeitet"
 
-#: compensation/views/compensation/compensation.py:190
-#: compensation/views/eco_account/eco_account.py:168 ema/views/ema.py:173
-#: intervention/views/intervention.py:175
-msgid "Edit {}"
-msgstr "Bearbeite {}"
-
 #: compensation/views/compensation/report.py:35
 #: compensation/views/eco_account/report.py:35 ema/views/report.py:35
 #: intervention/views/report.py:36
 msgid "Report {}"
 msgstr "Bericht {}"
 
-#: compensation/views/eco_account/eco_account.py:49
+#: compensation/views/eco_account/eco_account.py:51
 msgid "Eco-account - Overview"
 msgstr "Ökokonten - Übersicht"
 
-#: compensation/views/eco_account/eco_account.py:82
+#: compensation/views/eco_account/eco_account.py:108
 msgid "Eco-Account {} added"
 msgstr "Ökokonto {} hinzugefügt"
 
-#: compensation/views/eco_account/eco_account.py:145
+#: compensation/views/eco_account/eco_account.py:205
 msgid "Eco-Account {} edited"
 msgstr "Ökokonto {} bearbeitet"
 
-#: ema/forms.py:42 ema/tests/unit/test_forms.py:27 ema/views/ema.py:107
+#: ema/forms.py:42 ema/tests/unit/test_forms.py:27 ema/views/ema.py:79
+#: ema/views/ema.py:129
 msgid "New EMA"
 msgstr "Neue EMA hinzufügen"
 
@@ -1357,11 +1367,11 @@ msgstr "Ersatzzahlungsmaßnahme"
 msgid "EMAs - Overview"
 msgstr "EMAs - Übersicht"
 
-#: ema/views/ema.py:85
+#: ema/views/ema.py:111
 msgid "EMA {} added"
 msgstr "EMA {} hinzugefügt"
 
-#: ema/views/ema.py:150
+#: ema/views/ema.py:211
 msgid "EMA {} edited"
 msgstr "EMA {} bearbeitet"
 
@@ -1425,7 +1435,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:82 intervention/views/intervention.py:134
 msgid "New intervention"
 msgstr "Neuer Eingriff"
 
@@ -1661,15 +1671,15 @@ msgstr ""
 msgid "Check performed"
 msgstr "Prüfung durchgeführt"
 
-#: intervention/views/intervention.py:53
+#: intervention/views/intervention.py:56
 msgid "Interventions - Overview"
 msgstr "Eingriffe - Übersicht"
 
-#: intervention/views/intervention.py:86
+#: intervention/views/intervention.py:114
 msgid "Intervention {} added"
 msgstr "Eingriff {} hinzugefügt"
 
-#: intervention/views/intervention.py:150
+#: intervention/views/intervention.py:212
 msgid "Intervention {} edited"
 msgstr "Eingriff {} bearbeitet"
 
@@ -1797,16 +1807,11 @@ msgstr "Speichern"
 msgid "Not editable"
 msgstr "Nicht editierbar"
 
-#: konova/forms/geometry_form.py:31 konova/utils/quality.py:44
+#: konova/forms/geometry_form.py:30 konova/utils/quality.py:44
 #: konova/utils/quality.py:46 templates/form/collapsable/form.html:45
 msgid "Geometry"
 msgstr "Geometrie"
 
-#: konova/forms/geometry_form.py:105
-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."
-
 #: konova/forms/modals/document_form.py:37
 msgid "When has this file been created? Important for photos."
 msgstr "Wann wurde diese Datei erstellt oder das Foto aufgenommen?"
@@ -1961,6 +1966,7 @@ msgstr "Raumreferenz"
 #: konova/templates/konova/includes/parcels/parcels.html:28
 msgid "No geometry entry found on database. Please contact an admin!"
 msgstr ""
+"Keine Geometrie in Datenbank gefunden. Kontaktieren Sie einen Administrator!"
 
 #: konova/templates/konova/includes/quickstart/compensations.html:20
 #: konova/templates/konova/includes/quickstart/ecoaccounts.html:20
@@ -2006,39 +2012,52 @@ msgstr "In Zwischenablage kopiert"
 msgid "Search"
 msgstr "Suchen"
 
-#: konova/utils/mailer.py:69 konova/utils/mailer.py:146
+#: konova/utils/geometry/geometry_validator.py:311
+msgid ""
+"This feature does not hold valid EPSG:25832 coordinates:\n"
+" {}"
+msgstr ""
+"Dieses Feature enthält keine validen EPSG:25832 Koordinaten:\n"
+" {}"
+
+#: konova/utils/geometry/geometry_validator.py:319
+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."
+
+#: konova/utils/mailer.py:82 konova/utils/mailer.py:159
 msgid "{} - Shared access removed"
 msgstr "{} - Zugriff entzogen"
 
-#: konova/utils/mailer.py:94 konova/utils/mailer.py:120
+#: konova/utils/mailer.py:107 konova/utils/mailer.py:133
 msgid "{} - Shared access given"
 msgstr "{} - Zugriff freigegeben"
 
-#: konova/utils/mailer.py:172 konova/utils/mailer.py:325
+#: konova/utils/mailer.py:185 konova/utils/mailer.py:338
 msgid "{} - Shared data unrecorded"
 msgstr "{} - Freigegebene Daten entzeichnet"
 
-#: konova/utils/mailer.py:198 konova/utils/mailer.py:300
+#: konova/utils/mailer.py:211 konova/utils/mailer.py:313
 msgid "{} - Shared data recorded"
 msgstr "{} - Freigegebene Daten verzeichnet"
 
-#: konova/utils/mailer.py:224 konova/utils/mailer.py:375
+#: konova/utils/mailer.py:237 konova/utils/mailer.py:388
 msgid "{} - Shared data checked"
 msgstr "{} - Freigegebene Daten geprüft"
 
-#: konova/utils/mailer.py:249 konova/utils/mailer.py:401
+#: konova/utils/mailer.py:262 konova/utils/mailer.py:414
 msgid "{} - Deduction changed"
 msgstr "{} - Abbuchung geändert"
 
-#: konova/utils/mailer.py:275 konova/utils/mailer.py:350
+#: konova/utils/mailer.py:288 konova/utils/mailer.py:363
 msgid "{} - Shared data deleted"
 msgstr "{} - Freigegebene Daten gelöscht"
 
-#: konova/utils/mailer.py:422 templates/email/api/verify_token.html:4
+#: konova/utils/mailer.py:435 templates/email/api/verify_token.html:4
 msgid "Request for new API token"
 msgstr "Anfrage für neuen API Token"
 
-#: konova/utils/mailer.py:447
+#: konova/utils/mailer.py:460
 msgid "Resubmission - {}"
 msgstr "Wiedervorlage - {}"
 
@@ -2289,11 +2308,11 @@ msgstr "Neuer Token generiert. Administratoren sind informiert."
 msgid "missing"
 msgstr "fehlend"
 
-#: konova/utils/tables.py:222
+#: konova/utils/tables.py:224
 msgid "Full access granted"
 msgstr "Für Sie freigegeben - Datensatz kann bearbeitet werden"
 
-#: konova/utils/tables.py:222
+#: konova/utils/tables.py:224
 msgid "Access not granted"
 msgstr "Nicht freigegeben - Datensatz nur lesbar"
 
@@ -2303,7 +2322,7 @@ msgstr ""
 "Dieses Datum ist unrealistisch. Geben Sie bitte das korrekte Datum ein "
 "(>1950)."
 
-#: konova/views/home.py:75 templates/navbars/navbar.html:16
+#: konova/views/home.py:76 templates/navbars/navbar.html:16
 msgid "Home"
 msgstr "Home"
 
@@ -2323,7 +2342,7 @@ msgstr "{} verzeichnet"
 msgid "Errors found:"
 msgstr "Fehler gefunden:"
 
-#: konova/views/remove.py:35
+#: konova/views/remove.py:34
 msgid "{} removed"
 msgstr "{} entfernt"
 

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

@@ -1,65 +1,65 @@
 amqp==5.3.1
-asgiref==3.11.1
+asgiref==3.12.1
 async-timeout==5.0.1
-beautifulsoup4==4.14.3
+beautifulsoup4==4.15.0
 billiard==4.2.4
 cached-property==2.0.1
 celery==5.6.3
-certifi==2026.4.22
+certifi==2026.7.22
-cffi==2.0.0
+cffi==2.1.1
-chardet==7.4.3
+chardet==7.6.0
-charset-normalizer==3.4.7
+charset-normalizer==3.5.1
-click==8.3.3
+click==8.5.0
 click-didyoumean==0.3.1
 click-plugins==1.1.1.2
 click-repl==0.3.0
-coverage==7.13.5
+coverage==7.16.0
-cryptography==48.0.0
+cryptography==50.0.1
 Deprecated==1.3.1
-Django==6.0.5
+Django==6.1.1
-django-autocomplete-light==4.0.0
+django-autocomplete-light==5.0.0
 django-bootstrap-modal-forms==3.0.5
-django-bootstrap4==26.1
+django-bootstrap4==26.2
-django-environ==0.13.0
+django-environ==0.14.0
-django-filter==25.2
+django-filter==26.1
 django-fontawesome-5==1.0.18
-django-oauth-toolkit==3.2.0
+django-oauth-toolkit==3.4.1
-django-tables2==3.0.0
+django-tables2==3.0.1
 et_xmlfile==2.0.0
-gunicorn==26.0.0
+gunicorn==26.2.0
-idna==3.13
+idna==3.19
-importlib_metadata==9.0.0
+importlib_metadata==9.0.1
 itsdangerous==2.2.0
-jwcrypto==1.5.7
+jwcrypto==1.6.0
 kombu==5.6.2
 oauthlib==3.3.1
 openpyxl==3.2.0b1
-packaging==26.2
+packaging==26.3
-pika==1.4.0
+pika==1.4.4
-pillow==12.2.0
+pillow==12.3.0
-prompt_toolkit==3.0.52
+prompt_toolkit==3.0.53
-psycopg==3.3.4
+psycopg==3.3.5
-psycopg-binary==3.3.4
+psycopg-binary==3.3.5
 pycparser==3.0
 pyparsing==3.3.2
 pypng==0.20220715.0
-pyproj==3.7.2
+pyproj==3.8.0
 python-dateutil==2.9.0.post0
-pytz==2026.2
+pytz==2026.3
 PyYAML==6.0.3
 qrcode==8.2
-redis==7.4.0
+redis==8.1.0
-requests==2.33.1
+requests==2.34.2
 six==1.17.0
-soupsieve==2.8.3
+soupsieve==2.9.2
-sqlparse==0.5.5
+sqlparse==0.6.0
-typing_extensions==4.15.0
+typing_extensions==4.16.0
-tzdata==2026.2
+tzdata==2026.4
-tzlocal==5.3.1
+tzlocal==5.4.4
 urllib3==2.7.0
 vine==5.1.0
-wcwidth==0.7.0
+wcwidth==0.8.3
 webservices==0.7
-wrapt==2.1.2
+wrapt==2.4.1
 xmltodict==1.0.4
-zipp==3.23.1
+zipp==4.1.0

templates/map/client/config.json

@@ -56,11 +56,9 @@
 	],
 	"layers":
 	[
-		{ "id": "webatlas_farbe", "folder": "bg", "type": "WMS", "order": -1, "title": "WebatlasRP farbig", "attribution": "LVermGeo", "url": "https://maps.service24.rlp.de/gisserver/services/RP/RP_WebAtlasRP/MapServer/WmsServer?", "name": "RP_WebAtlasRP", "active": true},
-		{ "id": "webatlas_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "WebatlasRP grau", "attribution": "LVermGeo", "url": "https://maps.service24.rlp.de/gisserver/services/RP/RP_ETRS_Gt/MapServer/WmsServer?", "name": "0", "active": false },
 		{ "id": "luftbilder", "folder": "bg", "type": "WMS", "order": -1, "title": "Luftbilder", "attribution": "LVermGeo", "url": "https://geo4.service24.rlp.de/wms/rp_dop20.fcgi?", "name": "rp_dop20", "active": false },
 		{ "id": "basemap_farbe", "folder": "bg", "type": "WMS", "order": -1, "title": "BasemapDE farbig", "attribution": "BKG", "url": "https://sgx.geodatenzentrum.de/wms_basemapde?", "name": "de_basemapde_web_raster_farbe", "active": false },
-		{ "id": "basemap_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "BasemapDE grau", "attribution": "BKG", "url": "https://sgx.geodatenzentrum.de/wms_basemapde?", "name": "de_basemapde_web_raster_grau", "active": false },
+		{ "id": "basemap_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "BasemapDE grau", "attribution": "BKG", "url": "https://sgx.geodatenzentrum.de/wms_basemapde?", "name": "de_basemapde_web_raster_grau", "active": true },
 		{ "id": "dtk_farbe", "folder": "bg", "type": "WMS", "order": -1, "title": "DTK5 farbig", "attribution": "LVermGeo", "url": "https://geo4.service24.rlp.de/wms/dtk5_rp.fcgi?", "name": "rp_dtk5", "active": false },
 		{ "id": "dtk_grau", "folder": "bg", "type": "WMS", "order": -1, "title": "DTK5 grau", "attribution": "LVermGeo", "url": "https://geo4.service24.rlp.de/wms/dtk5_rp.fcgi?", "name": "rp_dtk5_grau", "active": false },