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

gisserver/parsers/fes20/filters.py

@@ -1,37 +1,111 @@
 from __future__ import annotations
 
-from typing import AnyStr, Union
-from xml.etree.ElementTree import Element, QName
+from dataclasses import dataclass, field
+from typing import AnyStr, ClassVar, Union
 
-from defusedxml.ElementTree import ParseError, fromstring
+from django.db.models import Q
 
-from gisserver.exceptions import ExternalParsingError
-from gisserver.parsers.base import tag_registry
-from gisserver.parsers.tags import expect_tag
-from gisserver.types import FES20, GML32
+from gisserver.exceptions import InvalidParameterValue
+from gisserver.parsers.ast import BaseNode, expect_tag, tag_registry
+from gisserver.parsers.gml import GEOSGMLGeometry
+from gisserver.parsers.ows import KVPRequest
+from gisserver.parsers.query import CompiledQuery
+from gisserver.parsers.xml import NSElement, parse_xml_from_string, xmlns
 
-from . import expressions, identifiers, operators, query
+from . import expressions, identifiers, operators
 
 FilterPredicates = Union[expressions.Function, operators.Operator]
 
+# Fully qualified tag names
+FES_RESOURCE_ID = xmlns.fes20.qname("ResourceId")
 
-class Filter:
+
+@dataclass
+@tag_registry.register("Filter", xmlns.fes20)
+class Filter(BaseNode):
     """The <fes:Filter> element.
 
-    As this is a wrapper, it only contains a "predicate" element with the contents.
+    This parses and handles the syntax::
+
+        <fes:Filter>
+            <fes:SomeOperator>
+                ...
+            </fes:SomeOperator>
+        </fes:Filter>
+
+    The :meth:`build_query` will convert the parsed tree
+    into a format that can build a Django ORM QuerySet.
+
+    .. seealso:: https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/filter_xsd.html#Filter
     """
 
-    query_language = "urn:ogc:def:queryLanguage:OGC-FES:Filter"
+    query_language: ClassVar[str] = "urn:ogc:def:queryLanguage:OGC-FES:Filter"
 
     predicate: FilterPredicates
-    source: AnyStr | None
+    source: AnyStr | None = field(default=None, compare=False)
+
+    @classmethod
+    def from_kvp_request(cls, kvp: KVPRequest) -> Filter | None:
+        """Parse the filter from the GET request."""
+
+        # Check filter language
+        filter_language = kvp.get_str("FILTER_LANGUAGE", default=cls.query_language)
+        if filter_language != cls.query_language:
+            raise InvalidParameterValue(
+                f"Invalid value for filterLanguage: {filter_language}", locator="filterLanguage"
+            )
+
+        # Parse filter
+        filter = kvp.get_custom(
+            "filter", default=None, parser=lambda x: cls.from_string(x, kvp.ns_aliases)
+        )
+
+        # Parse alternatives to filter
+        resource_ids = [
+            identifiers.ResourceId.from_string(rid, kvp.ns_aliases)
+            for rid in kvp.get_list("resourceID", default=[])
+        ]
+        bbox = kvp.get_custom("bbox", default=None, parser=GEOSGMLGeometry.from_bbox)
+
+        # Make sure the various query options are not mixed.
+        cls.validate_kvp_exclusions(filter, bbox, resource_ids)
+
+        if filter is None:
+            # See if the other KVP parameters still provide a basic filter.
+            # Instead of implementing these parameters separately in the AdhocQueryExpression,
+            # they are implemented by constructing the filter AST internally.
+            if resource_ids:
+                filter = Filter(predicate=operators.IdOperator(resource_ids))
+            elif bbox is not None:
+                filter = Filter(
+                    predicate=operators.BinarySpatialOperator(
+                        operatorType=operators.SpatialOperatorName.BBOX,
+                        operand1=None,
+                        operand2=bbox,
+                    )
+                )
+
+        return filter
 
-    def __init__(self, predicate: FilterPredicates, source: AnyStr | None = None):
-        self.predicate = predicate
-        self.source = source
+    @classmethod
+    def validate_kvp_exclusions(
+        cls, filter: Filter | None, bbox: GEOSGMLGeometry | None, resource_ids: list
+    ):
+        """Validate mutually exclusive parameters"""
+        if filter is not None and (bbox is not None or resource_ids):
+            raise InvalidParameterValue(
+                "The FILTER parameter is mutually exclusive with BBOX and RESOURCEID",
+                locator="filter",
+            )
+
+        if resource_ids and (bbox is not None or filter is not None):
+            raise InvalidParameterValue(
+                "The RESOURCEID parameter is mutually exclusive with BBOX and FILTER",
+                locator="resourceId",
+            )
 
     @classmethod
-    def from_string(cls, text: AnyStr) -> Filter:
+    def from_string(cls, text: AnyStr, ns_aliases: dict[str, str] | None = None) -> Filter:
         """Parse an XML <fes20:Filter> string.
 
         This uses defusedxml by default, to avoid various XML injection attacks.
@@ -47,51 +121,45 @@ class Filter:
             if "xmlns" not in first_tag and (
                 first_tag == "<Filter" or first_tag.startswith("<Filter ")
             ):
-                text = f'{first_tag} xmlns="{FES20}" xmlns:gml="{GML32}"{text[end_first:]}'
+                text = f'{first_tag} xmlns="{xmlns.fes20}" xmlns:gml="{xmlns.gml32}"{text[end_first:]}'
 
-        try:
-            root_element = fromstring(text)
-        except ParseError as e:
-            # Offer consistent results for callers to check for invalid data.
-            raise ExternalParsingError(str(e)) from e
+        root_element = parse_xml_from_string(text, extra_ns_aliases=ns_aliases)
         return Filter.from_xml(root_element, source=text)
 
     @classmethod
-    @expect_tag(FES20, "Filter")
-    def from_xml(cls, element: Element, source: AnyStr | None = None) -> Filter:
+    @expect_tag(xmlns.fes20, "Filter")
+    def from_xml(cls, element: NSElement, source: AnyStr | None = None) -> Filter:
         """Parse the <fes20:Filter> element."""
-        if len(element) > 1 or element[0].tag == QName(FES20, "ResourceId"):
+        if len(element) > 1 or element[0].tag == FES_RESOURCE_ID:
             # fes20:ResourceId is the only element that may appear multiple times.
+            # Wrap it in an IdOperator so this class can have a single element as predicate.
             return Filter(
                 predicate=operators.IdOperator(
-                    [identifiers.Id.from_child_xml(child) for child in element]
+                    [identifiers.Id.child_from_xml(child) for child in element]
                 ),
                 source=source,
             )
         else:
             return Filter(
-                predicate=tag_registry.from_child_xml(
-                    element[0], allowed_types=(expressions.Function, operators.Operator)
+                # Can be Function or Operator (e.g. BinaryComparisonOperator),
+                # but not Literal or ValueReference.
+                predicate=tag_registry.node_from_xml(
+                    element[0], allowed_types=FilterPredicates.__args__
                 ),
                 source=source,
             )
 
-    def compile_query(self, feature_type=None, using=None) -> query.CompiledQuery:
+    def build_query(self, compiler: CompiledQuery) -> Q | None:
         """Collect the data to perform a Django ORM query."""
-        compiler = query.CompiledQuery(feature_type=feature_type, using=using)
-
         # Function, Operator, IdList
-        q_object = self.predicate.build_query(compiler)
-        if q_object is not None:
-            compiler.add_lookups(q_object)
-
-        return compiler
+        # The operators may add the logic themselves, or return a Q object.
+        return self.predicate.build_query(compiler)
 
-    def __repr__(self):
-        return f"Filter(predicate={self.predicate!r}, source={self.source})"
-
-    def __eq__(self, other):
-        if isinstance(other, Filter):
-            return self.predicate == other.predicate
+    def get_resource_id_types(self) -> list[str] | None:
+        """When the filter parses ResourceId objects, return those.
+        This can return an empty list in case a ResourceId object doesn't define a type.
+        """
+        if isinstance(self.predicate, operators.IdOperator):
+            return self.predicate.get_type_names()
         else:
-            return NotImplemented
+            return None

gisserver/parsers/fes20/identifiers.py

@@ -11,16 +11,17 @@ from enum import Enum
 from django.db.models import Q
 
 from gisserver import conf
-from gisserver.exceptions import ExternalValueError
-from gisserver.parsers.base import BaseNode, tag_registry
-from gisserver.parsers.tags import expect_tag, get_attribute
+from gisserver.exceptions import ExternalValueError, InvalidParameterValue
+from gisserver.parsers.ast import BaseNode, expect_no_children, expect_tag, tag_registry
 from gisserver.parsers.values import auto_cast, parse_iso_datetime
-from gisserver.types import FES20
+from gisserver.parsers.xml import parse_qname, xmlns
 
 NoneType = type(None)
 
 
 class VersionActionTokens(Enum):
+    """Values for the 'version' attribute of the ResourceId node."""
+
     FIRST = "FIRST"
     LAST = "LAST"
     ALL = "ALL"
@@ -31,10 +32,10 @@ class VersionActionTokens(Enum):
 class Id(BaseNode):
     """Abstract base class, as defined by FES spec."""
 
-    xml_ns = FES20
+    xml_ns = xmlns.fes20
 
-    #: Tell which the type this ID belongs to, needs to be overwritten.
-    type_name = ...  # need to be defined by subclass!
+    def get_type_name(self):
+        raise NotImplementedError()
 
     def build_query(self, compiler) -> Q:
         raise NotImplementedError()
@@ -43,26 +44,36 @@ class Id(BaseNode):
 @dataclass
 @tag_registry.register("ResourceId")
 class ResourceId(Id):
-    """The <fes:ResourceId> element."""
+    """The <fes:ResourceId> element.
+    This element allow queries to retrieve a resource by their identifier.
+    """
 
+    # A raw "resource identifier". Needs to encode the object name somehow,
+    # and it's completely unrelated to XML namespacing.
     rid: str
+    type_name: str | None
     version: int | datetime | VersionActionTokens | NoneType = None
     startTime: datetime | None = None
     endTime: datetime | None = None
 
+    def get_type_name(self):
+        return self.type_name
+
     def __post_init__(self):
-        try:
-            self.type_name, self.id = self.rid.rsplit(".", 1)
-        except ValueError:
-            if conf.GISSERVER_WFS_STRICT_STANDARD:
-                raise ExternalValueError("Expected typename.id format") from None
+        if conf.GISSERVER_WFS_STRICT_STANDARD and "." not in self.rid:
+            raise ExternalValueError("Expected typename.id format") from None
 
-            # This should end in a 404 instead.
-            self.type_name = None
-            self.id = None
+    @classmethod
+    def from_string(cls, rid, ns_aliases: dict[str, str]):
+        # Like GeoServer, assume the "name" part of the "resource id" is a QName.
+        return cls(
+            rid=rid,
+            type_name=parse_qname(rid.rpartition(".")[0], ns_aliases),
+        )
 
     @classmethod
-    @expect_tag(FES20, "ResourceId", leaf=True)
+    @expect_tag(xmlns.fes20, "ResourceId")
+    @expect_no_children
     def from_xml(cls, element):
         version = element.get("version")
         startTime = element.get("startTime")
@@ -71,24 +82,31 @@ class ResourceId(Id):
         if version:
             version = auto_cast(version)
 
+        rid = element.get_str_attribute("rid")
         return cls(
-            rid=get_attribute(element, "rid"),
+            rid=rid,
+            type_name=element.parse_qname(rid.rpartition(".")[0]),
             version=version,
             startTime=parse_iso_datetime(startTime) if startTime else None,
             endTime=parse_iso_datetime(endTime) if endTime else None,
         )
 
-    def build_query(self, compiler=None) -> Q:
+    def build_query(self, compiler) -> Q:
         """Render the SQL filter"""
         if self.startTime or self.endTime or self.version:
             raise NotImplementedError(
                 "No support for <fes:ResourceId> startTime/endTime/version attributes"
             )
 
-        lookup = Q(pk=self.id or self.rid)
-        if compiler is not None:
-            # When the
-            # NOTE: type_name is currently read by the IdOperator that contains this object,
-            # This code path only happens for stand-alone KVP invocation.
-            compiler.add_lookups(lookup, type_name=self.type_name)
-        return lookup
+        object_id = self.rid.rpartition(".")[2]
+
+        try:
+            # The 'ID' parameter is typed as string, but here we can check
+            # whether the database model needs an integer instead.
+            compiler.feature_types[0].model._meta.pk.get_prep_value(object_id)
+        except (TypeError, ValueError) as e:
+            raise InvalidParameterValue(
+                f"Invalid resourceId value: {e}", locator="resourceId"
+            ) from e
+
+        return Q(pk=object_id)

gisserver/parsers/fes20/lookups.py

@@ -0,0 +1,144 @@
+"""Additional ORM lookups used by the fes-filter code."""
+
+from __future__ import annotations
+
+from django.contrib.gis.db.models.fields import BaseSpatialField
+from django.contrib.gis.db.models.lookups import DWithinLookup
+from django.db import models
+from django.db.models import lookups
+
+from gisserver.compat import ArrayField
+
+
+@models.CharField.register_lookup
+@models.TextField.register_lookup
+@models.ForeignObject.register_lookup
+class FesLike(lookups.Lookup):
+    """Allow fieldname__fes_like=... lookups in querysets."""
+
+    lookup_name = "fes_like"
+
+    def as_sql(self, compiler, connection):
+        """Generate the required SQL."""
+        # lhs = "table"."field"
+        # rhs = %s
+        # lhs_params = []
+        # lhs_params = ["prep-value"]
+        lhs, lhs_params = self.process_lhs(compiler, connection)
+        rhs, rhs_params = self.process_rhs(compiler, connection)
+        return f"{lhs} LIKE {rhs}", lhs_params + rhs_params
+
+    def get_db_prep_lookup(self, value, connection):
+        """This expects that the right-hand-side already has wildcard characters."""
+        return "%s", [value]
+
+
+@models.Field.register_lookup
+@models.ForeignObject.register_lookup
+class FesNotEqual(lookups.Lookup):
+    """Allow fieldname__fes_notequal=... lookups in querysets."""
+
+    lookup_name = "fes_notequal"
+
+    def as_sql(self, compiler, connection):
+        """Generate the required SQL."""
+        lhs, lhs_params = self.process_lhs(compiler, connection)  # = (table.field, %s)
+        rhs, rhs_params = self.process_rhs(compiler, connection)  # = ("prep-value", [])
+        return f"{lhs} != {rhs}", (lhs_params + rhs_params)
+
+
+@BaseSpatialField.register_lookup
+class FesBeyondLookup(DWithinLookup):
+    """Based on the FES 2.0.3 corrigendum:
+
+    DWithin(A,B,d) = Distance(A,B) < d
+    Beyond(A,B,d) = Distance(A,B) > d
+
+    See: https://docs.opengeospatial.org/is/09-026r2/09-026r2.html#61
+    """
+
+    lookup_name = "fes_beyond"
+    sql_template = "NOT %(func)s(%(lhs)s, %(rhs)s, %(value)s)"
+
+    def get_rhs_op(self, connection, rhs):
+        # Allow the SQL $(func)s to be different from the ORM lookup name.
+        # This uses ST_DWithin() on PostGIS
+        return connection.ops.gis_operators["dwithin"]
+
+
+if ArrayField is None:
+    ARRAY_LOOKUPS = {}
+else:
+    # Comparisons with array fields go through a separate ORM lookup expression,
+    # so these can check whether ANY element matches in the array.
+    # This gives consistency between other repeated elements (e.g. M2M, reverse FK)
+    # where the whole object is returned when one of the sub-objects match.
+    ARRAY_LOOKUPS = {
+        "exact": "fes_anyexact",
+        "fes_notequal": "fes_anynotequal",
+        "fes_like": "fes_anylike",
+        "lt": "fes_anylt",
+        "lte": "fes_anylte",
+        "gt": "fes_anygt",
+        "gte": "fes_anygte",
+    }
+
+    class ArrayAnyMixin:
+        any_operators = {
+            "exact": "= ANY(%s)",
+            "ne": "!= ANY(%s)",
+            "gt": "< ANY(%s)",
+            "gte": "<= ANY(%s)",
+            "lt": "> ANY(%s)",
+            "lte": ">= ANY(%s)",
+        }
+
+        def as_sql(self, compiler, connection):
+            # For the ANY() comparison, the filter operands need to be reversed.
+            # So instead of "field < value", it becomes "value > ANY(field)
+            lhs_sql, lhs_params = self.process_lhs(compiler, connection)
+            rhs_sql, rhs_params = self.process_rhs(compiler, connection)
+            lhs_sql = self.get_rhs_op(connection, lhs_sql)
+            return f"{rhs_sql} {lhs_sql}", (rhs_params + lhs_params)
+
+        def get_rhs_op(self, connection, rhs):
+            return self.any_operators[self.lookup_name] % rhs
+
+    def _register_any_lookup(base: type[lookups.BuiltinLookup]):
+        """Register array lookups under a different name."""
+        cls = type(f"FesArrayAny{base.__name__}", (ArrayAnyMixin, base), {})
+        ArrayField.register_lookup(cls, lookup_name=f"fes_any{base.lookup_name}")
+
+    _register_any_lookup(lookups.Exact)
+    _register_any_lookup(lookups.Exact)
+    _register_any_lookup(lookups.GreaterThan)
+    _register_any_lookup(lookups.GreaterThanOrEqual)
+    _register_any_lookup(lookups.LessThan)
+    _register_any_lookup(lookups.LessThanOrEqual)
+
+    @ArrayField.register_lookup
+    class FesArrayAnyNotEqual(lookups.Lookup):
+        """Inequality test for a single item in the array"""
+
+        lookup_name = "fes_anynotequal"
+
+        def as_sql(self, compiler, connection):
+            """Generate the required SQL."""
+            lhs, lhs_params = self.process_lhs(compiler, connection)
+            rhs, rhs_params = self.process_rhs(compiler, connection)
+            return f"{rhs} != ANY({lhs})", (rhs_params + lhs_params)
+
+    @ArrayField.register_lookup
+    class FesArrayLike(FesLike):
+        """Allow fieldname__fes_like=... lookups in querysets."""
+
+        lookup_name = "fes_anylike"
+
+        def as_sql(self, compiler, connection):
+            """Generate the required SQL."""
+            lhs, lhs_params = self.process_lhs(compiler, connection)  # = (table.field, %s)
+            rhs, rhs_params = self.process_rhs(compiler, connection)  # = ("prep-value", [])
+            return (
+                f"EXISTS(SELECT 1 FROM unnest({lhs}) AS item WHERE item LIKE {rhs})",  # noqa: S608
+                (lhs_params + rhs_params),
+            )