c2cgeoportal-geoportal 2.3.5.79__py3-none-any.whl → 2.9rc44__py3-none-any.whl

c2cgeoportal_geoportal/views/printproxy.py

@@ -0,0 +1,143 @@
+# 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 json
+import logging
+import urllib.parse
+
+import pyramid.request
+import pyramid.response
+import requests
+from pyramid.httpexceptions import HTTPBadGateway, HTTPFound
+from pyramid.view import view_config
+
+from c2cgeoportal_commons.lib.url import Url
+from c2cgeoportal_geoportal.lib import is_intranet
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache
+from c2cgeoportal_geoportal.lib.functionality import get_functionality
+from c2cgeoportal_geoportal.views.proxy import Proxy
+
+_LOG = logging.getLogger(__name__)
+_CACHE_REGION = get_region("std")
+
+
+class PrintProxy(Proxy):
+    """All the view concerned the print."""
+
+    def __init__(self, request: pyramid.request.Request):
+        Proxy.__init__(self, request)
+
+    @view_config(route_name="printproxy_capabilities")  # type: ignore[misc]
+    def capabilities(self) -> pyramid.response.Response:
+        """Get print capabilities."""
+        templates = get_functionality("print_template", self.request, is_intranet(self.request))
+
+        # get query string
+        params = dict(self.request.params)
+        query_string = urllib.parse.urlencode(params)
+
+        resp, content = self._capabilities(
+            templates, query_string, self.request.method, self.request.referrer, self.request.host
+        )
+
+        response = self._build_response(resp, content, Cache.PRIVATE, "print")
+        # Mapfish print will check the referrer header to return the capabilities.
+        response.vary += ("Referrer", "Referer")
+        return response
+
+    @_CACHE_REGION.cache_on_arguments()
+    def _capabilities(
+        self, templates: list[str], query_string: dict[str, str], method: str, referrer: str, host: str
+    ) -> tuple[requests.Response, str]:
+        del query_string  # Just for caching
+        del method  # Just for caching
+        del referrer  # Just for caching
+        del host  # Just for caching
+
+        # Get URL
+        _url = self.request.get_organization_print_url() + "/capabilities.json"
+
+        response = self._proxy(Url(_url))
+        response.raise_for_status()
+
+        if self.request.method == "GET":
+            try:
+                capabilities = response.json()
+            except json.decoder.JSONDecodeError:
+                _LOG.exception("Unable to parse capabilities: %s", response.text)
+                raise HTTPBadGateway(response.text)  # pylint: disable=raise-missing-from
+
+            capabilities["layouts"] = list(
+                layout for layout in capabilities["layouts"] if layout["name"] in templates
+            )
+
+            pretty = self.request.params.get("pretty", "false") == "true"
+            content = json.dumps(
+                capabilities, separators=None if pretty else (",", ":"), indent=4 if pretty else None
+            )
+        else:
+            content = ""
+
+        return response, content
+
+    @view_config(route_name="printproxy_report_create")  # type: ignore[misc]
+    def report_create(self) -> pyramid.response.Response:
+        """Create PDF."""
+        return self._proxy_response(
+            "print",
+            Url(
+                f"{ self.request.get_organization_print_url()}/report.{self.request.matchdict.get('format')}"
+            ),
+        )
+
+    @view_config(route_name="printproxy_status")  # type: ignore[misc]
+    def status(self) -> pyramid.response.Response:
+        """PDF status."""
+        return self._proxy_response(
+            "print",
+            Url(
+                f"{self.request.get_organization_print_url()}/status/{self.request.matchdict.get('ref')}.json"
+            ),
+        )
+
+    @view_config(route_name="printproxy_cancel")  # type: ignore[misc]
+    def cancel(self) -> pyramid.response.Response:
+        """PDF cancel."""
+        return self._proxy_response(
+            "print",
+            Url(f"{self.request.get_organization_print_url()}/cancel/{self.request.matchdict.get('ref')}"),
+        )
+
+    @view_config(route_name="printproxy_report_get")  # type: ignore[misc]
+    def report_get(self) -> pyramid.response.Response:
+        """Get the PDF."""
+        url = Url(f"{self.request.get_organization_print_url()}/report/{self.request.matchdict.get('ref')}")
+        if self.request.registry.settings.get("print_get_redirect", False):
+            raise HTTPFound(location=url.url())
+        return self._proxy_response("print", url)

c2cgeoportal_geoportal/views/profile.py

@@ -0,0 +1,192 @@
+# Copyright (c) 2012-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 json
+import logging
+import math
+import urllib.parse
+from decimal import Decimal
+from json.decoder import JSONDecodeError
+from typing import Any
+
+import geojson
+import pyramid.request
+import requests
+from pyramid.httpexceptions import HTTPBadRequest, HTTPInternalServerError, HTTPNotFound
+from pyramid.i18n import TranslationStringFactory
+from pyramid.view import view_config
+
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
+from c2cgeoportal_geoportal.views.raster import Raster
+
+_LOG = logging.getLogger(__name__)
+
+_ = TranslationStringFactory("c2cgeoportal")
+
+
+class Profile(Raster):
+    """All the view concerned the profile."""
+
+    def __init__(self, request: pyramid.request.Request):
+        Raster.__init__(self, request)
+
+    @staticmethod
+    def _to_filtered(points: list[dict[str, Any]], layers: list[str]) -> list[dict[str, Any]]:
+        profile = []
+        for point in points:
+            filtered_alts = {key: value for key, value in point["alts"].items() if key in layers}
+            profile.append(
+                {
+                    "dist": point["dist"],
+                    "values": filtered_alts,
+                    "x": point["easting"],
+                    "y": point["northing"],
+                }
+            )
+        return profile
+
+    def _get_profile_service_data(
+        self, layers: list[str], geom: dict[str, Any], rasters: dict[str, Any], nb_points: int
+    ) -> list[dict[str, Any]]:
+        request = f"{rasters[layers[0]]['url']}/profile.json?{urllib.parse.urlencode({'geom': geom, 'nbPoints': nb_points, 'distinct_points': 'true'})}"
+        response = requests.get(request, timeout=10)
+        if not response.ok:
+            _LOG.error("profile request %s failed with status code %s", request, response.status_code)
+            raise HTTPInternalServerError(
+                f"Failed to fetch profile data from internal request: \
+                {response.status_code} {response.reason}"
+            )
+
+        try:
+            points = json.loads(response.content)
+        except (TypeError, JSONDecodeError) as exc:
+            _LOG.exception("profile request %s failed", request)
+            raise HTTPInternalServerError("Failed to decode JSON response from internal request") from exc
+
+        return self._to_filtered(points, layers)
+
+    @view_config(route_name="profile.json", renderer="fast_json")  # type: ignore[misc]
+    def json(self) -> dict[str, Any]:
+        """Answer to /profile.json."""
+        _, points = self._compute_points()
+        set_common_headers(self.request, "profile", Cache.PUBLIC_NO)
+        return {"profile": points}
+
+    def _compute_points(self) -> tuple[list[str], list[dict[str, Any]]]:
+        """Compute the alt=fct(dist) array."""
+        geom = geojson.loads(self.request.params["geom"], object_hook=geojson.GeoJSON.to_instance)
+        nb_points = int(self.request.params["nbPoints"])
+        coords = []
+        service_results: list[dict[str, Any]] = []
+
+        layers: list[str]
+        if "layers" in self.request.params:
+            rasters = {}
+            layers = self.request.params["layers"].split(",")
+            for layer in layers:
+                if layer in self.rasters:
+                    rasters[layer] = self.rasters[layer]
+                else:
+                    raise HTTPNotFound(f"Layer {layer!s} not found")
+        else:
+            rasters = self.rasters
+            layers = list(rasters.keys())
+            layers.sort()
+
+        service_layers = [layer for layer in layers if rasters[layer].get("type") == "external_url"]
+
+        if len(service_layers) > 0:
+            urls = [rasters[layer]["url"] for layer in service_layers]
+            if len(set(urls)) != 1:
+                raise HTTPBadRequest("All service layers must have the same URL.")
+            service_results = self._get_profile_service_data(service_layers, geom, rasters, nb_points)
+            if len(service_layers) < len(layers):
+                coords = [(point["x"], point["y"]) for point in service_results]
+            else:
+                return layers, service_results
+
+        if len(service_results) == 0:
+            points: list[dict[str, Any]] = []
+
+            dist = 0
+            prev_coord = None
+            coords = self._create_points(geom.coordinates, nb_points)
+            for coord in coords:
+                if prev_coord is not None:
+                    dist += self._dist(prev_coord, coord)
+                _LOG.info("new dist %s", dist)
+
+                values = {}
+                for ref in list(rasters.keys()):
+                    value = self._get_raster_value(self.rasters[ref], ref, coord[0], coord[1])
+                    values[ref] = value
+                _LOG.info("values %s", values)
+
+                # 10cm accuracy is enough for distances
+                rounded_dist = Decimal(str(dist)).quantize(Decimal("0.1"))
+                points.append({"dist": rounded_dist, "values": values, "x": coord[0], "y": coord[1]})
+                prev_coord = coord
+            return layers, points
+        else:
+            additional_layers = [layer for layer in layers if layer not in service_layers]
+            for point in service_results:
+                for ref in additional_layers:
+                    value = self._get_raster_value(self.rasters[ref], ref, point["x"], point["y"])
+                    point["values"][ref] = value
+            return layers, service_results
+
+    @staticmethod
+    def _dist(coord1: tuple[float, float], coord2: tuple[float, float]) -> float:
+        """Compute the distance between 2 points."""
+        return math.sqrt(math.pow(coord1[0] - coord2[0], 2.0) + math.pow(coord1[1] - coord2[1], 2.0))
+
+    def _create_points(self, coords: list[tuple[float, float]], nb_points: int) -> list[tuple[float, float]]:
+        """Add some points in order to reach roughly the asked number of points."""
+        total_length = 0
+        prev_coord = None
+        for coord in coords:
+            if prev_coord is not None:
+                total_length += self._dist(prev_coord, coord)
+            prev_coord = coord
+
+        if total_length == 0.0:
+            return coords
+
+        result: list[tuple[float, float]] = []
+        prev_coord = None
+        for coord in coords:
+            if prev_coord is not None:
+                cur_length = self._dist(prev_coord, coord)
+                cur_nb_points = max(int(nb_points * cur_length / total_length + 0.5), 1)
+                dx = (coord[0] - prev_coord[0]) / float(cur_nb_points)
+                dy = (coord[1] - prev_coord[1]) / float(cur_nb_points)
+                for i in range(1, cur_nb_points + 1):
+                    result.append((prev_coord[0] + dx * i, prev_coord[1] + dy * i))
+            else:
+                result.append((coord[0], coord[1]))
+            prev_coord = coord
+        return result

c2cgeoportal_geoportal/views/proxy.py

@@ -0,0 +1,261 @@
+# Copyright (c) 2011-2025, 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 sys
+from typing import Any
+
+import pyramid.request
+import pyramid.response
+import requests
+from pyramid.httpexceptions import HTTPBadGateway, exception_response
+
+from c2cgeoportal_commons.lib.url import Url
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
+from c2cgeoportal_geoportal.views import restrict_headers
+
+_LOG = logging.getLogger(__name__)
+_CACHE_REGION = get_region("std")
+
+
+class Proxy:
+    """Some methods used by all the proxy."""
+
+    def __init__(self, request: pyramid.request.Request):
+        self.request = request
+        self.host_forward_host = request.registry.settings.get("host_forward_host", [])
+        self.headers_whitelist = request.registry.settings.get("headers_whitelist", [])
+        self.headers_blacklist = request.registry.settings.get("headers_blacklist", [])
+        self.http_options = self.request.registry.settings.get("http_options", {})
+
+    def _proxy(
+        self,
+        url: Url,
+        params: dict[str, str] | None = None,
+        method: str | None = None,
+        cache: bool = False,
+        body: bytes | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> requests.models.Response:
+        # Get query string
+        params = dict(self.request.params) if params is None else params
+        url = url.clone().add_query(params, True)
+
+        _LOG.debug("Send query to URL:\n%s.", url)
+
+        if method is None:
+            method = self.request.method
+
+        headers = dict(self.request.headers if headers is None else headers)
+
+        # Forward request to target (without Host Header).
+        # The original Host will be added back by pyramid.
+        if url.hostname not in self.host_forward_host and "Host" in headers:
+            headers.pop("Host")
+
+        # Forward the request tracking ID to the other service. This will allow to follow the logs belonging
+        # to a single request coming from the user
+        headers.setdefault("X-Request-ID", self.request.c2c_request_id)
+        # If we really want to respect the specification, we should chain with the content of the previous
+        # proxy, see also:
+        # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Forwarded
+        forwarded = {"for": self.request.client_addr, "proto": self.request.scheme}
+        if "Host" in self.request.headers:
+            forwarded["host"] = self.request.headers["Host"]
+        forwarded_str = ";".join(["=".join(e) for e in forwarded.items()])
+        if "Forwarded" in headers:
+            headers["Forwarded"] = ",".join([headers["Forwarded"], forwarded_str])
+        else:
+            headers["Forwarded"] = forwarded_str
+        # Set alternative "X-Forwarded" headers
+        for forwarded_elements in reversed(headers["Forwarded"].split(",")):
+            for element in forwarded_elements.split(";"):
+                key, value = element.split("=")
+                header_key = f"X-Forwarded-{key.capitalize()}"
+                header_value = headers.get(header_key)
+                headers[header_key] = value if header_value is None else ", ".join([header_value, value])
+
+        if not cache:
+            headers["Cache-Control"] = "no-cache"
+
+        if method in ("POST", "PUT") and body is None:
+            body = self.request.body
+
+        headers = restrict_headers(headers, self.headers_whitelist, self.headers_blacklist)
+
+        try:
+            if method in ("POST", "PUT"):
+                response = requests.request(
+                    method, url.url(), data=body, headers=headers, **self.http_options
+                )
+            else:
+                response = requests.request(method, url.url(), headers=headers, **self.http_options)
+        except Exception:
+            errors = ["Error '%s' while getting the URL:", "%s", "Method: %s", "--- With headers ---", "%s"]
+            args1 = [
+                sys.exc_info()[0],
+                url,
+                method,
+                "\n".join(
+                    [
+                        f"{h}: {v if h not in ('Authorization', 'Cookie') else '***'}"
+                        for h, v in list(headers.items())
+                    ]
+                ),
+            ]
+            if method in ("POST", "PUT") and body is not None:
+                errors += ["--- Query with body ---", "%s"]
+                args1.append(body.decode("utf-8"))
+            _LOG.exception("\n".join(errors), *args1)
+
+            raise HTTPBadGateway(  # pylint: disable=raise-missing-from
+                "Error on backend, See logs for detail"
+            )
+
+        if not response.ok:
+            errors = [
+                "Error '%s' in response of URL:",
+                "%s",
+                "Status: %d",
+                "Method: %s",
+                "--- With headers ---",
+                "%s",
+            ]
+            args2: list[str | int] = [
+                response.reason,
+                url.url(),
+                response.status_code,
+                method,
+                "\n".join(
+                    [
+                        f"{h}: {v if h not in ('Authorization', 'Cookie') else '***'}"
+                        for h, v in list(headers.items())
+                    ]
+                ),
+            ]
+            if method in ("POST", "PUT") and body is not None:
+                errors += ["--- Query with body ---", "%s"]
+                args2.append(body.decode("utf-8"))
+            errors += ["--- Return content ---", "%s"]
+            args2.append(response.text)
+            _LOG.error("\n".join(errors), *args2)
+
+            raise exception_response(response.status_code)
+        if not response.headers.get("Content-Type", "").startswith("image/"):
+            _LOG.debug("Get result for URL: %s:\n%s.", url, body)
+
+        return response
+
+    @_CACHE_REGION.cache_on_arguments()
+    def _proxy_cache(self, host: str, method: str, *args: Any, **kwargs: Any) -> pyramid.response.Response:
+        # Method is only for the cache
+        del host, method
+
+        kwargs["cache"] = True
+        return self._proxy(*args, **kwargs)
+
+    def _proxy_response(
+        self,
+        service_name: str,
+        url: Url,
+        headers_update: dict[str, str] | None = None,
+        public: bool = False,
+        **kwargs: Any,
+    ) -> pyramid.response.Response:
+        if headers_update is None:
+            headers_update = {}
+        cache = kwargs.get("cache", False)
+        if cache is True:
+            response = self._proxy_cache(url, self.request.host, self.request.method, **kwargs)
+        else:
+            response = self._proxy(url, **kwargs)
+
+        cache_control = (
+            (Cache.PUBLIC if public else Cache.PRIVATE)
+            if cache
+            else (Cache.PUBLIC_NO if public else Cache.PRIVATE_NO)
+        )
+        return self._build_response(
+            response, response.content, cache_control, service_name, headers_update=headers_update
+        )
+
+    def _build_response(
+        self,
+        response: pyramid.response.Response,
+        content: bytes,
+        cache_control: Cache,
+        service_name: str,
+        headers: dict[str, str] | None = None,
+        headers_update: dict[str, str] | None = None,
+        content_type: str | None = None,
+    ) -> pyramid.response.Response:
+        if headers_update is None:
+            headers_update = {}
+        headers = response.headers if headers is None else headers
+
+        # Hop-by-hop Headers are not supported by WSGI
+        # See:
+        # https://www.python.org/dev/peps/pep-3333/#other-http-features
+        # chapter 13.5.1 at https://www.faqs.org/rfcs/rfc2616.html
+        for header in [
+            "Connection",
+            "Keep-Alive",
+            "Proxy-Authenticate",
+            "Proxy-Authorization",
+            "te",
+            "Trailers",
+            "Transfer-Encoding",
+            "Upgrade",
+        ]:
+            if header in headers:
+                del headers[header]
+        # Other problematic headers
+        for header in ["Content-Length", "Content-Location", "Content-Encoding"]:
+            if header in headers:
+                del headers[header]
+
+        headers.update(headers_update)
+
+        response = pyramid.response.Response(content, status=response.status_code, headers=headers)
+
+        return set_common_headers(
+            self.request, service_name, cache_control, response=response, content_type=content_type
+        )
+
+    @staticmethod
+    def _get_lower_params(params: dict[str, str]) -> dict[str, str]:
+        return {k.lower(): str(v).lower() for k, v in params.items()}
+
+    def get_headers(self) -> dict[str, str]:
+        headers: dict[str, str] = self.request.headers
+        if "Cookie" in headers:
+            headers.pop("Cookie")
+        if "Authorization" in headers:
+            headers.pop("Authorization")
+        return headers