Read project translations from QGIS Server via GetTranslations

Ensures embedded project layer translations are also properly handled

Author: manisandro

src/config_generator/capabilities_reader.py

@@ -2,6 +2,7 @@
 from urllib.parse import urljoin, urlparse
 from xml.etree import ElementTree
 
+import json
 import os
 import posixpath
 import re
@@ -622,3 +623,36 @@ def collect_wfs_layers_attributes(self, full_url):
             )
             self.logger.debug(traceback.format_exc())
             return {}
+
+    def read_project_translations(self, service_name, viewer_languages):
+        """ Read translations from QGIS Server.
+        :param str service_name: service name
+        :param list viewer_languages: viewer languages
+
+        """
+        all_translations = {}
+        for language in viewer_languages:
+            try:
+                full_url = urljoin(
+                    self.default_qgis_server_url,
+                    posixpath.join(self.qgis_server_url_tenant_suffix, service_name)
+                )
+                params = {
+                    'SERVICE': 'GetTranslations',
+                    'LANG': language
+                }
+                document = self.fetch_cached(full_url, params, "GetTranslations_" + language, "GetTranslations " + language, True)
+                if not document:
+                    return {}
+                all_translations[language] = json.loads(document)
+                if all_translations[language]:
+                    self.logger.info("Read " + language + " translations for " + service_name)
+
+            except Exception as e:
+                self.logger.error(
+                    "Could not parse GetTranslations from %s:\n%s" %
+                    (full_url, e)
+                )
+                self.logger.debug(traceback.format_exc())
+
+        return all_translations

src/config_generator/map_viewer_config.py

@@ -446,7 +446,7 @@ def theme_item(self, cfg_item, themes_config, assets_dir, autogenExternalLayers,
         item['keywords'] = cap.get('keywords', '')
         item['onlineResource'] = cap.get('onlineResource', '')
         item['contact'] = cap.get('contact', {})
-        item['translations'] = project_metadata['translations']
+        item['translations'] = self.themes_reader.project_translations(service_name)
 
 
         projectCrs = project_metadata['project_crs']

src/config_generator/qgs_reader.py

@@ -38,32 +38,24 @@ def deep_merge(d1, d2):
 class QGSReader:
     """ Read QGIS projects and extract data for QWC config """
 
-    def __init__(self, config, logger, assets_dir, translations_dir, use_cached_project_metadata, global_print_layouts):
+    def __init__(self, config, logger, assets_dir, use_cached_project_metadata, global_print_layouts):
         """Constructor
 
         :param obj config: Config generator config
         :param Logger logger: Application logger
         :param string assets_dir: Assets directory
-        :param str translations_dir: Viewer translations directory
         :param bool use_cached_project_metadata: Whether to use cached project metadata
         :param list global_print_layouts: Global print layouts
         """
         self.config = config
         self.logger = logger
         self.assets_dir = assets_dir
-        self.translations_dir = translations_dir
         self.use_cached_project_metadata = use_cached_project_metadata
         self.global_print_layouts = global_print_layouts
 
         self.qgs_resources_path = config.get('qgis_projects_base_dir', '/tmp/')
         self.qgs_ext = config.get('qgis_project_extension', '.qgs')
         self.nested_nrels = config.get('generate_nested_nrel_forms', False)
-        try:
-            with open(os.path.join(self.translations_dir, 'tsconfig.json')) as fh:
-                self.viewer_languages = json.load(fh)['languages']
-        except:
-            self.logger.warning("Failed to detect viewer languages from tsconfig.json")
-            self.viewer_languages = ["en-US"]
 
         self.db_engine = DatabaseEngine()
 
@@ -147,20 +139,15 @@ def read(self, map_prefix, theme_item, edit_datasets):
 
         # Build layername -> shortname lookup
         shortname_map = {}
-        id_name_map = {}
         for maplayer in root.findall('.//maplayer'):
             layernameEl = maplayer.find('layername')
             if layernameEl is not None:
                 shortnameEl = maplayer.find('shortname')
-                idEl = maplayer.find('id')
                 shortname = shortnameEl.text if shortnameEl is not None else layernameEl.text
                 shortname_map[layernameEl.text] = shortname
-                if idEl is not None:
-                    id_name_map[idEl.text] = shortname
 
         return {
             "project_crs": self.__project_crs(root),
-            "translations": self.__theme_translations(qgs_dir, projectname, id_name_map),
             "print_templates": self.__print_templates(root, shortname_map),
             "visibility_presets": self.__visibility_presets(root),
             "layer_metadata": self.__layer_metadata(root, shortname_map, map_prefix, edit_datasets, theme_item, qgs_dir),
@@ -172,76 +159,6 @@ def __project_crs(self, root):
         authid = root.find('./projectCrs/spatialrefsys/authid')
         return authid.text if authid is not None else None
 
-    def __theme_translations(self, qgs_dir, projectname, id_name_map):
-        """ Read theme portion of translations from <projectname>_<lang>.json. """
-        all_translations = {}
-
-        for language in self.viewer_languages:
-            translations = {}
-
-            ts_file = os.path.join(qgs_dir, f"{projectname}_{language}.ts")
-            if not os.path.exists(ts_file):
-                ts_file = os.path.join(qgs_dir, f"{projectname}_{language[0:2]}.ts")
-            if os.path.exists(ts_file):
-                self.logger.info('Reading project translations %s' % ts_file)
-                try:
-                    ts_document = ElementTree.parse(ts_file)
-
-                    # Build translation string lookup
-                    for context in ts_document.findall("./context"):
-                        context_name = context.find('./name')
-                        if context_name is None:
-                            continue
-
-                        context_name_parts = context_name.text.split(":")
-                        key = None
-                        if len(context_name_parts) >= 3 and context_name_parts[0] == "project" and context_name_parts[1] == "layers":
-                            # replace layer id with layer name
-                            layername = id_name_map[context_name_parts[2]]
-
-                            if len(context_name_parts) == 3:
-                                ts_path = f"layertree"
-                                key = layername
-                            elif len(context_name_parts) == 4 and context_name_parts[3] == "fieldaliases":
-                                ts_path = f"layers.{layername}.fields"
-                            elif len(context_name_parts) == 4 and context_name_parts[3] == "formcontainers":
-                                ts_path = f"layers.{layername}.form"
-                        elif len(context_name_parts) == 2 and context_name_parts[0] == "project" and context_name_parts[1] == "layergroups":
-                            ts_path = f"layertree"
-                        else:
-                            # Unknown ts context
-                            continue
-
-                        context_ts = translations
-                        for entry in ts_path.split("."):
-                            context_ts[entry] = context_ts.get(entry, {})
-                            context_ts = context_ts[entry]
-
-                        for message in context.findall("./message"):
-                            source = message.find('./source')
-                            translation = message.find('./translation')
-                            if source is not None and translation is not None and translation.get('type', '') != "unfinished":
-                                context_ts[key or source.text] = translation.text
-
-                except Exception as e:
-                    self.logger.info('Failed to auxiliary project translations %s: %s' % (ts_file, str(e)))
-
-            json_file = os.path.join(qgs_dir, f"{projectname}_{language}.json")
-            if not os.path.exists(json_file):
-                json_file = os.path.join(qgs_dir, f"{projectname}_{language[0:2]}.json")
-            if os.path.exists(json_file):
-                self.logger.info('Reading auxiliary project translations %s' % json_file)
-                try:
-                    with open(json_file) as fh:
-                        translations = deep_merge(translations, json.load(fh))
-                except Exception as e:
-                    self.logger.info('Failed to read auxiliary project translations %s: %s' % (json_file, str(e)))
-
-            if translations:
-                all_translations[language] = translations
-
-        return all_translations
-
     def __print_templates(self, root, shortname_map):
         """ Collect print templates from QGS and merge with global print layouts. """
 

src/config_generator/theme_reader.py

@@ -1,3 +1,4 @@
+import json
 import os
 from collections import OrderedDict
 from pathlib import Path
@@ -36,8 +37,15 @@ def __init__(self, config, logger, config_models, themes_config, assets_dir, tra
 
         global_print_layouts = self.__search_global_print_layouts()
 
+        try:
+            with open(os.path.join(translations_dir, 'tsconfig.json')) as fh:
+                self.viewer_languages = json.load(fh)['languages']
+        except:
+            self.logger.warning("Failed to detect viewer languages from tsconfig.json")
+            self.viewer_languages = ["en-US"]
+
         self.capabilities_reader = CapabilitiesReader(config, logger, use_cached_project_metadata, cache_dir)
-        self.qgs_reader = QGSReader(config, logger, assets_dir, translations_dir, use_cached_project_metadata, global_print_layouts)
+        self.qgs_reader = QGSReader(config, logger, assets_dir, use_cached_project_metadata, global_print_layouts)
 
         self.default_qgis_server_url = config.get(
             'default_qgis_server_url', 'http://localhost:8001/ows/'
@@ -145,13 +153,15 @@ def __read_metadata_for_theme(self, item):
 
         wms_capabilities = self.capabilities_reader.read_wms_service_capabilities(service_name, item, self.themes_config)
         wfs_capabilities = self.capabilities_reader.read_wfs_service_capabilities(service_name, item)
+        project_translations = self.capabilities_reader.read_project_translations(service_name, self.viewer_languages)
         project_metadata = self.qgs_reader.read(service_name, item, self.__get_edit_datasets(service_name))
 
         self.theme_metadata[service_name] = {
             'service_name': service_name,
             'url': url,
             'wms_capabilities': wms_capabilities,
             'wfs_capabilities': wfs_capabilities,
+            'project_translations': project_translations,
             'project_metadata': project_metadata
         }
 
@@ -207,6 +217,10 @@ def wfs_capabilities(self, service_name):
         """ Return the WFS servcice capabilities for the specified OWS service. """
         return self.theme_metadata.get(service_name, {}).get('wfs_capabilities', {})
 
+    def project_translations(self, service_name):
+        """ Return the QGS project translations for the specified OWS service. """
+        return self.theme_metadata.get(service_name, {}).get('project_translations', {})
+
     def project_metadata(self, service_name):
         """ Return the QGS project metadata for the specified OWS service. """
         return self.theme_metadata.get(service_name, {}).get('project_metadata', {})