Merge pull request '565 unify geometry quality checking' (#582) from 565_Unify_geometry_quality_checking into master

Reviewed-on: #582

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,46 +1,28 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
+          [
             [
-                [
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ],
-                    [
-                        7.837371826171871,
-                        50.80155187891526
-                    ],
-                    [
-                        7.835698127746578,
-                        50.805267562209806
-                    ],
-                    [
-                        7.841062545776364,
-                        50.806623577403386
-                    ],
-                    [
-                        7.848916053771969,
-                        50.808359219420474
-                    ],
-                    [
-                        7.855696678161618,
-                        50.807057493952975
-                    ],
-                    [
-                        7.854666709899899,
-                        50.80423696434001
-                    ],
-                    [
-                        7.850461006164548,
-                        50.80217570040005
-                    ],
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ]
-                ]
+              7.489245186249832,
+              50.29519575559556
+            ],
+            [
+              7.5244137991026605,
+              50.29519575559556
+            ],
+            [
+              7.5244137991026605,
+              50.275124048323875
+            ],
+            [
+              7.489245186249832,
+              50.275124048323875
+            ],
+            [
+              7.489245186249832,
+              50.29519575559556
             ]
+          ]
         ],
     "properties": {
         "title": "TEST_compensation_CHANGED",

api/tests/v1/update/ecoaccount_update_put_body.json

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

api/tests/v1/update/ema_update_put_body.json

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

api/tests/v1/update/intervention_update_put_body.json

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

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)
-        self.assertEqual(put_geom, self.intervention.geometry.geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_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)
-        self.assertEqual(put_geom, self.compensation.geometry.geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_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)
-        self.assertEqual(put_geom, self.eco_account.geometry.geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_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)
-        self.assertEqual(put_geom, self.ema.geometry.geom)
+        put_geom = MultiPolygon(GeometryProcessor.cast_to_rlp_srid(put_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,13 +104,16 @@ class AbstractModelAPISerializer:
         Returns:
             serialized_data (dict)
         """
-        entries = self.model.objects.filter(
-            **self.lookup
-        ).filter(
-            self.shared_lookup
-        ).order_by(
-            "id"
-        ).distinct()
+        try:
+            entries = self.model.objects.filter(
+                **self.lookup
+            ).filter(
+                self.shared_lookup
+            ).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):
-            geojson = json.dumps(geojson)
-        geometry = geos.fromstr(geojson)
-        geometry = Geometry.cast_to_rlp_srid(geometry)
-        geometry = Geometry.cast_to_multipolygon(geometry)
+        if isinstance(geojson, str):
+            geojson = json.loads(geojson)
+
+        geojson_validator = GeoJsonValidator(geojson, DEFAULT_SRID)
+        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
-            pass
+            # Not found as external id - let's check whether this is a valid uuid and therefore
+            # 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,

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)
+        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()
         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)
+        body = request.body.decode("utf-8")
+        body = json.loads(body)
+        created_id = self.serializer.create_model_from_json(body, self.user)
         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)
+        body = request.body.decode("utf-8")
+        body = json.loads(body)
+        updated_id = self.serializer.update_model_from_json(id, body, self.user)
         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)
+        success = self.serializer.delete_entry(id, self.user)
         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):
-        super().mark_as_deleted(user, send_mail)
+    def mark_as_deleted(self, user, send_mail: bool = True, comment: str|None = None):
+        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">
-                            {% for deduction in deductions %}
-                                <a href="{% url 'intervention:report' deduction.intervention__id %}">
-                                    {{deduction.intervention__identifier}} - {{deduction.intervention__title}}
-                                </a>
-                                <br>
-                            {% empty %}
-                                {% trans 'None' %}
-                            {% endfor %}
+                            <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>
+                                    </td>
+                                    <td>{{ deduction.surface|floatformat:2 }} m²</td>
+                                </tr>
+                                {% empty %}
+                                <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

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, Polygon
-from django.contrib.gis.geos.prototypes.io import WKTWriter
+from django.contrib.gis.geos import MultiPolygon
 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
-        # proper empty MultiPolygon object
-        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
+        geojson_validator = GeoJsonValidator(geom, DEFAULT_SRID_RLP)
+        geojson_validator.validate()
 
-            # 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)
+        if geojson_validator.errors:
+            self.add_error("output", geojson_validator.errors)
+            return False
 
-            geometry_has_unwanted_dimensions = g.coord_dim > 2
-            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 cleaned_data is not proper empty dict, initialize one
         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

@@ -419,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

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,295 @@
+"""
+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
+
+
+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):
+        """ 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
+        """
+        if not geometry.centroid.coords:
+            # No coordinates at all found, therefore technically proper 4326
+            return True
+
+        try:
+            lat,lon = geometry.centroid.coords
+            return (-90.0 <= lat <= 90.0) and (-180.0 <= lon <= 180.0)
+        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", [])
+
+        is_input_geojson_empty = len(self._input_geojson) == 0
+        no_features_in_input_found = not features
+
+        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)
+
+            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
+
+"""

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
-cffi==2.0.0
-chardet==7.4.3
-charset-normalizer==3.4.7
-click==8.3.3
+certifi==2026.7.22
+cffi==2.1.1
+chardet==7.6.0
+charset-normalizer==3.5.1
+click==8.5.0
 click-didyoumean==0.3.1
 click-plugins==1.1.1.2
 click-repl==0.3.0
-coverage==7.13.5
-cryptography==48.0.0
+coverage==7.16.0
+cryptography==50.0.1
 Deprecated==1.3.1
-Django==6.0.5
-django-autocomplete-light==4.0.0
+Django==6.1.1
+django-autocomplete-light==5.0.0
 django-bootstrap-modal-forms==3.0.5
-django-bootstrap4==26.1
-django-environ==0.13.0
-django-filter==25.2
+django-bootstrap4==26.2
+django-environ==0.14.0
+django-filter==26.1
 django-fontawesome-5==1.0.18
-django-oauth-toolkit==3.2.0
-django-tables2==3.0.0
+django-oauth-toolkit==3.4.1
+django-tables2==3.0.1
 et_xmlfile==2.0.0
-gunicorn==26.0.0
-idna==3.13
-importlib_metadata==9.0.0
+gunicorn==26.2.0
+idna==3.19
+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
-pika==1.4.0
-pillow==12.2.0
-prompt_toolkit==3.0.52
-psycopg==3.3.4
-psycopg-binary==3.3.4
+packaging==26.3
+pika==1.4.4
+pillow==12.3.0
+prompt_toolkit==3.0.53
+psycopg==3.3.5
+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
-requests==2.33.1
+redis==8.1.0
+requests==2.34.2
 six==1.17.0
-soupsieve==2.8.3
-sqlparse==0.5.5
-typing_extensions==4.15.0
-tzdata==2026.2
-tzlocal==5.3.1
+soupsieve==2.9.2
+sqlparse==0.6.0
+typing_extensions==4.16.0
+tzdata==2026.4
+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 },