c2cgeoportal-geoportal 2.5.0.100__py2.py3-none-any.whl → 2.7.1.156__py2.py3-none-any.whl

c2cgeoportal_geoportal/__init__.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
@@ -27,46 +25,53 @@
 # of the authors and should not be interpreted as representing official policies,
 # either expressed or implied, of the FreeBSD Project.
 
-import binascii
 import importlib
-import json
 import logging
 import os
-import re
-import time
+from functools import partial
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, cast
 from urllib.parse import urlsplit
 
-from Crypto.Cipher import AES  # nosec
 import c2cgeoform
-from c2cgeoform import Form, translator
 import c2cwsgiutils
 import c2cwsgiutils.db
-from c2cwsgiutils.health_check import HealthCheck
 import c2cwsgiutils.index
+import pyramid.config
+import pyramid.renderers
+import pyramid.request
+import pyramid.response
+import pyramid.security
+import zope.event.classhandler
+from c2cgeoform import Form, translator
+from c2cwsgiutils.broadcast import decorator
+from c2cwsgiutils.health_check import HealthCheck
 from c2cwsgiutils.metrics import MemoryMapProvider, add_provider
 from dogpile.cache import register_backend
 from papyrus.renderers import GeoJSON
 from pyramid.config import Configurator
 from pyramid.httpexceptions import HTTPException
 from pyramid.path import AssetResolver
-import pyramid.security
 from pyramid_mako import add_mako_renderer
-from sqlalchemy.orm import Session
-import zope.event.classhandler
+from sqlalchemy.orm import Session, joinedload
 
 import c2cgeoportal_commons.models
+import c2cgeoportal_geoportal.views
 from c2cgeoportal_commons.models import InvalidateCacheEvent
 from c2cgeoportal_geoportal.lib import C2CPregenerator, caching, check_collector, checker
 from c2cgeoportal_geoportal.lib.cacheversion import version_cache_buster
-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.lib.i18n import available_locale_names
 from c2cgeoportal_geoportal.lib.metrics import (
     MemoryCacheSizeProvider,
     RasterDataSizeProvider,
     TotalPythonObjectMemoryProvider,
 )
 from c2cgeoportal_geoportal.lib.xsd import XSD
-import c2cgeoportal_geoportal.views
-from c2cgeoportal_geoportal.views.entry import Entry
+from c2cgeoportal_geoportal.views.entry import Entry, canvas_view
+
+if TYPE_CHECKING:
+    from c2cgeoportal_commons.models import static  # pylint: disable=ungrouped-imports,useless-suppression
+
 
 LOG = logging.getLogger(__name__)
 
@@ -76,64 +81,145 @@ GEOJSON_CONTENT_TYPE = r"Content-Type:application/geo\+json"
 
 
 class AssetRendererFactory:
-    def __init__(self, info):
+    """Get a renderer for the assets."""
+
+    def __init__(self, info: Any):
         del info  # unused
         self.resolver = AssetResolver("c2cgeoportal_geoportal")
 
-    def __call__(self, value, system):
+    def __call__(self, value: Any, system: Dict[str, str]) -> bytes:
+        del value
         asset = self.resolver.resolve(system["renderer_name"])
-        return asset.stream().read()
+        return cast(bytes, asset.stream().read())
 
 
 INTERFACE_TYPE_NGEO = "ngeo"
+INTERFACE_TYPE_CANVAS = "canvas"
 
 
-def add_interface(
-    config, interface_name="desktop", interface_type=INTERFACE_TYPE_NGEO, default=False, **kwargs
-):  # pragma: no cover
-    del interface_type  # unused
-    route = "/" if default else "/{}".format(interface_name)
-    add_interface_ngeo(
+def add_interface_config(config: pyramid.config.Configurator, interface_config: Dict[str, Any]) -> None:
+    """Add the interface (desktop, mobile, ...) views and routes with only the config."""
+    add_interface(
         config,
-        route_name=interface_name,
-        route=route,
-        renderer="/etc/static-ngeo/{}.html".format(interface_name),
-        **kwargs,
+        interface_config["name"],
+        interface_config.get("type", INTERFACE_TYPE_NGEO),
+        interface_config,
+        default=interface_config.get("default", False),
     )
 
 
-def add_interface_ngeo(config, route_name, route, renderer=None, permission=None):  # pragma: no cover
+def add_interface(
+    config: pyramid.config.Configurator,
+    interface_name: str = "desktop",
+    interface_type: str = INTERFACE_TYPE_NGEO,
+    interface_config: Optional[Dict[str, Any]] = None,
+    default: bool = False,
+    **kwargs: Any,
+) -> None:
+    """Add the interface (desktop, mobile, ...) views and routes."""
+    route = "/" if default else f"/{interface_name}"
+    if interface_type == INTERFACE_TYPE_NGEO:
+        add_interface_ngeo(
+            config,
+            route_name=interface_name,
+            route=route,
+            renderer=f"/etc/static-ngeo/{interface_name}.html",
+            **kwargs,
+        )
+    elif interface_type == INTERFACE_TYPE_CANVAS:
+        assert interface_config is not None
+        add_interface_canvas(
+            config,
+            route_name=interface_name,
+            route=route,
+            interface_config=interface_config,
+            **kwargs,
+        )
+    else:
+        LOG.error(
+            "Unknown interface type '%s', should be '%s' or '%s'.",
+            interface_type,
+            INTERFACE_TYPE_NGEO,
+            INTERFACE_TYPE_CANVAS,
+        )
+
+
+def add_interface_ngeo(
+    config: pyramid.config.Configurator,
+    route_name: str,
+    route: str,
+    renderer: Optional[str] = None,
+    permission: Optional[str] = None,
+) -> None:
+    """Add the ngeo interfaces views and routes."""
 
     config.add_route(route_name, route, request_method="GET")
-    config.add_view(
-        Entry, attr="get_ngeo_index_vars", route_name=route_name, renderer=renderer, permission=permission
-    )
     # Permalink theme: recover the theme for generating custom viewer.js url
     config.add_route(
-        "{}theme".format(route_name),
-        "{}{}theme/{{themes}}".format(route, "" if route[-1] == "/" else "/"),
+        f"{route_name}theme",
+        f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}",
         request_method="GET",
     )
+    config.add_view(
+        Entry, attr="get_ngeo_index_vars", route_name=route_name, renderer=renderer, permission=permission
+    )
     config.add_view(
         Entry,
         attr="get_ngeo_index_vars",
-        route_name="{}theme".format(route_name),
+        route_name=f"{route_name}theme",
+        renderer=renderer,
+        permission=permission,
+    )
+
+
+def add_interface_canvas(
+    config: pyramid.config.Configurator,
+    route_name: str,
+    route: str,
+    interface_config: Dict[str, Any],
+    permission: Optional[str] = None,
+) -> None:
+    """Add the ngeo interfaces views and routes."""
+
+    renderer = f"/etc/geomapfish/interfaces/{route_name}.html.mako"
+    config.add_route(route_name, route, request_method="GET")
+    # Permalink theme: recover the theme for generating custom viewer.js URL
+    config.add_route(
+        f"{route_name}theme",
+        f"{route}{'' if route[-1] == '/' else '/'}theme/{{themes}}",
+        request_method="GET",
+    )
+    view = partial(canvas_view, interface_config=interface_config)
+    view.__module__ = canvas_view.__module__
+    config.add_view(
+        view,
+        route_name=route_name,
+        renderer=renderer,
+        permission=permission,
+    )
+    config.add_view(
+        view,
+        route_name=f"{route_name}theme",
         renderer=renderer,
         permission=permission,
     )
 
 
-def add_admin_interface(config):
+def add_admin_interface(config: pyramid.config.Configurator) -> None:
+    """Add the administration interface views and routes."""
     if config.get_settings().get("enable_admin_interface", False):
         config.add_request_method(
-            lambda request: c2cgeoportal_commons.models.DBSession(), "dbsession", reify=True,
+            lambda request: c2cgeoportal_commons.models.DBSession(),
+            "dbsession",
+            reify=True,
         )
         config.add_view(c2cgeoportal_geoportal.views.add_ending_slash, route_name="admin_add_ending_slash")
         config.add_route("admin_add_ending_slash", "/admin", request_method="GET")
         config.include("c2cgeoportal_admin")
 
 
-def add_getitfixed(config):
+def add_getitfixed(config: pyramid.config.Configurator) -> None:
+    """Add the get it fixed views and routes."""
     if config.get_settings()["getitfixed"].get("enabled", False):
         for route_name, pattern in (
             ("getitfixed_add_ending_slash", "/getitfixed"),
@@ -146,8 +232,9 @@ def add_getitfixed(config):
         Form.set_zpt_renderer(c2cgeoform.default_search_paths, translator=translator)
 
 
-def locale_negotiator(request):
-    lang = request.params.get("lang")
+def locale_negotiator(request: pyramid.request.Request) -> str:
+    """Get the current language."""
+    lang: str = request.params.get("lang")
     if lang is None:
         lang = request.cookies.get("_LOCALE_")
     else:
@@ -161,30 +248,34 @@ def locale_negotiator(request):
     return lang
 
 
-def _match_url_start(reference, value):
-    """
-    Checks that the val URL starts like the ref URL.
-    """
+def _match_url_start(reference: str, value: List[str]) -> bool:
+    """Check that the val URL starts like the ref URL."""
     reference_parts = reference.rstrip("/").split("/")
-    # fmt: off
-    value_parts = value[0:len(reference_parts)]
-    # fmt: on
+    value_parts = value[0 : len(reference_parts)]
     return reference_parts == value_parts
 
 
-def is_valid_referer(request, settings=None):
+def is_valid_referrer(request: pyramid.request.Request, settings: Optional[Dict[str, Any]] = None) -> bool:
+    """Check if the referrer is valid."""
     if request.referer is not None:
-        referer = urlsplit(request.referer)._replace(query="", fragment="").geturl().rstrip("/").split("/")
+        referrer = urlsplit(request.referer)._replace(query="", fragment="").geturl().rstrip("/").split("/")
         if settings is None:
             settings = request.registry.settings
         list_ = settings.get("authorized_referers", [])
-        return any(_match_url_start(e, referer) for e in list_)
+        return any(_match_url_start(e, referrer) for e in list_)
     return True
 
 
-def create_get_user_from_request(settings):
-    def get_user_from_request(request, username=None):
-        """ Return the User object for the request.
+def create_get_user_from_request(
+    settings: Dict[str, Any]
+) -> Callable[[pyramid.request.Request, Optional[str]], Optional["static.User"]]:
+    """Get the get_user_from_request function."""
+
+    def get_user_from_request(
+        request: pyramid.request.Request, username: Optional[str] = None
+    ) -> Optional["static.User"]:
+        """
+        Return the User object for the request.
 
         Return ``None`` if:
         * user is anonymous
@@ -194,35 +285,8 @@ def create_get_user_from_request(settings):
         from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
         from c2cgeoportal_commons.models.static import User  # pylint: disable=import-outside-toplevel
 
-        try:
-            if request.method == "GET" and "auth" in request.params:
-                auth_enc = request.params.get("auth")
-
-                if auth_enc is not None:
-                    urllogin = request.registry.settings.get("urllogin", {})
-                    aeskey = urllogin.get("aes_key")
-                    if aeskey is None:  # pragma: nocover
-                        raise Exception("urllogin is not configured")
-                    now = int(time.time())
-                    data = binascii.unhexlify(auth_enc.encode("ascii"))
-                    nonce = data[0:16]
-                    tag = data[16:32]
-                    ciphertext = data[32:]
-                    cipher = AES.new(aeskey.encode("ascii"), AES.MODE_EAX, nonce)
-                    auth = json.loads(
-                        cipher.decrypt_and_verify(ciphertext, tag).decode("utf-8")  # type: ignore
-                    )
-
-                    if "t" in auth and "u" in auth and "p" in auth:
-                        timestamp = int(auth["t"])
-                        if now < timestamp and request.registry.validate_user(request, auth["u"], auth["p"]):
-                            headers = pyramid.security.remember(request, auth["u"])
-                            request.response.headerlist.extend(headers)
-        except Exception as e:
-            LOG.error("URL login error: %s.", e, exc_info=True)
-
         if not hasattr(request, "is_valid_referer"):
-            request.is_valid_referer = is_valid_referer(request, settings)
+            request.is_valid_referer = is_valid_referrer(request, settings)
         if not request.is_valid_referer:
             LOG.debug("Invalid referer for %s: %s", request.path_qs, repr(request.referer))
             return None
@@ -234,15 +298,20 @@ def create_get_user_from_request(settings):
             if username is not None:
                 # We know we will need the role object of the
                 # user so we use joined loading
-                request.user_ = DBSession.query(User).filter_by(username=username).first()
+                request.user_ = (
+                    DBSession.query(User).filter_by(username=username).options(joinedload("roles")).first()
+                )
 
-        return request.user_
+        return cast(User, request.user_)
 
     return get_user_from_request
 
 
-def set_user_validator(config, user_validator):
-    """ Call this function to register a user validator function.
+def set_user_validator(
+    config: pyramid.config.Configurator, user_validator: Callable[[pyramid.request.Request, str, str], str]
+) -> None:
+    """
+    Call this function to register a user validator function.
 
     The validator function is passed three arguments: ``request``,
     ``username``, and ``password``. The function should return the
@@ -258,11 +327,12 @@ def set_user_validator(config, user_validator):
     config.action("user_validator", register)
 
 
-def default_user_validator(request, username, password):
+def default_user_validator(request: pyramid.request.Request, username: str, password: str) -> Optional[str]:
     """
-    Validate the username/password. This is c2cgeoportal's
-    default user validator.
-    Return None if we are anonymous, the string to remember otherwise.
+    Validate the username/password.
+
+    This is c2cgeoportal's default user validator. Return None if we are anonymous, the string to remember
+    otherwise.
     """
     del request  # unused
     from c2cgeoportal_commons.models import DBSession  # pylint: disable=import-outside-toplevel
@@ -270,7 +340,7 @@ def default_user_validator(request, username, password):
 
     user = DBSession.query(User).filter_by(username=username).first()
     if user is None:
-        LOG.info('Unknow user "%s" tried to log in', username)
+        LOG.info('Unknown user "%s" tried to log in', username)
         return None
     if user.deactivated:
         LOG.info('Deactivated user "%s" tried to log in', username)
@@ -285,49 +355,52 @@ def default_user_validator(request, username, password):
 
 
 class MapserverproxyRoutePredicate:
-    """ Serve as a custom route predicate function for mapserverproxy.
-    If the hide_capabilities setting is set and is true then we want to
-    return 404s on GetCapabilities requests."""
+    """
+    Serve as a custom route predicate function for mapserverproxy.
+
+    If the hide_capabilities setting is set and is true then we want to return 404s on GetCapabilities
+    requests.
+    """
 
-    def __init__(self, val, config):
-        pass
+    def __init__(self, val: Any, config: pyramid.config.Configurator) -> None:
+        del val, config
 
-    def __call__(self, context, request):
+    def __call__(self, context: Any, request: pyramid.request.Request) -> bool:
+        del context
         hide_capabilities = request.registry.settings.get("hide_capabilities")
         if not hide_capabilities:
             return True
-        params = dict((k.lower(), v.lower()) for k, v in request.params.items())
+        params = {k.lower(): v.lower() for k, v in request.params.items()}
         return "request" not in params or params["request"] not in ("getcapabilities", "capabilities")
 
     @staticmethod
-    def text():
+    def text() -> str:
         return "mapserverproxy"
 
     phash = text
 
 
-def add_cors_route(config, pattern, service):
-    """
-    Add the OPTIONS route and view need for services supporting CORS.
-    """
+def add_cors_route(config: pyramid.config.Configurator, pattern: str, service: str) -> None:
+    """Add the OPTIONS route and view need for services supporting CORS."""
 
-    def view(request):  # pragma: no cover
-        return set_common_headers(request, service, NO_CACHE)
+    def view(request: pyramid.request.Request) -> pyramid.response.Response:
+        return set_common_headers(request, service, Cache.PRIVATE_NO)
 
     name = pattern + "_options"
     config.add_route(name, pattern, request_method="OPTIONS")
     config.add_view(view, route_name=name)
 
 
-def error_handler(http_exception, request):  # pragma: no cover
-    """
-    View callable for handling all the exceptions that are not already handled.
-    """
+def error_handler(
+    http_exception: HTTPException, request: pyramid.request.Request
+) -> pyramid.response.Response:
+    """View callable for handling all the exceptions that are not already handled."""
     LOG.warning("%s returned status code %s", request.url, http_exception.status_code)
-    return caching.set_common_headers(request, "error", caching.NO_CACHE, http_exception)
+    return set_common_headers(request, "error", Cache.PRIVATE_NO, http_exception)
 
 
-def call_hook(settings, name, *args, **kwargs):
+def call_hook(settings: pyramid.config.Configurator, name: str, *args: Any, **kwargs: Any) -> None:
+    """Call the hook defined in the settings."""
     hooks = settings.get("hooks", {})
     hook = hooks.get(name)
     if hook is None:
@@ -338,24 +411,32 @@ def call_hook(settings, name, *args, **kwargs):
     function_(*args, **kwargs)
 
 
-def includeme(config: pyramid.config.Configurator):
-    """
-    This function returns a Pyramid WSGI application.
-    """
-
+def includeme(config: pyramid.config.Configurator) -> None:
+    """Get the Pyramid WSGI application."""
     settings = config.get_settings()
 
-    config.include("c2cgeoportal_commons")
+    if "available_locale_names" not in settings:
+        settings["available_locale_names"] = available_locale_names()
 
     call_hook(settings, "after_settings", settings)
 
     get_user_from_request = create_get_user_from_request(settings)
     config.add_request_method(get_user_from_request, name="user", property=True)
     config.add_request_method(get_user_from_request, name="get_user")
+    # Be able for an organization to override the method to use alternate:
+    # - Organization roles name for the standard roles 'anonymous', 'registered' and 'intranet'.
+    config.add_request_method(lambda request, role_type: role_type, name="get_organization_role")
+    # - Organization print URL
+    config.add_request_method(
+        lambda request: request.registry.settings["print_url"], name="get_organization_print_url"
+    )
+    # - Organization interface name (in the config and in the admin interface)
+    config.add_request_method(lambda request, interface: interface, name="get_organization_interface")
 
     # Configure 'locale' dir as the translation dir for c2cgeoportal app
     config.add_translation_dirs("c2cgeoportal_geoportal:locale/")
 
+    config.include("pyramid_mako")
     config.include("c2cwsgiutils.pyramid.includeme")
     health_check = HealthCheck(config)
     config.registry["health_check"] = health_check
@@ -373,28 +454,31 @@ def includeme(config: pyramid.config.Configurator):
         add_provider(TotalPythonObjectMemoryProvider())
 
     # Initialise DBSessions
-    init_dbsessions(settings, config, health_check)
+    init_db_sessions(settings, config, health_check)
 
     checker.init(config, health_check)
     check_collector.init(config, health_check)
 
     # dogpile.cache configuration
     if "cache" in settings:
-        register_backend("c2cgeoportal.hybrid", "c2cgeoportal_geoportal.lib.caching", "HybridBackend")
+        register_backend("c2cgeoportal.hybrid", "c2cgeoportal_geoportal.lib.caching", "HybridRedisBackend")
+        register_backend(
+            "c2cgeoportal.hybridsentinel", "c2cgeoportal_geoportal.lib.caching", "HybridRedisSentinelBackend"
+        )
         for name, cache_config in settings["cache"].items():
             caching.init_region(cache_config, name)
 
-            @zope.event.classhandler.handler(InvalidateCacheEvent)
-            def handle(event: InvalidateCacheEvent):  # pylint: disable=unused-variable
+            @zope.event.classhandler.handler(InvalidateCacheEvent)  # type: ignore
+            def handle(event: InvalidateCacheEvent) -> None:
                 del event
                 caching.invalidate_region()
                 if caching.MEMORY_CACHE_DICT:
-                    caching.get_region("std").delete_multi(caching.MEMORY_CACHE_DICT.keys())
+                    caching.get_region("std").delete_multi(list(caching.MEMORY_CACHE_DICT.keys()))
                 caching.MEMORY_CACHE_DICT.clear()
 
     # Register a tween to get back the cache buster path.
     if "cache_path" not in config.get_settings():
-        config.get_settings()["cache_path"] = ["static"]
+        config.get_settings()["cache_path"] = ["static", "static-geomapfish"]
     config.add_tween("c2cgeoportal_geoportal.lib.cacheversion.CachebusterTween")
     config.add_tween("c2cgeoportal_geoportal.lib.headers.HeadersTween")
 
@@ -412,6 +496,10 @@ def includeme(config: pyramid.config.Configurator):
     config.add_directive("set_user_validator", set_user_validator)
     config.set_user_validator(default_user_validator)
 
+    config.add_route("oauth2token", "/oauth/token", request_method="POST")
+    config.add_route("oauth2loginform", "/oauth/login", request_method="GET")
+    config.add_route("notlogin", "/notlogin", request_method="GET")
+
     config.add_route("dynamic", "/dynamic.json", request_method="GET")
 
     # Add routes to the mapserver proxy
@@ -430,6 +518,22 @@ def includeme(config: pyramid.config.Configurator):
         pregenerator=C2CPregenerator(role=True),
         request_method="POST",
     )
+    # The tow next views are used to serve the application on the URL /mapserv_proxy/<ogc server name>
+    # instead of /mapserv_proxy?ogcserver=<ogc server name>, required for QGIS server landing page
+    config.add_route(
+        "mapserverproxy_get_path",
+        "/mapserv_proxy/{ogcserver}/*path",
+        mapserverproxy=True,
+        pregenerator=C2CPregenerator(role=True),
+        request_method="GET",
+    )
+    config.add_route(
+        "mapserverproxy_post_path",
+        "/mapserv_proxy/{ogcserver}/*path",
+        mapserverproxy=True,
+        pregenerator=C2CPregenerator(role=True),
+        request_method="POST",
+    )
     add_cors_route(config, "/mapserv_proxy", "mapserver")
 
     # Add route to the tinyows proxy
@@ -454,14 +558,15 @@ def includeme(config: pyramid.config.Configurator):
     config.add_renderer(".css", AssetRendererFactory)
     config.add_renderer(".ico", AssetRendererFactory)
     config.add_route("localejson", "/locale.json", request_method="GET")
+    config.add_route("localepot", "/locale.pot", request_method="GET")
 
-    def add_static_route(name: str, attr: str, path: str, renderer: str):
+    def add_static_route(name: str, attr: str, path: str, renderer: str) -> None:
         config.add_route(name, path, request_method="GET")
         config.add_view(Entry, attr=attr, route_name=name, renderer=renderer)
 
     add_static_route("favicon", "favicon", "/favicon.ico", "/etc/geomapfish/static/images/favicon.ico")
     add_static_route("robot.txt", "robot_txt", "/robot.txt", "/etc/geomapfish/static/robot.txt")
-    add_static_route("apijs", "apijs", "/api.js", "/etc/static-ngeo/api.js")
+    config.add_route("apijs", "/api.js", request_method="GET")
     add_static_route("apijsmap", "apijsmap", "/api.js.map", "/etc/static-ngeo/api.js.map")
     add_static_route("apicss", "apicss", "/api.css", "/etc/static-ngeo/api.css")
     add_static_route("apihelp", "apihelp", "/apihelp/index.html", "/etc/geomapfish/static/apihelp/index.html")
@@ -501,6 +606,13 @@ def includeme(config: pyramid.config.Configurator):
     add_cors_route(config, "/profile.json", "profile")
     config.add_route("profile.json", "/profile.json", request_method="POST")
 
+    # Access to vector tiles
+    add_cors_route(config, "/vector_tiles", "vector_tiles")
+    config.add_route("vector_tiles", "/vector_tiles/{layer_name}/{z}/{x}/{y}.pbf", request_method="GET")
+    # There is no view corresponding to that route, it is to be used from
+    # mako templates to get the root of the "vector_tiles" web service
+    config.add_route("vector_tiles_root", "/vector_tiles", request_method="HEAD")
+
     # Shortener
     add_cors_route(config, "/short/create", "shortener")
     config.add_route("shortener_create", "/short/create", request_method="POST")
@@ -581,13 +693,29 @@ def includeme(config: pyramid.config.Configurator):
         cache_max_age=int(config.get_settings()["default_max_age"]),
     )
 
+    # Add the c2cgeoportal static view with cache buster
+    config.add_static_view(
+        name="static-geomapfish",
+        path="c2cgeoportal_geoportal:static",
+        cache_max_age=int(config.get_settings()["default_max_age"]),
+    )
+    config.add_cache_buster("c2cgeoportal_geoportal:static", version_cache_buster)
+
+    # Add the project static view without cache buster
+    config.add_static_view(
+        name="static-ngeo-dist",
+        path="/opt/c2cgeoportal/geoportal/node_modules/ngeo/dist",
+        cache_max_age=int(config.get_settings()["default_max_age"]),
+    )
+
     # Handles the other HTTP errors raised by the views. Without that,
     # the client receives a status=200 without content.
     config.add_view(error_handler, context=HTTPException)
 
     c2cwsgiutils.index.additional_title = (
-        '<div class="row"><div class="col-lg-3"><h2>GeoMapFish</h2>' '</div><div class="col-lg">'
+        '<div class="row"><div class="col-lg-3"><h2>GeoMapFish</h2></div><div class="col-lg">'
     )
+
     c2cwsgiutils.index.additional_auth.extend(
         [
             '<a href="../tiles/admin/">TileCloud chain admin</a><br>',
@@ -612,10 +740,13 @@ def includeme(config: pyramid.config.Configurator):
     c2cwsgiutils.index.additional_noauth.append("</div></div><hr>")
 
 
-def init_dbsessions(settings: dict, config: Configurator, health_check: HealthCheck = None) -> None:
+def init_db_sessions(
+    settings: Dict[str, Any], config: Configurator, health_check: Optional[HealthCheck] = None
+) -> None:
+    """Initialize the database sessions."""
     db_chooser = settings.get("db_chooser", {})
-    master_paths = [re.compile(i.replace("//", "/")) for i in db_chooser.get("master", [])]
-    slave_paths = [re.compile(i.replace("//", "/")) for i in db_chooser.get("slave", [])]
+    master_paths = [i.replace("//", "/") for i in db_chooser.get("master", [])]
+    slave_paths = [i.replace("//", "/") for i in db_chooser.get("slave", [])]
 
     slave_prefix = "sqlalchemy_slave" if "sqlalchemy_slave.url" in settings else None
 
@@ -653,7 +784,7 @@ def init_dbsessions(settings: dict, config: Configurator, health_check: HealthCh
                         version_schema=settings["schema_static"],
                         level=1,
                     )
-            else:  # pragma: no cover
+            else:
 
                 def check(session_: Session) -> None:
                     session_.execute("SELECT 1")