c2cgeoportal-geoportal 2.6.0__py2.py3-none-any.whl → 2.8.1.180__py2.py3-none-any.whl

c2cgeoportal_geoportal/views/memory.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2018-2021, Camptocamp SA
 # All rights reserved.
 
@@ -30,8 +28,9 @@
 
 import logging
 import time
-from typing import Any, Dict
+from typing import Any, Dict, cast
 
+import pyramid.request
 from c2cwsgiutils import broadcast
 from c2cwsgiutils.auth import auth_view
 from c2cwsgiutils.debug import get_size
@@ -43,27 +42,28 @@ from c2cgeoportal_geoportal.views import raster
 LOG = logging.getLogger(__name__)
 
 
-@view_config(route_name="memory", renderer="fast_json")
-def memory(request):
+@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 _memory()
+    return cast(Dict[str, Any], _memory())
 
 
-def _nice_type_name(obj, dogpile_cache=False):
+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 "{}.{}".format(type_.__module__, type_.__name__)
+    return f"{type_.__module__}.{type_.__name__}"
 
 
-def _process_dict(dict_, dogpile_cache=False):
+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),
@@ -72,8 +72,8 @@ def _process_dict(dict_, dogpile_cache=False):
                     "size_kb": get_size(value) / 1024 if time.monotonic() < timeout else -1,
                 }
                 for key, value in dict_.items()
-            ],
-            key=lambda i: -i["size_kb"],
+            ),
+            key=lambda i: cast(float, -i["size_kb"]),
         ),
         "id": id(dict_),
         "size_kb": get_size(dict_) / 1024 if time.monotonic() < timeout else -1,

c2cgeoportal_geoportal/views/ogcproxy.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2020, Camptocamp SA
+# Copyright (c) 2011-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,14 +26,14 @@
 # either expressed or implied, of the FreeBSD Project.
 
 import logging
-from typing import Set
+from typing import Dict, Optional, Set, cast
 
+import pyramid.request
 from pyramid.httpexceptions import HTTPBadRequest
 from sqlalchemy.orm.exc import NoResultFound
 
-from c2cgeoportal_commons.lib.url import get_url2
-from c2cgeoportal_commons.models import DBSession
-from c2cgeoportal_commons.models.main import OGCServer
+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
 
@@ -44,54 +42,78 @@ LOG = logging.getLogger(__name__)
 
 
 class OGCProxy(Proxy):
-    def __init__(self, request, has_default_ogc_server=False):
+    """
+    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:  # pragma: no cover
+        if "role_id" in self.params:
             del self.params["role_id"]
-        if "user_id" in self.params:  # pragma: no cover
+        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)
-        if not has_default_ogc_server and "ogcserver" not in 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")
-        if "ogcserver" in self.params:
-            self.ogc_server = self._get_ogcserver_byname(self.params["ogcserver"])
 
-    @CACHE_REGION.cache_on_arguments()
-    def _get_ogcserver_byname(self, name):  # pylint: disable=no-self-use
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def _get_ogcserver_byname(self, name: str) -> main.OGCServer:
         try:
-            result = DBSession.query(OGCServer).filter(OGCServer.name == name).one()
+            result = DBSession.query(main.OGCServer).filter(main.OGCServer.name == name).one()
             DBSession.expunge(result)
-            return result
-        except NoResultFound:  # pragma nocover
-            raise HTTPBadRequest(
-                "OGSServer '{}' does not exists (existing: {}).".format(
-                    name, ",".join([t[0] for t in DBSession.query(OGCServer.name).all()])
-                )
+            return cast(main.OGCServer, 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):
+    def _get_wms_url(self, errors: Set[str]) -> Optional[Url]:
         ogc_server = self.ogc_server
-        errors: Set[str] = set()
-        url = get_url2("The OGC server '{}'".format(ogc_server.name), ogc_server.url, self.request, errors)
-        if errors:  # pragma: no cover
+        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):
+    def _get_wfs_url(self, errors: Set[str]) -> Optional[Url]:
         ogc_server = self.ogc_server
-        errors: Set[str] = set()
         url = get_url2(
-            "The OGC server (WFS) '{}'".format(ogc_server.name),
+            f"The OGC server (WFS) '{ogc_server.name}'",
             ogc_server.url_wfs or ogc_server.url,
             self.request,
             errors,
         )
-        if errors:  # pragma: no cover
+        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

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -29,44 +27,49 @@
 
 import logging
 from json import dumps, loads
+from typing import Any, Dict, List, Union
 
+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 add_url_params
+from c2cgeoportal_commons.lib.url import Url
 from c2cgeoportal_commons.models import main
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE
+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):  # pragma: no cover
+class PdfReport(OGCProxy):
+    """All the views concerned the PDF report."""
 
     layername = None
 
-    def __init__(self, request):
+    def __init__(self, request: pyramid.request.Request):
         OGCProxy.__init__(self, request)
         self.config = self.request.registry.settings.get("pdfreport", {})
 
-    def _do_print(self, spec):
+    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(
-            "{0!s}/buildreport.{1!s}".format(self.config["print_url"], spec["outputFormat"]),
+            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, NO_CACHE, "pdfreport")
+        return self._build_response(response, response.content, Cache.PRIVATE_NO, "pdfreport")
 
     @staticmethod
-    def _build_map(mapserv_url, vector_request_url, srs, map_config):
+    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 {
@@ -98,19 +101,19 @@ class PdfReport(OGCProxy):  # pragma: no cover
             ],
         }
 
-    @view_config(route_name="pdfreport", renderer="json")
-    def get_report(self):
+    @view_config(route_name="pdfreport", renderer="json")  # type: ignore
+    def get_report(self) -> pyramid.response.Response:
         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(",")
 
-        if layer_config is None:
-            raise HTTPBadRequest("Layer not found")
-
         features_ids = (
             [self.layername + "." + id_ for id_ in ids] if multiple else [self.layername + "." + ids]
         )
@@ -138,8 +141,8 @@ class PdfReport(OGCProxy):  # pragma: no cover
         mapserv_url = self.request.route_url(
             "mapserverproxy", _query={"ogcserver": layer_config["ogc_server"]}
         )
-        vector_request_url = add_url_params(
-            mapserv_url,
+        url = Url(mapserv_url)
+        url.add_query(
             {
                 "service": "WFS",
                 "version": "1.1.0",
@@ -148,8 +151,9 @@ class PdfReport(OGCProxy):  # pragma: no cover
                 "typeName": self.layername,
                 "featureid": ",".join(features_ids),
                 "srsName": srs,
-            },
+            }
         )
+        vector_request_url = url.url()
 
         spec = layer_config["spec"]
         if spec is None:
@@ -221,7 +225,7 @@ class PdfReport(OGCProxy):  # pragma: no cover
 
         return self._do_print(spec)
 
-    def walker(self, spec, name, value):
+    def walker(self, spec: Union[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):
@@ -231,9 +235,9 @@ class PdfReport(OGCProxy):  # pragma: no cover
                     self.walker(v, name, value)
 
         if isinstance(spec, list):
-            for k, v in enumerate(spec):
-                if isinstance(v, str):
-                    if v == name:
-                        spec[k] = value
+            for k2, v2 in enumerate(spec):
+                if isinstance(v2, str):
+                    if v2 == name:
+                        spec[k2] = value
                 else:
-                    self.walker(v, name, value)
+                    self.walker(v2, name, value)

c2cgeoportal_geoportal/views/printproxy.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2024, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -31,12 +29,18 @@
 import json
 import logging
 import urllib.parse
+from typing import Dict, List, Tuple
 
+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 PRIVATE_CACHE, get_region
+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
 
@@ -44,93 +48,97 @@ LOG = logging.getLogger(__name__)
 CACHE_REGION = get_region("std")
 
 
-class PrintProxy(Proxy):  # pragma: no cover
-    def __init__(self, request):
+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")
-    def capabilities(self):
+    @view_config(route_name="printproxy_capabilities")  # type: ignore
+    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)
+        resp, content = self._capabilities(
+            templates, query_string, self.request.method, self.request.referrer, self.request.host
+        )
 
-        return self._build_response(resp, content, PRIVATE_CACHE, "print")
+        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, query_string, method):
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    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
-        # get URL
+        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)
+        response = self._proxy(Url(_url))
+        response.raise_for_status()
 
         if self.request.method == "GET":
-            if response.ok:
-                try:
-                    capabilities = response.json()
-                except json.decoder.JSONDecodeError as e:
-                    # log and raise
-                    LOG.error("Unable to parse capabilities.")
-                    LOG.exception(e)
-                    LOG.error(response.text)
-                    raise HTTPBadGateway(response.text)
-
-                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
-                )
+            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")
-    def report_create(self):
+    @view_config(route_name="printproxy_report_create")  # type: ignore
+    def report_create(self) -> pyramid.response.Response:
         """Create PDF."""
         return self._proxy_response(
             "print",
-            "{0!s}/report.{1!s}".format(
-                self.request.get_organization_print_url(), self.request.matchdict.get("format")
+            Url(
+                f"{ self.request.get_organization_print_url()}/report.{self.request.matchdict.get('format')}"
             ),
         )
 
-    @view_config(route_name="printproxy_status")
-    def status(self):
+    @view_config(route_name="printproxy_status")  # type: ignore
+    def status(self) -> pyramid.response.Response:
         """PDF status."""
         return self._proxy_response(
             "print",
-            "{0!s}/status/{1!s}.json".format(
-                self.request.get_organization_print_url(), self.request.matchdict.get("ref")
+            Url(
+                f"{self.request.get_organization_print_url()}/status/{self.request.matchdict.get('ref')}.json"
             ),
         )
 
-    @view_config(route_name="printproxy_cancel")
-    def cancel(self):
+    @view_config(route_name="printproxy_cancel")  # type: ignore
+    def cancel(self) -> pyramid.response.Response:
         """PDF cancel."""
         return self._proxy_response(
             "print",
-            "{0!s}/cancel/{1!s}".format(
-                self.request.get_organization_print_url(), self.request.matchdict.get("ref")
-            ),
+            Url(f"{self.request.get_organization_print_url()}/cancel/{self.request.matchdict.get('ref')}"),
         )
 
-    @view_config(route_name="printproxy_report_get")
-    def report_get(self):
+    @view_config(route_name="printproxy_report_get")  # type: ignore
+    def report_get(self) -> pyramid.response.Response:
         """Get the PDF."""
-        url = "{0!s}/report/{1!s}".format(
-            self.request.get_organization_print_url(), self.request.matchdict.get("ref")
-        )
+        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)
+            raise HTTPFound(location=url.url())
         return self._proxy_response("print", url)

c2cgeoportal_geoportal/views/profile.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2012-2020, Camptocamp SA
+# Copyright (c) 2012-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -30,33 +28,38 @@
 
 import math
 from decimal import Decimal
+from typing import Any, Dict, List, Tuple
 
 import geojson
+import pyramid.request
 from pyramid.httpexceptions import HTTPNotFound
 from pyramid.i18n import TranslationStringFactory
 from pyramid.view import view_config
 
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, set_common_headers
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 from c2cgeoportal_geoportal.views.raster import Raster
 
 _ = TranslationStringFactory("c2cgeoportal")
 
 
 class Profile(Raster):
-    def __init__(self, request):
+    """All the view concerned the profile."""
+
+    def __init__(self, request: pyramid.request.Request):
         Raster.__init__(self, request)
 
-    @view_config(route_name="profile.json", renderer="fast_json")
-    def json(self):
-        """answers to /profile.json"""
+    @view_config(route_name="profile.json", renderer="fast_json")  # type: ignore
+    def json(self) -> Dict[str, Any]:
+        """Answer to /profile.json."""
         _, points = self._compute_points()
-        set_common_headers(self.request, "profile", NO_CACHE)
+        set_common_headers(self.request, "profile", Cache.PUBLIC_NO)
         return {"profile": points}
 
-    def _compute_points(self):
-        """Compute the alt=fct(dist) array"""
+    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)
 
+        layers: List[str]
         if "layers" in self.request.params:
             rasters = {}
             layers = self.request.params["layers"].split(",")
@@ -64,13 +67,13 @@ class Profile(Raster):
                 if layer in self.rasters:
                     rasters[layer] = self.rasters[layer]
                 else:
-                    raise HTTPNotFound("Layer {0!s} not found".format(layer))
+                    raise HTTPNotFound(f"Layer {layer!s} not found")
         else:
             rasters = self.rasters
             layers = list(rasters.keys())
             layers.sort()
 
-        points = []
+        points: List[Dict[str, Any]] = []
 
         dist = 0
         prev_coord = None
@@ -92,12 +95,12 @@ class Profile(Raster):
         return layers, points
 
     @staticmethod
-    def _dist(coord1, coord2):
-        """Compute the distance between 2 points"""
+    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, nb_points):
-        """Add some points in order to reach roughly the asked number of points"""
+    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:
@@ -108,19 +111,17 @@ class Profile(Raster):
         if total_length == 0.0:
             return coords
 
-        result = []
+        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 = int(nb_points * cur_length / total_length + 0.5)
-                if cur_nb_points < 1:
-                    cur_nb_points = 1
+                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])
+                    result.append((prev_coord[0] + dx * i, prev_coord[1] + dy * i))
             else:
-                result.append([coord[0], coord[1]])
+                result.append((coord[0], coord[1]))
             prev_coord = coord
         return result