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

gisserver/parsers/fes20/identifiers.py

@@ -1,5 +1,11 @@
 """These classes map to the FES 2.0 specification for identifiers.
 The class names are identical to those in the FES spec.
+
+Inheritance structure:
+
+* :class:`Id`
+
+ * :class:`ResourceId`
 """
 
 from __future__ import annotations
@@ -11,16 +17,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 AstNode, 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 :class:`ResourceId` node."""
+
     FIRST = "FIRST"
     LAST = "LAST"
     ALL = "ALL"
@@ -28,13 +35,16 @@ class VersionActionTokens(Enum):
     PREVIOUS = "PREVIOUS"
 
 
-class Id(BaseNode):
-    """Abstract base class, as defined by FES spec."""
+class Id(AstNode):
+    """Abstract base class, as defined by FES spec.
+    Any custom identifier-element needs to extend from this node.
+    By default, the :class:`ResourceId` element is supported.
+    """
 
-    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 +53,47 @@ 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.
 
+    This parses the syntax::
+
+        <fes:ResourceId rid="typename.123" />
+
+    This element is placed inside a :class:`~gisserver.parsers.fes20.filters.Filter`.
+    """
+
+    #: A raw "resource identifier". It typically includes the object name,
+    #: which is completely unrelated to XML namespacing.
     rid: str
+
+    #: Internal extra attribute, referencing the inferred typename from the :attr:`rid`.
+    type_name: str | None
+
+    #: Unused, this is part of additional conformance classes.
     version: int | datetime | VersionActionTokens | NoneType = None
     startTime: datetime | None = None
     endTime: datetime | None = None
 
+    def get_type_name(self):
+        """Implemented/override to expose the inferred type name."""
+        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 +102,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,146 @@
+"""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):
+    """Allow ``fieldname__fes_beyond=...`` lookups in querysets.
+
+    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 like lookups for array fields."""
+
+        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),
+            )