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

c2cgeoportal_geoportal/views/login.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2021, Camptocamp SA
+# Copyright (c) 2011-2022, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -30,12 +28,14 @@
 
 import json
 import logging
+import secrets
 import sys
-import xml.dom.minidom  # noqa # pylint: disable=unused-import
-from random import Random
-from typing import Dict, Set, Tuple  # noqa # pylint: disable=unused-import
+import urllib.parse
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 import pyotp
+import pyramid.request
+import pyramid.response
 from pyramid.httpexceptions import (
     HTTPBadRequest,
     HTTPForbidden,
@@ -45,15 +45,16 @@ from pyramid.httpexceptions import (
 )
 from pyramid.response import Response
 from pyramid.security import forget, remember
-from pyramid.view import view_config
+from pyramid.view import forbidden_view_config, view_config
 from sqlalchemy.orm.exc import NoResultFound
 
 from c2cgeoportal_commons import models
 from c2cgeoportal_commons.lib.email_ import send_email_config
 from c2cgeoportal_commons.models import static
-from c2cgeoportal_geoportal import is_valid_referer
+from c2cgeoportal_geoportal import is_valid_referrer
 from c2cgeoportal_geoportal.lib import get_setting, is_intranet, oauth2
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, PUBLIC_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.functionality import get_functionality
 
 LOG = logging.getLogger(__name__)
@@ -61,7 +62,13 @@ CACHE_REGION = get_region("std")
 
 
 class Login:
-    def __init__(self, request):
+    """
+    All the login, logout, oauth2, user information views.
+
+    Also manage the 2fa.
+    """
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
         self.settings = request.registry.settings
         self.lang = request.locale_name
@@ -71,7 +78,7 @@ class Login:
         self.two_factor_auth = authentication_settings.get("two_factor", False)
         self.two_factor_issuer_name = authentication_settings.get("two_factor_issuer_name")
 
-    def _functionality(self):
+    def _functionality(self) -> Dict[str, List[Union[str, int, float, bool, List[Any], Dict[str, Any]]]]:
         functionality = {}
         for func_ in get_setting(self.settings, ("functionalities", "available_in_templates"), []):
             functionality[func_] = get_functionality(func_, self.request, is_intranet(self.request))
@@ -79,26 +86,28 @@ class Login:
 
     def _referer_log(self) -> None:
         if not hasattr(self.request, "is_valid_referer"):
-            self.request.is_valid_referer = is_valid_referer(self.request)
+            self.request.is_valid_referer = is_valid_referrer(self.request)
         if not self.request.is_valid_referer:
             LOG.info("Invalid referer for %s: %s", self.request.path_qs, repr(self.request.referer))
 
-    @view_config(context=HTTPForbidden, renderer="login.html")
-    def loginform403(self):
-        if self.request.authenticated_userid:
-            return HTTPUnauthorized()  # pragma: no cover
+    @forbidden_view_config(renderer="login.html")  # type: ignore
+    def loginform403(self) -> Union[Dict[str, Any], pyramid.response.Response]:
+        if self.request.authenticated_userid is not None:
+            return HTTPForbidden()
 
-        set_common_headers(self.request, "login", NO_CACHE)
+        set_common_headers(self.request, "login", Cache.PRIVATE_NO)
 
         return {
             "lang": self.lang,
-            "login_params": {"came_from": self.request.path},
+            "login_params": {
+                "came_from": (f"{self.request.path}?{urllib.parse.urlencode(self.request.GET)}")
+            },
             "two_fa": self.two_factor_auth,
         }
 
-    @view_config(route_name="loginform", renderer="login.html")
-    def loginform(self):
-        set_common_headers(self.request, "login", PUBLIC_CACHE)
+    @view_config(route_name="loginform", renderer="login.html")  # type: ignore
+    def loginform(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "login", Cache.PUBLIC)
 
         return {
             "lang": self.lang,
@@ -107,18 +116,18 @@ class Login:
         }
 
     @staticmethod
-    def _validate_2fa_totp(user, otp: str) -> bool:
+    def _validate_2fa_totp(user: static.User, otp: str) -> bool:
         if pyotp.TOTP(user.tech_data.get("2fa_totp_secret", "")).verify(otp):
             return True
         return False
 
-    @view_config(route_name="login")
-    def login(self):
+    @view_config(route_name="login")  # type: ignore
+    def login(self) -> pyramid.response.Response:
         self._referer_log()
 
         login = self.request.POST.get("login")
         password = self.request.POST.get("password")
-        if login is None or password is None:  # pragma nocover
+        if login is None or password is None:
             raise HTTPBadRequest("'login' and 'password' should be available in request params.")
         username = self.request.registry.validate_user(self.request, login, password)
         if username is not None:
@@ -133,7 +142,7 @@ class Login:
                     return set_common_headers(
                         self.request,
                         "login",
-                        NO_CACHE,
+                        Cache.PRIVATE_NO,
                         response=Response(
                             json.dumps(
                                 {
@@ -164,7 +173,7 @@ class Login:
                 return set_common_headers(
                     self.request,
                     "login",
-                    NO_CACHE,
+                    Cache.PRIVATE_NO,
                     response=Response(
                         json.dumps(
                             {
@@ -189,7 +198,7 @@ class Login:
             return set_common_headers(
                 self.request,
                 "login",
-                NO_CACHE,
+                Cache.PRIVATE_NO,
                 response=Response(json.dumps(self._user(self.request.get_user(username))), headers=headers),
             )
         user = models.DBSession.query(static.User).filter(static.User.username == login).one_or_none()
@@ -207,7 +216,7 @@ class Login:
             self.request.tm.commit()
         raise HTTPUnauthorized("See server logs for details")
 
-    def _oauth2_login(self, user):
+    def _oauth2_login(self, user: static.User) -> pyramid.response.Response:
         self.request.user_ = user
         LOG.debug(
             "Call OAuth create_authorization_response with:\nurl: %s\nmethod: %s\nbody:\n%s",
@@ -236,12 +245,12 @@ class Login:
         return set_common_headers(
             self.request,
             "login",
-            NO_CACHE,
+            Cache.PRIVATE_NO,
             response=Response(body, headers=headers.items()),
         )
 
-    @view_config(route_name="logout")
-    def logout(self):
+    @view_config(route_name="logout")  # type: ignore
+    def logout(self) -> pyramid.response.Response:
         headers = forget(self.request)
 
         if not self.request.user:
@@ -251,9 +260,11 @@ class Login:
         LOG.info("User '%s' (%s) logging out.", self.request.user.username, self.request.user.id)
 
         headers.append(("Content-Type", "text/json"))
-        return set_common_headers(self.request, "login", NO_CACHE, response=Response("true", headers=headers))
+        return set_common_headers(
+            self.request, "login", Cache.PRIVATE_NO, response=Response("true", headers=headers)
+        )
 
-    def _user(self, user=None):
+    def _user(self, user: Optional[static.User] = None) -> Dict[str, Any]:
         result = {
             "functionalities": self._functionality(),
             "is_intranet": is_intranet(self.request),
@@ -270,122 +281,124 @@ class Login:
             )
         return result
 
-    @view_config(route_name="loginuser", renderer="json")
-    def loginuser(self):
+    @view_config(route_name="loginuser", renderer="json")  # type: ignore
+    def loginuser(self) -> Dict[str, Any]:
         LOG.info("Client IP address: %s", self.request.client_addr)
-        set_common_headers(self.request, "login", NO_CACHE)
+        set_common_headers(self.request, "login", Cache.PRIVATE_NO)
         return self._user()
 
-    @view_config(route_name="change_password", renderer="json")
-    def change_password(self):
-        set_common_headers(self.request, "login", NO_CACHE)
+    @view_config(route_name="change_password", renderer="json")  # type: ignore
+    def change_password(self) -> pyramid.response.Response:
+        set_common_headers(self.request, "login", Cache.PRIVATE_NO)
 
         login = self.request.POST.get("login")
         old_password = self.request.POST.get("oldPassword")
         new_password = self.request.POST.get("newPassword")
         new_password_confirm = self.request.POST.get("confirmNewPassword")
+        otp = self.request.POST.get("otp")
         if new_password is None or new_password_confirm is None or old_password is None:
             raise HTTPBadRequest(
                 "'oldPassword', 'newPassword' and 'confirmNewPassword' should be available in "
                 "request params."
             )
+        if self.two_factor_auth and otp is None:
+            raise HTTPBadRequest("The second factor is missing.")
+        if login is None and self.request.user is None:
+            raise HTTPBadRequest("You should be logged in or 'login' should be available in request params.")
+        if new_password != new_password_confirm:
+            raise HTTPBadRequest("The new password and the new password confirmation do not match")
 
         if login is not None:
-            try:
-                user = self.request.get_user(login)
-                if user is None:
-                    LOG.info("The login '%s' does not exist.", login)
-                    raise HTTPUnauthorized("See server logs for details")
-            except NoResultFound:  # pragma: no cover
+            user = models.DBSession.query(static.User).filter_by(username=login).one_or_none()
+            if user is None:
                 LOG.info("The login '%s' does not exist.", login)
                 raise HTTPUnauthorized("See server logs for details")
 
             if self.two_factor_auth:
-                otp = self.request.POST.get("otp")
-                if otp is None:
-                    raise HTTPBadRequest("The second factor is missing.")
                 if not self._validate_2fa_totp(user, otp):
                     LOG.info("The second factor is wrong for user '%s'.", login)
                     raise HTTPUnauthorized("See server logs for details")
-
         else:
-            if self.request.user is not None:
-                user = self.request.user
-            else:
-                raise HTTPBadRequest(
-                    "You should be logged in or 'login' should be available in request params."
-                )
+            user = self.request.user
 
-        username = self.request.registry.validate_user(self.request, user.username, old_password)
-        if username is None:
-            LOG.info("The old password is wrong for user '%s'.", username)
+        if self.request.registry.validate_user(self.request, user.username, old_password) is None:
+            LOG.info("The old password is wrong for user '%s'.", user.username)
             raise HTTPUnauthorized("See server logs for details")
 
-        if new_password != new_password_confirm:
-            raise HTTPBadRequest("The new password and the new password confirmation do not match")
-
         user.password = new_password
         user.is_password_changed = True
         models.DBSession.flush()
-        LOG.info("Password changed for user '%s'", username)
+        LOG.info("Password changed for user '%s'", user.username)
 
-        headers = remember(self.request, username)
+        headers = remember(self.request, user.username)
         headers.append(("Content-Type", "text/json"))
         return set_common_headers(
-            self.request, "login", NO_CACHE, response=Response(json.dumps(self._user(user)), headers=headers)
+            self.request,
+            "login",
+            Cache.PRIVATE_NO,
+            response=Response(json.dumps(self._user(user)), headers=headers),
         )
 
     @staticmethod
-    def generate_password():
-        allchars = "123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-        rand = Random()
+    def generate_password() -> str:
+        all_chars = "123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
-        password = ""
+        password = ""  # nosec
         for _ in range(8):
-            password += rand.choice(allchars)
+            password += secrets.choice(all_chars)
 
         return password
 
-    def _loginresetpassword(self):
+    def _loginresetpassword(
+        self,
+    ) -> Tuple[Optional[static.User], Optional[str], Optional[str], Optional[str]]:
         username = self.request.POST.get("login")
         if username is None:
             raise HTTPBadRequest("'login' should be available in request params.")
-        username = self.request.POST["login"]
         try:
             user = models.DBSession.query(static.User).filter(static.User.username == username).one()
-        except NoResultFound:  # pragma: no cover
-            return None, None, None, "The login '{}' does not exist.".format(username)
+        except NoResultFound:
+            return None, None, None, f"The login '{username}' does not exist."
 
-        if user.email is None or user.email == "":  # pragma: no cover
-            return None, None, None, "The user '{}' has no registered email address.".format(user.username)
+        if user.email is None or user.email == "":
+            return None, None, None, f"The user '{user.username}' has no registered email address."
 
         password = self.generate_password()
         user.set_temp_password(password)
 
         return user, username, password, None
 
-    @view_config(route_name="loginresetpassword", renderer="json")
-    def loginresetpassword(self):  # pragma: no cover
-        set_common_headers(self.request, "login", NO_CACHE)
+    @view_config(route_name="loginresetpassword", renderer="json")  # type: ignore
+    def loginresetpassword(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "login", Cache.PRIVATE_NO)
 
         user, username, password, error = self._loginresetpassword()
         if error is not None:
             LOG.info(error)
-            raise HTTPUnauthorized("See server logs for details")
+            return {"success": True}
+
+        if user is None:
+            LOG.info("The user is not found without any error.")
+            return {"success": True}
+
         if user.deactivated:
             LOG.info("The user '%s' is deactivated", username)
-            raise HTTPUnauthorized("See server logs for details")
+            return {"success": True}
 
         send_email_config(
-            self.request.registry.settings, "reset_password", user.email, user=username, password=password
+            self.request.registry.settings,
+            "reset_password",
+            user.email,
+            user=username,
+            password=password,
+            application_url=self.request.route_url("base"),
+            current_url=self.request.current_route_url(),
         )
 
         return {"success": True}
 
-    @view_config(route_name="oauth2token")
-    def oauth2token(self):
-        set_common_headers(self.request, "login", PUBLIC_CACHE)
-
+    @view_config(route_name="oauth2token")  # type: ignore
+    def oauth2token(self) -> pyramid.response.Response:
         LOG.debug(
             "Call OAuth create_token_response with:\nurl: %s\nmethod: %s\nbody:\n%s",
             self.request.current_route_url(_query=self.request.GET),
@@ -412,13 +425,13 @@ class Login:
         return set_common_headers(
             self.request,
             "login",
-            NO_CACHE,
+            Cache.PRIVATE_NO,
             response=Response(body, headers=headers.items()),
         )
 
-    @view_config(route_name="oauth2loginform", renderer="login.html")
-    def oauth2loginform(self):
-        set_common_headers(self.request, "login", PUBLIC_CACHE)
+    @view_config(route_name="oauth2loginform", renderer="login.html")  # type: ignore
+    def oauth2loginform(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "login", Cache.PUBLIC)
 
         if self.request.user:
             self._oauth2_login(self.request.user)
@@ -431,8 +444,8 @@ class Login:
             "two_fa": self.two_factor_auth,
         }
 
-    @view_config(route_name="notlogin", renderer="notlogin.html")
-    def notlogin(self):
-        set_common_headers(self.request, "login", PUBLIC_CACHE)
+    @view_config(route_name="notlogin", renderer="notlogin.html")  # type: ignore
+    def notlogin(self) -> Dict[str, Any]:
+        set_common_headers(self.request, "login", Cache.PUBLIC)
 
         return {"lang": self.lang}

c2cgeoportal_geoportal/views/mapserverproxy.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
@@ -29,16 +27,18 @@
 
 
 import logging
-from typing import Any, Dict  # noqa, pylint: disable=unused-import
+from typing import Any, Dict, Set
 
-from pyramid.httpexceptions import HTTPUnauthorized
+from pyramid.httpexceptions import HTTPFound, HTTPInternalServerError, HTTPUnauthorized
 from pyramid.request import Request
 from pyramid.response import Response
 from pyramid.view import view_config
 
+from c2cgeoportal_commons.lib.url import Url
 from c2cgeoportal_commons.models import main
 from c2cgeoportal_geoportal.lib import get_roles_id, get_roles_name
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, PRIVATE_CACHE, PUBLIC_CACHE, get_region
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache
 from c2cgeoportal_geoportal.lib.filter_capabilities import filter_capabilities
 from c2cgeoportal_geoportal.lib.functionality import get_mapserver_substitution_params
 from c2cgeoportal_geoportal.views.ogcproxy import OGCProxy
@@ -48,6 +48,7 @@ LOG = logging.getLogger(__name__)
 
 
 class MapservProxy(OGCProxy):
+    """Proxy for OGC (WMS/WFS) servers."""
 
     params: Dict[str, str] = {}
 
@@ -55,8 +56,10 @@ class MapservProxy(OGCProxy):
         OGCProxy.__init__(self, request)
         self.user = self.request.user
 
-    @view_config(route_name="mapserverproxy")
-    @view_config(route_name="mapserverproxy_post")
+    @view_config(route_name="mapserverproxy")  # type: ignore
+    @view_config(route_name="mapserverproxy_post")  # type: ignore
+    @view_config(route_name="mapserverproxy_get_path")  # type: ignore
+    @view_config(route_name="mapserverproxy_post_path")  # type: ignore
     def proxy(self) -> Response:
         if self.user is None and "authentication_required" in self.request.params:
             LOG.debug("proxy() detected authentication_required")
@@ -75,7 +78,7 @@ class MapservProxy(OGCProxy):
             self.params["role_ids"] = ",".join([str(e) for e in get_roles_id(self.request)])
 
             # In some application we want to display the features owned by a user than we need his id.
-            self.params["user_id"] = self.user.id if self.user is not None else "-1"  # pragma: no cover
+            self.params["user_id"] = self.user.id if self.user is not None else "-1"
 
         # Do not allows direct variable substitution
         for k in list(self.params.keys()):
@@ -97,11 +100,12 @@ class MapservProxy(OGCProxy):
         # DescribeFeatureType requests
         use_cache = False
 
+        errors: Set[str] = set()
         if method == "GET":
             # For GET requests, params are added only if the self.request
             # parameter is actually provided.
             if "request" not in self.lower_params:
-                self.params = {}  # pragma: no cover
+                self.params = {}
             else:
                 if self.ogc_server.type != main.OGCSERVER_TYPE_QGISSERVER or "user_id" not in self.params:
 
@@ -114,28 +118,33 @@ class MapservProxy(OGCProxy):
                         del self.params["role_ids"]
 
             if "service" in self.lower_params and self.lower_params["service"] == "wfs":
-                _url = self._get_wfs_url()
+                _url = self._get_wfs_url(errors)
             else:
-                _url = self._get_wms_url()
+                _url = self._get_wms_url(errors)
         else:
             # POST means WFS
-            _url = self._get_wfs_url()
-
-        cache_control = PRIVATE_CACHE
-        if method == "GET" and "service" in self.lower_params and self.lower_params["service"] == "wms":
-            if self.lower_params.get("request") in ("getmap", "getfeatureinfo"):
-                cache_control = NO_CACHE
-            elif self.lower_params.get("request") == "getlegendgraphic":
-                cache_control = PUBLIC_CACHE
-        elif method == "GET" and "service" in self.lower_params and self.lower_params["service"] == "wfs":
-            if self.lower_params.get("request") == "getfeature":
-                cache_control = NO_CACHE
-        elif method != "GET":
-            cache_control = NO_CACHE
-
-        headers = self._get_headers()
+            _url = self._get_wfs_url(errors)
+
+        if _url is None:
+            LOG.error("Error getting the URL:\n%s", "\n".join(errors))
+            raise HTTPInternalServerError()
+
+        cache_control = (
+            Cache.PRIVATE
+            if method == "GET"
+            and self.lower_params.get("request")
+            in (
+                "getcapabilities",
+                "getlegendgraphic",
+                "describefeaturetype",
+                "describelayer",
+            )
+            else Cache.PRIVATE_NO
+        )
+
+        headers = self.get_headers()
         # Add headers for Geoserver
-        if self.ogc_server.auth == main.OGCSERVER_AUTH_GEOSERVER:
+        if self.ogc_server.auth == main.OGCSERVER_AUTH_GEOSERVER and self.user is not None:
             headers["sec-username"] = self.user.username
             headers["sec-roles"] = ";".join(get_roles_name(self.request))
 
@@ -157,7 +166,15 @@ class MapservProxy(OGCProxy):
 
         return response
 
-    def _proxy_callback(self, cache_control: int, url: str, params: dict, **kwargs: Any) -> Response:
+    def _proxy_callback(
+        self, cache_control: Cache, url: Url, params: Dict[str, str], **kwargs: Any
+    ) -> Response:
+        if self.request.matched_route.name.endswith("_path"):
+            if self.request.matchdict["path"] == ("favicon.ico",):
+                return HTTPFound("/favicon.ico")
+            url = url.clone()
+            url.path = self.request.path
+
         response = self._proxy(url=url, params=params, **kwargs)
 
         content = response.content

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,