Merge pull request '# HOTFIX' (#584) from hotfix_feature_checl into master

Reviewed-on: #584

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.489245186249832,
-                    [
+              50.29519575559556
-                        7.845568656921382,
+            ],
-                        50.79829702304368
+            [
-                    ],
+              7.5244137991026605,
-                    [
+              50.29519575559556
-                        7.837371826171871,
+            ],
-                        50.80155187891526
+            [
-                    ],
+              7.5244137991026605,
-                    [
+              50.275124048323875
-                        7.835698127746578,
+            ],
-                        50.805267562209806
+            [
-                    ],
+              7.489245186249832,
-                    [
+              50.275124048323875
-                        7.841062545776364,
+            ],
-                        50.806623577403386
+            [
-                    ],
+              7.489245186249832,
-                    [
+              50.29519575559556
-                        7.848916053771969,
-                        50.808359219420474
-                    ],
-                    [
-                        7.855696678161618,
-                        50.807057493952975
-                    ],
-                    [
-                        7.854666709899899,
-                        50.80423696434001
-                    ],
-                    [
-                        7.850461006164548,
-                        50.80217570040005
-                    ],
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ]
-                ]
             ]
+          ]
         ],
     "properties": {
         "title": "TEST_compensation_CHANGED",

api/tests/v1/update/ecoaccount_update_put_body.json

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

api/tests/v1/update/ema_update_put_body.json

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

api/tests/v1/update/intervention_update_put_body.json

@@ -1,46 +1,28 @@
 {
-    "type": "MultiPolygon",
+    "type": "Polygon",
     "coordinates": [
+          [
             [
-                [
+              7.489245186249832,
-                    [
+              50.29519575559556
-                        7.845568656921382,
+            ],
-                        50.79829702304368
+            [
-                    ],
+              7.5244137991026605,
-                    [
+              50.29519575559556
-                        7.837371826171871,
+            ],
-                        50.80155187891526
+            [
-                    ],
+              7.5244137991026605,
-                    [
+              50.275124048323875
-                        7.835698127746578,
+            ],
-                        50.805267562209806
+            [
-                    ],
+              7.489245186249832,
-                    [
+              50.275124048323875
-                        7.841062545776364,
+            ],
-                        50.806623577403386
+            [
-                    ],
+              7.489245186249832,
-                    [
+              50.29519575559556
-                        7.848916053771969,
-                        50.808359219420474
-                    ],
-                    [
-                        7.855696678161618,
-                        50.807057493952975
-                    ],
-                    [
-                        7.854666709899899,
-                        50.80423696434001
-                    ],
-                    [
-                        7.850461006164548,
-                        50.80217570040005
-                    ],
-                    [
-                        7.845568656921382,
-                        50.79829702304368
-                    ]
-                ]
             ]
+          ]
         ],
     "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)
+        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,13 +104,16 @@ class AbstractModelAPISerializer:
         Returns:
             serialized_data (dict)
         """
-        entries = self.model.objects.filter(
+        try:
-            **self.lookup
+            entries = self.model.objects.filter(
-        ).filter(
+                **self.lookup
-            self.shared_lookup
+            ).filter(
-        ).order_by(
+                self.shared_lookup
-            "id"
+            ).order_by(
-        ).distinct()
+                "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,
@@ -202,3 +224,33 @@ class AbstractModelAPISerializer:
             obj (Intervention)
         """
         raise NotImplementedError("Must be implemented in subclasses")
+
+
+    def _geometry_conflicts_to_list(self, geometry) -> list:
+        """ Serializes geometry conflict ids into dict
+
+        Args:
+            geometry (Geometry): The geometry to fetch geometry conflicts from
+
+        Returns:
+            ids (list): Serialized geometry conflicts as dict objects inside a list
+        """
+        ids = []
+        conflict_geometries = geometry.get_conflict_geometries()
+        for geom in conflict_geometries:
+            try:
+                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(
+                {
+                    "identifier": data["identifier"],
+                    "id": data["id"],
+                }
+            )
+
+        return ids

api/utils/serializer/v1/serializer.py

@@ -54,6 +54,7 @@ class AbstractModelAPISerializerV1(AbstractModelAPISerializer):
             "created_on": self._created_on_to_json(entry),
             "modified_on": self._modified_on_to_json(entry),
             "external_identifiers": ext_ids,
+            "geometry_conflicts": self._geometry_conflicts_to_list(entry.geometry)
         }
         self._extend_properties_data(entry)
         geo_json["properties"] = self.properties_data

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.rpp = int(request.GET.get("rpp", self.rpp))
+        self.page_number = int(request.GET.get("p", self.page_number))
-            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.rpp = self.rpp
+        self.serializer.prepare_lookup(id, self.user)
-            self.serializer.page_number = self.page_number
+        data = self.serializer.fetch_and_serialize()
-
-            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 = request.body.decode("utf-8")
+        body = json.loads(body)
-            body = json.loads(body)
+        created_id = self.serializer.create_model_from_json(body, self.user)
-            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 = request.body.decode("utf-8")
+        body = json.loads(body)
-            body = json.loads(body)
+        updated_id = self.serializer.update_model_from_json(id, body, self.user)
-            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)
-            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">
-                            {% for deduction in deductions %}
+                            <table class="table table-hover">
-                                <a href="{% url 'intervention:report' deduction.intervention__id %}">
+                                <th scope="col">
-                                    {{deduction.intervention__identifier}} - {{deduction.intervention__title}}
+                                    {% translate 'Intervention' %}
-                                </a>
+                                </th>
-                                <br>
+                                <th scope="col">
-                            {% empty %}
+                                    {% translate 'Amount' %}
-                                {% trans 'None' %}
+                                </th>
-                            {% endfor %}
+                                {% 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()

intervention/tests/test_views.py

@@ -36,6 +36,7 @@ class InterventionViewTestCase(BaseViewTestCase):
         self.run_check_url = reverse("intervention:check", args=(self.intervention.id,))
         self.record_url = reverse("intervention:record", args=(self.intervention.id,))
         self.report_url = reverse("intervention:report", args=(self.intervention.id,))
+        self.compensation_remove_url = reverse("intervention:remove-compensation", args=(self.compensation.intervention.id, self.compensation.id))
 
         self.deduction.intervention = self.intervention
         self.deduction.save()
@@ -83,6 +84,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.revocation_new_url: f"{login_redirect_base}{self.revocation_new_url}",
             self.revocation_edit_url: f"{login_redirect_base}{self.revocation_edit_url}",
             self.revocation_remove_url: f"{login_redirect_base}{self.revocation_remove_url}",
+            self.compensation_remove_url: f"{login_redirect_base}{self.compensation_remove_url}",
         }
 
         self.assert_url_success(client, success_urls)
@@ -124,6 +126,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.deduction_new_url,
             self.deduction_edit_url,
             self.deduction_remove_url,
+            self.compensation_remove_url,
         ]
 
         self.assert_url_success(client, success_urls)
@@ -162,6 +165,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.deduction_new_url,
             self.deduction_edit_url,
             self.deduction_remove_url,
+            self.compensation_remove_url,
         ]
         fail_urls = [
             self.run_check_url,
@@ -212,6 +216,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.deduction_new_url,
             self.deduction_edit_url,
             self.deduction_remove_url,
+            self.compensation_remove_url,
         ]
         success_urls_redirect = {
             self.share_url: self.detail_url
@@ -258,6 +263,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.deduction_new_url,
             self.deduction_edit_url,
             self.deduction_remove_url,
+            self.compensation_remove_url,
         ]
         success_urls_redirect = {
             self.share_url: self.detail_url
@@ -304,6 +310,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.deduction_new_url,
             self.deduction_edit_url,
             self.deduction_remove_url,
+            self.compensation_remove_url,
         ]
         success_urls_redirect = {
             self.share_url: self.detail_url
@@ -350,6 +357,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.deduction_new_url,
             self.deduction_edit_url,
             self.deduction_remove_url,
+            self.compensation_remove_url,
         ]
         success_urls_redirect = {
             self.share_url: self.detail_url
@@ -396,6 +404,7 @@ class InterventionViewTestCase(BaseViewTestCase):
             self.deduction_new_url,
             self.deduction_edit_url,
             self.deduction_remove_url,
+            self.compensation_remove_url,
         ]
         # Define urls where a redirect to a specific location is the proper response
         success_urls_redirect = {

intervention/views/compensation.py

@@ -14,7 +14,7 @@ from django.utils.decorators import method_decorator
 from django.views import View
 
 from intervention.models import Intervention
-from konova.decorators import shared_access_required
+from konova.decorators import shared_access_required, default_group_required
 from konova.forms.modals import RemoveModalForm
 from konova.utils.message_templates import COMPENSATION_REMOVED_TEMPLATE
 
@@ -45,10 +45,12 @@ class RemoveCompensationFromInterventionView(LoginRequiredMixin, View):
             redirect_url=reverse("intervention:detail", args=(id,)) + "#related_data",
         )
 
+    @method_decorator(default_group_required)
     @method_decorator(shared_access_required(Intervention, "id"))
     def get(self, request, id: str, comp_id: str, *args, **kwargs) -> HttpResponse:
         return self.__process_request(request, id, comp_id, *args, **kwargs)
 
+    @method_decorator(default_group_required)
     @method_decorator(shared_access_required(Intervention, "id"))
     def post(self, request, id: str, comp_id: str, *args, **kwargs) -> HttpResponse:
         return self.__process_request(request, id, comp_id, *args, **kwargs)

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,
@@ -125,28 +125,44 @@ class Geometry(BaseResource):
                 deleted=None
             )
             if limit_to_attrs:
-                objs += set_objs.values_list(*limit_to_attrs, flat=True)
+                objs += set_objs.values(*limit_to_attrs)
             else:
                 objs += set_objs
 
-        # ... but we need a special treatment for compensations, since they can be deleted directly OR inherit their
+            stop_searching = len(objs) > 0
-        # de-facto-deleted status from their deleted parent intervention
+            if stop_searching:
-        comp_objs = self.compensation_set.filter(
+                break
-            Q(deleted=None) & Q(intervention__deleted=None)
+
-        )
+        if not stop_searching:
-        if limit_to_attrs:
+            # ... but we need a special treatment for compensations, since they can be deleted directly OR inherit their
-            objs += comp_objs.values_list(*limit_to_attrs, flat=True)
+            # de-facto-deleted status from their deleted parent intervention
-        else:
+            comp_objs = self.compensation_set.filter(
-            objs += comp_objs
+                Q(deleted=None) | Q(intervention__deleted=None)
+            )
+            if limit_to_attrs:
+                objs += comp_objs.values(*limit_to_attrs)
+            else:
+                objs += comp_objs
         return objs
 
-    def get_data_object(self):
+    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()
+        objs = self.get_data_objects(limit_to_attrs)
         assert (len(objs) <= 1)
-        result = objs.pop()
+        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,38 +419,15 @@ class Geometry(BaseResource):
 
         return complexity_factor
 
-    @staticmethod
+    def get_conflict_geometries(self):
-    def cast_to_multipolygon(input_geom):
+        """ Getter for geometry ids which conflict with this geometry or are conflicted by this one
-        """ If input_geom is not a MultiPolygon, cast to MultiPolygon
-
-        Args:
-            input_geom ():
 
         Returns:
-            output_geom
+            geom_ids (list): List of geometry ids
         """
-        output_geom = input_geom
+        conflict_geoms_id = GeometryConflict.get_conflict_geometries(self)
-        if not isinstance(input_geom, MultiPolygon):
+        conflict_geoms = Geometry.objects.filter(id__in=conflict_geoms_id)
-            try:
+        return conflict_geoms
-                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
 
 
 class GeometryConflict(UuidModel):
@@ -459,3 +452,23 @@ class GeometryConflict(UuidModel):
 
     def __str__(self):
         return f"{self.conflicting_geometry.id} conflicts with {self.affected_geometry.id}"
+
+    @staticmethod
+    def get_conflict_geometries(geometry: Geometry):
+        """ Getter for geometries which conflict in one or another way with the given one
+
+        Args:
+            geometry (Geometry): The geometry which shall be checked
+
+        Returns:
+            conflict_geometries (QuerySet): QuerySet of geometries which have conflicts with the given geometry
+        """
+        conflict_geometries = GeometryConflict.objects.filter(
+            affected_geometry=geometry.id,
+        ).values_list("conflicting_geometry__id", flat=True)
+        conflict_geometries = conflict_geometries.union(
+            GeometryConflict.objects.filter(
+                conflicting_geometry=geometry.id,
+            ).values_list("affected_geometry__id", flat=True)
+        )
+        return conflict_geometries

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
@@ -676,24 +705,17 @@ class GeoReferencedMixin(models.Model):
         if self.geometry is None:
             return request
 
-        instance_objs = []
+        conflicting_geometries = self.geometry.get_conflict_geometries()
-        needed_data_object_attrs = [
+        data_object_identifiers = []
-            "identifier"
+        for conflicting_geom in conflicting_geometries:
-        ]
+            data_obj_id = conflicting_geom.get_data_object(["identifier"])
-        conflicts = self.geometry.conflicts_geometries.iterator()
+            if data_obj_id:
+                data_object_identifiers.append(data_obj_id)
 
-        for conflict in conflicts:
+        add_message = len(data_object_identifiers) > 0
-            # Only check the affected geometry of this conflict, since we know the conflicting geometry is self.geometry
-            instance_objs += conflict.affected_geometry.get_data_objects(needed_data_object_attrs)
-
-        conflicts = self.geometry.conflicted_by_geometries.iterator()
-        for conflict in conflicts:
-            # Only check the conflicting geometry of this conflict, since we know the affected geometry is self.geometry
-            instance_objs += conflict.conflicting_geometry.get_data_objects(needed_data_object_attrs)
-
-        add_message = len(instance_objs) > 0
         if add_message:
-            instance_identifiers = ", ".join(instance_objs)
+            data_object_identifiers = [x["identifier"] for x in data_object_identifiers]
+            instance_identifiers = ", ".join(data_object_identifiers)
             message_str = GEOMETRY_CONFLICT_WITH_TEMPLATE.format(instance_identifiers)
             messages.info(request, message_str)
         return request

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.save()
+                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/generators.py

@@ -5,22 +5,18 @@ Contact: michel.peltriaux@sgdnord.rlp.de
 Created on: 09.11.20
 
 """
-import random
+import secrets
 import string
-import qrcode
-import qrcode.image.svg
-
-from io import BytesIO
 
 
-def generate_token() -> str:
+def generate_token(length: int = 64) -> str:
     """ Shortcut for default generating of e.g. API token
 
     Returns:
         token (str)
     """
     return generate_random_string(
-        length=64,
+        length=length,
         use_numbers=True,
         use_letters_lc=True
     )
@@ -39,7 +35,7 @@ def generate_random_string(length: int, use_numbers: bool = False, use_letters_l
         elements.append(string.ascii_uppercase)
 
     elements = "".join(elements)
-    ret_val = "".join(random.choice(elements) for i in range(length))
+    ret_val = "".join(secrets.choice(elements) for i in range(length))
     return ret_val
 
 class IdentifierGenerator:

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", 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)
+
+            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
+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 },
 

templates/map/client/libs/jspdf/1.3.2/jspdf.debug.js

@@ -9615,212 +9615,212 @@ Copyright (c) 2012 Willow Systems Corporation, willow-systems.com
     };
 })(jsPDF.API);
 
-/* Blob.js
+/* Blob.js
- * A Blob implementation.
+ * A Blob implementation.
- * 2014-07-24
+ * 2014-07-24
- *
+ *
- * By Eli Grey, http://eligrey.com
+ * By Eli Grey, http://eligrey.com
- * By Devin Samarin, https://github.com/dsamarin
+ * By Devin Samarin, https://github.com/dsamarin
- * License: X11/MIT
+ * License: X11/MIT
- *   See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md
+ *   See https://github.com/eligrey/Blob.js/blob/master/LICENSE.md
- */
+ */
-
+
-/*global self, unescape */
+/*global self, unescape */
-/*jslint bitwise: true, regexp: true, confusion: true, es5: true, vars: true, white: true,
+/*jslint bitwise: true, regexp: true, confusion: true, es5: true, vars: true, white: true,
-  plusplus: true */
+  plusplus: true */
-
+
-/*! @source http://purl.eligrey.com/github/Blob.js/blob/master/Blob.js */
+/*! @source http://purl.eligrey.com/github/Blob.js/blob/master/Blob.js */
-
+
-(function (view) {
+(function (view) {
-	"use strict";
+	"use strict";
-
+
-	view.URL = view.URL || view.webkitURL;
+	view.URL = view.URL || view.webkitURL;
-
+
-	if (view.Blob && view.URL) {
+	if (view.Blob && view.URL) {
-		try {
+		try {
-			new Blob;
+			new Blob;
-			return;
+			return;
-		} catch (e) {}
+		} catch (e) {}
-	}
+	}
-
+
-	// Internally we use a BlobBuilder implementation to base Blob off of
+	// Internally we use a BlobBuilder implementation to base Blob off of
-	// in order to support older browsers that only have BlobBuilder
+	// in order to support older browsers that only have BlobBuilder
-	var BlobBuilder = view.BlobBuilder || view.WebKitBlobBuilder || view.MozBlobBuilder || (function(view) {
+	var BlobBuilder = view.BlobBuilder || view.WebKitBlobBuilder || view.MozBlobBuilder || (function(view) {
-		var
+		var
-			  get_class = function(object) {
+			  get_class = function(object) {
-				return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
+				return Object.prototype.toString.call(object).match(/^\[object\s(.*)\]$/)[1];
-			}
+			}
-			, FakeBlobBuilder = function BlobBuilder() {
+			, FakeBlobBuilder = function BlobBuilder() {
-				this.data = [];
+				this.data = [];
-			}
+			}
-			, FakeBlob = function Blob(data, type, encoding) {
+			, FakeBlob = function Blob(data, type, encoding) {
-				this.data = data;
+				this.data = data;
-				this.size = data.length;
+				this.size = data.length;
-				this.type = type;
+				this.type = type;
-				this.encoding = encoding;
+				this.encoding = encoding;
-			}
+			}
-			, FBB_proto = FakeBlobBuilder.prototype
+			, FBB_proto = FakeBlobBuilder.prototype
-			, FB_proto = FakeBlob.prototype
+			, FB_proto = FakeBlob.prototype
-			, FileReaderSync = view.FileReaderSync
+			, FileReaderSync = view.FileReaderSync
-			, FileException = function(type) {
+			, FileException = function(type) {
-				this.code = this[this.name = type];
+				this.code = this[this.name = type];
-			}
+			}
-			, file_ex_codes = (
+			, file_ex_codes = (
-				  "NOT_FOUND_ERR SECURITY_ERR ABORT_ERR NOT_READABLE_ERR ENCODING_ERR "
+				  "NOT_FOUND_ERR SECURITY_ERR ABORT_ERR NOT_READABLE_ERR ENCODING_ERR "
-				+ "NO_MODIFICATION_ALLOWED_ERR INVALID_STATE_ERR SYNTAX_ERR"
+				+ "NO_MODIFICATION_ALLOWED_ERR INVALID_STATE_ERR SYNTAX_ERR"
-			).split(" ")
+			).split(" ")
-			, file_ex_code = file_ex_codes.length
+			, file_ex_code = file_ex_codes.length
-			, real_URL = view.URL || view.webkitURL || view
+			, real_URL = view.URL || view.webkitURL || view
-			, real_create_object_URL = real_URL.createObjectURL
+			, real_create_object_URL = real_URL.createObjectURL
-			, real_revoke_object_URL = real_URL.revokeObjectURL
+			, real_revoke_object_URL = real_URL.revokeObjectURL
-			, URL = real_URL
+			, URL = real_URL
-			, btoa = view.btoa
+			, btoa = view.btoa
-			, atob = view.atob
+			, atob = view.atob
-
+
-			, ArrayBuffer = view.ArrayBuffer
+			, ArrayBuffer = view.ArrayBuffer
-			, Uint8Array = view.Uint8Array
+			, Uint8Array = view.Uint8Array
-
+
-			, origin = /^[\w-]+:\/*\[?[\w\.:-]+\]?(?::[0-9]+)?/;
+			, origin = /^[\w-]+:\/*\[?[\w\.:-]+\]?(?::[0-9]+)?/;
-		FakeBlob.fake = FB_proto.fake = true;
+		FakeBlob.fake = FB_proto.fake = true;
-		while (file_ex_code--) {
+		while (file_ex_code--) {
-			FileException.prototype[file_ex_codes[file_ex_code]] = file_ex_code + 1;
+			FileException.prototype[file_ex_codes[file_ex_code]] = file_ex_code + 1;
-		}
+		}
-		// Polyfill URL
+		// Polyfill URL
-		if (!real_URL.createObjectURL) {
+		if (!real_URL.createObjectURL) {
-			URL = view.URL = function(uri) {
+			URL = view.URL = function(uri) {
-				var
+				var
-					  uri_info = document.createElementNS("http://www.w3.org/1999/xhtml", "a")
+					  uri_info = document.createElementNS("http://www.w3.org/1999/xhtml", "a")
-					, uri_origin;
+					, uri_origin;
-				uri_info.href = uri;
+				uri_info.href = uri;
-				if (!("origin" in uri_info)) {
+				if (!("origin" in uri_info)) {
-					if (uri_info.protocol.toLowerCase() === "data:") {
+					if (uri_info.protocol.toLowerCase() === "data:") {
-						uri_info.origin = null;
+						uri_info.origin = null;
-					} else {
+					} else {
-						uri_origin = uri.match(origin);
+						uri_origin = uri.match(origin);
-						uri_info.origin = uri_origin && uri_origin[1];
+						uri_info.origin = uri_origin && uri_origin[1];
-					}
+					}
-				}
+				}
-				return uri_info;
+				return uri_info;
-			};
+			};
-		}
+		}
-		URL.createObjectURL = function(blob) {
+		URL.createObjectURL = function(blob) {
-			var
+			var
-				  type = blob.type
+				  type = blob.type
-				, data_URI_header;
+				, data_URI_header;
-			if (type === null) {
+			if (type === null) {
-				type = "application/octet-stream";
+				type = "application/octet-stream";
-			}
+			}
-			if (blob instanceof FakeBlob) {
+			if (blob instanceof FakeBlob) {
-				data_URI_header = "data:" + type;
+				data_URI_header = "data:" + type;
-				if (blob.encoding === "base64") {
+				if (blob.encoding === "base64") {
-					return data_URI_header + ";base64," + blob.data;
+					return data_URI_header + ";base64," + blob.data;
-				} else if (blob.encoding === "URI") {
+				} else if (blob.encoding === "URI") {
-					return data_URI_header + "," + decodeURIComponent(blob.data);
+					return data_URI_header + "," + decodeURIComponent(blob.data);
-				} if (btoa) {
+				} if (btoa) {
-					return data_URI_header + ";base64," + btoa(blob.data);
+					return data_URI_header + ";base64," + btoa(blob.data);
-				} else {
+				} else {
-					return data_URI_header + "," + encodeURIComponent(blob.data);
+					return data_URI_header + "," + encodeURIComponent(blob.data);
-				}
+				}
-			} else if (real_create_object_URL) {
+			} else if (real_create_object_URL) {
-				return real_create_object_URL.call(real_URL, blob);
+				return real_create_object_URL.call(real_URL, blob);
-			}
+			}
-		};
+		};
-		URL.revokeObjectURL = function(object_URL) {
+		URL.revokeObjectURL = function(object_URL) {
-			if (object_URL.substring(0, 5) !== "data:" && real_revoke_object_URL) {
+			if (object_URL.substring(0, 5) !== "data:" && real_revoke_object_URL) {
-				real_revoke_object_URL.call(real_URL, object_URL);
+				real_revoke_object_URL.call(real_URL, object_URL);
-			}
+			}
-		};
+		};
-		FBB_proto.append = function(data/*, endings*/) {
+		FBB_proto.append = function(data/*, endings*/) {
-			var bb = this.data;
+			var bb = this.data;
-			// decode data to a binary string
+			// decode data to a binary string
-			if (Uint8Array && (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
+			if (Uint8Array && (data instanceof ArrayBuffer || data instanceof Uint8Array)) {
-				var
+				var
-					  str = ""
+					  str = ""
-					, buf = new Uint8Array(data)
+					, buf = new Uint8Array(data)
-					, i = 0
+					, i = 0
-					, buf_len = buf.length;
+					, buf_len = buf.length;
-				for (; i < buf_len; i++) {
+				for (; i < buf_len; i++) {
-					str += String.fromCharCode(buf[i]);
+					str += String.fromCharCode(buf[i]);
-				}
+				}
-				bb.push(str);
+				bb.push(str);
-			} else if (get_class(data) === "Blob" || get_class(data) === "File") {
+			} else if (get_class(data) === "Blob" || get_class(data) === "File") {
-				if (FileReaderSync) {
+				if (FileReaderSync) {
-					var fr = new FileReaderSync;
+					var fr = new FileReaderSync;
-					bb.push(fr.readAsBinaryString(data));
+					bb.push(fr.readAsBinaryString(data));
-				} else {
+				} else {
-					// async FileReader won't work as BlobBuilder is sync
+					// async FileReader won't work as BlobBuilder is sync
-					throw new FileException("NOT_READABLE_ERR");
+					throw new FileException("NOT_READABLE_ERR");
-				}
+				}
-			} else if (data instanceof FakeBlob) {
+			} else if (data instanceof FakeBlob) {
-				if (data.encoding === "base64" && atob) {
+				if (data.encoding === "base64" && atob) {
-					bb.push(atob(data.data));
+					bb.push(atob(data.data));
-				} else if (data.encoding === "URI") {
+				} else if (data.encoding === "URI") {
-					bb.push(decodeURIComponent(data.data));
+					bb.push(decodeURIComponent(data.data));
-				} else if (data.encoding === "raw") {
+				} else if (data.encoding === "raw") {
-					bb.push(data.data);
+					bb.push(data.data);
-				}
+				}
-			} else {
+			} else {
-				if (typeof data !== "string") {
+				if (typeof data !== "string") {
-					data += ""; // convert unsupported types to strings
+					data += ""; // convert unsupported types to strings
-				}
+				}
-				// decode UTF-16 to binary string
+				// decode UTF-16 to binary string
-				bb.push(unescape(encodeURIComponent(data)));
+				bb.push(unescape(encodeURIComponent(data)));
-			}
+			}
-		};
+		};
-		FBB_proto.getBlob = function(type) {
+		FBB_proto.getBlob = function(type) {
-			if (!arguments.length) {
+			if (!arguments.length) {
-				type = null;
+				type = null;
-			}
+			}
-			return new FakeBlob(this.data.join(""), type, "raw");
+			return new FakeBlob(this.data.join(""), type, "raw");
-		};
+		};
-		FBB_proto.toString = function() {
+		FBB_proto.toString = function() {
-			return "[object BlobBuilder]";
+			return "[object BlobBuilder]";
-		};
+		};
-		FB_proto.slice = function(start, end, type) {
+		FB_proto.slice = function(start, end, type) {
-			var args = arguments.length;
+			var args = arguments.length;
-			if (args < 3) {
+			if (args < 3) {
-				type = null;
+				type = null;
-			}
+			}
-			return new FakeBlob(
+			return new FakeBlob(
-				  this.data.slice(start, args > 1 ? end : this.data.length)
+				  this.data.slice(start, args > 1 ? end : this.data.length)
-				, type
+				, type
-				, this.encoding
+				, this.encoding
-			);
+			);
-		};
+		};
-		FB_proto.toString = function() {
+		FB_proto.toString = function() {
-			return "[object Blob]";
+			return "[object Blob]";
-		};
+		};
-		FB_proto.close = function() {
+		FB_proto.close = function() {
-			this.size = 0;
+			this.size = 0;
-			delete this.data;
+			delete this.data;
-		};
+		};
-		return FakeBlobBuilder;
+		return FakeBlobBuilder;
-	}(view));
+	}(view));
-
+
-	view.Blob = function(blobParts, options) {
+	view.Blob = function(blobParts, options) {
-		var type = options ? (options.type || "") : "";
+		var type = options ? (options.type || "") : "";
-		var builder = new BlobBuilder();
+		var builder = new BlobBuilder();
-		if (blobParts) {
+		if (blobParts) {
-			for (var i = 0, len = blobParts.length; i < len; i++) {
+			for (var i = 0, len = blobParts.length; i < len; i++) {
-				if (Uint8Array && blobParts[i] instanceof Uint8Array) {
+				if (Uint8Array && blobParts[i] instanceof Uint8Array) {
-					builder.append(blobParts[i].buffer);
+					builder.append(blobParts[i].buffer);
-				}
+				}
-				else {
+				else {
-					builder.append(blobParts[i]);
+					builder.append(blobParts[i]);
-				}
+				}
-			}
+			}
-		}
+		}
-		var blob = builder.getBlob(type);
+		var blob = builder.getBlob(type);
-		if (!blob.slice && blob.webkitSlice) {
+		if (!blob.slice && blob.webkitSlice) {
-			blob.slice = blob.webkitSlice;
+			blob.slice = blob.webkitSlice;
-		}
+		}
-		return blob;
+		return blob;
-	};
+	};
-
+
-	var getPrototypeOf = Object.getPrototypeOf || function(object) {
+	var getPrototypeOf = Object.getPrototypeOf || function(object) {
-		return object.__proto__;
+		return object.__proto__;
-	};
+	};
-	view.Blob.prototype = getPrototypeOf(new view.Blob());
+	view.Blob.prototype = getPrototypeOf(new view.Blob());
 }(typeof self !== "undefined" && self || typeof window !== "undefined" && window || undefined.content || undefined));
 
 /* FileSaver.js

user/views/propagate.py

@@ -7,9 +7,10 @@ Created on: 10.05.24
 """
 import base64
 import hashlib
+import http
 import json
 
-from cryptography.fernet import Fernet
+from cryptography.fernet import Fernet, InvalidToken
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import HttpRequest, JsonResponse
 from django.utils.decorators import method_decorator
@@ -27,34 +28,77 @@ class PropagateUserView(View):
     proper rights management)
 
     """
+    class PropagateStatus:
+        UNPROCESSED = "unprocessed"
+        UPDATED = "updated"
+        CREATED = "created"
 
     @method_decorator(csrf_exempt)
     def dispatch(self, request, *args, **kwargs):
         return super().dispatch(request, *args, **kwargs)
 
     def post(self, request: HttpRequest, *args, **kwargs):
+        response_data = {
+            "success": None,
+            "status": None
+        }
+
         # Decrypt
         encrypted_body = request.body
         _hash = hashlib.md5()
         _hash.update(PROPAGATION_SECRET.encode("utf-8"))
         key = base64.urlsafe_b64encode(_hash.hexdigest().encode("utf-8"))
         fernet = Fernet(key)
-        body = fernet.decrypt(encrypted_body).decode("utf-8")
-        body = json.loads(body)
-
         try:
-            status = "updated"
+            body = fernet.decrypt(encrypted_body).decode("utf-8")
-            user = User.resolve_user_using_propagation_data(body)
+            body = json.loads(body)
-            user = user.update_user_using_propagation_data(body)
+        except InvalidToken:
-        except ObjectDoesNotExist:
+            response_data["error"] = "Invalid Token"
-            user = User(**body)
+            response_data["success"] = False
-            status = "created"
+            response_data["status"] = self.PropagateStatus.UNPROCESSED
+            return JsonResponse(
+                status=http.HTTPStatus.UNPROCESSABLE_CONTENT,
+                data=response_data
+            )
+        except (json.JSONDecodeError) as e:
+            response_data["error"] = str(e)
+            response_data["success"] = False
+            response_data["status"] = self.PropagateStatus.UNPROCESSED
+            return JsonResponse(
+                status=http.HTTPStatus.UNPROCESSABLE_CONTENT,
+                data=response_data
+            )
+
+        # Process decrypted user data
+        processing_ret_vals = self.__process_user_data(body)
+        response_data["success"] = processing_ret_vals[0]
+        response_data["status"] = processing_ret_vals[1]
+        user = processing_ret_vals[2]
+
         user.set_unusable_password()
         user.save()
 
-        data = {
+        return JsonResponse(
-            "success": True,
+            status=http.HTTPStatus.OK,
-            "status": status
+            data=response_data
-        }
+        )
 
-        return JsonResponse(data)
+    def __process_user_data(self, body: dict) -> (bool, str, User):
+        """ Process decrypted user data
+
+        Args:
+            body:
+
+        Returns:
+            success (bool): Whether the processing was successful
+            status (str): In which way the data was used ('created' | 'updated')
+            user (User): Processed user object
+        """
+        try:
+            user = User.resolve_user_using_propagation_data(body)
+            user = user.update_user_using_propagation_data(body)
+            status = self.PropagateStatus.UPDATED
+        except ObjectDoesNotExist:
+            user = User(**body)
+            status = self.PropagateStatus.CREATED
+        return True, status, user