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

gisserver/queries/base.py

@@ -1,186 +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
-
-from .projection import FeatureProjection
-
-
-class QueryExpression:
-    """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:`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: fes20.ValueReference | None = None
-    property_names: list[fes20.ValueReference] | None = None
-    projections: dict[FeatureType, FeatureProjection] | None = None
-
-    def bind(
-        self,
-        all_feature_types: dict[str, FeatureType],
-        value_reference: fes20.ValueReference | None = None,
-        property_names: list[fes20.ValueReference] | None = None,
-    ):
-        """Bind the query to presentation-layer logic (e.g. request parameters).
-
-        :param all_feature_types: Which features are queried.
-        :param value_reference: Which field is returned (by ``GetPropertyValue``)
-        :param property_name: Which field is returned (by ``GetFeature`` + propertyName parameter)
-        """
-        self.projections = {}
-        self.all_feature_types = all_feature_types
-        if value_reference is not None:
-            self.value_reference = value_reference
-        if property_names is not None:
-            self.property_names = property_names
-
-    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 a utility that custom 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`.
-        """
-        results = []
-        number_matched = 0
-        for feature_type in self.get_type_names():
-            queryset = self.get_queryset(feature_type)
-            number_matched += queryset.count()
-
-            # Include empty feature collections,
-            # so the selected feature types are still known.
-            results.append(
-                SimpleFeatureCollection(
-                    self, feature_type, queryset=queryset.none(), start=0, stop=0
-                )
-            )
-
-        return FeatureCollection(results=results, number_matched=number_matched)
-
-    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
-        results = [
-            # The querysets are not executed yet, until the output is reading them.
-            SimpleFeatureCollection(
-                self,
-                feature_type,
-                queryset=self.get_queryset(feature_type),
-                start=start_index,
-                stop=stop,
-            )
-            for feature_type in self.get_type_names()
-        ]
-
-        # 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 FeatureCollection(results=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 defined, limit which fields will be queried.
-        if self.property_names:
-            for property_name in self.property_names:
-                compiler.add_property_name(property_name)
-
-        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 get_projection(self, feature_type: FeatureType) -> FeatureProjection:
-        """Provide the projection of this query for a given feature.
-
-        NOTE: as the AdhocQuery has a typeNames (plural!) argument,
-        this class still needs to check per feature type which fields to apply to.
-        """
-        try:
-            return self.projections[feature_type]
-        except KeyError:
-            projection = FeatureProjection(feature_type, self.property_names)
-            self.projections[feature_type] = projection
-            return projection
-
-    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/projection.py

@@ -1,240 +0,0 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from dataclasses import dataclass
-from functools import cached_property
-from typing import cast
-
-from django.db import models
-
-from gisserver.features import FeatureType
-from gisserver.parsers import fes20
-from gisserver.types import GmlElement, XPathMatch, XsdElement, _XsdElement_WithComplexType
-
-
-class FeatureProjection:
-    """Tell which fields to access and render for a single feature.
-    This is inspired on 'fes:AbstractProjectionClause'.
-
-    Instead of walking over the full XSD object tree,
-    this object wraps that and makes sure only the actual requested fields are used.
-    When a PROPERTYNAME is used in the request, this will limit
-    which fields to retrieve, which to prefetch, and which to render.
-    """
-
-    feature_type: FeatureType
-
-    def __init__(self, feature_type: FeatureType, property_names: list[fes20.ValueReference]):
-        self.feature_type = feature_type
-        self.property_names = property_names
-
-        if property_names:
-            # Discover which elements should be rendered.
-            child_nodes = self._get_child_nodes_subset()
-            self.xsd_root_elements = child_nodes.pop(None)  # Pop it to avoid recursion risks
-            self.xsd_child_nodes = child_nodes
-        else:
-            # Retrieve all elements.
-            self.xsd_root_elements = feature_type.xsd_type.all_elements
-            self.xsd_child_nodes = feature_type.xsd_type.elements_with_children
-
-    def _get_child_nodes_subset(self) -> dict[XsdElement | None, list[XsdElement]]:
-        """Translate the PROPERTYNAME into a dictionary of nodes to render."""
-        child_nodes = defaultdict(list)
-        for xpath_match in self.xpath_matches:
-            # Make sure the tree is known beforehand, and it has no duplicate parent nodes.
-            # (e.g. PROPERTYNAME=node/child1,node/child2)
-            parent = None
-            for xsd_node in xpath_match.nodes:
-                if xsd_node not in child_nodes[parent]:
-                    child_nodes[parent].append(xsd_node)
-                parent = xsd_node
-
-        return dict(child_nodes)
-
-    def add_field(self, xsd_element: XsdElement):
-        """Restore the retrieval of a field that was not asked for in the original query."""
-        if not self.property_names:
-            return
-        if xsd_element.type.is_complex_type:
-            raise NotImplementedError("Can't restore nested elements right now")
-
-        # For now, add to all cached properties:
-        # TODO: have a better approach?
-        self.xsd_root_elements.append(xsd_element)
-        if xsd_element.is_geometry:
-            self.geometry_elements.append(xsd_element)
-
-        if xsd_element.orm_path not in self.only_fields:
-            self.only_fields.append(xsd_element.orm_path)
-
-        if xsd_element.is_flattened:
-            self.flattened_elements.append(xsd_element)
-
-    @cached_property
-    def xpath_matches(self) -> list[XPathMatch]:
-        """Resolve which elements the property names point to"""
-        if not self.property_names:
-            raise RuntimeError("This method is only useful for propertyname projections.")
-
-        return [
-            self.feature_type.resolve_element(property_name.xpath)
-            for property_name in self.property_names
-        ]
-
-    @cached_property
-    def geometry_elements(self) -> list[GmlElement]:
-        """Tell which GML elements will be hit."""
-        gml_elements = []
-        for e in self.xsd_root_elements:
-            if e.is_geometry and e.xml_name != "gml:boundedBy":
-                # Prefetching a flattened relation
-                gml_elements.append(e)
-
-        for xsd_children in self.xsd_child_nodes.values():
-            for e in xsd_children:
-                if e.is_geometry and e.xml_name != "gml:boundedBy":
-                    gml_elements.append(e)
-
-        return gml_elements
-
-    @cached_property
-    def complex_elements(self) -> list[_XsdElement_WithComplexType]:
-        """Shortcut to get all elements with a complex type"""
-        if not self.property_names:
-            return self.feature_type.xsd_type.complex_elements
-        else:
-            return [e for e in self.xsd_root_elements if e.type.is_complex_type]
-
-    @cached_property
-    def flattened_elements(self) -> list[XsdElement]:
-        """Shortcut to get all elements with a flattened model attribute"""
-        if not self.property_names:
-            return self.feature_type.xsd_type.flattened_elements
-        else:
-            return [e for e in self.xsd_root_elements if e.is_flattened]
-
-    @cached_property
-    def main_geometry_element(self) -> GmlElement | None:
-        """Return the field used to describe the geometry of the feature.
-        When the projection excludes the geometry, ``None`` is returned.
-        """
-        main_field = self.feature_type.geometry_field
-        if self.property_names and main_field not in self.xsd_root_elements:
-            return None
-
-        xpath_match = self.feature_type.resolve_element(main_field)
-        return cast(GmlElement, xpath_match.child)
-
-    @cached_property
-    def orm_relations(self) -> list[FeatureRelation]:
-        """Tell which fields will be retrieved from related fields.
-
-        This gives an object layout based on the XSD elements,
-        that can be used for prefetching data.
-        """
-        related_models: dict[str, type[models.Model]] = {}
-        fields: dict[str, set[XsdElement]] = defaultdict(set)
-        elements = defaultdict(list)
-
-        # Check all elements that render as "dotted" flattened relation
-        for xsd_element in self.flattened_elements:
-            if xsd_element.source is not None:
-                # Split "relation.field" notation into path, and take the field as child attribute.
-                obj_path, field = xsd_element.orm_relation
-                elements[obj_path].append(xsd_element)
-                fields[obj_path].add(xsd_element)
-                # field is already on relation:
-                related_models[obj_path] = xsd_element.source.model
-
-        # Check all elements that render as "nested" complex type:
-        for xsd_element in self.complex_elements:
-            # The complex element itself points to the root of the path,
-            # all sub elements become the child attributes.
-            obj_path = xsd_element.orm_path
-            elements[obj_path].append(xsd_element)
-            fields[obj_path] = {
-                f
-                for f in self.xsd_child_nodes[xsd_element]
-                if not f.is_many or f.is_array  # exclude M2M, but include ArrayField
-            }
-            if xsd_element.source:
-                # field references a related object:
-                related_models[obj_path] = xsd_element.source.related_model
-
-        return [
-            FeatureRelation(
-                orm_path=obj_path,
-                sub_fields=sub_fields,
-                related_model=related_models.get(obj_path),
-                xsd_elements=elements[obj_path],
-            )
-            for obj_path, sub_fields in fields.items()
-        ]
-
-    @cached_property
-    def only_fields(self) -> list[str]:
-        """Tell which fields to limit the queryset to.
-        This excludes M2M fields because those are not part of the local model data.
-        """
-        if self.property_names is not None:
-            return [
-                # TODO: While ORM rel__child paths can be passed to .only(),
-                # these may not be accurately applied to foreign keys yet.
-                # Also, this is bypassed by our generated Prefetch() objects.
-                xpath_match.orm_path
-                for xpath_match in self.xpath_matches
-                if not xpath_match.is_many or xpath_match.child.is_array
-            ]
-        else:
-            # Also limit the queryset to the actual fields that are shown.
-            # No need to request more data
-            return [
-                f.orm_field
-                for f in self.feature_type.xsd_type.elements
-                if not f.is_many or f.is_array  # avoid M2M fields for .only(), but keep ArrayField
-            ]
-
-
-@dataclass
-class FeatureRelation:
-    """Tell which related fields are queried by the feature.
-    Each dict holds an ORM-path, with the relevant sub-elements.
-    """
-
-    #: The ORM path that is queried for this particular relation
-    orm_path: str
-    #: The fields that will be retrieved for that path (limited by the projection)
-    sub_fields: set[XsdElement]
-    #: The model that is accessed for this relation (if set)
-    related_model: type[models.Model] | None
-    #: The source elements that access this relation.
-    xsd_elements: list[XsdElement]
-
-    @cached_property
-    def _local_model_field_names(self) -> list[str]:
-        """Tell which local fields of the model will be accessed by this feature."""
-        result = []
-        for field in self.sub_fields:
-            model_field = field.source
-            if not model_field.many_to_many and not model_field.one_to_many:
-                result.append(model_field.name)
-
-        result.extend(self._local_backlink_field_names)
-        return result
-
-    @property
-    def _local_backlink_field_names(self) -> list[str]:
-        # When this relation is retrieved through a ManyToOneRel (reverse FK),
-        # the prefetch_related() also needs to have the original foreign key
-        # in order to link all prefetches to the proper parent instance.
-        return [
-            xsd_element.source.field.name
-            for xsd_element in self.xsd_elements
-            if xsd_element.source is not None and xsd_element.source.one_to_many
-        ]
-
-    @property
-    def geometry_elements(self) -> list[GmlElement]:
-        """Tell which geometry elements this relation will access."""
-        return [f for f in self.sub_fields if f.is_geometry and f.name != "gml:boundedBy"]

gisserver/queries/stored.py

@@ -1,206 +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(
-                    f"Stored query {cls.meta.id} requires an '{name}' parameter", locator=name
-                ) 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(
-                    "Stored query can't be combined with adhoc-query parameters", locator=name
-                )
-
-        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(
-                f"Stored query does not exist: {query_id}",
-                locator="STOREDQUERY_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("Expected typeName.id for ID parameter", locator="ID") 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(f"Invalid ID value: {e}", locator="ID") 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(f"Feature not found with ID {self.id}.", locator="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>