c2cgeoportal-geoportal 2.3.5.80__py3-none-any.whl → 2.9rc2__py3-none-any.whl

c2cgeoportal_geoportal/views/mapserverproxy.py

@@ -0,0 +1,191 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import logging
+from typing import Any
+
+from pyramid.httpexceptions import HTTPForbidden, HTTPFound, HTTPInternalServerError, HTTPUnauthorized
+from pyramid.request import Request
+from pyramid.response import Response
+from pyramid.view import view_config
+
+from c2cgeoportal_commons.lib.url import Url
+from c2cgeoportal_commons.models import main
+from c2cgeoportal_geoportal.lib import get_roles_id, get_roles_name
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache
+from c2cgeoportal_geoportal.lib.filter_capabilities import filter_capabilities
+from c2cgeoportal_geoportal.lib.functionality import get_mapserver_substitution_params
+from c2cgeoportal_geoportal.views.ogcproxy import OGCProxy
+
+_CACHE_REGION = get_region("std")
+_LOG = logging.getLogger(__name__)
+
+
+class MapservProxy(OGCProxy):
+    """Proxy for OGC (WMS/WFS) servers."""
+
+    params: dict[str, str] = {}
+
+    def __init__(self, request: Request) -> None:
+        OGCProxy.__init__(self, request)
+        self.user = self.request.user
+
+    @view_config(route_name="mapserverproxy")  # type: ignore
+    @view_config(route_name="mapserverproxy_post")  # type: ignore
+    @view_config(route_name="mapserverproxy_get_path")  # type: ignore
+    @view_config(route_name="mapserverproxy_post_path")  # type: ignore
+    def proxy(self) -> Response:
+        if self.user is None and "authentication_required" in self.request.params:
+            _LOG.debug("proxy() detected authentication_required")
+            if self.request.registry.settings.get("basicauth", "False").lower() == "true":
+                raise HTTPUnauthorized(
+                    headers={"WWW-Authenticate": 'Basic realm="Access to restricted layers"'}
+                )
+            raise HTTPForbidden("Basic auth is not enabled")
+
+        # We have a user logged in. We need to set group_id and possible layer_name in the params. We set
+        # layer_name when either QUERY_PARAMS or LAYERS is set in the WMS params, i.e. for GetMap and
+        # GetFeatureInfo requests. For GetLegendGraphic requests we do not send layer_name, but MapServer
+        # should not use the DATA string for GetLegendGraphic.
+
+        if self.ogc_server.auth == main.OGCSERVER_AUTH_STANDARD:
+            self.params["role_ids"] = ",".join([str(e) for e in get_roles_id(self.request)])
+
+            # In some application we want to display the features owned by a user than we need his id.
+            self.params["user_id"] = self.user.id if self.user is not None else "-1"
+
+        # Do not allows direct variable substitution
+        for k in list(self.params.keys()):
+            if len(k) > 1 and k[:2].capitalize() == "S_":
+                _LOG.warning("Direct substitution not allowed (%s=%s).", k, self.params[k])
+                del self.params[k]
+
+        if (
+            self.ogc_server.auth == main.OGCSERVER_AUTH_STANDARD
+            and self.ogc_server.type == main.OGCSERVER_TYPE_MAPSERVER
+        ):
+            # Add functionalities params
+            self.params.update(get_mapserver_substitution_params(self.request))
+
+        # Get method
+        method = self.request.method
+
+        # we want the browser to cache GetLegendGraphic and
+        # DescribeFeatureType requests
+        use_cache = False
+
+        errors: set[str] = set()
+        if method == "GET":
+            # For GET requests, params are added only if the self.request
+            # parameter is actually provided.
+            if "request" not in self.lower_params:
+                self.params = {}
+            else:
+                if self.ogc_server.type != main.OGCSERVER_TYPE_QGISSERVER or "user_id" not in self.params:
+                    use_cache = self.lower_params["request"] in ("getlegendgraphic",)
+
+                    # no user_id and role_id or cached queries
+                    if use_cache and "user_id" in self.params:
+                        del self.params["user_id"]
+                    if use_cache and "role_ids" in self.params:
+                        del self.params["role_ids"]
+
+            if "service" in self.lower_params and self.lower_params["service"] == "wfs":
+                _url = self._get_wfs_url(errors)
+            else:
+                _url = self._get_wms_url(errors)
+        else:
+            # POST means WFS
+            _url = self._get_wfs_url(errors)
+
+        if _url is None:
+            _LOG.error("Error getting the URL:\n%s", "\n".join(errors))
+            raise HTTPInternalServerError()
+
+        cache_control = (
+            Cache.PRIVATE
+            if method == "GET"
+            and self.lower_params.get("request")
+            in (
+                "getcapabilities",
+                "getlegendgraphic",
+                "describefeaturetype",
+                "describelayer",
+            )
+            else Cache.PRIVATE_NO
+        )
+
+        headers = self.get_headers()
+        # Add headers for Geoserver
+        if self.ogc_server.auth == main.OGCSERVER_AUTH_GEOSERVER and self.user is not None:
+            headers["sec-username"] = self.user.username
+            headers["sec-roles"] = ";".join(get_roles_name(self.request))
+
+        response = self._proxy_callback(
+            cache_control,
+            url=_url,
+            params=self.params,
+            cache=use_cache,
+            headers=headers,
+            body=self.request.body,
+        )
+
+        if (
+            self.lower_params.get("request") == "getmap"
+            and not response.content_type.startswith("image/")
+            and response.status_code < 400
+        ):
+            response.status_code = 400
+
+        return response
+
+    def _proxy_callback(
+        self, cache_control: Cache, url: Url, params: dict[str, str], **kwargs: Any
+    ) -> Response:
+        if self.request.matched_route.name.endswith("_path"):
+            if self.request.matchdict["path"] == ("favicon.ico",):
+                return HTTPFound("/favicon.ico")
+            url = url.clone()
+            url.path = self.request.path
+
+        response = self._proxy(url=url, params=params, **kwargs)
+
+        content = response.content
+        if self.lower_params.get("request") == "getcapabilities":
+            content = filter_capabilities(
+                self.request,
+                response.text,
+                self.lower_params.get("service") == "wms",
+                url,
+                self.request.headers,
+            ).encode("utf-8")
+
+        content_type = response.headers["Content-Type"]
+
+        return self._build_response(response, content, cache_control, "mapserver", content_type=content_type)

c2cgeoportal_geoportal/views/memory.py

@@ -0,0 +1,90 @@
+# Copyright (c) 2018-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import logging
+import os
+import time
+from typing import Any, cast
+
+import pyramid.request
+from c2cwsgiutils import broadcast
+from c2cwsgiutils.auth import auth_view
+from c2cwsgiutils.debug import get_size
+from pyramid.view import view_config
+
+from c2cgeoportal_geoportal.lib.caching import MEMORY_CACHE_DICT
+from c2cgeoportal_geoportal.views import raster
+
+_LOG = logging.getLogger(__name__)
+
+
+@view_config(route_name="memory", renderer="fast_json")  # type: ignore
+def memory(request: pyramid.request.Request) -> dict[str, Any]:
+    """Offer an authenticated view throw c2cwsgiutils to provide some memory information."""
+    auth_view(request)
+    return cast(dict[str, Any], _memory())
+
+
+def _nice_type_name(obj: Any, dogpile_cache: bool = False) -> str:
+    # See: https://dogpilecache.sqlalchemy.org/en/latest/api.html#dogpile.cache.api.CachedValue
+    if dogpile_cache:
+        obj, _ = obj
+    type_ = type(obj)
+    return f"{type_.__module__}.{type_.__name__}"
+
+
+def _process_dict(dict_: dict[str, Any], dogpile_cache: bool = False) -> dict[str, Any]:
+    # Timeout after one minute, must be set to a bit less that the timeout of the broadcast
+    timeout = time.monotonic() + 20
+
+    return {
+        "elements": sorted(
+            (
+                {
+                    "key": key,
+                    "type": _nice_type_name(value, dogpile_cache),
+                    "repr": repr(value),
+                    "id": id(value),
+                    "size_kb": get_size(value) / 1024 if time.monotonic() < timeout else -1,
+                }
+                for key, value in dict_.items()
+            ),
+            key=lambda i: cast(float, -i["size_kb"]),
+        ),
+        "id": id(dict_),
+        "size_kb": get_size(dict_) / 1024 if time.monotonic() < timeout else -1,
+        "timeout": time.monotonic() > timeout,
+    }
+
+
+@broadcast.decorator(expect_answers=True, timeout=110)
+def _memory() -> dict[str, Any]:
+    result = {"raster_data": _process_dict(raster.Raster.data)}
+    if os.environ.get("GEOMAPFISH_DEBUG_MEMORY_CACHE", "false").lower() in ("true", "1", "yes", "on"):
+        result["memory_cache"] = _process_dict(MEMORY_CACHE_DICT, True)
+    return result

c2cgeoportal_geoportal/views/ogcproxy.py

@@ -0,0 +1,120 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+import logging
+
+import pyramid.request
+from pyramid.httpexceptions import HTTPBadRequest
+from sqlalchemy.orm.exc import NoResultFound  # type: ignore[attr-defined]
+
+from c2cgeoportal_commons.lib.url import Url, get_url2
+from c2cgeoportal_commons.models import DBSession, main
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.views.proxy import Proxy
+
+_CACHE_REGION = get_region("std")
+_LOG = logging.getLogger(__name__)
+
+
+class OGCProxy(Proxy):
+    """
+    Proxy implementation that manly manage the ogcserver parameter.
+
+    Then load the corresponding OGCServer.
+    """
+
+    def __init__(self, request: pyramid.request.Request, has_default_ogc_server: bool = False):
+        Proxy.__init__(self, request)
+
+        # params hold the parameters we"re going to send to backend
+        self.params = dict(self.request.params)
+
+        # reset possible value of role_id and user_id
+        if "role_id" in self.params:
+            del self.params["role_id"]
+        if "user_id" in self.params:
+            del self.params["user_id"]
+
+        main_ogc_server = self.request.registry.settings.get("main_ogc_server")
+
+        self.lower_params = self._get_lower_params(self.params)
+
+        # We need original case for OGCSERVER parameter value
+        self.lower_key_params = {k.lower(): v for k, v in self.params.items()}
+
+        if "ogcserver" in request.matchdict:
+            self.ogc_server = self._get_ogcserver_byname(request.matchdict["ogcserver"])
+        elif "ogcserver" in self.lower_key_params:
+            self.ogc_server = self._get_ogcserver_byname(self.lower_key_params["ogcserver"])
+        elif main_ogc_server is not None:
+            self.ogc_server = self._get_ogcserver_byname(main_ogc_server)
+        elif not has_default_ogc_server:
+            raise HTTPBadRequest("The querystring argument 'ogcserver' is required")
+
+    @_CACHE_REGION.cache_on_arguments()
+    def _get_ogcserver_byname(self, name: str) -> main.OGCServer:
+        assert DBSession is not None
+
+        try:
+            result = DBSession.query(main.OGCServer).filter(main.OGCServer.name == name).one()
+            DBSession.expunge(result)
+            return result
+        except NoResultFound:
+            raise HTTPBadRequest(  # pylint: disable=raise-missing-from
+                f"The OGC Server '{name}' does not exist (existing: "
+                f"{','.join([t[0] for t in DBSession.query(main.OGCServer.name).all()])})."
+            )
+
+    def _get_wms_url(self, errors: set[str]) -> Url | None:
+        ogc_server = self.ogc_server
+        url = get_url2(f"The OGC server '{ogc_server.name}'", ogc_server.url, self.request, errors)
+        if errors:
+            _LOG.error("\n".join(errors))
+        return url
+
+    def _get_wfs_url(self, errors: set[str]) -> Url | None:
+        ogc_server = self.ogc_server
+        url = get_url2(
+            f"The OGC server (WFS) '{ogc_server.name}'",
+            ogc_server.url_wfs or ogc_server.url,
+            self.request,
+            errors,
+        )
+        if errors:
+            _LOG.error("\n".join(errors))
+        return url
+
+    def get_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = super().get_headers()
+        if self.ogc_server.type == main.OGCSERVER_TYPE_QGISSERVER:
+            if self.request.matched_route.name.endswith("_path"):
+                headers["X-Qgis-Service-Url"] = self.request.current_route_url(path=[], _query={})
+            else:
+                headers["X-Qgis-Service-Url"] = self.request.current_route_url(
+                    _query={"ogcserver": self.ogc_server.name}
+                )
+        return headers

c2cgeoportal_geoportal/views/pdfreport.py

@@ -0,0 +1,245 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+import logging
+from json import dumps, loads
+from typing import Any
+
+import pyramid.request
+import pyramid.response
+from pyramid.httpexceptions import HTTPBadRequest, HTTPForbidden
+from pyramid.view import view_config
+
+from c2cgeoportal_commons import models
+from c2cgeoportal_commons.lib.url import Url
+from c2cgeoportal_commons.models import main
+from c2cgeoportal_geoportal.lib.common_headers import Cache
+from c2cgeoportal_geoportal.lib.layers import get_private_layers, get_protected_layers
+from c2cgeoportal_geoportal.views.ogcproxy import OGCProxy
+
+_LOG = logging.getLogger(__name__)
+
+
+class PdfReport(OGCProxy):
+    """All the views concerned the PDF report."""
+
+    layername = None
+
+    def __init__(self, request: pyramid.request.Request):
+        OGCProxy.__init__(self, request)
+        self.config = self.request.registry.settings.get("pdfreport", {})
+
+    def _do_print(self, spec: dict[str, Any]) -> pyramid.response.Response:
+        """Create and get report PDF."""
+        headers = dict(self.request.headers)
+        headers["Content-Type"] = "application/json"
+        response = self._proxy(
+            Url(f"{self.config['print_url']}/buildreport.{spec['outputFormat']}"),
+            method="POST",
+            body=dumps(spec).encode("utf-8"),
+            headers=headers,
+        )
+
+        return self._build_response(response, response.content, Cache.PRIVATE_NO, "pdfreport")
+
+    @staticmethod
+    def _build_map(
+        mapserv_url: str, vector_request_url: str, srs: str, map_config: dict[str, Any]
+    ) -> dict[str, Any]:
+        backgroundlayers = map_config["backgroundlayers"]
+        imageformat = map_config["imageformat"]
+        return {
+            "projection": srs,
+            "dpi": 254,
+            "rotation": 0,
+            "bbox": [0, 0, 1000000, 1000000],
+            "zoomToFeatures": {
+                "zoomType": map_config["zoomType"],
+                "layer": "vector",
+                "minScale": map_config["minScale"],
+            },
+            "layers": [
+                {
+                    "type": "gml",
+                    "name": "vector",
+                    "style": {"version": "2", "[1 > 0]": map_config["style"]},
+                    "opacity": 1,
+                    "url": vector_request_url,
+                },
+                {
+                    "baseURL": mapserv_url,
+                    "opacity": 1,
+                    "type": "WMS",
+                    "serverType": "mapserver",
+                    "layers": backgroundlayers,
+                    "imageFormat": imageformat,
+                },
+            ],
+        }
+
+    @view_config(route_name="pdfreport", renderer="json")  # type: ignore
+    def get_report(self) -> pyramid.response.Response:
+        assert models.DBSession is not None
+
+        self.layername = self.request.matchdict["layername"]
+        layer_config = self.config["layers"].get(self.layername)
+
+        if layer_config is None:
+            raise HTTPBadRequest("Layer not found: " + self.layername)
+
+        multiple = layer_config.get("multiple", False)
+        ids = self.request.matchdict["ids"]
+        if multiple:
+            ids = ids.split(",")
+
+        features_ids = (
+            [self.layername + "." + id_ for id_ in ids] if multiple else [self.layername + "." + ids]
+        )
+
+        if layer_config["check_credentials"]:
+            # FIXME: support of mapserver groups
+            ogc_server = (
+                models.DBSession.query(main.OGCServer)
+                .filter(main.OGCServer.name == layer_config["ogc_server"])
+                .one()
+            )
+            ogc_server_ids = [ogc_server]
+
+            private_layers_object = get_private_layers(ogc_server_ids)
+            private_layers_names = [private_layers_object[oid].name for oid in private_layers_object]
+
+            protected_layers_object = get_protected_layers(self.request.user, ogc_server_ids)
+            protected_layers_names = [protected_layers_object[oid].name for oid in protected_layers_object]
+
+            if self.layername in private_layers_names and self.layername not in protected_layers_names:
+                raise HTTPForbidden
+
+        srs = layer_config["srs"]
+
+        mapserv_url = self.request.route_url(
+            "mapserverproxy", _query={"ogcserver": layer_config["ogc_server"]}
+        )
+        url = Url(mapserv_url)
+        url.add_query(
+            {
+                "service": "WFS",
+                "version": "1.1.0",
+                "outputformat": "gml3",
+                "request": "GetFeature",
+                "typeName": self.layername,
+                "featureid": ",".join(features_ids),
+                "srsName": srs,
+            }
+        )
+        vector_request_url = url.url()
+
+        spec = layer_config["spec"]
+        if spec is None:
+            spec = {
+                "layout": self.layername,
+                "outputFormat": "pdf",
+                "attributes": {"ids": [{"id": id_} for id_ in ids]} if multiple else {"id": id},
+            }
+            map_config = layer_config.get("map")
+            if map_config is not None:
+                spec["attributes"]["map"] = self._build_map(mapserv_url, vector_request_url, srs, map_config)
+
+            maps_config = layer_config.get("maps")
+            if maps_config is not None:
+                spec["attributes"]["maps"] = []
+                for map_config in maps_config:
+                    spec["attributes"]["maps"].append(
+                        self._build_map(mapserv_url, vector_request_url, srs, map_config)
+                    )
+        else:
+            datasource = layer_config.get("datasource", True)
+            if multiple and datasource:
+                data = dumps(layer_config["data"])
+                data_list = [
+                    loads(
+                        data
+                        % {
+                            "layername": self.layername,
+                            "id": id_,
+                            "srs": srs,
+                            "mapserv_url": mapserv_url,
+                            "vector_request_url": vector_request_url,
+                        }
+                    )
+                    for id_ in ids
+                ]
+                self.walker(spec, "%(datasource)s", data_list)
+                spec = loads(
+                    dumps(spec)
+                    % {
+                        "layername": self.layername,
+                        "srs": srs,
+                        "mapserv_url": mapserv_url,
+                        "vector_request_url": vector_request_url,
+                    }
+                )
+            elif multiple:
+                spec = loads(
+                    dumps(spec)
+                    % {
+                        "layername": self.layername,
+                        "ids": ",".join(ids),
+                        "srs": srs,
+                        "mapserv_url": mapserv_url,
+                        "vector_request_url": vector_request_url,
+                    }
+                )
+            else:
+                spec = loads(
+                    dumps(spec)
+                    % {
+                        "layername": self.layername,
+                        "id": ids,
+                        "srs": srs,
+                        "mapserv_url": mapserv_url,
+                        "vector_request_url": vector_request_url,
+                    }
+                )
+
+        return self._do_print(spec)
+
+    def walker(self, spec: dict[str, Any] | list[dict[str, Any]], name: str, value: Any) -> None:
+        if isinstance(spec, dict):
+            for k, v in spec.items():
+                if isinstance(v, str):
+                    if v == name:
+                        spec[k] = value
+                else:
+                    self.walker(v, name, value)
+
+        if isinstance(spec, list):
+            for k2, v2 in enumerate(spec):
+                if isinstance(v2, str):
+                    if v2 == name:
+                        spec[k2] = value
+                else:
+                    self.walker(v2, name, value)