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

gisserver/parsers/wfs20/base.py

@@ -0,0 +1,143 @@
+"""Entry point to handle queries.
+
+WFS defines 2 query types:
+- Adhoc queries are constructed directly from request parameters.
+- Stored queries are defined first, and executed later.
+
+Both use the FES (Filter Encoding Syntax) filtering logic internally.
+
+The objects in this module closely follow the WFS spec.
+By using the same type definitions, a lot of code logic follows naturally.
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar
+
+from django.db.models import Q, QuerySet
+
+from gisserver.exceptions import (
+    ExternalValueError,
+    InvalidParameterValue,
+    OperationNotSupported,
+)
+from gisserver.features import FeatureType
+from gisserver.parsers import fes20, wfs20
+from gisserver.parsers.ast import BaseNode
+from gisserver.parsers.query import CompiledQuery
+from gisserver.projection import FeatureProjection
+
+
+class QueryExpression(BaseNode):
+    """WFS base class for all queries.
+    This object type is defined in the WFS spec (as ``<fes:AbstractQueryExpression>``).
+
+    The WFS server can initiate queries in multiple ways.
+    This class provides the common interface for all these query types;
+    whether the request provided "ad-hoc" parameters or called a stored procedure.
+    Each query type has its own way of generating the actual database statement to perform.
+
+    The subclasses can override the following logic:
+
+    * :meth:`get_type_names` defines which types this query applies to.
+    * :meth:`build_query` defines how to filter the queryset.
+
+    For full control, these methods can also be overwritten instead:
+
+    * :meth:`get_queryset` defines the full results.
+    """
+
+    query_locator: ClassVar[str] = None
+
+    # QueryExpression
+    handle: str = ""
+
+    # Projection parameters (overwritten by subclasses)
+    # In the WFS spec, this is only part of the operation/presentation.
+    # For Django, we'd like to make this part of the query too.
+    property_names: list[wfs20.PropertyName] | None = None  # PropertyName
+    value_reference: fes20.ValueReference | None = None  # GetPropertyValue call
+
+    def bind(
+        self,
+        feature_types: list[FeatureType],
+        value_reference: fes20.ValueReference | None = None,
+    ):
+        """Bind the query to context outside its tag definition.
+
+        :param feature_types: The corresponding feature types for :meth:`get_type_names`.
+        :param value_reference: Which field is returned (by ``GetPropertyValue``)
+        """
+        # Store the resolved feature types
+        self.feature_types = feature_types
+
+        # for GetPropertyValue
+        if value_reference is not None:
+            self.value_reference = value_reference
+
+    def get_queryset(self) -> QuerySet:
+        """Generate the queryset for the specific feature type.
+
+        This method can be overwritten in subclasses to define the returned data.
+        However, consider overwriting :meth:`build_query` instead of simple data.
+        """
+        if len(self.feature_types) > 1:
+            raise OperationNotSupported("Join queries are not supported", locator="typeNames")
+
+        # To apply the filters, an internal CompiledQuery object is created.
+        # This collects all steps, to create the final QuerySet object.
+        # The build_query() method may return an Q object, or fill the compiler itself.
+        compiler = CompiledQuery(self.feature_types)
+        q_object = self.build_query(compiler)
+        if q_object is not None:
+            compiler.add_lookups(q_object)
+
+        # While property names are projection, this hook should
+        # make it possible to perform extra query adjustments for complex expressions.
+        if self.property_names:
+            for property_name in self.property_names:
+                property_name.decorate_query(compiler)
+
+        if self.value_reference is not None:
+            try:
+                self.value_reference.parse_xpath(self.feature_types)
+            except ExternalValueError as e:
+                raise InvalidParameterValue(
+                    f"Field '{self.value_reference.xpath}' does not exist.",
+                    locator="valueReference",
+                ) from e
+
+            # For GetPropertyValue, adjust the query so only that value is requested.
+            # This makes sure XPath attribute selectors are already handled by the
+            # database query, instead of being a presentation-layer handling.
+            # This supports cases like: ``addresses/Address[street="Oxfordstrasse"]/number``
+            field = self.value_reference.build_rhs(compiler)
+
+            queryset = compiler.get_queryset()
+            return queryset.values("pk", member=field)
+        else:
+            return compiler.get_queryset()
+
+    def get_type_names(self) -> list[str]:
+        """Tell which type names this query applies to.
+
+        This method needs to be defined in subclasses.
+        """
+        raise NotImplementedError(
+            f"{self.__class__.__name__}.get_type_names() should be implemented."
+        )
+
+    def get_projection(self) -> FeatureProjection:
+        """Tell how the query should be displayed."""
+        raise NotImplementedError()
+
+    def build_query(self, compiler: CompiledQuery) -> Q | None:
+        """Define the compiled query that filters the queryset."""
+        raise NotImplementedError()
+
+    def as_kvp(self):
+        """Translate the POST request into KVP GET parameters. This is needed for pagination."""
+        params = {}
+        if self.property_names:
+            params["PROPERTYNAME"] = ",".join(p.xpath for p in self.property_names)
+        return params

gisserver/parsers/wfs20/projection.py

@@ -0,0 +1,103 @@
+"""Projection tag parsing for WFS 2.0"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from gisserver.exceptions import (
+    InvalidParameterValue,
+    OperationParsingFailed,
+    OperationProcessingFailed,
+)
+from gisserver.parsers.ast import BaseNode, tag_registry
+from gisserver.parsers.query import CompiledQuery
+from gisserver.parsers.xml import NSElement, xmlns
+from gisserver.types import XPathMatch
+
+
+class ResolveValue(Enum):
+    """The wfs:ResolveValueType enum, used by :class:`StandardResolveParameters`."""
+
+    local = "local"
+    remote = "remote"
+    all = "all"
+    none = "none"
+
+    @classmethod
+    def _missing_(cls, value):
+        raise OperationParsingFailed(f"Invalid resolve value: {value}", locator="resolve")
+
+
+@dataclass
+@tag_registry.register("PropertyName", xmlns.wfs)
+class PropertyName(BaseNode):
+    """The ``<wfs:PropertyName>`` element in the projection clause.
+
+    This parses and handles the syntax::
+
+        <wfs:PropertyName>ns0:tagname</wfs:PropertyName>
+
+    More advanced syntax is not supported, such as::
+
+      <wfs:PropertyName resolve="all" resolvePath="valueOf(relatedTo)">valueOf(registerEntry)</wfs:PropertyName>
+
+    Note this element exists in the WFS namespace, not the FES namespace!
+    The ``<fes:PropertyName>`` is an old FES 1.x element that has been replaced by ``<fes:ValueReference>``.
+    The old ``<fes:PropertyName>`` is still supported as an alias by this server.
+    """
+
+    xpath: str  # Officially only a 'QName'
+    xpath_ns_aliases: dict[str, str]
+
+    # Unused, yet included for completeness.
+    # These are available in the XML syntax, and override
+    # the default given in the <wfs:GetFeature> element.
+    resolve: ResolveValue = ResolveValue.none
+    resolve_depth: int | None = None
+    resolve_path: str | None = None
+    resolve_timeout: int = 300
+
+    @classmethod
+    def from_xml(cls, element: NSElement):
+        """Parse the XML tag."""
+        depth = parse_resolve_depth(element.attrib.get("resolveDepth", None))
+        return cls(
+            xpath=element.text,
+            resolve=ResolveValue[element.attrib.get("resolve", "none")],
+            resolve_depth=depth,
+            resolve_path=element.attrib.get("resolvePath"),
+            resolve_timeout=element.get_int_attribute("resolveTimeout", 300),
+            xpath_ns_aliases=element.ns_aliases,
+        )
+
+    def parse_xpath(self, feature_types: list) -> XPathMatch:
+        """Convert the XPath into the required ORM query elements."""
+        if self.resolve_path:
+            raise OperationProcessingFailed("resolvePath is not supported", locator="propertyName")
+        if "valueOf(" in self.xpath or (self.resolve_path and "valueOf(" in self.resolve_path):
+            raise OperationProcessingFailed(
+                "valueOf(..) syntax is not supported", locator="propertyName"
+            )
+
+        # Can resolve against XSD paths, find the correct DB field name
+        return feature_types[0].resolve_element(self.xpath, self.xpath_ns_aliases)
+
+    def decorate_query(self, compiler: CompiledQuery):
+        """Update the low-level query based on this property projection."""
+        # This will also validate the name because it resolves the ORM path.
+        # The actual limiting of fields happens inside the decorate_queryset() of the renderer.
+        xpath_match = self.parse_xpath(compiler.feature_types)
+        if xpath_match.orm_filters:
+            # Apply any xpath [attr=value] lookups.
+            compiler.add_extra_lookup(xpath_match.orm_filters)
+
+
+def parse_resolve_depth(depth: str | None) -> int | None:
+    """Parse the resolve depth value."""
+    try:
+        return None if depth is None or depth == "*" else int(depth)
+    except (ValueError, TypeError) as e:
+        raise InvalidParameterValue(
+            "ResolveDepth must be an integer or '*'", locator="resolveDepth"
+        ) from e