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

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,123 @@
 # 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
+import os
+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  # noqa
         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."""
+    results = glob.glob(f"/opt/c2cgeoportal/geoportal/node_modules/ngeo/dist/{pattern}")
+    if not results:
+        LOG.error(
+            "No file found for pattern %s, in: [%s]",
+            pattern,
+            ", ".join(os.listdir("/opt/c2cgeoportal/geoportal/node_modules/ngeo/dist/")),
+        )
+    return results
+
+
+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,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2011-2021, Camptocamp SA
 # All rights reserved.
 
@@ -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-2021, 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.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:
             {

c2cgeoportal_geoportal/views/i18n.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2019-2020, Camptocamp SA
+# Copyright (c) 2019-2022, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,20 +26,104 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
-from pyramid.httpexceptions import HTTPFound
+import glob
+import logging
+
+import pyramid.request
+import pyramid.response
+from lingua.extract import (  # strip_linenumbers,
+    ExtractorOptions,
+    POEntry,
+    create_catalog,
+    find_file,
+    list_files,
+    no_duplicates,
+    read_config,
+)
+from lingua.extractors import get_extractor, register_extractors
+from lingua.extractors.babel import register_babel_plugins
+from pyramid.httpexceptions import HTTPFound, HTTPInternalServerError
 from pyramid.view import view_config
 
 from c2cgeoportal_geoportal.lib.cacheversion import get_cache_version
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, set_common_headers
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 
+LOG = logging.getLogger(__name__)
+_INITIALIZED = False
 
-@view_config(route_name="localejson")
-def locale(request):
+
+@view_config(route_name="localejson")  # type: ignore
+def locale(request: pyramid.request.Request) -> pyramid.response.Response:
+    """Get the locale json file for the API."""
     response = HTTPFound(
         request.static_url(
-            "/etc/geomapfish/static/{lang}.json".format(lang=request.locale_name),
+            f"/etc/geomapfish/static/{request.locale_name}.json",
             _query={"cache": get_cache_version()},
         )
     )
-    set_common_headers(request, "api", NO_CACHE, response=response)
+    set_common_headers(request, "api", Cache.PUBLIC_NO, response=response)
     return response
+
+
+@view_config(route_name="localepot")  # type: ignore
+def localepot(request: pyramid.request.Request) -> pyramid.response.Response:
+    """Get the pot from an HTTP request."""
+
+    # Build the list of files to be processed
+    sources = []
+    sources += glob.glob(f"/app/{request.registry.package_name}/static-ngeo/js/apps/*.html.ejs")
+    sources += glob.glob(f"/app/{request.registry.package_name}/static-ngeo/js/**/*.js", recursive=True)
+    sources += glob.glob(f"/app/{request.registry.package_name}/static-ngeo/js/**/*.html", recursive=True)
+    sources += glob.glob("/usr/local/tomcat/webapps/ROOT/**/config.yaml", recursive=True)
+    sources += ["/etc/geomapfish/config.yaml", "/app/development.ini"]
+
+    # The following code is a modified version of the main function of this file:
+    # https://github.com/wichert/lingua/blob/master/src/lingua/extract.py
+
+    global _INITIALIZED
+    if not _INITIALIZED:
+        register_extractors()
+        register_babel_plugins()
+        _INITIALIZED = True
+
+        with open("/app/lingua-client.cfg", encoding="utf-8") as config_file:
+            read_config(config_file)
+        _INITIALIZED = True
+
+    catalog = create_catalog(
+        width=110,
+        copyright_holder="",
+        package_name="GeoMapFish-project",
+        package_version="1.0",
+        msgid_bugs_address=None,
+    )
+
+    for filename in no_duplicates(list_files(None, sources)):
+        real_filename = find_file(filename)
+        if real_filename is None:
+            LOG.error("Can not find file %s", filename)
+            raise HTTPInternalServerError(f"Can not find file {filename}")
+        extractor = get_extractor(real_filename)
+        if extractor is None:
+            LOG.error("No extractor available for file %s", filename)
+            raise HTTPInternalServerError(f"No extractor available for file {filename}")
+
+        extractor_options = ExtractorOptions(
+            comment_tag=True,
+            domain=None,
+            keywords=None,
+        )
+        for message in extractor(real_filename, extractor_options):
+            entry = catalog.find(message.msgid, msgctxt=message.msgctxt)
+            if entry is None:
+                entry = POEntry(msgctxt=message.msgctxt, msgid=message.msgid)
+                catalog.append(entry)
+            entry.update(message)
+
+    # for entry in catalog:
+    #     strip_linenumbers(entry)
+
+    # Build the response
+    request.response.text = catalog.__unicode__()
+    set_common_headers(request, "api", Cache.PUBLIC, content_type="text/x-gettext-translation")
+    return request.response