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

gisserver/queries/base.py

@@ -1,146 +0,0 @@
-from __future__ import annotations
-
-from django.db.models import QuerySet
-
-from gisserver.exceptions import InvalidParameterValue
-from gisserver.features import FeatureType
-from gisserver.output import FeatureCollection, SimpleFeatureCollection
-from gisserver.parsers import fes20
-from gisserver.types import split_xml_name
-
-
-class QueryExpression:
-    """WFS base class for all queries.
-    This object type is defined in the WFS spec (as <fes:AbstractQueryExpression>).
-
-    The subclasses can override the following logic:
-
-    * :meth:`get_type_names` defines which types this query applies to.
-    * :meth:`compile_query` defines how to filter the queryset.
-
-    For full control, these methods can also be overwritten instead:
-
-    * :meth:`get_queryset` defines the full results.
-    * :meth:`get_hits` to return the collection for RESULTTYPE=hits.
-    * :meth:`get_results` to return the collection for RESULTTYPE=results
-    """
-
-    handle = ""
-    value_reference = None
-
-    def bind(
-        self,
-        all_feature_types: dict[str, FeatureType],
-        value_reference: fes20.ValueReference | None,
-    ):
-        """Bind the query to presentation-layer logic"""
-        self.all_feature_types = all_feature_types
-        self.value_reference = value_reference
-
-    def check_permissions(self, request):
-        """Verify whether the user has access to view these data sources"""
-        for feature_type in self.get_type_names():
-            feature_type.check_permissions(request)
-
-    def resolve_type_name(self, type_name, locator="typename") -> FeatureType:
-        """Find the feature type for a given name.
-        This is an utility that cusstom subclasses can use.
-        """
-        # Strip the namespace prefix. The Python ElementTree parser does
-        # not expose the used namespace prefixes, so text-values can't be
-        # mapped against it. As we expose just one namespace, just strip it.
-        xmlns, type_name = split_xml_name(type_name)
-
-        try:
-            return self.all_feature_types[type_name]
-        except KeyError:
-            raise InvalidParameterValue(
-                locator, f"Typename '{type_name}' doesn't exist in this server."
-            ) from None
-
-    def get_hits(self) -> FeatureCollection:
-        """Run the query, return the number of hits only.
-
-        Override this method in case you need full control over the response data.
-        Otherwise, override :meth:`compile_query` or :meth:`get_queryset`.
-        """
-        querysets = self.get_querysets()
-        return FeatureCollection(
-            results=[
-                # Include empty feature collections,
-                # so the selected feature types are still known.
-                SimpleFeatureCollection(feature_type=ft, queryset=qs.none(), start=0, stop=0)
-                for ft, qs in querysets
-            ],
-            number_matched=sum(qs.count() for ft, qs in querysets),
-        )
-
-    def get_results(self, start_index=0, count=100) -> FeatureCollection:
-        """Run the query, return the full paginated results.
-
-        Override this method in case you need full control over the response data.
-        Otherwise, override :meth:`compile_query` or :meth:`get_queryset`.
-        """
-        stop = start_index + count
-
-        # The querysets are not executed yet, until the output is reading them.
-        querysets = self.get_querysets()
-        return FeatureCollection(
-            results=[
-                SimpleFeatureCollection(feature_type, qs, start=start_index, stop=stop)
-                for feature_type, qs in querysets
-            ]
-        )
-
-    def get_querysets(self) -> list[tuple[FeatureType, QuerySet]]:
-        """Construct the querysets that return the database results."""
-        results = []
-        for feature_type in self.get_type_names():
-            queryset = self.get_queryset(feature_type)
-            results.append((feature_type, queryset))
-
-        return results
-
-    def get_queryset(self, feature_type: FeatureType) -> 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:`compile_query` instead of simple data.
-        """
-        queryset = feature_type.get_queryset()
-
-        # Apply filters
-        compiler = self.compile_query(feature_type, using=queryset.db)
-
-        if self.value_reference is not None:
-            if feature_type.resolve_element(self.value_reference.xpath) is None:
-                raise InvalidParameterValue(
-                    "valueReference",
-                    f"Field '{self.value_reference.xpath}' does not exist.",
-                )
-
-            # 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.
-            field = compiler.add_value_reference(self.value_reference)
-            queryset = compiler.filter_queryset(queryset, feature_type=feature_type)
-            return queryset.values("pk", member=field)
-        else:
-            return compiler.filter_queryset(queryset, feature_type=feature_type)
-
-    def get_type_names(self) -> list[FeatureType]:
-        """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 compile_query(self, feature_type: FeatureType, using=None) -> fes20.CompiledQuery:
-        """Define the compiled query that filters the queryset.
-
-        Subclasses need to define this method, unless
-        :meth:`get_queryset` is completely overwritten.
-        """
-        raise NotImplementedError()

gisserver/queries/stored.py

@@ -1,205 +0,0 @@
-"""Handle (stored)query objects.
-
-These definitions follow the WFS spec.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from django.db.models import Q, QuerySet
-
-from gisserver.exceptions import InvalidParameterValue, MissingParameterValue, NotFound
-from gisserver.features import FeatureType
-from gisserver.operations.base import Parameter
-from gisserver.output import FeatureCollection
-from gisserver.parsers import fes20
-from gisserver.types import XsdTypes
-
-from .base import QueryExpression
-
-
-class QueryExpressionText:
-    """Define the body of a stored query.
-
-    This object type is defined in the WFS spec.
-    It may contain a wfs:Query or wfs:StoredQuery element.
-    """
-
-    return_feature_types: list[str] | None = None
-    language: str = fes20.Filter.query_language
-    is_private: bool = False
-
-
-@dataclass
-class StoredQueryDescription:
-    """WFS metadata of a stored query.
-    This object type is defined in the WFS spec.
-    """
-
-    id: str = None
-    title: str | None = None
-    abstract: str | None = None
-    parameters: dict[str, XsdTypes] | None = None
-    expressions: list = None  # TODO: support multiple body expressions
-
-
-class StoredQuery(QueryExpression):
-    """Base class for stored queries.
-
-    This represents all predefined queries on the server.
-    A good description can be found at:
-    https://mapserver.org/ogc/wfs_server.html#stored-queries-wfs-2-0
-
-    The implementation logic is fully defined by the :class:`QueryExpression`
-    base class. For a simple implementation, the following data should be
-    overwritten:
-
-    * :meth:`get_type_names` to define which type this query references.
-    * :meth:`compile_query` to define the queryset filter.
-
-    For advanced overriding, see the :class:`QueryExpression` base class,
-    or the :class:`GetFeatureById` implementation.
-    """
-
-    # Official WFS docs have an 'id' and 'parameters' property for the
-    # StoredQuery class, but these are avoided here to give subclasses full
-    # control over which properties to store. E.g. "id" conflicts with Django
-    # model subclasses that stores the query.
-    meta: StoredQueryDescription
-
-    def __init__(self, **parameters):
-        self.parameters = parameters
-
-    @classmethod
-    def extract_parameters(cls, KVP) -> dict[str, str]:
-        """Extract the arguments from the key-value-pair (=HTTP GET) request."""
-        args = {}
-        for name, _xsd_type in cls.meta.parameters.items():
-            try:
-                args[name] = KVP[name]
-            except KeyError:
-                raise MissingParameterValue(
-                    name, f"Stored query {cls.meta.id} requires an '{name}' parameter"
-                ) from None
-
-        # Avoid unexpected behavior, check whether the client also sends adhoc query parameters
-        for name in ("filter", "bbox", "resourceID"):
-            if name not in args and KVP.get(name.upper()):
-                raise InvalidParameterValue(
-                    name, "Stored query can't be combined with adhoc-query parameters"
-                )
-
-        return args
-
-
-class StoredQueryRegistry:
-    """Registry of functions to be callable by <fes:Query>."""
-
-    def __init__(self):
-        self.stored_queries = {}
-
-    def __bool__(self):
-        return bool(self.stored_queries)
-
-    def __iter__(self):
-        return iter(self.stored_queries.values())
-
-    def register(self, meta: StoredQueryDescription | None = None, **meta_kwargs):
-        """Register a custom class that handles a stored query"""
-
-        def _metadata_dec(query: type[StoredQuery]):
-            query.meta = meta or StoredQueryDescription(**meta_kwargs)
-            self.stored_queries[query.meta.id] = query
-            return query
-
-        return _metadata_dec
-
-    def resolve_query(self, query_id) -> type[StoredQuery]:
-        """Find the stored procedure using the ID."""
-        try:
-            return self.stored_queries[query_id]
-        except KeyError:
-            raise InvalidParameterValue(
-                "STOREDQUERY_ID", f"Stored query does not exist: {query_id}"
-            ) from None
-
-
-stored_query_registry = StoredQueryRegistry()
-
-
-class StoredQueryParameter(Parameter):
-    """Special parameter parsing for the 'STOREDQUERY_ID' parameter"""
-
-    def __init__(self):
-        super().__init__(name="STOREDQUERY_ID", parser=stored_query_registry.resolve_query)
-
-    def value_from_query(self, KVP: dict):
-        """Customize the request parsing to read custom parameters too."""
-        stored_query_class = super().value_from_query(KVP)
-        if stored_query_class is None:
-            return None
-
-        parameters = stored_query_class.extract_parameters(KVP)
-        return stored_query_class(**parameters)
-
-
-@stored_query_registry.register(
-    id="urn:ogc:def:query:OGC-WFS::GetFeatureById",
-    title="Get feature by identifier",
-    abstract="Returns the single feature that corresponds with the ID argument",
-    parameters={"ID": XsdTypes.string},
-    # expressions=[QueryExpressionText],
-)
-class GetFeatureById(StoredQuery):
-    """The stored query for GetFeatureById.
-
-    This is essentially the same as:
-
-    <wfs:Query xmlns:wfs='..." xmlns:fes='...'>
-        <fes:Filter><fes:ResourceId rid='{ID}'/></fes:Filter>
-    </wfs:Query>
-
-    Except that the response is supposed to contain only the item itself.
-    """
-
-    def __init__(self, ID):
-        super().__init__(ID=ID)
-        try:
-            type_name, id = ID.rsplit(".", 1)
-        except ValueError:
-            # Always report this as 404
-            raise NotFound("ID", "Expected typeName.id for ID parameter") from None
-
-        self.type_name = type_name
-        self.id = id
-
-    def get_type_names(self) -> list[FeatureType]:
-        """Tell which type names this query applies to."""
-        feature_type = self.all_feature_types[self.type_name]
-        return [feature_type]
-
-    def get_queryset(self, feature_type: FeatureType) -> QuerySet:
-        """Override to implement ID type checking."""
-        try:
-            return super().get_queryset(feature_type)
-        except (ValueError, TypeError) as e:
-            raise InvalidParameterValue("ID", f"Invalid ID value: {e}") from e
-
-    def get_results(self, *args, **kwargs) -> FeatureCollection:
-        """Override to implement 404 checking."""
-        collection = super().get_results(*args, **kwargs)
-
-        # Directly attempt to collect the data.
-        # Avoid having to do that in the output renderer.
-        if collection.results[0].first() is None:
-            # WFS 2.0.2: Return NotFound instead of InvalidParameterValue
-            raise NotFound("ID", f"Feature not found with ID {self.id}.")
-
-        return collection
-
-    def compile_query(self, feature_type: FeatureType, using=None) -> fes20.CompiledQuery:
-        """Create the internal query object that will be applied to the queryset."""
-        compiler = fes20.CompiledQuery(feature_type=feature_type)
-        compiler.add_lookups(Q(pk=self.id), type_name=self.type_name)
-        return compiler

gisserver/templates/gisserver/wfs/2.0.0/describe_stored_queries.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<wfs:DescribeStoredQueriesResponse
-    xmlns="http://www.opengis.net/wfs/2.0"
-    xmlns:app="{{ app_xml_namespace }}"
-    xmlns:wfs="http://www.opengis.net/wfs/2.0"
-    xmlns:xs="http://www.w3.org/2001/XMLSchema"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://www.opengis.net/wfs/2.0 http://schemas.opengis.net/wfs/2.0/wfs.xsd">
-
-{% for query_meta in stored_queries %}
-  <StoredQueryDescription id="{{ query_meta.id }}">
-    <Title>{{ query_meta.title }}</Title>
-    <Abstract>{{ query_meta.abstract }}</Abstract>
-    {% for name, type in query_meta.parameters.items %}
-    <Parameter name="{{ name }}" type="{{ type.with_prefix }}"/>{% endfor %}
-    <QueryExpressionText isPrivate="true" language="urn:ogc:def:queryLanguage:OGC-WFS::WFS_QueryExpression" returnFeatureTypes="{% for feature in feature_types %}{% if not forloop.first %} {% endif %}{{ feature.name }}{% endfor %}"/>
-  </StoredQueryDescription>
-{% endfor %}
-
-</wfs:DescribeStoredQueriesResponse>

gisserver/templates/gisserver/wfs/2.0.0/list_stored_queries.xml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<wfs:ListStoredQueriesResponse
-    xmlns="http://www.opengis.net/wfs/2.0"
-    xmlns:app="{{ app_xml_namespace }}"
-    xmlns:wfs="http://www.opengis.net/wfs/2.0"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://www.opengis.net/wfs/2.0 http://schemas.opengis.net/wfs/2.0/wfs.xsd">
-
-  <StoredQuery id="urn:ogc:def:query:OGC-WFS::GetFeatureById">
-    <Title>Get feature by identifier</Title>{% for feature_type in feature_types %}
-    <ReturnFeatureType>{{ feature_type.name }}</ReturnFeatureType>{% endfor %}
-  </StoredQuery>
-
-</wfs:ListStoredQueriesResponse>