c2cgeoportal-geoportal 2.3.5.79__py3-none-any.whl → 2.9rc1__py3-none-any.whl

c2cgeoportal_geoportal/views/dev.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2011-2021, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+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: pyramid.request.Request):
+        super().__init__(request)
+        self.dev_url = self.request.registry.settings["devserver_url"]
+
+    @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", Url(f"{self.dev_url.rstrip('/')}/{path.lstrip('/')}"))

c2cgeoportal_geoportal/views/dynamic.py

@@ -0,0 +1,208 @@
+# Copyright (c) 2018-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import re
+import urllib.parse
+from typing import Any, cast
+
+import pyramid.request
+from pyramid.httpexceptions import HTTPNotFound
+from pyramid.view import view_config
+from sqlalchemy import func
+
+from c2cgeoportal_commons import models
+from c2cgeoportal_commons.models import main
+from c2cgeoportal_geoportal import is_allowed_host
+from c2cgeoportal_geoportal.lib.cacheversion import get_cache_version
+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:
+    """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: 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) -> list[str]:
+        assert models.DBSession is not None
+
+        return [
+            group[0]
+            for group in models.DBSession.query(func.distinct(main.FullTextSearch.layer_name))
+            .filter(main.FullTextSearch.layer_name.isnot(None))
+            .all()
+        ]
+
+    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,
+                original_interface_name,
+                dynamic,
+            )
+        else:
+            constants = {}
+
+        constants.update(interface_config.get("constants", {}))
+        constants.update(
+            {
+                name: dynamic[value]
+                for name, value in interface_config.get("dynamic_constants", {}).items()
+                if value is not None
+            }
+        )
+        constants.update(
+            {
+                name: self.request.static_url(static_["name"]) + static_.get("append", "")
+                for name, static_ in interface_config.get("static", {}).items()
+            }
+        )
+
+        for constant, config in interface_config.get("routes", {}).items():
+            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():
+                params[name] = dynamic[dyn]
+            constants[constant] = self.request.route_url(
+                route_name, *config.get("elements", []), _query=params, **config.get("kw", {})
+            )
+
+        return constants
+
+    @view_config(route_name="dynamic", renderer="json")  # type: ignore
+    def dynamic(self) -> dict[str, Any]:
+        is_allowed_host(self.request)
+
+        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:
+            interface_separator = "', '"
+            raise HTTPNotFound(
+                f"Interface '{interface_name}' doesn't exist in the 'interfaces_config', "
+                f"available interfaces are: '{interface_separator.join(self.interfaces_config.keys())}'."
+            )
+
+        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,
+            "cache_version": get_cache_version(),
+            "two_factor": self.request.registry.settings.get("authentication", {}).get("two_factor", False),
+            "lang_urls": {
+                lang: self.request.static_url(
+                    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, original_interface_name, dynamic)
+
+        do_redirect = False
+        url = None
+        if "redirect_interface" in interface_config:
+            no_redirect_query: dict[str, str | list[str]] = {"no_redirect": "t"}
+            if "query" in self.request.params:
+                query = urllib.parse.parse_qs(self.request.params["query"][1:], keep_blank_values=True)
+                no_redirect_query.update(query)
+            else:
+                query = {}
+            theme = None
+            if "path" in self.request.params:
+                match = re.match(".*/theme/(.*)", self.request.params["path"])
+                if match is not None:
+                    theme = match.group(1)
+            if theme is not None:
+                no_redirect_url = self.request.route_url(
+                    interface_config["redirect_interface"] + "theme", themes=theme, _query=no_redirect_query
+                )
+                url = self.request.route_url(
+                    interface_config["redirect_interface"] + "theme", themes=theme, _query=query
+                ).replace("+", "%20")
+            else:
+                no_redirect_url = self.request.route_url(
+                    interface_config["redirect_interface"], _query=no_redirect_query
+                )
+                url = self.request.route_url(interface_config["redirect_interface"], _query=query).replace(
+                    "+", "%20"
+                )
+
+            if "no_redirect" in query:
+                constants["redirectUrl"] = ""
+            else:
+                if interface_config.get("do_redirect", False):
+                    do_redirect = True
+                else:
+                    constants["redirectUrl"] = no_redirect_url
+
+        set_common_headers(self.request, "dynamic", Cache.PUBLIC_NO)
+        return {"constants": constants, "doRedirect": do_redirect, "redirectUrl": url}

c2cgeoportal_geoportal/views/entry.py

@@ -0,0 +1,174 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import glob
+import logging
+import os
+from typing import Any
+
+import pyramid.request
+from bs4 import BeautifulSoup
+from pyramid.i18n import TranslationStringFactory
+from pyramid.view import view_config
+
+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:
+    """All the entry points views."""
+
+    def __init__(self, request: pyramid.request.Request):
+        self.request = request
+
+    @view_config(route_name="testi18n", renderer="testi18n.html")  # type: ignore[misc]
+    def testi18n(self) -> dict[str, Any]:
+        _ = self.request.translate
+        return {"title": _("title i18n")}
+
+    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 {}
+
+    @staticmethod
+    @_CACHE_REGION.cache_on_arguments()
+    def get_apijs(api_filename: str, api_name: str | None) -> str:
+        with open(api_filename, 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["static_files"]["api.js"],
+            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 robot_txt(self) -> dict[str, Any]:
+        set_common_headers(self.request, "index", Cache.PUBLIC, content_type="text/plain")
+        return {}
+
+    def apijsmap(self) -> dict[str, Any]:
+        set_common_headers(self.request, "api", Cache.PUBLIC, content_type="application/octet-stream")
+        return {}
+
+    def apicss(self) -> dict[str, Any]:
+        set_common_headers(self.request, "api", Cache.PUBLIC, content_type="text/css")
+        return {}
+
+    def apihelp(self) -> dict[str, Any]:
+        set_common_headers(self.request, "apihelp", Cache.PUBLIC)
+        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,
+    }
+
+
+def custom_view(
+    request: pyramid.request.Request, interface_config: dict[str, Any]
+) -> pyramid.response.Response:
+    """Get view used as entry point of a canvas interface."""
+
+    set_common_headers(request, "index", Cache.PUBLIC_NO, content_type="text/html")
+
+    html_filename = interface_config.get("html_filename", f"{interface_config['name']}.html")
+    if not html_filename.startswith("/"):
+        html_filename = os.path.join("/etc/static-frontend/", html_filename)
+
+    with open(html_filename, encoding="utf-8") as html_file:
+        html = BeautifulSoup(html_file, "html.parser")
+
+    meta = html.find("meta", attrs={"name": "interface"})
+    if meta is not None:
+        meta["content"] = interface_config["name"]
+    meta = html.find("meta", attrs={"name": "dynamicUrl"})
+    if meta is not None:
+        meta["content"] = request.route_url("dynamic")
+
+    if hasattr(request, "custom_interface_transformer"):
+        request.custom_interface_transformer(html, interface_config)
+
+    request.response.text = str(html)
+
+    return request.response

c2cgeoportal_geoportal/views/fulltextsearch.py

@@ -0,0 +1,189 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import re
+
+import pyramid.request
+from geoalchemy2.shape import to_shape
+from geojson import Feature, FeatureCollection
+from pyramid.httpexceptions import HTTPBadRequest, HTTPInternalServerError
+from pyramid.view import view_config
+from sqlalchemy import ColumnElement, 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 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")
+IGNORED_CHARS_RE = re.compile(r"[()&|!:<>\t]")
+IGNORED_STARTUP_CHARS_RE = re.compile(r"^[']*")
+
+
+class FullTextSearchView:
+    """All the full-text search view."""
+
+    def __init__(self, request: pyramid.request.Request):
+        self.request = request
+        set_common_headers(request, "fulltextsearch", Cache.PUBLIC_NO)
+        self.settings = request.registry.settings.get("fulltextsearch", {})
+        self.languages = self.settings.get("languages", {})
+        self.fts_normalizer = Normalize(self.settings)
+
+    @staticmethod
+    @CACHE_REGION.cache_on_arguments()
+    def _get_interface_id(interface: str) -> int:
+        assert DBSession is not None
+
+        return DBSession.query(Interface).filter_by(name=interface).one().id
+
+    @view_config(route_name="fulltextsearch", renderer="geojson")  # type: ignore[misc]
+    def fulltextsearch(self) -> FeatureCollection:
+        assert DBSession is not None
+
+        lang = locale_negotiator(self.request)
+
+        try:
+            language = self.languages[lang]
+        except KeyError:
+            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_normalizer(self.request.params.get("query"))
+
+        maxlimit = self.settings.get("maxlimit", 200)
+
+        try:
+            limit = int(self.request.params.get("limit", self.settings.get("defaultlimit", 30)))
+        except ValueError:
+            return HTTPBadRequest(detail="limit value is incorrect")
+        limit = min(limit, maxlimit)
+
+        try:
+            partitionlimit = int(self.request.params.get("partitionlimit", 0))
+        except ValueError:
+            return HTTPBadRequest(detail="partitionlimit value is incorrect")
+        partitionlimit = min(partitionlimit, maxlimit)
+
+        terms_array = [
+            IGNORED_STARTUP_CHARS_RE.sub("", elem) for elem in IGNORED_CHARS_RE.sub(" ", terms).split(" ")
+        ]
+        terms_ts = "&".join(w + ":*" for w in terms_array if w != "")
+        _filter: ColumnElement[bool] = FullTextSearch.ts.op("@@")(func.to_tsquery(language, terms_ts))
+
+        if self.request.user is None:
+            _filter = and_(_filter, FullTextSearch.public.is_(True))
+        else:
+            _filter = and_(
+                _filter,
+                or_(
+                    FullTextSearch.public.is_(True),
+                    FullTextSearch.role_id.is_(None),
+                    FullTextSearch.role_id.in_([r.id for r in self.request.user.roles]),
+                ),
+            )
+
+        if "interface" in self.request.params:
+            _filter = and_(
+                _filter,
+                or_(
+                    FullTextSearch.interface_id.is_(None),
+                    FullTextSearch.interface_id == self._get_interface_id(self.request.params["interface"]),
+                ),
+            )
+        else:
+            _filter = and_(_filter, FullTextSearch.interface_id.is_(None))
+
+        _filter = and_(_filter, or_(FullTextSearch.lang.is_(None), FullTextSearch.lang == lang))
+
+        rank_system = self.request.params.get("ranksystem")
+        if rank_system == "ts_rank_cd":
+            # The numbers used in ts_rank_cd() below indicate a normalization method.
+            # Several normalization methods can be combined using |.
+            # 2 divides the rank by the document length
+            # 8 divides the rank by the number of unique words in document
+            # By combining them, shorter results seem to be preferred over longer ones
+            # with the same ratio of matching words. But this relies only on testing it
+            # and on some assumptions about how it might be calculated
+            # (the normalization is applied two times with the combination of 2 and 8,
+            # so the effect on at least the one-word-results is therefore stronger).
+            rank = func.ts_rank_cd(FullTextSearch.ts, func.to_tsquery(language, terms_ts), 2 | 8)
+        else:
+            # Use similarity ranking system from module pg_trgm.
+            rank = func.similarity(FullTextSearch.label, terms)
+
+        if partitionlimit:
+            # Here we want to partition the search results based on
+            # layer_name and limit each partition.
+            row_number = (
+                func.row_number()
+                .over(partition_by=FullTextSearch.layer_name, order_by=(desc(rank), FullTextSearch.label))
+                .label("row_number")
+            )
+            sub_query = DBSession.query(FullTextSearch).add_columns(row_number).filter(_filter).subquery()
+            query = DBSession.query(
+                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(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)
+        objects = query.all()
+
+        features = []
+        for o in objects:
+            properties = {"label": o.label}
+            if o.layer_name is not None:
+                properties["layer_name"] = o.layer_name
+            if o.params is not None:
+                properties["params"] = o.params
+            if o.actions is not None:
+                properties["actions"] = o.actions
+            if o.actions is None and o.layer_name is not None:
+                properties["actions"] = [{"action": "add_layer", "data": o.layer_name}]
+
+            if o.the_geom is not None:
+                geom = to_shape(o.the_geom)
+                feature = Feature(id=o.id, geometry=geom, properties=properties, bbox=geom.bounds)
+                features.append(feature)
+            else:
+                feature = Feature(id=o.id, properties=properties)
+                features.append(feature)
+
+        return FeatureCollection(features)