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

c2cgeoportal_geoportal/views/__init__.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
@@ -27,17 +25,36 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
+from typing import Dict, List
 
+import pyramid.config
+import pyramid.request
 from pyramid.httpexceptions import HTTPFound
 
 
-def add_ending_slash(request):
+def add_ending_slash(request: pyramid.request.Request) -> HTTPFound:
+    """Add an ending slash view."""
     return HTTPFound(location=request.path + "/")
 
 
-def add_redirect(config, name, from_, to):
-    def redirect_view(request):
+def add_redirect(config: pyramid.config.Configurator, name: str, from_: str, to: str) -> None:
+    """Add a redirect view."""
+
+    def redirect_view(request: pyramid.request.Request) -> HTTPFound:
         return HTTPFound(location=request.route_url(to))
 
     config.add_route(name, from_, request_method="GET")
     config.add_view(redirect_view, route_name=name)
+
+
+def restrict_headers(headers: Dict[str, str], whitelist: List[str], blacklist: List[str]) -> Dict[str, str]:
+    """
+    Filter headers with a whitelist then a blacklist.
+
+    Some default pyramid headers will be added back by pyramid.
+    """
+    if len(whitelist) > 0:
+        headers = {key: value for key, value in headers.items() if key in whitelist}
+
+    headers = {key: value for key, value in headers.items() if key not in blacklist}
+    return headers

c2cgeoportal_geoportal/views/dev.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2020, Camptocamp SA
+# Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -31,25 +29,29 @@
 import logging
 import re
 
+import pyramid.request
+import pyramid.response
 from pyramid.httpexceptions import HTTPFound
 from pyramid.view import view_config
 
+from c2cgeoportal_commons.lib.url import Url
 from c2cgeoportal_geoportal.views.proxy import Proxy
 
 logger = logging.getLogger(__name__)
 
 
 class Dev(Proxy):
+    """All the development views."""
 
     THEME_RE = re.compile(r"/theme/.*$")
 
-    def __init__(self, request):
+    def __init__(self, request: pyramid.request.Request):
         super().__init__(request)
         self.dev_url = self.request.registry.settings["devserver_url"]
 
-    @view_config(route_name="dev")
-    def dev(self):
+    @view_config(route_name="dev")  # type: ignore
+    def dev(self) -> pyramid.response.Response:
         path = self.THEME_RE.sub("", self.request.path_info)
         if self.request.path.endswith("/dynamic.js"):
             return HTTPFound(location=self.request.route_url("dynamic", _query=self.request.params))
-        return self._proxy_response("dev", "{}/{}".format(self.dev_url.rstrip("/"), path.lstrip("/")))
+        return self._proxy_response("dev", Url(f"{self.dev_url.rstrip('/')}/{path.lstrip('/')}"))

c2cgeoportal_geoportal/views/dynamic.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2021, Camptocamp SA
+# Copyright (c) 2018-2025, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -30,8 +28,9 @@
 
 import re
 import urllib.parse
-from typing import Dict, List, Union
+from typing import Any, Dict, List, Union, cast
 
+import pyramid.request
 from pyramid.httpexceptions import HTTPNotFound
 from pyramid.view import view_config
 from sqlalchemy import func
@@ -39,22 +38,25 @@ from sqlalchemy import func
 from c2cgeoportal_commons import models
 from c2cgeoportal_commons.models import main
 from c2cgeoportal_geoportal.lib.cacheversion import get_cache_version
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, get_region, set_common_headers
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 
 CACHE_REGION = get_region("std")
 
 
 class DynamicView:
-    def __init__(self, request):
+    """The dynamic vies that provide the configuration of the client application."""
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
         self.settings = request.registry.settings
         self.interfaces_config = self.settings["interfaces_config"]
 
-    def get(self, value, interface):
-        return self.interfaces_config.get(interface, {}).get(value, {})
+    def get(self, value: Dict[str, Any], interface: str) -> Dict[str, Any]:
+        return cast(Dict[str, Any], self.interfaces_config.get(interface, {}).get(value, {}))
 
-    @CACHE_REGION.cache_on_arguments()
-    def _fulltextsearch_groups(self):  # pylint: disable=no-self-use
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def _fulltextsearch_groups(self) -> List[str]:
         return [
             group[0]
             for group in models.DBSession.query(func.distinct(main.FullTextSearch.layer_name))
@@ -62,11 +64,30 @@ class DynamicView:
             .all()
         ]
 
-    def _interface(self, interface_config, interface_name, dynamic):
+    def _interface(
+        self,
+        interface_config: Dict[str, Any],
+        interface_name: str,
+        original_interface_name: str,
+        dynamic: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Get the interface configuration.
+
+        Arguments:
+
+            interface_config: Current interface configuration
+            interface_name: Interface name (we use in the configuration)
+            original_interface_name: Original interface name (directly for the query string)
+            dynamic: The values that's dynamically generated
+        """
 
         if "extends" in interface_config:
             constants = self._interface(
-                self.interfaces_config[interface_config["extends"]], interface_name, dynamic
+                self.interfaces_config[interface_config["extends"]],
+                interface_name,
+                original_interface_name,
+                dynamic,
             )
         else:
             constants = {}
@@ -87,7 +108,7 @@ class DynamicView:
         )
 
         for constant, config in interface_config.get("routes", {}).items():
-            route_name = interface_name if config.get("currentInterface", False) else config["name"]
+            route_name = original_interface_name if config.get("currentInterface", False) else config["name"]
             params: Dict[str, str] = {}
             params.update(config.get("params", {}))
             for name, dyn in config.get("dynamic_params", {}).items():
@@ -98,14 +119,29 @@ class DynamicView:
 
         return constants
 
-    @view_config(route_name="dynamic", renderer="json")
-    def dynamic(self):
-        interface_name = self.request.get_organization_interface(self.request.params.get("interface"))
+    @view_config(route_name="dynamic", renderer="json")  # type: ignore
+    def dynamic(self) -> Dict[str, Any]:
+        self.request.response.headers["Vary"] = "Host"
+        original_interface_name = self.request.params.get("interface")
+        interface_name = self.request.get_organization_interface(original_interface_name)
 
         if interface_name not in self.interfaces_config:
             raise HTTPNotFound("Interface {} doesn't exists in the 'interfaces_config'.")
 
         interface_config = self.interfaces_config[interface_name]
+        lang_urls_suffix = interface_config.get("lang_urls_suffix", "")
+
+        i18next_configuration = self.settings.get("i18next", {})
+        i18next_configuration.setdefault("backend", {})
+        if "loadPath" not in i18next_configuration["backend"]:
+            path: List[str] = [
+                self.request.route_url("base").rstrip("/"),
+                "static-{{ns}}",
+                get_cache_version(),
+                "locales",
+                "{{lng}}.json",
+            ]
+            i18next_configuration["backend"]["loadPath"] = "/".join(path)
 
         dynamic = {
             "interface": interface_name,
@@ -113,14 +149,15 @@ class DynamicView:
             "two_factor": self.request.registry.settings.get("authentication", {}).get("two_factor", False),
             "lang_urls": {
                 lang: self.request.static_url(
-                    "/etc/geomapfish/static/{lang}.json".format(lang=lang),
+                    f"/etc/geomapfish/static/{lang}{lang_urls_suffix}.json",
                 )
                 for lang in self.request.registry.settings["available_locale_names"]
             },
+            "i18next_configuration": i18next_configuration,
             "fulltextsearch_groups": self._fulltextsearch_groups(),
         }
 
-        constants = self._interface(interface_config, interface_name, dynamic)
+        constants = self._interface(interface_config, interface_name, original_interface_name, dynamic)
 
         do_redirect = False
         url = None
@@ -159,5 +196,5 @@ class DynamicView:
                 else:
                     constants["redirectUrl"] = no_redirect_url
 
-        set_common_headers(self.request, "dynamic", NO_CACHE)
+        set_common_headers(self.request, "dynamic", Cache.PUBLIC_NO)
         return {"constants": constants, "doRedirect": do_redirect, "redirectUrl": url}

c2cgeoportal_geoportal/views/entry.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,52 +26,115 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+import glob
 import logging
-import xml.dom.minidom  # noqa # pylint: disable=unused-import
-from typing import Dict, Set, Tuple  # noqa # pylint: disable=unused-import
+from typing import Any, Dict, List, Optional
 
+import pyramid.request
 from pyramid.i18n import TranslationStringFactory
 from pyramid.view import view_config
 
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, PUBLIC_CACHE, set_common_headers
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 
 _ = TranslationStringFactory("c2cgeoportal")
 LOG = logging.getLogger(__name__)
+CACHE_REGION = get_region("std")
 
 
 class Entry:
-    def __init__(self, request):
+    """All the entry points views."""
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
 
-    @view_config(route_name="testi18n", renderer="testi18n.html")
-    def testi18n(self):  # pragma: no cover
+    @view_config(route_name="testi18n", renderer="testi18n.html")  # type: ignore
+    def testi18n(self) -> Dict[str, Any]:
         _ = self.request.translate
         return {"title": _("title i18n")}
 
-    def get_ngeo_index_vars(self):
-        set_common_headers(self.request, "index", NO_CACHE, content_type="text/html")
+    def get_ngeo_index_vars(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "index", Cache.PUBLIC_NO, content_type="text/html")
+        # Force urllogin to be converted to cookie when requesting the main HTML page
+        self.request.user  # pylint: disable=pointless-statement
         return {}
 
-    def apijs(self):
-        set_common_headers(self.request, "api", PUBLIC_CACHE, content_type="application/javascript")
+    @staticmethod
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def get_apijs(api_name: Optional[str]) -> str:
+        with open("/etc/static-ngeo/api.js", encoding="utf-8") as api_file:
+            api = api_file.read().split("\n")
+        sourcemap = api.pop(-1)
+        if api_name:
+            api += [
+                f"if (window.{api_name} === undefined && window.geomapfishapp) {{",
+                f"  window.{api_name} = window.geomapfishapp;",
+                "}",
+            ]
+        api.append(sourcemap)
+
+        return "\n".join(api)
+
+    @view_config(route_name="apijs")  # type: ignore
+    def apijs(self) -> pyramid.response.Response:
+        self.request.response.text = self.get_apijs(self.request.registry.settings["api"].get("name"))
+        set_common_headers(self.request, "api", Cache.PUBLIC, content_type="application/javascript")
+        return self.request.response
+
+    def favicon(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "index", Cache.PUBLIC, content_type="image/vnd.microsoft.icon")
         return {}
 
-    def favicon(self):
-        set_common_headers(self.request, "index", NO_CACHE, content_type="image/vnd.microsoft.icon")
+    def robot_txt(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "index", Cache.PUBLIC, content_type="text/plain")
         return {}
 
-    def robot_txt(self):
-        set_common_headers(self.request, "index", NO_CACHE, content_type="text/plain")
+    def apijsmap(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "api", Cache.PUBLIC, content_type="application/octet-stream")
         return {}
 
-    def apijsmap(self):
-        set_common_headers(self.request, "api", NO_CACHE, content_type="application/octet-stream")
+    def apicss(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "api", Cache.PUBLIC, content_type="text/css")
         return {}
 
-    def apicss(self):
-        set_common_headers(self.request, "api", PUBLIC_CACHE, content_type="text/css")
+    def apihelp(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "apihelp", Cache.PUBLIC)
         return {}
 
-    def apihelp(self):
-        set_common_headers(self.request, "apihelp", NO_CACHE)
-        return {}
+
+def _get_ngeo_resources(pattern: str) -> List[str]:
+    """Return the list of ngeo dist files matching the pattern."""
+    return glob.glob(f"/opt/c2cgeoportal/geoportal/node_modules/ngeo/dist/{pattern}")
+
+
+def canvas_view(request: pyramid.request.Request, interface_config: Dict[str, Any]) -> Dict[str, Any]:
+    """Get view used as entry point of a canvas interface."""
+
+    js_files = _get_ngeo_resources(f"{interface_config.get('layout', interface_config['name'])}*.js")
+    css_files = _get_ngeo_resources(f"{interface_config.get('layout', interface_config['name'])}*.css")
+    css = "\n    ".join(
+        [
+            f'<link href="{request.static_url(css)}" rel="stylesheet" crossorigin="anonymous">'
+            for css in css_files
+        ]
+    )
+
+    set_common_headers(request, "index", Cache.PUBLIC_NO, content_type="text/html")
+
+    spinner = ""
+    spinner_filenames = _get_ngeo_resources("spinner*.svg")
+    if spinner_filenames:
+        with open(spinner_filenames[0], encoding="utf-8") as spinner_file:
+            spinner = spinner_file.read()
+
+    return {
+        "request": request,
+        "header": f"""
+<meta name="dynamicUrl" content="{request.route_url("dynamic")}">
+<meta name="interface" content="{interface_config['name']}">
+{css}""",
+        "footer": "\n    ".join(
+            [f'<script src="{request.static_url(js)}" crossorigin="anonymous"></script>' for js in js_files]
+        ),
+        "spinner": spinner,
+    }

c2cgeoportal_geoportal/views/fulltextsearch.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -29,7 +27,9 @@
 
 
 import re
+from typing import cast
 
+import pyramid.request
 from geoalchemy2.shape import to_shape
 from geojson import Feature, FeatureCollection
 from pyramid.httpexceptions import HTTPBadRequest, HTTPInternalServerError
@@ -39,7 +39,8 @@ from sqlalchemy import and_, desc, func, or_
 from c2cgeoportal_commons.models import DBSession
 from c2cgeoportal_commons.models.main import FullTextSearch, Interface
 from c2cgeoportal_geoportal import locale_negotiator
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, get_region, set_common_headers
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 from c2cgeoportal_geoportal.lib.fulltextsearch import Normalize
 
 CACHE_REGION = get_region("std")
@@ -48,30 +49,32 @@ IGNORED_STARTUP_CHARS_RE = re.compile(r"^[']*")
 
 
 class FullTextSearchView:
-    def __init__(self, request):
+    """All the full-text search view."""
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
-        set_common_headers(request, "fulltextsearch", NO_CACHE)
+        set_common_headers(request, "fulltextsearch", Cache.PUBLIC_NO)
         self.settings = request.registry.settings.get("fulltextsearch", {})
         self.languages = self.settings.get("languages", {})
-        self.fts_normiliser = Normalize(self.settings)
+        self.fts_normalizer = Normalize(self.settings)
 
     @staticmethod
-    @CACHE_REGION.cache_on_arguments()
-    def _get_interface_id(interface):
-        return DBSession.query(Interface).filter_by(name=interface).one().id
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def _get_interface_id(interface: str) -> int:
+        return cast(int, DBSession.query(Interface).filter_by(name=interface).one().id)
 
-    @view_config(route_name="fulltextsearch", renderer="geojson")
-    def fulltextsearch(self):
+    @view_config(route_name="fulltextsearch", renderer="geojson")  # type: ignore
+    def fulltextsearch(self) -> FeatureCollection:
         lang = locale_negotiator(self.request)
 
         try:
             language = self.languages[lang]
         except KeyError:
-            return HTTPInternalServerError(detail="{0!s} not defined in languages".format(lang))
+            return HTTPInternalServerError(detail=f"{lang!s} not defined in languages")
 
         if "query" not in self.request.params:
             return HTTPBadRequest(detail="no query")
-        terms = self.fts_normiliser(self.request.params.get("query"))
+        terms = self.fts_normalizer(self.request.params.get("query"))
 
         maxlimit = self.settings.get("maxlimit", 200)
 
@@ -79,15 +82,13 @@ class FullTextSearchView:
             limit = int(self.request.params.get("limit", self.settings.get("defaultlimit", 30)))
         except ValueError:
             return HTTPBadRequest(detail="limit value is incorrect")
-        if limit > maxlimit:
-            limit = maxlimit
+        limit = min(limit, maxlimit)
 
         try:
             partitionlimit = int(self.request.params.get("partitionlimit", 0))
         except ValueError:
             return HTTPBadRequest(detail="partitionlimit value is incorrect")
-        if partitionlimit > maxlimit:
-            partitionlimit = maxlimit
+        partitionlimit = min(partitionlimit, maxlimit)
 
         terms_array = [
             IGNORED_STARTUP_CHARS_RE.sub("", elem) for elem in IGNORED_CHARS_RE.sub(" ", terms).split(" ")
@@ -144,21 +145,26 @@ class FullTextSearchView:
                 .over(partition_by=FullTextSearch.layer_name, order_by=(desc(rank), FullTextSearch.label))
                 .label("row_number")
             )
-            subq = DBSession.query(FullTextSearch).add_columns(row_number).filter(_filter).subquery()
+            sub_query = DBSession.query(FullTextSearch).add_columns(row_number).filter(_filter).subquery()
             query = DBSession.query(
-                subq.c.id, subq.c.label, subq.c.params, subq.c.layer_name, subq.c.the_geom, subq.c.actions
+                sub_query.c.id,
+                sub_query.c.label,
+                sub_query.c.params,
+                sub_query.c.layer_name,
+                sub_query.c.the_geom,
+                sub_query.c.actions,
             )
-            query = query.filter(subq.c.row_number <= partitionlimit)
+            query = query.filter(sub_query.c.row_number <= partitionlimit)
         else:
             query = DBSession.query(FullTextSearch).filter(_filter)
             query = query.order_by(desc(rank))
             query = query.order_by(FullTextSearch.label)
 
         query = query.limit(limit)
-        objs = query.all()
+        objects = query.all()
 
         features = []
-        for o in objs:
+        for o in objects:
             properties = {"label": o.label}
             if o.layer_name is not None:
                 properties["layer_name"] = o.layer_name

c2cgeoportal_geoportal/views/geometry_processing.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,28 +26,38 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+from typing import Optional
+
+import pyramid.request
 from geoalchemy2.shape import from_shape, to_shape
 from geojson import loads
 from pyramid.httpexceptions import HTTPBadRequest
 from pyramid.view import view_config
-from shapely.geometry import asShape
+from shapely.geometry import shape
+from shapely.geometry.base import BaseGeometry
 from sqlalchemy import func
 
 from c2cgeoportal_commons.models import DBSession
 
 
 class GeometryProcessing:
-    def __init__(self, request):
+    """
+    View used to provide processing on a geometry.
+
+    Currently only difference between geometries.
+    """
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
 
-    @view_config(route_name="difference", renderer="geojson")
-    def difference(self):
+    @view_config(route_name="difference", renderer="geojson")  # type: ignore
+    def difference(self) -> Optional[BaseGeometry]:
         body = loads(self.request.body)
         if (
             "geometries" not in body
             or not isinstance(body["geometries"], list)
             or len(body["geometries"]) != 2
-        ):  # pragma: no cover
+        ):
             raise HTTPBadRequest(
                 """Wrong body, it should be like that:
             {
@@ -61,7 +69,7 @@ class GeometryProcessing:
         return to_shape(
             DBSession.query(
                 func.ST_Difference(
-                    from_shape(asShape(body["geometries"][0])), from_shape(asShape(body["geometries"][1]))
+                    from_shape(shape(body["geometries"][0])), from_shape(shape(body["geometries"][1]))
                 )
             ).scalar()
         )