Read theme translations from project translation auxiliary files

Author: manisandro

src/config_generator/config_generator.py

@@ -248,14 +248,21 @@ def __init__(self, config, logger, config_file_dir, use_cached_project_metadata,
         viewer_config_json = map_viewer_config.get('generator_config', {}).get('qwc2_config', {}).get('qwc2_config_file')
         try:
             with open(viewer_config_json, 'r') as fh:
+                viewer_config = json.load(fh)
                 assets_dir = os.path.join(
                     qwc_base_dir,
-                    json.load(fh).get('assetsPath', 'assets').lstrip('/')
+                    viewer_config.get('assetsPath', 'assets').lstrip('/')
+                )
+                translations_dir = os.path.join(
+                    qwc_base_dir,
+                    viewer_config.get('translationsPath', 'translations').lstrip('/')
                 )
         except:
-            self.logger.warning("Failed to read assets path from viewer config.json, using default")
+            self.logger.warning("Failed to read assets/translations path from viewer config.json, using default")
             assets_dir = os.path.join(qwc_base_dir, 'assets')
+            translations_dir = os.path.join(qwc_base_dir, 'translations')
         self.logger.info(f"Assets destination: {assets_dir}")
+        self.logger.info(f"Translations destination: {translations_dir}")
 
         # Search for QGS projects in scan dir and automatically generate theme items
         self.search_qgs_projects(generator_config, config["themesConfig"])
@@ -264,7 +271,7 @@ def __init__(self, config, logger, config_file_dir, use_cached_project_metadata,
         capabilities_cache_dir = os.path.join(self.config_path, "__capabilities_cache")
         self.theme_reader = ThemeReader(
             generator_config, self.logger, self.config_models, config["themesConfig"],
-            assets_dir, use_cached_project_metadata, capabilities_cache_dir
+            assets_dir, translations_dir, use_cached_project_metadata, capabilities_cache_dir
         )
 
         # load schema-versions.json

src/config_generator/map_viewer_config.py

@@ -445,6 +445,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']
 
 
         projectCrs = project_metadata['project_crs']

src/config_generator/qgs_reader.py

@@ -1,5 +1,6 @@
 import html
 import io
+import json
 import math
 import os
 import re
@@ -24,24 +25,32 @@ def element_attr(element, attr, default=None):
 class QGSReader:
     """ Read QGIS projects and extract data for QWC config """
 
-    def __init__(self, config, logger, assets_dir, use_cached_project_metadata, global_print_layouts):
+    def __init__(self, config, logger, assets_dir, translations_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()
 
@@ -57,8 +66,9 @@ def read(self, map_prefix, theme_item, edit_datasets):
         try:
             if map_prefix.startswith("pg/"):
                 parts = map_prefix.split("/")
-                qgs_path = self.qgs_resources_path
+                qgs_dir = self.qgs_resources_path
                 qgs_filename = 'postgresql:///?service=qgisprojects&schema=%s&project=%s' % (parts[1], parts[2])
+                projectname = parts[2]
 
                 qgis_projects_db = self.db_engine.db_engine("postgresql:///?service=qgisprojects")
 
@@ -84,6 +94,8 @@ def read(self, map_prefix, theme_item, edit_datasets):
             else:
                 qgs_filename = map_prefix + self.qgs_ext
                 qgs_path = os.path.join(self.qgs_resources_path, qgs_filename)
+                qgs_dir = os.path.dirname(qgs_path)
+                projectname = os.path.basename(qgs_path).removesuffix(self.qgs_ext)
                 if not os.path.exists(qgs_path):
                     self.logger.error("Could not find QGS project '%s'" % qgs_filename)
                     return None
@@ -131,9 +143,10 @@ def read(self, map_prefix, theme_item, edit_datasets):
 
         return {
             "project_crs": self.__project_crs(root),
+            "translations": self.__theme_translations(qgs_dir, projectname),
             "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_path)
+            "layer_metadata": self.__layer_metadata(root, shortname_map, map_prefix, edit_datasets, theme_item, qgs_dir),
         }
 
 
@@ -142,6 +155,28 @@ 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):
+        """ Read theme portion of translations from <projectname>_<lang>.json. """
+        all_translations = {}
+
+        for language in self.viewer_languages:
+            translations = {}
+
+            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 project translations %s' % json_file)
+                try:
+                    with open(json_file) as fh:
+                        translations = json.load(fh)['theme']
+                except Exception as e:
+                    self.logger.info('Failed to read 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. """
@@ -248,7 +283,7 @@ def __visibility_presets(self, root):
         return result
 
 
-    def __layer_metadata(self, root, shortname_map, map_prefix, edit_datasets, theme_item, qgs_path):
+    def __layer_metadata(self, root, shortname_map, map_prefix, edit_datasets, theme_item, qgs_dir):
         """ Read additional layer metadata from QGS. """
         layers_metadata = {}
         # Collect metadata for layers
@@ -276,7 +311,7 @@ def __layer_metadata(self, root, shortname_map, map_prefix, edit_datasets, theme
 
             # Edit metadata
             if editable:
-                self.__layer_edit_metadata(root, layer_metadata, maplayer, layername, map_prefix, shortname_map, qgs_path, theme_item)
+                self.__layer_edit_metadata(root, layer_metadata, maplayer, layername, map_prefix, shortname_map, qgs_dir, theme_item)
 
             layers_metadata[layername] = layer_metadata
 
@@ -291,7 +326,7 @@ def __layer_metadata(self, root, shortname_map, map_prefix, edit_datasets, theme
         return layers_metadata
 
 
-    def __layer_edit_metadata(self, root, layer_metadata, maplayer, layername, map_prefix, shortnames, qgs_path, theme_item):
+    def __layer_edit_metadata(self, root, layer_metadata, maplayer, layername, map_prefix, shortnames, qgs_dir, theme_item):
         """ Read layer metadata relevant for editing from QGS. """
 
         provider = maplayer.find('provider').text
@@ -384,7 +419,7 @@ def __layer_edit_metadata(self, root, layer_metadata, maplayer, layername, map_p
 
         # Generate form
         layer_metadata["edit_form"] = self.__generate_edit_form(
-            root, qgs_path, map_prefix, shortnames, maplayer, layer_metadata, layername, theme_item
+            root, qgs_dir, map_prefix, shortnames, maplayer, layer_metadata, layername, theme_item
         )
 
 
@@ -686,7 +721,7 @@ def __column_metadata(self, field_metadata, datasource, column, data_type_only =
                         constraints['max'] = ranges[data_type]['max']
 
 
-    def __generate_edit_form(self, project, qgs_path, map_prefix, shortnames, maplayer, layer_metadata, layername, theme_item):
+    def __generate_edit_form(self, project, qgs_dir, map_prefix, shortnames, maplayer, layer_metadata, layername, theme_item):
         """ Copy / generate edit from from QGIS form settings. """
 
         projectname = os.path.basename(map_prefix)
@@ -708,7 +743,7 @@ def __generate_edit_form(self, project, qgs_path, map_prefix, shortnames, maplay
             if editform is not None:
                 formpath = editform.text
                 if not os.path.isabs(formpath):
-                    formpath = os.path.join(os.path.dirname(qgs_path), formpath)
+                    formpath = os.path.join(qgs_dir, formpath)
                 try:
                     os.makedirs(outputdir, exist_ok=True)
                     shutil.copy(formpath, outputfile)

src/config_generator/theme_reader.py

@@ -14,14 +14,15 @@ class ThemeReader():
     Reads project metadata for all theme items in the QWC2 theme configuration.
     """
 
-    def __init__(self, config, logger, config_models, themes_config, assets_dir, use_cached_project_metadata, cache_dir):
+    def __init__(self, config, logger, config_models, themes_config, assets_dir, translations_dir, use_cached_project_metadata, cache_dir):
         """Constructor
 
         :param obj config: ConfigGenerator config
         :param Logger logger: Logger
         :param ConfigModels config_models: Helper for ORM models
         :param dict themes_config: themes config
         :param str assets_dir: Viewer assets directory
+        :param str translations_dir: Viewer translations directory
         :param bool use_cached_project_metadata: Whether to use cached project metadata if available
         :param str cache_dir: Project metadata cache directory
         """
@@ -36,7 +37,7 @@ def __init__(self, config, logger, config_models, themes_config, assets_dir, use
         global_print_layouts = self.__search_global_print_layouts()
 
         self.capabilities_reader = CapabilitiesReader(config, logger, use_cached_project_metadata, cache_dir)
-        self.qgs_reader = QGSReader(config, logger, assets_dir, use_cached_project_metadata, global_print_layouts)
+        self.qgs_reader = QGSReader(config, logger, assets_dir, translations_dir, use_cached_project_metadata, global_print_layouts)
 
         self.default_qgis_server_url = config.get(
             'default_qgis_server_url', 'http://localhost:8001/ows/'