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

gisserver/parsers/ows/kvp.py

@@ -105,7 +105,9 @@ class KVPRequest:
     def split_parameter_lists(self) -> list[KVPRequest]:
         """Split the parameter lists into individual requests.
 
-        This translates a request such as::
+        This translates a request such as:
+
+        .. code-block:: urlencoded
 
             TYPENAMES=(ns1:F1,ns2:F2)(ns1:F1,ns1:F1)
             &ALIASES=(A,B)(C,D)
@@ -113,15 +115,21 @@ class KVPRequest:
 
         into separate pairs:
 
+        .. code-block:: urlencoded
+
             TYPENAMES=ns1:F1,ns2:F2&ALIASES=A,B&FILTER=<Filter>…for A,B…</Filter>
             TYPENAMES=ns1:F1,ns1:F1&ALIASES=C,D&FILTER=<Filter>…for C,D…</Filter>
 
         It's both possible have some query parameters split and some shared.
         For example to have two different bounding boxes:
 
+        .. code-block:: urlencoded
+
              TYPENAMES=(INWATER_1M)(BuiltUpA_1M)&BBOX=(40.9821,...)(40.5874,...)
 
-        or have a single bounding box for both queries::
+        or have a single bounding box for both queries:
+
+        .. code-block:: urlencoded
 
              TYPENAMES=(INWATER_1M)(BuiltUpA_1M)&BBOX=40.9821,23.4948,41.0257,23.5525
         """

gisserver/parsers/ows/requests.py

@@ -13,7 +13,7 @@ from gisserver.exceptions import (
     OperationNotSupported,
     OperationParsingFailed,
 )
-from gisserver.parsers.ast import BaseNode, tag_registry
+from gisserver.parsers.ast import AstNode, tag_registry
 from gisserver.parsers.xml import NSElement, parse_xml_from_string, split_ns, xmlns
 
 from .kvp import KVPRequest
@@ -28,7 +28,7 @@ __all__ = (
 
 
 @dataclass
-class BaseOwsRequest(BaseNode):
+class BaseOwsRequest(AstNode):
     """Base request data for all request types of the OWS standards.
     This mirrors the ``<wfs:BaseRequestType>`` element from the WFS spec.
     """
@@ -80,7 +80,7 @@ class BaseOwsRequest(BaseNode):
         return {
             "SERVICE": self.service,
             "VERSION": str(self.version),
-            "REQUEST": split_ns(self.xml_tags[0])[1],
+            "REQUEST": split_ns(self.xml_name)[1],
         }
 
 
@@ -118,7 +118,9 @@ def resolve_kvp_parser_class(kvp: KVPRequest) -> type[BaseOwsRequest]:
     try:
         request_cls = request_classes[request.upper()]
     except KeyError:
-        allowed = ", ".join(node.xml_tags[0] for node in request_classes.values())
+        allowed = ", ".join(
+            xml_tag for node in request_classes.values() for xml_tag in node.get_tag_names()
+        )
         raise OperationNotSupported(
             f"'{request}' is not implemented, supported are: {allowed}.",
             locator="request",

gisserver/parsers/query.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import logging
 import operator
 from datetime import date, datetime
+from decimal import Decimal as D
 from functools import reduce
 from typing import Union
 
@@ -16,14 +17,15 @@ from django.db.models.expressions import Combinable, Func
 from gisserver.features import FeatureType
 
 logger = logging.getLogger(__name__)
-RhsTypes = Union[Combinable, Func, Q, GEOSGeometry, bool, int, str, date, datetime, tuple]
+ScalarTypes = (bool, int, str, D, date, datetime)  # Not Union for Python 3.9
+RhsTypes = Union[Combinable, Func, Q, GEOSGeometry, bool, int, D, str, date, datetime, tuple]
 
 
 class CompiledQuery:
     """Intermediate data for translating FES queries to Django.
 
     This class effectively contains all data from the ``<fes:Filter>`` object,
-    but using a format that can be translated to a django QuerySet.
+    but using a format that can be translated to a Django QuerySet.
 
     As the Abstract Syntax Tree of a FES-filter creates the ORM query,
     it fills this object with all intermediate bits. This allows building
@@ -64,6 +66,7 @@ class CompiledQuery:
         return name
 
     def add_distinct(self):
+        """Enforce "SELECT DISTINCT" on the query, used when joining 1-N or N-M relationships."""
         self.distinct = True
 
     def add_lookups(self, q_object: Q, type_name: str | None = None):
@@ -87,6 +90,7 @@ class CompiledQuery:
         """
         if not isinstance(q_object, Q):
             raise TypeError()
+        # Note the ORM also provides a FilteredRelation() option, that is not explored yet here.
         self.extra_lookups.append(q_object)
 
     def add_ordering(self, ordering: list[str]):

gisserver/parsers/values.py

@@ -1,9 +1,11 @@
+"""Parsing of scalar values in the request."""
+
 import logging
 import re
-from datetime import datetime
+from datetime import date, datetime, time
 from decimal import Decimal as D
 
-from django.utils.dateparse import parse_datetime
+from django.utils.dateparse import parse_date, parse_datetime, parse_duration, parse_time
 
 from gisserver.exceptions import ExternalParsingError
 
@@ -12,7 +14,15 @@ RE_FLOAT = re.compile(r"\A[0-9]+(\.[0-9]+)\Z")
 
 
 def auto_cast(value: str):
-    """Automatically cast a value to a scalar."""
+    """Automatically cast a value to a scalar.
+
+    This recognizes integers, floats and ISO datetimes.
+    Booleans are not handled, as that leads to unpredictable behavior
+    (as seen in Yaml for example).
+    """
+    if not isinstance(value, str):
+        return value
+
     if value.isdigit():
         return int(value)
     elif RE_FLOAT.match(value):
@@ -26,14 +36,61 @@ def auto_cast(value: str):
     return value
 
 
+def parse_iso_date(raw_value: str) -> date:
+    """Translate ISO date into a Python date value."""
+    try:
+        value = parse_date(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
+    if value is None:
+        raise ExternalParsingError("Date must be in YYYY-MM-DD format.")
+    return value
+
+
 def parse_iso_datetime(raw_value: str) -> datetime:
-    value = parse_datetime(raw_value)
+    """Translate ISO datetimes into a Python datetime value."""
+    try:
+        value = parse_datetime(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
     if value is None:
         raise ExternalParsingError("Date must be in YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format.")
     return value
 
 
+def parse_iso_time(raw_value: str) -> time:
+    """Translate ISO times into a Python time value."""
+    try:
+        value = parse_time(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
+    if value is None:
+        raise ExternalParsingError("Time must be in HH:MM[:ss[.uuuuuu]][TZ] format.")
+    return value
+
+
+def parse_iso_duration(raw_value: str) -> time:
+    """Translate ISO times into a Python time value."""
+    # The parse_duration() supports multiple formats, including ISO8601.
+    # Limit it to only one format.
+    if not raw_value.startswith(("P", "-P")):
+        raise ExternalParsingError("Duration must be in ISO8601 format (e.g. PT1H).")
+
+    try:
+        value = parse_duration(raw_value)
+    except ValueError as e:
+        raise ExternalParsingError(str(e)) from e
+
+    if value is None:
+        raise ExternalParsingError("Duration must be in ISO8601 format (e.g. PT1H).")
+    return value
+
+
 def parse_bool(raw_value: str):
+    """Translate XML notations of true/1 and false/0 into a boolean."""
     if raw_value in ("true", "1"):
         return True
     elif raw_value in ("false", "0"):

gisserver/parsers/wfs20/__init__.py

@@ -1,5 +1,7 @@
 """WFS 2.0 element parsing.
 
+These classes parse the XML request body.
+
 The full spec can be found at: https://www.ogc.org/publications/standard/wfs/.
 Secondly, using https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/wfs_xsd.html can be very
 helpful to see which options each object type should support.

gisserver/parsers/wfs20/adhoc.py

@@ -14,12 +14,12 @@ from functools import cached_property
 
 from django.db.models import Q
 
+from gisserver.crs import CRS
 from gisserver.exceptions import (
     InvalidParameterValue,
     MissingParameterValue,
     OperationNotSupported,
 )
-from gisserver.geometries import CRS
 from gisserver.parsers import fes20
 from gisserver.parsers.ast import tag_registry
 from gisserver.parsers.ows import KVPRequest
@@ -59,7 +59,7 @@ class AdhocQuery(QueryExpression):
 
     The WFS Spec has 3 class levels for this:
 
-    - AdhocQueryExpression (types, projection, selection, sorting)
+     - AdhocQueryExpression (types, projection, selection, sorting)
      - Query (adds srsName, featureVersion)
      - StoredQuery (adds storedQueryID)
 
@@ -71,25 +71,31 @@ class AdhocQuery(QueryExpression):
         https://www.mediamaps.ch/ogc/schemas-xsdoc/sld/1.2/query_xsd.html#AbstractAdhocQueryExpressionType
     """
 
-    # Tag attributes (fes:AbstractAdhocQueryExpression)
+    # Tag attributes (implements ``fes:AbstractAdhocQueryExpression``)
     # WFS allows multiple names to construct JOIN queries.
     # See https://docs.ogc.org/is/09-025r2/09-025r2.html#107
     # and https://docs.ogc.org/is/09-025r2/09-025r2.html#190
-    typeNames: list[str]  # typeNames in WFS/FES spec, multiple values means a JOIN is made.
-    aliases: list[str] | None = None  # aliases for typeNames for joining the same table twice.
-    handle: str = ""  # only for XML POST requests, is returned in ows:Exception
-    # Query tag attributes
+
+    #: The 'typeNames' value if the request provided them. use :meth:`get_type_names` instead.
+    typeNames: list[str]
+    #: Aliases for typeNames are used for joining the same table twice. (JOIN statements are not supported yet).
+    aliases: list[str] | None = None
+    #: For XML POST requests, this handle value is returned in the ``<ows:Exception>``.
+    handle: str = ""
+
+    # part of the <wfs:Query> tag attributes:
+    #: The Coordinate Reference System to render the tag in
     srsName: CRS | None = None
 
-    # Projection clause (fes:AbstractProjectionClause)
+    #: Projection clause (implements ``fes:AbstractProjectionClause``)
     property_names: list[PropertyName] | None = None
 
-    # Selection clause (fes:AbstractSelectionClause):
-    # - for XML POST this is encoded in a <fes:Query>
-    # - for HTTP GET, this is encoded as FILTER, FILTER_LANGUAGE, RESOURCEID, BBOX.
+    #: Selection clause (implements ``fes:AbstractSelectionClause``).
+    #: - for XML POST this is encoded in a <fes:Filter> tag.
+    #: - for HTTP GET, this is encoded as FILTER, FILTER_LANGUAGE, RESOURCEID, BBOX.
     filter: fes20.Filter | None = None
 
-    # Sorting Clause (fes:AbstractSortingClause)
+    #: Sorting Clause (implements ``fes:AbstractSortingClause``)
     sortBy: fes20.SortBy | None = None
 
     def __post_init__(self):
@@ -188,7 +194,9 @@ class AdhocQuery(QueryExpression):
             return "filter"
 
     def get_type_names(self) -> list[str]:
-        """Tell which type names this query uses."""
+        """Tell which type names this query uses.
+        Multiple values means a JOIN is made (not supported yet).
+        """
         if not self.typeNames and self.filter is not None:
             # Also make the behavior consistent, always supply the type name.
             return self.filter.get_resource_id_types() or []
@@ -196,7 +204,7 @@ class AdhocQuery(QueryExpression):
             return self.typeNames
 
     def get_projection(self) -> FeatureProjection:
-        """Tell how the <wfs:Query> element should be displayed."""
+        """Tell how the ``<wfs:Query>`` element should be displayed."""
         return FeatureProjection(
             self.feature_types,
             self.property_names,
@@ -205,7 +213,7 @@ class AdhocQuery(QueryExpression):
         )
 
     def bind(self, *args, **kwargs):
-        """Make sure the 'locator' points to the actual object that defined the type."""
+        """Override to make sure the 'locator' points to the actual object that defined the type."""
         try:
             super().bind(*args, **kwargs)
         except InvalidParameterValue as e:
@@ -219,7 +227,7 @@ class AdhocQuery(QueryExpression):
 
     def build_query(self, compiler: CompiledQuery) -> Q | None:
         """Apply our collected filter data to the compiler."""
-        # Add the
+        # Add the sorting
         if self.sortBy is not None:
             self.sortBy.build_ordering(compiler)
 
@@ -230,7 +238,7 @@ class AdhocQuery(QueryExpression):
         else:
             return None
 
-    def as_kvp(self):
+    def as_kvp(self) -> dict:
         """Translate the POST request into KVP GET parameters. This is needed for pagination."""
         params = super().as_kvp()
         params["TYPENAMES"] = ",".join(self.typeNames)

gisserver/parsers/wfs20/base.py

@@ -23,12 +23,12 @@ from gisserver.exceptions import (
 )
 from gisserver.features import FeatureType
 from gisserver.parsers import fes20, wfs20
-from gisserver.parsers.ast import BaseNode
+from gisserver.parsers.ast import AstNode
 from gisserver.parsers.query import CompiledQuery
 from gisserver.projection import FeatureProjection
 
 
-class QueryExpression(BaseNode):
+class QueryExpression(AstNode):
     """WFS base class for all queries.
     This object type is defined in the WFS spec (as ``<fes:AbstractQueryExpression>``).
 
@@ -47,16 +47,20 @@ class QueryExpression(BaseNode):
     * :meth:`get_queryset` defines the full results.
     """
 
+    #: Configuration for the 'locator' argument in exceptions
     query_locator: ClassVar[str] = None
 
     # QueryExpression
+    #: The 'handle' that will be returned in exceptions.
     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.
+    #: 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
+
+    #: The valueReference for the GetPropertyValue call, provided here for extra ORM filtering.
+    value_reference: fes20.ValueReference | None = None
 
     def bind(
         self,
@@ -120,6 +124,7 @@ class QueryExpression(BaseNode):
 
     def get_type_names(self) -> list[str]:
         """Tell which type names this query applies to.
+        Multiple values means a JOIN is made (not supported yet).
 
         This method needs to be defined in subclasses.
         """
@@ -135,7 +140,7 @@ class QueryExpression(BaseNode):
         """Define the compiled query that filters the queryset."""
         raise NotImplementedError()
 
-    def as_kvp(self):
+    def as_kvp(self) -> dict:
         """Translate the POST request into KVP GET parameters. This is needed for pagination."""
         params = {}
         if self.property_names:

gisserver/parsers/wfs20/projection.py

@@ -10,14 +10,14 @@ from gisserver.exceptions import (
     OperationParsingFailed,
     OperationProcessingFailed,
 )
-from gisserver.parsers.ast import BaseNode, tag_registry
+from gisserver.parsers.ast import AstNode, 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`."""
+    """The ``wfs:ResolveValueType`` enum, used by :class:`StandardResolveParameters`."""
 
     local = "local"
     remote = "remote"
@@ -31,7 +31,7 @@ class ResolveValue(Enum):
 
 @dataclass
 @tag_registry.register("PropertyName", xmlns.wfs)
-class PropertyName(BaseNode):
+class PropertyName(AstNode):
     """The ``<wfs:PropertyName>`` element in the projection clause.
 
     This parses and handles the syntax::

gisserver/parsers/wfs20/requests.py

@@ -45,6 +45,7 @@ WFS_STORED_QUERY = xmlns.wfs20.qname("StoredQuery")
 
 @dataclass
 @tag_registry.register("GetCapabilities", xmlns.wfs20)
+@tag_registry.register("GetCapabilities", xmlns.wfs1, hidden=True)  # to give negotiation error.
 class GetCapabilities(BaseOwsRequest):
     """Request parsing for GetCapabilities.
 

gisserver/parsers/wfs20/stored.py

@@ -60,7 +60,7 @@ class StoredQuery(QueryExpression):
     Note that the base class logic (such as ``<wfs:PropertyName>`` elements) are still applicable.
 
     This element resolves the stored query using the
-    :class:`~gisserver.projection.storage.StoredQueryRegistry`,
+    :class:`~gisserver.extensions.queries.StoredQueryRegistry`,
     and passes the execution to this custom function.
     """
 
@@ -165,7 +165,8 @@ class StoredQuery(QueryExpression):
         """Forward queryset creation to the implementation class."""
         return self.implementation.build_query(compiler)
 
-    def as_kvp(self):
+    def as_kvp(self) -> dict:
+        """Translate the POST request into KVP GET parameters. This is needed for pagination."""
         # As this is such edge case, only support the minimal for CITE tests.
         params = super().as_kvp()
         params["STOREDQUERY_ID"] = self.id

gisserver/parsers/xml.py

@@ -50,8 +50,10 @@ class xmlns(Enum):
     ows20 = "http://www.opengis.net/ows/2.0"
     wms = "http://www.opengis.net/wms"  # Web Map Service (WMS)
     wcs = "http://www.opengis.net/wcs"  # Web Coverage Service (WCS)
+    wcs20 = "http://www.opengis.net/wcs/2.0"
     wps = "http://www.opengis.net/wps/1.0.0"  # Web Processing Service (WPS)
     wmts = "http://www.opengis.net/wmts/1.0"  # Web Map Tile Service (WMTS)
+    wfs1 = "http://www.opengis.net/wfs"
     wfs20 = "http://www.opengis.net/wfs/2.0"  # Web Feature Service (WFS)
     fes20 = "http://www.opengis.net/fes/2.0"  # Filter Encoding Standard (FES)
     gml21 = "http://www.opengis.net/gml"
@@ -108,6 +110,16 @@ class NSElement(Element):
         """Resolve an aliased QName value to its fully qualified name."""
         return parse_qname(qname, self.ns_aliases)
 
+    @property
+    def qname(self) -> str:
+        """Provde the tag name in its original short format"""
+        ns, localname = split_ns(self.tag)
+        if ns:
+            for prefix, full_ns in self.ns_aliases.items():
+                if full_ns == ns:
+                    return f"{prefix}:{localname}" if prefix else localname
+        return localname
+
     def get_str_attribute(self, name: str) -> str:
         """Resolve an attribute, raise an error when it's missing."""
         try:

gisserver/projection.py

@@ -29,8 +29,8 @@ if typing.TYPE_CHECKING:
     from django.contrib.gis.geos import GEOSGeometry
     from django.db import models
 
+    from gisserver.crs import CRS
     from gisserver.features import FeatureType
-    from gisserver.geometries import CRS
     from gisserver.parsers import fes20, wfs20
 
 __all__ = (
@@ -47,14 +47,25 @@ class FeatureProjection:
 
     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.
+    When a ``PROPERTYNAME`` (or ``<wfs:PropertyName>``) is used in the request,
+    this will limit which fields to retrieve, which to prefetch, and which to render.
     """
 
+    #: Referencing the Feature that is rendered.
     feature_type: FeatureType
+
+    #: The list of root element to render for this feature.
     xsd_root_elements: list[XsdElement]
+
+    #: The subset of child nodes to render for a given element.
     xsd_child_nodes: dict[XsdElement | None, list[XsdElement]]
 
+    #: The output Coordinate Reference System
+    output_crs: CRS
+
+    #: Whether the output should be rendered without wrapper tags (for GetFeatureById).
+    output_standalone: bool
+
     def __init__(
         self,
         feature_types: list[FeatureType],
@@ -69,7 +80,8 @@ class FeatureProjection:
         :param property_names: Limited list of fields to render only.
         :param value_reference: Single element to display fo GetPropertyValue
         :param output_crs: Which coordinate reference system to use for geometry data.
-        :param output_standalone: Whether the ``<wfs:
+        :param output_standalone: Used for the ``GetFeatureById`` stored query.
+            This removes the ``wfs:FeatureCollection><wfs:member>`` wrapper elements from the output.
         """
         self.feature_types = feature_types
         self.feature_type = feature_types[0]  # JOIN still not supported.
@@ -302,9 +314,7 @@ class FeatureProjection:
 
 @dataclass
 class FeatureRelation:
-    """Tell which related fields are queried by the feature.
-    Each dict holds an ORM-path, with the relevant sub-elements.
-    """
+    """Tell which related fields are queried by the feature."""
 
     #: The ORM path that is queried for this particular relation
     orm_path: str

gisserver/static/gisserver/index.css

@@ -1,3 +1,5 @@
+/* general CSS that can be disabled by removing the .meta-page in the overwritten templates */
+
 .meta-page {
   font-family: Arial, sans-serif;
   line-height: 1.5;
@@ -8,8 +10,11 @@
 .meta-page h3 { margin: 1rem 0 0.5rem 0; }
 .meta-page p { margin: 0 0 1rem 0; }
 
+/* application-specific */
+.connect-url { margin-left: 4rem; }
+
 tbody th { text-align: left; padding-right: 2rem; }
 tbody td { padding-right: 2rem; }
-.complex-level-1 th { padding-left: 16px; }
-.complex-level-2 th { padding-left: 32px; }
-.complex-level-3 th { padding-left: 48px; }
+.table > tbody > tr.complex-level-1 > th { padding-left: 20px; }
+.table > tbody > tr.complex-level-2 > th { padding-left: 40px; }
+.table > tbody > tr.complex-level-3 > th { padding-left: 60px; }

gisserver/templates/gisserver/base.html

@@ -0,0 +1,12 @@
+<!doctype html>{% load i18n static %}{# This is a very basic template that can be overwritten in projects #}
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8">
+  <title>{% block title %}{{ service_description.title }} {{ accept_operations|dictsort:0|join:"/" }}{% endblock %}</title>
+  {% block link %}<link rel="stylesheet" type="text/css" href="{% static 'gisserver/index.css' %}">{% endblock %}
+  {% block extrahead %}{% endblock %}
+</head>
+<body class="{% block body-class %}meta-page{% endblock %}">
+  {% block content %}{% endblock %}
+</body>
+</html>

gisserver/templates/gisserver/index.html

@@ -1,26 +1,20 @@
-<!doctype html>{% load i18n static %}{# This is a very basic template that can be overwritten in projects #}
-<html>
-<head>
-  <meta http-equiv="content-type" content="text/html; charset=utf-8">
-  <title>{{ service_description.title }} {{ accept_operations|dictsort:0|join:"/" }}</title>
-  {% block link %}<link rel="stylesheet" type="text/css" href="{% static 'gisserver/index.css' %}">{% endblock %}
-  {% block extrahead %}{% endblock %}
-</head>
-<body class="{% block body-class %}meta-page{% endblock %}">
-  <header>
+
+{% extends "gisserver/base.html" %}{% load i18n %}
+
+{% block title %}{{ service_description.title }} {{ accept_operations|dictsort:0|join:"/" }}{% endblock %}
+{% block content %}
+  <header id="wfs-header">
     {% block header %}{% include "gisserver/service_description.html" %}{% endblock %}
   </header>
 
-  <main>
+  <main id="wfs-main">
     {% block main %}
       {% if wfs_features %}
-        <h2>WFS Feature Types</h2>
+        <h2>{% translate "WFS Feature Types" %}</h2>
         {% for feature_type in wfs_features %}
           <article>{% include "gisserver/wfs/feature_type.html" %}</article>
         {% endfor %}
       {% endif %}
     {% endblock %}
   </main>
-
-</body>
-</html>
+{% endblock %}

gisserver/templates/gisserver/service_description.html

@@ -2,15 +2,21 @@
 <h1>{{ service_description.title }} {{ accept_operations|dictsort:0|join:"/" }}</h1>
 {% if service_description.abstract %}{{ service_description.abstract|linebreaks }}{% endif %}
 
+{% if service_description.keywords or service_description.provider_name %}
+<dl>
 {% if service_description.keywords %}
-<p>{% trans "Keywords" %}: {{ service_description.keywords|join:", " }}</p>
+<dt>{% translate "Keywords" %}:</dt><dd>{{ service_description.keywords|join:", " }}</dd>
 {% endif %}
 {% if service_description.provider_name %}
-  <p>{% trans "Provider" %}: {% if service_description.provider_site %}<a href="{{ service_description.provider_site }}">{% endif %}{{ service_description.provider_name }}{% if service_description.provider_site %}</a></p>{% endif %}
-  {% if service_description.contact_person %}<p>{% trans "Contact" %}: {{ service_description.contact_person }}</p>{% endif %}
+  <dt>{% translate "Provider" %}:</dt>
+  <dd>{% if service_description.provider_site %}<a href="{{ service_description.provider_site }}">{% endif %}{{ service_description.provider_name }}{% if service_description.provider_site %}</a></dd>{% endif %}
+  {% if service_description.contact_person %}<dt>{% translate "Contact" %}:</dt><dd>{{ service_description.contact_person }}</dd>{% endif %}
 {% endif %}
+</dl>
+{% endif %}
+
 {% if connect_url %}
-<h2>{% trans "Using This WFS" %}</h2>
-<p>{% trans "Add the following URL to your GIS application:" %}</p>
-<blockquote><code>{{ connect_url }}</code></blockquote>
+<h2>{% translate "Using This WFS" %}</h2>
+<p>{% translate "Add the following URL to your GIS application:" %}</p>
+<p class="connect-url"><code>{{ connect_url }}</code></p>
 {% endif %}

gisserver/templates/gisserver/wfs/feature_field.html

@@ -1,5 +1,5 @@
 {% load gisserver_tags %}<tr{% if level %} class="complex-field-member complex-level-{{ level }}"{% endif %}>
-  <th><code>{{ field.name }}</code></th>
+  <th><code>{% if level %}/{% endif %}{{ field.name }}</code></th>
   <td>{{ field.xsd_element.type|to_qname:xml_namespaces }}{% if field.xsd_element.is_many %} <em>(maxOccurs={{ field.xsd_element.max_occurs }})</em>{% endif %}</td>
   <td>{{ field.abstract|default:'' }}</td>
 </tr>