django-gisserver 1.5.0__py3-none-any.whl → 2.1__py3-none-any.whl

gisserver/operations/wfs20.py

@@ -1,107 +1,104 @@
-"""Operations that implement the WFS 2.0 spec.
-
-Useful docs:
-* http://portal.opengeospatial.org/files/?artifact_id=39967
-* https://www.opengeospatial.org/standards/wfs#downloads
-* http://schemas.opengis.net/wfs/2.0/
-* https://mapserver.org/development/rfc/ms-rfc-105.html
-* https://enonline.supermap.com/iExpress9D/API/WFS/WFS200/WFS_2.0.0_introduction.htm
+"""Operations that implement the WFS 2.0 specification.
+
+These operations are called by the :class:`~gisserver.views.WFSView`,
+and receive the request that was parsed using :mod:`gisserver.parsers.wfs20`.
+Thus, there is nearly no difference between GET/POST requests here.
+
+In a way this looks like an MVC (Model-View-Controller) design:
+
+* :mod:`gisserver.parsers.wfs20` parsed the request, and provides the "model".
+* :mod:`gisserver.operations.wfs20` orchestrates here what to do (the controller).
+* :mod:`gisserver.output` performs the rendering (the view).
 """
 
+from __future__ import annotations
+
 import logging
 import math
 import re
+import typing
 from urllib.parse import urlencode
 
-from django.core.exceptions import FieldError, ValidationError
-from django.db import InternalError, ProgrammingError
+from django.core.exceptions import ImproperlyConfigured
+from django.utils.module_loading import import_string
 
-from gisserver import conf, output, queries
+from gisserver import conf, output
 from gisserver.exceptions import (
-    ExternalParsingError,
-    ExternalValueError,
     InvalidParameterValue,
-    MissingParameterValue,
-    OperationParsingFailed,
     VersionNegotiationFailed,
+    wrap_filter_errors,
 )
-from gisserver.geometries import CRS, BoundingBox
-from gisserver.parsers import fes20
-from gisserver.queries import stored_query_registry
-
-from .base import (
-    OutputFormat,
-    Parameter,
-    UnsupportedParameter,
-    WFSMethod,
-    WFSTypeNamesMethod,
-)
+from gisserver.extensions.functions import function_registry
+from gisserver.extensions.queries import stored_query_registry
+from gisserver.features import FeatureType
+from gisserver.output import CollectionOutputRenderer
+from gisserver.parsers import ows, wfs20
+
+from .base import OutputFormat, OutputFormatMixin, Parameter, WFSOperation, XmlTemplateMixin
 
 logger = logging.getLogger(__name__)
 
 SAFE_VERSION = re.compile(r"\A[0-9.]+\Z")
 RE_SAFE_FILENAME = re.compile(r"\A[A-Za-z0-9]+[A-Za-z0-9.]*")  # no dot at the start.
 
+__all__ = [
+    "GetCapabilities",
+    "DescribeFeatureType",
+    "BaseWFSGetDataOperation",
+    "GetFeature",
+    "GetPropertyValue",
+    "ListStoredQueries",
+    "DescribeStoredQueries",
+]
 
-class GetCapabilities(WFSMethod):
+
+class GetCapabilities(XmlTemplateMixin, OutputFormatMixin, WFSOperation):
     """This operation returns map features, and available operations this WFS server supports."""
 
-    output_formats = [
-        OutputFormat("text/xml"),
-        OutputFormat(
-            # for FME (Feature Manipulation Engine)
-            "application/gml+xml",
-            version="3.2",
-            title="GML",
-            in_capabilities=False,
-        ),
-    ]
+    ows_request: wfs20.GetCapabilities
+
     xml_template_name = "get_capabilities.xml"
 
-    def get_parameters(self):
-        # Not calling super, as this differs slightly (e.g. no output formats)
+    def get_output_formats(self):
         return [
-            Parameter(
-                "service",
-                required=True,
-                in_capabilities=True,
-                allowed_values=list(self.view.accept_operations.keys()),
-            ),
-            Parameter(
-                # Version parameter can still be sent,
-                # but not mandatory for GetCapabilities
-                "version",
-                allowed_values=self.view.accept_versions,
-            ),
-            Parameter(
-                "AcceptVersions",
-                in_capabilities=True,
-                allowed_values=self.view.accept_versions,
-                parser=self._parse_accept_versions,
-            ),
-            Parameter(
-                "AcceptFormats",
-                in_capabilities=True,
-                allowed_values=self.output_formats,
-                parser=self._parse_output_format,
-                default=self.output_formats[0],
+            OutputFormat("text/xml", renderer_class=None),
+            OutputFormat(
+                # for FME (Feature Manipulation Engine)
+                "application/gml+xml",
+                renderer_class=None,
+                version="3.2",
+                title="GML",
+                in_capabilities=False,
             ),
-        ] + self.parameters
+        ]
 
-    def _parse_accept_versions(self, accept_versions) -> str:
+    def get_parameters(self):
+        # Not calling super, as this differs slightly (not requiring VERSION)
+        return [
+            Parameter("service", allowed_values=list(self.view.accept_operations.keys())),
+            Parameter("AcceptVersions", allowed_values=self.view.accept_versions),
+            Parameter("AcceptFormats", allowed_values=[str(o) for o in self.get_output_formats()]),
+        ]
+
+    def validate_request(self, ows_request: wfs20.GetCapabilities):
+        # Validate AcceptVersions
+        self._parse_accept_versions(ows_request)
+
+        # Validate AcceptFormats
+        if ows_request.acceptFormats:
+            for output_format in ows_request.acceptFormats:
+                self.resolve_output_format(output_format, locator="AcceptFormats")
+
+    def _parse_accept_versions(self, ows_request: wfs20.GetCapabilities) -> str | None:
         """Special parsing for the ACCEPTVERSIONS parameter."""
-        if "VERSION" in self.view.KVP:
-            # Even GetCapabilities can still receive a VERSION argument to fixate it.
-            raise InvalidParameterValue(
-                "Can't provide both ACCEPTVERSIONS and VERSION",
-                locator="AcceptVersions",
-            )
+        if not ows_request.acceptVersions:
+            return None
 
-        matched_versions = set(accept_versions.split(",")).intersection(self.view.accept_versions)
+        matched_versions = set(ows_request.acceptVersions).intersection(self.view.accept_versions)
         if not matched_versions:
             allowed = ", ".join(self.view.accept_versions)
             raise VersionNegotiationFailed(
-                f"'{accept_versions}' does not contain supported versions, "
+                f"'{','.join(ows_request.acceptVersions)}' does not contain supported versions, "
                 f"supported are: {allowed}.",
                 locator="acceptversions",
             )
@@ -110,269 +107,281 @@ class GetCapabilities(WFSMethod):
         requested_version = sorted(matched_versions, reverse=True)[0]
 
         # Make sure the views+exceptions continue to operate in this version
-        self.view.set_version(requested_version)
-
+        self.view.set_version(ows_request.service, requested_version)
         return requested_version
 
-    def __call__(self, **params):
-        """GetCapabilities only supports XML output"""
-        context = self.get_context_data(**params)
-        return self.render_xml(context, **params)
-
-    def get_context_data(self, **params):
-        view = self.view
-
+    def get_context_data(self) -> dict:
         # The 'service' is not read from 'params' to avoid dependency on get_parameters()
-        service = view.KVP["SERVICE"]  # is WFS
-        service_operations = view.accept_operations[service]
-        feature_output_formats = service_operations["GetFeature"].output_formats
+        service_operations = self.view.accept_operations[self.ows_request.service]
+        app_namespaces = self.view.get_xml_namespaces_to_prefixes()
+
+        get_feature_op_cls = service_operations["GetFeature"]
+        feature_output_formats = get_feature_op_cls(self.view, None).get_output_formats()
 
         return {
-            "service_description": view.get_service_description(service),
+            "xml_namespaces": app_namespaces,
+            "service_description": self.view.get_service_description(self.ows_request.service),
             "accept_operations": {
-                name: operation(view) for name, operation in service_operations.items()
+                name: operation_class(self.view, None).get_parameters()
+                for name, operation_class in service_operations.items()
             },
             "service_constraints": self.view.wfs_service_constraints,
             "filter_capabilities": self.view.wfs_filter_capabilities,
-            "function_registry": fes20.function_registry,
+            "function_registry": function_registry,
             "accept_versions": self.view.accept_versions,
-            "feature_types": self.view.get_feature_types(),
+            "feature_types": self.view.get_bound_feature_types(),
             "feature_output_formats": feature_output_formats,
             "default_max_features": self.view.max_page_size,
             "BOUNDING_BOX": conf.GISSERVER_CAPABILITIES_BOUNDING_BOX,
         }
 
 
-class DescribeFeatureType(WFSTypeNamesMethod):
+class DescribeFeatureType(OutputFormatMixin, WFSOperation):
     """This returns an XML Schema for the provided objects.
     Each feature is exposed as an XSD definition with its fields.
     """
 
-    output_formats = [
-        OutputFormat("XMLSCHEMA", renderer_class=output.XMLSchemaRenderer),
-        # At least one version of FME (Feature Manipulation Engine) seems to
-        # send a DescribeFeatureType request with this GML as output format.
-        # Do what mapserver does and just send it XML Schema.
-        OutputFormat(
-            "application/gml+xml",
-            version="3.2",
-            renderer_class=output.XMLSchemaRenderer,
-            in_capabilities=False,
-        ),
-        # OutputFormat("text/xml", subtype="gml/3.1.1"),
-    ]
-
-    def get_context_data(self, typeNames, **params):
-        if self.view.KVP.get("TYPENAMES") == "" or self.view.KVP.get("TYPENAME") == "":
-            # Using TYPENAMES= does result in an error.
-            raise MissingParameterValue("Empty TYPENAMES parameter", locator="typeNames")
-        elif typeNames is None:
-            # Not given, all types are returned
-            typeNames = self.all_feature_types
-
-        return {"feature_types": typeNames}
-
-
-class ListStoredQueries(WFSMethod):
-    """This describes the available queries"""
+    ows_request: wfs20.DescribeFeatureType
+
+    def get_output_formats(self):
+        return [
+            OutputFormat("XMLSCHEMA", renderer_class=output.XmlSchemaRenderer),
+            # At least one version of FME (Feature Manipulation Engine) seems to
+            # send a DescribeFeatureType request with this GML as output format.
+            # Do what mapserver does and just send it XML Schema.
+            # This output format also seems to be used in the WFS 2.0.2 spec!
+            OutputFormat(
+                "application/gml+xml",
+                version="3.2",
+                renderer_class=output.XmlSchemaRenderer,
+                in_capabilities=False,
+            ),
+            # OutputFormat("text/xml", subtype="gml/3.1.1"),
+        ]
 
-    xml_template_name = "list_stored_queries.xml"
+    def validate_request(self, ows_request: wfs20.DescribeFeatureType):
+        if not ows_request.typeNames:
+            self.feature_types = self.view.get_bound_feature_types()
+        else:
+            self.feature_types = [
+                self.resolve_feature_type(type_name) for type_name in ows_request.typeNames
+            ]
+        self.output_format = self.resolve_output_format(ows_request.outputFormat)
 
-    def get_context_data(self, **params):
-        return {"feature_types": self.view.get_feature_types()}
+    def process_request(self, ows_request: wfs20.DescribeFeatureType):
+        renderer_class = self.output_format.renderer_class or output.XmlSchemaRenderer
+        renderer = renderer_class(self, self.feature_types)
+        return renderer.get_response()
 
 
-class DescribeStoredQueries(WFSMethod):
+class ListStoredQueries(WFSOperation):
     """This describes the available queries"""
 
-    xml_template_name = "describe_stored_queries.xml"
+    ows_request: wfs20.ListStoredQueries
 
-    parameters = [
-        Parameter(
-            "STOREDQUERY_ID",
-            parser=lambda value: [
-                stored_query_registry.resolve_query(name) for name in value.split(",")
-            ],
+    def process_request(self, ows_request: ows.BaseOwsRequest):
+        renderer = output.ListStoredQueriesRenderer(
+            self,
+            query_descriptions=stored_query_registry.get_queries(),
         )
-    ]
+        return renderer.get_response()
 
-    def get_context_data(self, **params):
-        queries = params["STOREDQUERY_ID"] or list(stored_query_registry)
-        return {
-            "feature_types": self.view.get_feature_types(),
-            "stored_queries": [q.meta for q in queries],
-        }
 
+class DescribeStoredQueries(WFSOperation):
+    """This describes the available queries"""
+
+    ows_request: wfs20.DescribeStoredQueries
+
+    def validate_request(self, ows_request: wfs20.DescribeStoredQueries):
+        if ows_request.storedQueryId is None:
+            self.query_descriptions = stored_query_registry.get_queries()
+        else:
+            self.query_descriptions = [
+                stored_query_registry.resolve_query(query_id)
+                for query_id in ows_request.storedQueryId
+            ]
+
+    def process_request(self, ows_request: ows.BaseOwsRequest):
+        renderer = output.DescribeStoredQueriesRenderer(self, self.query_descriptions)
+        return renderer.get_response()
 
-class BaseWFSGetDataMethod(WFSTypeNamesMethod):
+
+class BaseWFSGetDataOperation(OutputFormatMixin, WFSOperation):
     """Base class for GetFeature / GetPropertyValue"""
 
-    parameters = [
-        # StandardPresentationParameters
-        Parameter(
-            "resultType",
-            in_capabilities=True,
-            parser=lambda x: x.upper(),
-            allowed_values=["RESULTS", "HITS"],
-            default="RESULTS",
-        ),
-        Parameter("startIndex", parser=int, default=0),
-        Parameter("count", alias="maxFeatures", parser=int),  # maxFeatures is WFS 1.x
-        # outputFormat will be added by the base class.
-        # StandardResolveParameters
-        Parameter("resolve", allowed_values=["local"], in_capabilities=True),
-        UnsupportedParameter("resolveDepth"),  # subresource settings
-        UnsupportedParameter("resolveTimeout"),
-        # StandardInputParameters
-        Parameter("srsName", parser=CRS.from_string),
-        # Projection clause parameters
-        Parameter("propertyName", parser=fes20.parse_property_name),
-        # AdHoc Query parameters
-        Parameter("bbox", parser=BoundingBox.from_string),
-        Parameter(
-            "filter_language",
-            default=fes20.Filter.query_language,
-            allowed_values=[fes20.Filter.query_language],
-        ),
-        Parameter("filter", parser=fes20.Filter.from_string),
-        Parameter("sortBy", parser=fes20.SortBy.from_string),
-        Parameter("resourceID", parser=fes20.parse_resource_id_kvp),
-        UnsupportedParameter("aliases"),
-        queries.StoredQueryParameter(),
-    ]
-
-    def get_context_data(self, resultType, **params):  # noqa: C901
-        query = self.get_query(**params)
-        query.check_permissions(self.view.request)
-
-        try:
-            if resultType == "HITS":
-                collection = query.get_hits()
-            elif resultType == "RESULTS":
-                # Validate StandardPresentationParameters
-                collection = self.get_paginated_results(query, **params)
-            else:
-                raise NotImplementedError()
-        except ExternalParsingError as e:
-            # Bad input data
-            self._log_filter_error(query, logging.ERROR, e)
-            raise OperationParsingFailed(str(e), locator=self._get_locator(**params)) from e
-        except ExternalValueError as e:
-            # Bad input data
-            self._log_filter_error(query, logging.ERROR, e)
-            raise InvalidParameterValue(str(e), locator=self._get_locator(**params)) from e
-        except ValidationError as e:
-            # Bad input data
-            self._log_filter_error(query, logging.ERROR, e)
-            raise OperationParsingFailed(
-                "\n".join(map(str, e.messages)),
-                locator=self._get_locator(**params),
-            ) from e
-        except FieldError as e:
-            # e.g. doing a LIKE on a foreign key, or requesting an unknown field.
-            if not conf.GISSERVER_WRAP_FILTER_DB_ERRORS:
-                raise
-            self._log_filter_error(query, logging.ERROR, e)
-            raise InvalidParameterValue(
-                "Internal error when processing filter",
-                locator=self._get_locator(**params),
-            ) from e
-        except (InternalError, ProgrammingError) as e:
-            # e.g. comparing datetime against integer
-            if not conf.GISSERVER_WRAP_FILTER_DB_ERRORS:
-                raise
-            logger.exception("WFS request failed: %s\nParams: %r", str(e), params)
-            msg = str(e)
-            locator = "srsName" if "Cannot find SRID" in msg else self._get_locator(**params)
-            raise InvalidParameterValue(f"Invalid request: {msg}", locator=locator) from e
-        except (TypeError, ValueError) as e:
-            # TypeError/ValueError could reference a datatype mismatch in an
-            # ORM query, but it could also be an internal bug. In most cases,
-            # this is already caught by XsdElement.validate_comparison().
-            if self._is_orm_error(e):
-                raise InvalidParameterValue(
-                    f"Invalid filter query: {e}",
-                    locator=self._get_locator(**params),
-                ) from e
-            raise
-
-        output_crs = params["srsName"]
-        if not output_crs and collection.results:
-            output_crs = collection.results[0].feature_type.crs
+    ows_request: wfs20.GetFeature | wfs20.GetPropertyValue
 
-        return {
-            # These become init kwargs for the selected OutputRenderer class:
-            "source_query": query,
-            "collection": collection,
-            "output_crs": output_crs,
-        }
+    if typing.TYPE_CHECKING:
+        # Tell the type checker subclasses will only work with CollectionOutputRenderer rendering.
+
+        def resolve_output_format(
+            self, value, locator="outputFormat"
+        ) -> OutputFormat[CollectionOutputRenderer]:
+            return super().resolve_output_format(value, locator=locator)
+
+    def get_parameters(self) -> list[Parameter]:
+        """Parameters to advertise in the capabilities for this method."""
+        return [
+            # Advertise parameters in GetCapabilities
+            Parameter("resultType", allowed_values=["RESULTS", "HITS"]),
+            Parameter("resolve", allowed_values=["local"]),
+        ]
+
+    def validate_request(self, ows_request: wfs20.GetFeature | wfs20.GetPropertyValue):
+        """Validate the incoming data before execution."""
+        self.output_format = self.resolve_output_format(ows_request.outputFormat)
+
+        # Resolve the feature types
+        # Allow these to skip, e.g. when the query needs to return 0 results (GetFeatureById).
+        for query in ows_request.queries:
+            type_names = query.get_type_names()
+            feature_types = [
+                self.resolve_feature_type(
+                    type_name,
+                    locator=("resourceId" if query.query_locator == "resourceId" else "typeNames"),
+                )
+                for type_name in type_names
+            ]
+            self.bind_query(query, feature_types)
+
+            # Allow both the view and feature-type to check for access.
+            # Before 2.0 only FeatureType classes offered this, which required subclassing
+            # FeatureType to access view.request.user. The direct view check avoids that need.
+            for feature_type in feature_types:
+                self.view.check_permissions(feature_type)
+                feature_type.check_permissions(self.view.request)
+
+    def bind_query(self, query: wfs20.QueryExpression, feature_types: list[FeatureType]):
+        """Allow to be overwritten in GetFeatureValue"""
+        query.bind(feature_types)
+
+    def process_request(self, ows_request: wfs20.GetFeature | wfs20.GetPropertyValue):
+        """Process the query, and generate the output."""
+        # Initialize the collection, which constructs the ORM querysets.
+        if ows_request.resultType == wfs20.ResultType.hits:
+            collection = self.get_hits()
+        elif self.ows_request.resultType == wfs20.ResultType.results:
+            collection = self.get_results()
+        else:
+            raise NotImplementedError()
+
+        # assert False, str(collection.results[0].queryset.query)
+
+        # Initialize the renderer.
+        # This can also decorate the querysets with projection information,
+        # such as converting geometries to the correct CRS or add prefetch_related logic.
+        renderer = self.output_format.renderer_class(operation=self, collection=collection)
 
-    def get_query(self, **params) -> queries.QueryExpression:
-        """Create or retrieve the query object that will process this request.
+        # Fixing pagination will invoke the query,
+        # hence this is done at the end
+        self.set_pagination_links(collection)
 
-        This can either retrieve the stored procedure (e.g. from a database),
-        or construct an ad-hoc query from request parameters.
+        # Render it!
+        return renderer.get_response()
+
+    def get_hits(self) -> output.FeatureCollection:
+        """Handle the resultType=hits query.
+        This creates the QuerySet and counts the number of results.
         """
-        if params["STOREDQUERY_ID"]:
-            # The 'StoredQueryParameter' already parses the input into a complete object.
-            # When it's not provided, the regular Adhoc-query will be created from the KVP request.
-            query = params["STOREDQUERY_ID"]
-            query.bind(
-                # TODO: pass this in a cleaner way?
-                all_feature_types=self.all_feature_types_by_name,  # for GetFeatureById
-                value_reference=params.get("valueReference"),  # for GetPropertyValue
-                property_names=params.get("propertyName"),  # for GetFeature with PropertyName
+        start, count = self.get_pagination()
+        results = []
+        for query in self.ows_request.queries:
+            with wrap_filter_errors(query):
+                queryset = query.get_queryset()
+
+            results.append(
+                output.SimpleFeatureCollection(
+                    source_query=query,
+                    feature_types=query.feature_types,
+                    queryset=queryset.none(),
+                    start=start,
+                    stop=start + count,  # yes, count can be passed for hits
+                    number_matched=queryset.count(),
+                )
+            )
+
+        return output.FeatureCollection(
+            results=results,
+            number_matched=sum(r.number_matched for r in results),
+        )
+
+    def get_results(self) -> output.FeatureCollection:
+        """Handle the resultType=results query.
+        This creates the queryset, allowing to read over all results.
+        """
+        start, count = self.get_pagination()
+        results = []
+        for query in self.ows_request.queries:
+            # The querysets are not executed yet, until the output is reading them.
+            with wrap_filter_errors(query):
+                queryset = query.get_queryset()
+
+            results.append(
+                output.SimpleFeatureCollection(
+                    source_query=query,
+                    feature_types=query.feature_types,
+                    queryset=queryset,
+                    start=start,
+                    stop=start + count,
+                )
             )
-        else:
-            query = queries.AdhocQuery.from_kvp_request(index=0, **params)
-            query.bind(all_feature_types=self.all_feature_types_by_name)
 
-        return query
+        # number_matched is not given here, so some rendering formats can count it instead.
+        # For GML it need to be printed at the start, but for GeoJSON it can be rendered
+        # as the last bit of the response. That avoids performing an expensive COUNT query.
+        return output.FeatureCollection(results=results)
 
-    def get_paginated_results(
-        self, query: queries.QueryExpression, outputFormat, **params
-    ) -> output.FeatureCollection:
-        """Handle pagination settings."""
-        start = max(0, params["startIndex"])
+    def get_pagination(self) -> tuple[int, int]:
+        """Tell what the requested page size is."""
+        start = max(0, self.ows_request.startIndex)
 
         # outputFormat.max_page_size can be math.inf to enable endless scrolling.
         # this only works when the COUNT parameter is not given.
-        max_page_size = outputFormat.max_page_size or self.view.max_page_size
-        page_size = min(max_page_size, params["count"] or max_page_size)
-        stop = start + page_size
-
-        # Perform query
-        collection = query.get_results(start, count=page_size)
-
-        # Allow presentation-layer to add extra logic.
-        if outputFormat.renderer_class is not None:
-            output_crs = params["srsName"]
-            if not output_crs and collection.results:
-                output_crs = collection.results[0].feature_type.crs
+        max_page_size = self.output_format.max_page_size or self.view.max_page_size
+        default_page_size = (
+            0 if self.ows_request.resultType == wfs20.ResultType.hits else max_page_size
+        )
+        count = min(max_page_size, self.ows_request.count or default_page_size)
+        return start, count
 
-            outputFormat.renderer_class.decorate_collection(collection, output_crs, **params)
+    def set_pagination_links(self, collection: output.FeatureCollection):
+        """Assign the pagination links to the collection.
+        This happens within the operation logic, as it can access the original GET request.
+        """
+        if self.ows_request.resultType == wfs20.ResultType.hits and not self.ows_request.count:
+            return
 
+        start, count = self.get_pagination()
+        stop = start + count
         if stop != math.inf:
             if start > 0:
                 collection.previous = self._replace_url_params(
-                    STARTINDEX=max(0, start - page_size),
-                    COUNT=page_size,
+                    STARTINDEX=max(0, start - count),
+                    COUNT=count,
                 )
+
+            # Note that reading collection.has_next will invoke the query!
             if collection.has_next:
                 # TODO: fix this when returning multiple typeNames:
                 collection.next = self._replace_url_params(
-                    STARTINDEX=start + page_size,
-                    COUNT=page_size,
+                    STARTINDEX=start + count,
+                    COUNT=count,
                 )
 
-        return collection
-
-    def _replace_url_params(self, **updates) -> str:
+    def _replace_url_params(self, **updates) -> str | None:
         """Replace a query parameter in the URL"""
         new_params = self.view.request.GET.copy()  # preserve lowercase fields too
+        if self.view.request.method != "GET":
+            # CITE compliance testing wants to see a 'next' link for POST requests too.
+            try:
+                new_params.update(self.ows_request.as_kvp())
+            except NotImplementedError:
+                # Various POST requests can't be translated back to KVP
+                # mapserver omits the 'next' link in these cases too.
+                return None
 
         # Replace any lower/mixed case variants of the previous names:
-        for name in self.view.request.GET:
+        for name in new_params:
             upper = name.upper()
             if upper in updates:
                 new_params[name] = updates.pop(upper)
@@ -381,112 +390,127 @@ class BaseWFSGetDataMethod(WFSTypeNamesMethod):
         new_params.update(updates)
         return f"{self.view.server_url}?{urlencode(new_params)}"
 
-    def _is_orm_error(self, exception: Exception):
-        traceback = exception.__traceback__
-        while traceback.tb_next is not None:
-            traceback = traceback.tb_next
-            if "/django/db/models/query" in traceback.tb_frame.f_code.co_filename:
-                return True
-        return False
-
-    def _log_filter_error(self, query, level, exc):
-        """Report a filtering parsing error in the logging"""
-        filter = getattr(query, "filter", None)  # AdhocQuery only
-        fes_xml = filter.source if filter is not None else "(not provided)"
-        try:
-            sql = exc.__cause__.cursor.query.decode()
-        except AttributeError:
-            logger.log(level, "WFS query failed: %s\nFilter:\n%s", exc, fes_xml)
-        else:
-            logger.log(
-                level,
-                "WFS query failed: %s\nSQL Query: %s\n\nFilter:\n%s",
-                exc,
-                sql,
-                fes_xml,
+
+class GetFeature(BaseWFSGetDataOperation):
+    """This returns all properties of the feature.
+
+    Various query parameters allow limiting the data.
+    """
+
+    def get_output_formats(self) -> list[OutputFormat]:
+        """Return the default output formats.
+        This selects a different rendering depending on the ``GISSERVER_USE_DB_RENDERING`` setting.
+        """
+        if conf.GISSERVER_GET_FEATURE_OUTPUT_FORMATS:
+            return self.get_custom_output_formats(
+                conf.GISSERVER_GET_FEATURE_OUTPUT_FORMATS | conf.GISSERVER_EXTRA_OUTPUT_FORMATS
             )
 
-    def _get_locator(self, **params):
-        """Tell which field is likely causing the query error"""
-        if params["resourceID"]:
-            return "resourceId"
-        elif params["STOREDQUERY_ID"]:
-            return "STOREDQUERY_ID"
+        if conf.GISSERVER_USE_DB_RENDERING:
+            csv_renderer = output.DBCSVRenderer
+            gml32_renderer = output.DBGML32Renderer
+            geojson_renderer = output.DBGeoJsonRenderer
         else:
-            return "filter"
+            csv_renderer = output.CSVRenderer
+            gml32_renderer = output.GML32Renderer
+            geojson_renderer = output.GeoJsonRenderer
 
+        return [
+            OutputFormat(
+                # Needed for cite compliance tests
+                "application/gml+xml",
+                version="3.2",
+                renderer_class=gml32_renderer,
+                title="GML",
+            ),
+            OutputFormat(
+                "text/xml",
+                subtype="gml/3.2.1",
+                renderer_class=gml32_renderer,
+                title="GML 3.2.1",
+            ),
+            # OutputFormat("gml"),
+            OutputFormat(
+                # identical to mapserver:
+                "application/json",
+                subtype="geojson",
+                charset="utf-8",
+                renderer_class=geojson_renderer,
+                title="GeoJSON",
+            ),
+            OutputFormat(
+                # Alias needed to make ESRI ArcGIS online accept the WFS.
+                # It does not recognize the "subtype" as an alias.
+                "geojson",
+                renderer_class=geojson_renderer,
+            ),
+            OutputFormat(
+                "text/csv",
+                subtype="csv",
+                charset="utf-8",
+                renderer_class=csv_renderer,
+                title="CSV",
+            ),
+            # OutputFormat("shapezip"),
+            # OutputFormat("application/zip"),
+        ] + self.get_custom_output_formats(conf.GISSERVER_EXTRA_OUTPUT_FORMATS)
+
+    def get_custom_output_formats(self, output_formats_setting: dict) -> list[OutputFormat]:
+        """Add custom output formats defined in the settings."""
+        result = []
+        for content_type, format_kwargs in output_formats_setting.items():
+            renderer_class = format_kwargs["renderer_class"]
+            if isinstance(renderer_class, str):
+                format_kwargs["renderer_class"] = import_string(renderer_class)
+
+            if not issubclass(renderer_class, CollectionOutputRenderer):
+                raise ImproperlyConfigured(
+                    f"The 'renderer_class' of output format {content_type!r},"
+                    f" should be a subclass of CollectionOutputRenderer."
+                )
 
-class GetFeature(BaseWFSGetDataMethod):
-    """This returns all properties of the feature.
+            result.append(OutputFormat(content_type, **format_kwargs))
+
+        return result
 
-    Various query parameters allow limiting the data.
-    """
 
-    output_formats = [
-        OutputFormat(
-            # Needed for cite compliance tests
-            "application/gml+xml",
-            version="3.2",
-            renderer_class=output.gml32_renderer,
-            title="GML",
-        ),
-        OutputFormat(
-            "text/xml",
-            subtype="gml/3.2.1",
-            renderer_class=output.gml32_renderer,
-            title="GML 3.2.1",
-        ),
-        # OutputFormat("gml"),
-        OutputFormat(
-            # identical to mapserver:
-            "application/json",
-            subtype="geojson",
-            charset="utf-8",
-            renderer_class=output.geojson_renderer,
-            title="GeoJSON",
-        ),
-        OutputFormat(
-            # Alias needed to make ESRI ArcGIS online accept the WFS.
-            # It does not recognize the "subtype" as an alias.
-            "geojson",
-            renderer_class=output.geojson_renderer,
-        ),
-        OutputFormat(
-            "text/csv",
-            subtype="csv",
-            charset="utf-8",
-            renderer_class=output.csv_renderer,
-            title="CSV",
-        ),
-        # OutputFormat("shapezip"),
-        # OutputFormat("application/zip"),
-    ]
-
-
-class GetPropertyValue(BaseWFSGetDataMethod):
+class GetPropertyValue(BaseWFSGetDataOperation):
     """This returns a limited set of properties of the feature.
     It works almost identical to GetFeature, except that it returns a single field.
     """
 
-    output_formats = [
-        OutputFormat(
-            "application/gml+xml",
-            version="3.2",
-            renderer_class=output.gml32_value_renderer,
-            title="GML",
-        ),
-        OutputFormat("text/xml", subtype="gml/3.2", renderer_class=output.gml32_value_renderer),
-    ]
-
-    parameters = BaseWFSGetDataMethod.parameters + [
-        Parameter("valueReference", required=True, parser=fes20.ValueReference)
-    ]
-
-    def get_context_data(self, **params):
-        # Pass valueReference to output format.
-        # NOTE: The AdhocQuery object also performs internal processing,
-        # so the query performs a "SELECT id, <fieldname>" as well.
+    ows_request: wfs20.GetPropertyValue
+
+    def get_output_formats(self) -> list[OutputFormat]:
+        """Define the output format for GetPropertyValue."""
+        gml32_value_renderer = (
+            output.DBGML32ValueRenderer
+            if conf.GISSERVER_USE_DB_RENDERING
+            else output.GML32ValueRenderer
+        )
+
+        return [
+            OutputFormat(
+                "application/gml+xml",
+                version="3.2",
+                renderer_class=gml32_value_renderer,
+                title="GML",
+            ),
+            OutputFormat("text/xml", subtype="gml/3.2", renderer_class=gml32_value_renderer),
+        ]
+
+    def validate_request(self, ows_request: wfs20.GetPropertyValue):
+        super().validate_request(ows_request)
+
+        if ows_request.resolvePath:
+            raise InvalidParameterValue(
+                "Support for resolvePath is not implemented!", locator="resolvePath"
+            )
+
+    def bind_query(self, query: wfs20.QueryExpression, feature_types: list[FeatureType]):
+        """Allow to be overwritten in GetFeatureValue"""
+        # Pass valueReference to the query, which will include it in the FeatureProjection.
         # In the WFS-spec, the valueReference is only a presentation layer change.
-        context = super().get_context_data(**params)
-        context["value_reference"] = params["valueReference"]
-        return context
+        # However, in our case AdhocQuery object also performs internal processing,
+        # so the query performs a "SELECT id, <fieldname>" as well.
+        query.bind(feature_types, value_reference=self.ows_request.valueReference)