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

c2cgeoportal_geoportal/views/dynamic.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2018-2020, Camptocamp SA
+# Copyright (c) 2018-2021, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,36 +26,37 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
-import json
 import re
-from typing import Dict, List, Union
 import urllib.parse
+from typing import Any, Dict, List, Union, cast
 
+import pyramid.request
+from pyramid.httpexceptions import HTTPNotFound
 from pyramid.view import view_config
 from sqlalchemy import func
 
 from c2cgeoportal_commons import models
 from c2cgeoportal_commons.models import main
 from c2cgeoportal_geoportal.lib.cacheversion import get_cache_version
-from c2cgeoportal_geoportal.lib.caching import NO_CACHE, get_region, set_common_headers
+from c2cgeoportal_geoportal.lib.caching import get_region
+from c2cgeoportal_geoportal.lib.common_headers import Cache, set_common_headers
 
 CACHE_REGION = get_region("std")
 
 
 class DynamicView:
-    def __init__(self, request):
+    """The dynamic vies that provide the configuration of the client application."""
+
+    def __init__(self, request: pyramid.request.Request):
         self.request = request
         self.settings = request.registry.settings
         self.interfaces_config = self.settings["interfaces_config"]
-        self.default = self.interfaces_config.get("default", {})
 
-    def get(self, value, interface):
-        result = dict(self.default.get(value, {}))
-        result.update(self.interfaces_config.get(interface, {}).get(value, {}))
-        return result
+    def get(self, value: Dict[str, Any], interface: str) -> Dict[str, Any]:
+        return cast(Dict[str, Any], self.interfaces_config.get(interface, {}).get(value, {}))
 
-    @CACHE_REGION.cache_on_arguments()
-    def _fulltextsearch_groups(self):  # pylint: disable=no-self-use
+    @CACHE_REGION.cache_on_arguments()  # type: ignore
+    def _fulltextsearch_groups(self) -> List[str]:  # pylint: disable=no-self-use
         return [
             group[0]
             for group in models.DBSession.query(func.distinct(main.FullTextSearch.layer_name))
@@ -65,7 +64,34 @@ class DynamicView:
             .all()
         ]
 
-    def _interface(self, interface_config, interface_name, dynamic, constants):
+    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(
             {
@@ -81,35 +107,40 @@ class DynamicView:
             }
         )
 
-        routes = dict(currentInterfaceUrl={"name": interface_name})
-        routes.update(interface_config.get("routes", {}))
-        for constant, config in routes.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(
-                config["name"], *config.get("elements", []), _query=params, **config.get("kw", {})
+                route_name, *config.get("elements", []), _query=params, **config.get("kw", {})
             )
 
         return constants
 
-    @view_config(route_name="dynamic", renderer="fast_json")
-    def dynamic(self):
-        interfaces_names = [interface["name"] for interface in self.settings.get("interfaces")]
-        default_interfaces_names = [
-            interface["name"]
-            for interface in self.settings.get("interfaces")
-            if interface.get("default", False)
-        ]
-        assert len(default_interfaces_names) == 1, "More than one default interface in: " + json.dumps(
-            self.settings.get("interfaces")
-        )
-        default_interface_name = default_interfaces_names[0]
-        interface_name = self.request.params.get("interface")
-        if interface_name not in interfaces_names:
-            interface_name = default_interface_name
+    @view_config(route_name="dynamic", renderer="json")  # type: ignore
+    def dynamic(self) -> Dict[str, Any]:
+        original_interface_name = self.request.params.get("interface")
+        interface_name = self.request.get_organization_interface(original_interface_name)
+
+        if interface_name not in self.interfaces_config:
+            raise HTTPNotFound("Interface {} doesn't exists in the 'interfaces_config'.")
+
         interface_config = self.interfaces_config[interface_name]
+        lang_urls_suffix = interface_config.get("lang_urls_suffix", "")
+
+        i18next_configuration = self.settings.get("i18next", {})
+        i18next_configuration.setdefault("backend", {})
+        if "loadPath" not in i18next_configuration["backend"]:
+            path: List[str] = [
+                self.request.route_url("base").rstrip("/"),
+                "static-{{ns}}",
+                get_cache_version(),
+                "locales",
+                "{{lng}}.json",
+            ]
+            i18next_configuration["backend"]["loadPath"] = "/".join(path)
 
         dynamic = {
             "interface": interface_name,
@@ -117,23 +148,22 @@ class DynamicView:
             "two_factor": self.request.registry.settings.get("authentication", {}).get("two_factor", False),
             "lang_urls": {
                 lang: self.request.static_url(
-                    "/etc/geomapfish/static/{lang}.json".format(lang=lang),
-                    _query={"cache": get_cache_version()},
+                    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(self.default, interface_name, dynamic, {})
-        constants = self._interface(interface_config, interface_name, dynamic, constants)
+        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, Union[str, List[str]]] = {"no_redirect": "t"}
             if "query" in self.request.params:
-                query = urllib.parse.parse_qs(self.request.params["query"][1:])
+                query = urllib.parse.parse_qs(self.request.params["query"][1:], keep_blank_values=True)
                 no_redirect_query.update(query)
             else:
                 query = {}
@@ -165,5 +195,5 @@ class DynamicView:
                 else:
                     constants["redirectUrl"] = no_redirect_url
 
-        set_common_headers(self.request, "dynamic", NO_CACHE)
+        set_common_headers(self.request, "dynamic", Cache.PUBLIC_NO)
         return {"constants": constants, "doRedirect": do_redirect, "redirectUrl": url}

c2cgeoportal_geoportal/views/entry.py

@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2011-2020, Camptocamp SA
+# Copyright (c) 2011-2023, Camptocamp SA
 # All rights reserved.
 
 # Redistribution and use in source and binary forms, with or without
@@ -28,52 +26,123 @@
 # either expressed or implied, of the FreeBSD Project.
 
 
+import glob
 import logging
-from typing import Dict, Set, Tuple  # noqa # pylint: disable=unused-import
-import xml.dom.minidom  # 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,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
@@ -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,37 +39,42 @@ 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")
-IGNORED_CHARS_RE = re.compile(r"[()&|!:<>]")
+IGNORED_CHARS_RE = re.compile(r"[()&|!:<>\t]")
 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_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.request.params.get("query")
+        terms = self.fts_normalizer(self.request.params.get("query"))
 
         maxlimit = self.settings.get("maxlimit", 200)
 
@@ -77,21 +82,18 @@ 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
-
-        terms_ts = "&".join(
-            w + ":*"
-            for w in IGNORED_STARTUP_CHARS_RE.sub("", IGNORED_CHARS_RE.sub(" ", terms)).split(" ")
-            if w != ""
-        )
+        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 = FullTextSearch.ts.op("@@")(func.to_tsquery(language, terms_ts))
 
         if self.request.user is None:
@@ -143,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