Merge branch 'refs/heads/master' into netgis_map_client_update

# Conflicts:
#	konova/forms/geometry_form.py
#	templates/map/client/config.json

konova/decorators.py

@@ -11,7 +11,7 @@ from uuid import UUID
 
 from bootstrap_modal_forms.mixins import is_ajax
 from django.contrib import messages
-from django.http import Http404
+from django.core.exceptions import BadRequest
 from django.shortcuts import redirect, get_object_or_404, render
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
@@ -185,7 +185,7 @@ def uuid_required(function):
         try:
             uuid = UUID(uuid)
         except ValueError:
-            raise Http404(
+            raise BadRequest(
                 "Invalid UUID"
             )
         return function(request, *args, **kwargs)

konova/forms/geometry_form.py

@@ -27,7 +27,7 @@ class SimpleGeomForm(BaseForm):
     """
     read_only = True
     geometry_simplified = False
-    output = JSONField(
+    geom = JSONField(
         label=_("Geometry"),
         help_text=_(""),
         label_suffix="",
@@ -55,27 +55,26 @@ class SimpleGeomForm(BaseForm):
             geom = ""
             self.empty = True
 
-        self.initialize_form_field("output", geom)
+        self.initialize_form_field("geom", geom)
 
     def is_valid(self):
         super().is_valid()
         is_valid = True
 
         # Get geojson from form
-        geom = self.data["output"]
+        geom = self.data["geom"]
         if geom is None or len(geom) == 0:
             # empty geometry is a valid geometry
-            self.cleaned_data["output"] = MultiPolygon(srid=DEFAULT_SRID_RLP).ewkt
+            self.cleaned_data["geom"] = MultiPolygon(srid=DEFAULT_SRID_RLP).ewkt
             return is_valid
         geom = json.loads(geom)
 
         # Write submitted data back into form field to make sure invalid geometry
         # will be rendered again on failed submit
-        self.initialize_form_field("output", self.data["output"])
+        self.initialize_form_field("geom", self.data["geom"])
 
-        # Read geojson into gdal geometry
-        # HINT: This can be simplified if the geojson format holds data in epsg:4326 (GDAL provides direct creation for
-        # this case)
+        # 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 = [
@@ -98,33 +97,35 @@ class SimpleGeomForm(BaseForm):
                 g = self.__flatten_geom_to_2D(g)
 
             if g.geom_type not in accepted_ogr_types:
-                self.add_error("output", _("Only surfaces allowed. Points or lines must be buffered."))
+                self.add_error("geom", _("Only surfaces allowed. Points or lines must be buffered."))
                 is_valid &= False
                 return is_valid
 
             is_valid &= self.__is_area_valid(g)
-
-            polygon = Polygon.from_ewkt(g.ewkt)
-            is_valid &= polygon.valid
-            if not polygon.valid:
-                self.add_error("output", polygon.valid_reason)
+            g = Polygon.from_ewkt(g.ewkt)
+            is_valid &= g.valid
+            if not g.valid:
+                self.add_error("geom", g.valid_reason)
                 return is_valid
 
-            features.append(polygon)
+            if isinstance(g, Polygon):
+                features.append(g)
+            elif isinstance(g, MultiPolygon):
+                features.extend(list(g))
 
         # Unionize all geometry features into one new MultiPolygon
-        form_geom = MultiPolygon(srid=DEFAULT_SRID_RLP)
-        for feature in features:
-            form_geom = form_geom.union(feature)
+        if features:
+            form_geom = MultiPolygon(*features, srid=DEFAULT_SRID_RLP).unary_union
+        else:
+            form_geom = MultiPolygon(srid=DEFAULT_SRID_RLP)
 
         # Make sure to convert into a MultiPolygon. Relevant if a single Polygon is provided.
-        if form_geom.geom_type != "MultiPolygon":
-            form_geom = MultiPolygon(form_geom, srid=DEFAULT_SRID_RLP)
+        form_geom = Geometry.cast_to_multipolygon(form_geom)
 
         # Write unioned Multipolygon into cleaned data
         if self.cleaned_data is None:
             self.cleaned_data = {}
-        self.cleaned_data["output"] = form_geom.ewkt
+        self.cleaned_data["geom"] = form_geom.ewkt
 
         return is_valid
 
@@ -134,7 +135,7 @@ class SimpleGeomForm(BaseForm):
         Returns:
 
         """
-        geom = self.cleaned_data.get("output")
+        geom = self.cleaned_data.get("geom")
         g = gdal.OGRGeometry(geom, srs=DEFAULT_SRID_RLP)
         num_vertices = g.num_coords
 
@@ -150,7 +151,7 @@ class SimpleGeomForm(BaseForm):
 
         if not is_area_valid:
             self.add_error(
-                "output",
+                "geom",
                 _("Geometry must be greater than 1m². Currently is {}m²").format(
                     float(geom.area)
                 )
@@ -193,14 +194,14 @@ class SimpleGeomForm(BaseForm):
             if self.instance is None or self.instance.geometry is None:
                 raise LookupError
             geometry = self.instance.geometry
-            geometry.geom = self.cleaned_data.get("output", MultiPolygon(srid=DEFAULT_SRID_RLP))
+            geometry.geom = self.cleaned_data.get("geom", MultiPolygon(srid=DEFAULT_SRID_RLP))
             geometry.modified = action
 
             geometry.save()
         except LookupError:
             # No geometry or linked instance holding a geometry exist --> create a new one!
             geometry = Geometry.objects.create(
-                geom=self.cleaned_data.get("output", MultiPolygon(srid=DEFAULT_SRID_RLP)),
+                geom=self.cleaned_data.get("geom", MultiPolygon(srid=DEFAULT_SRID_RLP)),
                 created=action,
             )
 

konova/models/geometry.py

@@ -11,6 +11,7 @@ from django.contrib.gis.db.models import MultiPolygonField
 from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned
 from django.db import models, transaction
 from django.utils import timezone
+from django.contrib.gis.geos import MultiPolygon
 
 from konova.models import BaseResource, UuidModel
 from konova.sub_settings.lanis_settings import DEFAULT_SRID_RLP
@@ -384,6 +385,36 @@ 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):
+            output_geom = MultiPolygon(input_geom, srid=DEFAULT_SRID_RLP)
+        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):
     """

konova/tests/test_views.py

@@ -469,7 +469,7 @@ class BaseTestCase(TestCase):
         eco_account.save()
         return eco_account
 
-    def assert_equal_geometries(self, geom1: MultiPolygon, geom2: MultiPolygon, tolerance = 0.001):
+    def assert_equal_geometries(self, geom1: MultiPolygon, geom2: MultiPolygon, tolerance=0.001):
         """ Assert for geometries to be equal
 
         Transforms the geometries to matching srids before checking
@@ -491,7 +491,10 @@ class BaseTestCase(TestCase):
             # transformation from one coordinate system into the other, which is valid
             geom1.transform(geom2.srid)
             geom2.transform(geom1.srid)
-        self.assertTrue(geom1.equals_exact(geom2, tolerance) or geom2.equals_exact(geom1, tolerance))
+        self.assertTrue(
+            geom1.equals_exact(geom2, tolerance=tolerance),
+            msg=f"Difference is {abs(geom1.area - geom2.area)} with {geom1.area} and {geom2.area} in a tolerance of {tolerance}"
+        )
 
 
 class BaseViewTestCase(BaseTestCase):

konova/urls.py

@@ -42,5 +42,6 @@ urlpatterns = [
     path('client/proxy/wfs', ClientProxyParcelWFS.as_view(), name="client-proxy-wfs"),
 ]
 
+handler400 = "konova.views.error.get_400_view"
 handler404 = "konova.views.error.get_404_view"
 handler500 = "konova.views.error.get_500_view"

konova/views/error.py

@@ -25,6 +25,20 @@ def get_404_view(request: HttpRequest, exception=None):
     return render(request, "404.html", context, status=404)
 
 
+def get_400_view(request: HttpRequest, exception=None):
+    """ Returns a 400 handling view
+
+    Args:
+        request ():
+        exception ():
+
+    Returns:
+
+    """
+    context = BaseContext.context
+    return render(request, "400.html", context, status=400)
+
+
 def get_500_view(request: HttpRequest):
     """ Returns a 404 handling view