django-gisserver 2.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

gisserver/output/gml32.py

@@ -11,6 +11,7 @@ much extra method calls per field. Some bits are non-DRY inlined for this reason
 from __future__ import annotations
 
 import itertools
+import re
 from collections import defaultdict
 from datetime import date, datetime, time, timezone
 from decimal import Decimal as D
@@ -23,6 +24,7 @@ from django.core.exceptions import ImproperlyConfigured
 from django.db import models
 from django.http import HttpResponse
 
+from gisserver.crs import CRS84
 from gisserver.db import (
     AsGML,
     get_db_geometry_target,
@@ -46,6 +48,7 @@ from .utils import (
 )
 
 GML_RENDER_FUNCTIONS = {}
+RE_SRS_NAME = re.compile(r'srsName="([^"]+)"')
 
 
 def register_geos_type(geos_type):
@@ -170,7 +173,7 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
     def render_exception(self, exception: Exception):
         """Render the exception in a format that fits with the output.
 
-        The WSF XSD spec has a hidden gem: an <wfs:truncatedResponse> element
+        The WSF XSD spec has a hidden gem: an ``<wfs:truncatedResponse>`` element
         can be rendered at the end of a feature collection
         to inform the client an error happened during rendering.
         """
@@ -182,15 +185,14 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
             exception = WFSException(message, code=exception.__class__.__name__, status_code=500)
         exception.debug_hint = False
 
-        # Only at the top-level, an exception report can be rendered
-        closing_child = (
-            f"</wfs:{self.xml_sub_collection_tag}></wfs:member>\n"
-            if len(self.collection.results) > 1
-            else ""
-        )
+        # Only at the top-level, an exception report can be rendered, close any remaining tags.
+        if len(self.collection.results) > 1:
+            sub_closing = f"</wfs:{self.xml_sub_collection_tag}>\n</wfs:member>\n"
+            if not buffer.endswith(sub_closing):
+                buffer += sub_closing
+
         return (
             f"{buffer}"
-            f"{closing_child}"
             "  <wfs:truncatedResponse>"
             f"{exception.as_xml()}"
             "  </wfs:truncatedResponse>\n"
@@ -204,9 +206,14 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
         collection = self.collection
         self.output = output = StringIO()
         self._write = self.output.write
+
+        # The base class peaks the generator and handles early exceptions.
+        # Any database exceptions during calculating the number of results
+        # are all handled by the main WFS view.
         number_matched = collection.number_matched
         number_matched = int(number_matched) if number_matched is not None else "unknown"
         number_returned = collection.number_returned
+
         next = previous = ""
         if collection.next:
             next = f' next="{attr_escape(collection.next)}"'
@@ -228,6 +235,15 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
 
             for sub_collection in collection.results:
                 projection = sub_collection.projection
+                if projection.output_crs.force_xy and projection.output_crs.is_north_east_order:
+                    self._write(
+                        "<!--\n"
+                        f" NOTE: you are requesting the legacy projection notation '{tag_escape(projection.output_crs.origin)}'."
+                        f" Please use '{tag_escape(projection.output_crs.urn)}' instead.\n\n"
+                        " This also means output coordinates are ordered in legacy the 'west, north' axis ordering.\n"
+                        "\n-->\n"
+                    )
+
                 self.start_collection(sub_collection)
                 if has_multiple_collections:
                     self._write(
@@ -238,7 +254,7 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
                         f' numberReturned="{int(sub_collection.number_returned)}">\n'
                     )
 
-                for instance in sub_collection:
+                for instance in self.read_features(sub_collection):
                     self.gml_seq = 0  # need to increment this between write_xml_field calls
                     self._write("<wfs:member>\n")
                     self.write_feature(projection, instance)
@@ -368,11 +384,11 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
         if geo_element.type is XsdTypes.gmlBoundingShapeType:
             # Special case for <gml:boundedBy>, which doesn't need xsd:nil values, nor a gml:id.
             # The value is not a GEOSGeometry either, as that is not exposed by django.contrib.gis.
-            value = cast(GmlBoundedByElement, geo_element).get_value(
+            envelope = cast(GmlBoundedByElement, geo_element).get_value(
                 instance, crs=projection.output_crs
             )
-            if value is not None:
-                self._write(self.render_gml_bounds(value))
+            if envelope is not None:
+                self._write(self.render_gml_bounds(envelope))
         else:
             # Regular geometry elements.
             xml_qname = self.xml_qnames[geo_element]
@@ -398,12 +414,12 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
 
     def render_gml_bounds(self, envelope: BoundingBox) -> str:
         """Render the gml:boundedBy element that contains an Envelope.
-        Note this uses an internal object type,
-        as :mod:`django.contrib.gis.geos` only provides a Point/Polygon or 4-tuple envelope.
+        This uses an internal object type,
+        as :mod:`django.contrib.gis.geos` only provides a 4-tuple envelope.
         """
-        return f"""<gml:boundedBy><gml:Envelope srsDimension="2" srsName="{attr_escape(envelope.crs.urn)}">
-            <gml:lowerCorner>{envelope.south} {envelope.west}</gml:lowerCorner>
-            <gml:upperCorner>{envelope.north} {envelope.east}</gml:upperCorner>
+        return f"""<gml:boundedBy><gml:Envelope srsDimension="2" srsName="{attr_escape(str(envelope.crs))}">
+            <gml:lowerCorner>{envelope.min_x} {envelope.min_y}</gml:lowerCorner>
+            <gml:upperCorner>{envelope.max_x} {envelope.max_y}</gml:upperCorner>
           </gml:Envelope></gml:boundedBy>\n"""
 
     def render_gml_value(
@@ -415,7 +431,7 @@ class GML32Renderer(CollectionOutputRenderer, XmlOutputRenderer):
     ) -> str:
         """Normal case: 'value' is raw geometry data.."""
         # In case this is a standalone response, this will be the top-level element, hence includes the xmlns.
-        base_attrs = f' gml:id="{attr_escape(gml_id)}" srsName="{attr_escape(projection.output_crs.urn)}"{extra_xmlns}'
+        base_attrs = f' gml:id="{attr_escape(gml_id)}" srsName="{attr_escape(str(projection.output_crs))}"{extra_xmlns}'
         projection.output_crs.apply_to(value)
         return self._render_gml_type(value, base_attrs=base_attrs)
 
@@ -517,11 +533,11 @@ class DBGMLRenderingMixin:
         id_pos = gml_tag.find("gml:id=")
         if id_pos == -1:
             # Inject
-            return f'{gml_tag} gml:id="{attr_escape(gml_id)}"{extra_xmlns}{value[end_pos:]}'
+            gml = f'{gml_tag} gml:id="{attr_escape(gml_id)}"{extra_xmlns}{value[end_pos:]}'
         else:
             # Replace
             end_pos1 = gml_tag.find('"', id_pos + 8)
-            return (
+            gml = (
                 f"{gml_tag[:id_pos]}"
                 f'gml:id="{attr_escape(gml_id)}'
                 f"{value[end_pos1:end_pos]}"  # from " right until >
@@ -529,6 +545,23 @@ class DBGMLRenderingMixin:
                 f"{value[end_pos:]}"  # from > and beyond
             )
 
+        return self._fix_db_crs_name(projection, gml)
+
+    def _fix_db_crs_name(self, projection: FeatureProjection, gml: str) -> str:
+        if projection.output_crs.force_xy:
+            # When legacy output is used, make sure the srsName matches the input.
+            # PostgreSQL will still generate the EPSG:xxxx notation.
+            return gml.replace(
+                'srsName="EPSG:', 'srsName="http://www.opengis.net/gml/srs/epsg.xml#', 1
+            )
+        elif projection.output_crs == CRS84:
+            # Fix PostgreSQL not knowing it's CRS84 or WGS84 (both srid 4326)
+            return gml.replace(
+                'srsName="urn:ogc:def:crs:EPSG::4326"', 'srsName="urn:ogc:def:crs:OGC::CRS84"', 1
+            )
+        else:
+            return gml
+
 
 class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
     """Faster GetFeature renderer that uses the database to render GML 3.2"""
@@ -549,8 +582,14 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
         # Retrieve geometries as pre-rendered instead.
         # Only take the geometries of the current level.
         # The annotations for relations will be handled by prefetches and get_prefetch_queryset()
+        use_modern = not projection.output_crs.force_xy
         return replace_queryset_geometries(
-            queryset, projection.geometry_elements, projection.output_crs, AsGML
+            queryset,
+            projection.geometry_elements,
+            projection.output_crs,
+            AsGML,
+            is_latlon=use_modern and projection.output_crs.is_north_east_order,
+            long_urn=use_modern,
         )
 
     def get_prefetch_queryset(
@@ -564,8 +603,14 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
             return None
 
         # Find which fields are GML elements
+        use_modern = not projection.output_crs.force_xy
         return replace_queryset_geometries(
-            queryset, feature_relation.geometry_elements, projection.output_crs, AsGML
+            queryset,
+            feature_relation.geometry_elements,
+            projection.output_crs,
+            AsGML,
+            is_latlon=use_modern and projection.output_crs.is_north_east_order,
+            long_urn=use_modern,
         )
 
     def get_db_envelope_as_gml(self, projection: FeatureProjection, queryset) -> AsGML:
@@ -574,7 +619,13 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
         This also avoids offloads the geometry union calculation to the DB.
         """
         geo_fields_union = self._get_geometries_union(projection, queryset)
-        return AsGML(geo_fields_union, envelope=True)
+        use_modern = not projection.output_crs.force_xy
+        return AsGML(
+            geo_fields_union,
+            envelope=True,
+            is_latlon=use_modern and projection.output_crs.is_north_east_order,
+            long_urn=use_modern,
+        )
 
     def _get_geometries_union(self, projection: FeatureProjection, queryset):
         """Combine all geometries of the model in a single SQL function."""
@@ -604,6 +655,8 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
             gml = instance._as_envelope_gml
             if gml is None:
                 return
+
+            gml = self._fix_db_crs_name(projection, gml)
         else:
             value = get_db_rendered_geometry(instance, geo_element, AsGML)
             if value is None:
@@ -621,9 +674,9 @@ class DBGML32Renderer(DBGMLRenderingMixin, GML32Renderer):
 class GML32ValueRenderer(GML32Renderer):
     """Render the GetPropertyValue XML output in GML 3.2 format.
 
-    Geoserver seems to generate the element tag inside each <wfs:member> element. We've applied this one.
-    The GML standard demonstrates to render only their content inside a <wfs:member> element
-    (either plain text or an <gml:...> tag). Not sure what is right here.
+    Geoserver seems to generate the element tag inside each ``<wfs:member>`` element. We've applied this one.
+    The GML standard demonstrates to render only their content inside a ``<wfs:member>`` element
+    (either plain text or an ``<gml:...>`` tag). Not sure what is right here.
     """
 
     content_type = "text/xml; charset=utf-8"
@@ -734,8 +787,14 @@ class DBGML32ValueRenderer(DBGMLRenderingMixin, GML32ValueRenderer):
         if element.type.is_geometry:
             # Add 'gml_member' to point to the pre-rendered GML version.
             geo_element = cast(GeometryXsdElement, element)
+            use_modern = not projection.output_crs.force_xy
             return queryset.values(
-                "pk", gml_member=AsGML(get_db_geometry_target(geo_element, projection.output_crs))
+                "pk",
+                gml_member=AsGML(
+                    get_db_geometry_target(geo_element, projection.output_crs),
+                    is_latlon=use_modern and projection.output_crs.is_north_east_order,
+                    long_urn=use_modern,
+                ),
             )
         else:
             return queryset

gisserver/output/results.py

@@ -7,18 +7,17 @@ properties match the WFS 2.0 spec closely.
 from __future__ import annotations
 
 import math
-import operator
 import typing
 from collections.abc import Iterable
 from datetime import timezone
-from functools import cached_property, reduce
+from functools import cached_property
 
 from django.db import models
 from django.utils.timezone import now
 
 from gisserver import conf
+from gisserver.exceptions import wrap_filter_errors
 from gisserver.features import FeatureType
-from gisserver.geometries import BoundingBox
 
 from .iters import ChunkedQuerySetIterator, CountingIterator
 
@@ -33,7 +32,7 @@ class SimpleFeatureCollection:
     """Wrapper to read a result set.
 
     This object type is defined in the WFS spec.
-    It holds a collection of "wfs:member" objects.
+    It holds a collection of ``<wfs:member>`` objects.
     """
 
     def __init__(
@@ -86,7 +85,8 @@ class SimpleFeatureCollection:
         """Explicitly request the results to be streamed.
 
         This can be used by output formats that stream results, and don't
-        access `number_returned`. Note this is not compatible with prefetch_related().
+        access :attr:`number_returned`.
+        Note this is not compatible with ``prefetch_related()``.
         """
         if self._result_iterator is not None:
             raise RuntimeError("Results for feature collection are read twice.")
@@ -126,12 +126,13 @@ class SimpleFeatureCollection:
             return self.queryset[self.start : self.stop + (1 if add_sentinel else 0)]
 
     def first(self):
-        try:
-            # Don't query a full page, return only one instance (for GetFeatureById)
-            # This also preserves the extra added annotations (like _as_gml_FIELD)
-            return self.queryset[self.start]
-        except IndexError:
-            return None
+        with wrap_filter_errors(self.source_query):
+            try:
+                # Don't query a full page, return only one instance (for GetFeatureById)
+                # This also preserves the extra added annotations (like _as_gml_FIELD)
+                return self.queryset[self.start]
+            except IndexError:
+                return None
 
     def fetch_results(self):
         """Forcefully read the results early."""
@@ -148,11 +149,15 @@ class SimpleFeatureCollection:
             if self.stop == math.inf:
                 # Infinite page requested, see if start is still requested
                 qs = self.queryset[self.start :] if self.start else self.queryset.all()
-                self._result_cache = list(qs)
+
+                with wrap_filter_errors(self.source_query):
+                    self._result_cache = list(qs)
             elif self._use_sentinel_record:
                 # No counting, but instead fetch an extra item as sentinel to see if there are more results.
                 qs = self.queryset[self.start : self.stop + 1]
-                page_results = list(qs)
+
+                with wrap_filter_errors(self.source_query):
+                    page_results = list(qs)
 
                 # The stop + 1 sentinel allows checking if there is a next page.
                 # This means no COUNT() is needed to detect that.
@@ -167,7 +172,9 @@ class SimpleFeatureCollection:
                 # Fetch exactly the page size, no more is needed.
                 # Will use a COUNT on the total table, so it can be used to see if there are more pages.
                 qs = self.queryset[self.start : self.stop]
-                self._result_cache = list(qs)
+
+                with wrap_filter_errors(self.source_query):
+                    self._result_cache = list(qs)
 
     @cached_property
     def _use_sentinel_record(self) -> bool:
@@ -224,7 +231,8 @@ class SimpleFeatureCollection:
             qs.query.annotations = clean_annotations
 
         # Calculate, cache and return
-        self._number_matched = qs.count()
+        with wrap_filter_errors(self.source_query):
+            self._number_matched = qs.count()
         return self._number_matched
 
     @property
@@ -278,28 +286,11 @@ class SimpleFeatureCollection:
         # but since the projection needs to be calculated once, it's stored here for convenience.
         return self.source_query.get_projection()
 
-    def get_bounding_box(self) -> BoundingBox:
-        """Determine bounding box of all items."""
-        self.fetch_results()  # Avoid querying results twice
-
-        # Start with an obviously invalid bbox,
-        # which corrects at the first extend_to_geometry call.
-        bbox = BoundingBox(math.inf, math.inf, -math.inf, -math.inf)
-
-        # Allow the geometry to exist in a dotted relationship.
-        for instance in self:
-            geometry_value = self.projection.get_main_geometry_value(instance)
-            if geometry_value is None:
-                continue
-
-            bbox.extend_to_geometry(geometry_value)
-
-        return bbox
-
 
 class FeatureCollection:
-    """WFS object that holds the result type for GetFeature.
+    """WFS object that holds the result type for ``GetFeature``.
     This object type is defined in the WFS spec.
+    It holds a collection of :class:`SimpleFeatureCollection` results.
     """
 
     def __init__(
@@ -323,11 +314,6 @@ class FeatureCollection:
         self.date = now()
         self.timestamp = self.date.astimezone(timezone.utc).isoformat()
 
-    def get_bounding_box(self) -> BoundingBox:
-        """Determine bounding box of all items."""
-        # Combine the bounding box of all collections
-        return reduce(operator.add, [c.get_bounding_box() for c in self.results])
-
     @cached_property
     def number_returned(self) -> int:
         """Return the total number of returned features"""

gisserver/output/utils.py

@@ -23,16 +23,20 @@ __all__ = (
 
 
 def tag_escape(s: str):
+    """Escape a value for usage in XML text."""
     return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
 
 
 def attr_escape(s: str):
-    # Slightly faster then html.escape() as it doesn't replace single quotes.
+    """Escape a value for usage in an XML attribute.
+    This is slightly faster than ``html.escape()`` as it doesn't replace single quotes.
+    """
     # Having tried all possible variants, this code still outperforms other forms of escaping.
     return s.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;").replace('"', "&quot;")
 
 
 def value_to_xml_string(value):
+    """Format a Python value for usage in XML text."""
     # Simple scalar value
     if isinstance(value, str):  # most cases
         return tag_escape(value)
@@ -47,6 +51,9 @@ def value_to_xml_string(value):
 
 
 def value_to_text(value):
+    """Format a Python value for usage in plain text output.
+    This doesn't do any XML escaping.
+    """
     # Simple scalar value, no XML escapes
     if isinstance(value, str):  # most cases
         return value
@@ -59,7 +66,7 @@ def value_to_text(value):
 
 
 def render_xmlns_attributes(xml_namespaces: dict[str, str]):
-    """Render XML Namespace declaration attributes"""
+    """Render XML Namespace declaration attributes, i.e. ``xmlns:prefix="uri"`` for each dict item."""
     return " ".join(
         f'xmlns:{prefix}="{xml_namespace}"' if prefix else f'xmlns="{xml_namespace}"'
         for xml_namespace, prefix in xml_namespaces.items()