[Fixes #12957] Metadata editor: customizable title and description labels

Author: etj

geonode/metadata/handlers/abstract.py

@@ -35,11 +35,14 @@ class MetadataHandler(metaclass=ABCMeta):
     """
 
     @abstractmethod
-    def update_schema(self, jsonschema: dict, context, lang=None):
+    def update_schema(self, jsonschema: dict, context: dict, lang=None):
         """
         It is called by the MetadataManager when creating the JSON Schema
         It adds the subschema handled by the handler, and returns the
         augmented instance of the JSON Schema.
+        Context is populated by the manager with some common info:
+         - key "labels": contains the localized label loaded from the db as a dict, where key is the ThesaurusKeyword about
+           and value is the localized ThesaurusKeywordLabel, or the AltLabel if the localized label does not exist.
         """
         pass
 
@@ -58,7 +61,7 @@ def update_resource(
         self, resource: ResourceBase, field_name: str, json_instance: dict, context: dict, errors: dict, **kwargs
     ):
         """
-        Called when persisting data, updates the field field_name of the resource
+        Called when persisting data, updates the field `field_name` of the resource
         with the content content, where json_instance is  the full JSON Schema instance,
         in case the handler needs some cross related data contained in the resource.
         """
@@ -135,15 +138,22 @@ def _set_error(errors: dict, path: list, msg: str):
 
     @staticmethod
     def _localize_label(context, lang: str, text: str):
-        # Try localization via thesaurus:
-        label = context["labels"].get(text, None)
-        # fallback: gettext()
-        if not label:
-            label = _(text)
+        label = MetadataHandler._get_tkl_labels(context, lang, text)
+        return label if label else _(text)
 
-        return label
+    @staticmethod
+    def _get_tkl_labels(context, lang: str, text: str):
+        return context["labels"].get(text, None)
 
     @staticmethod
-    def _localize_subschema_label(context, subschema: dict, lang: str, annotation_name: str):
-        if annotation_name in subschema:
-            subschema[annotation_name] = MetadataHandler._localize_label(context, lang, subschema[annotation_name])
+    def _localize_subschema_labels(context, subschema: dict, lang: str, property_name: str = None):
+        for annotation_name, synt in (
+            ("title", ""),
+            ("description", "__descr"),
+        ):
+            if annotation_name in subschema:
+                subschema[annotation_name] = MetadataHandler._localize_label(context, lang, subschema[annotation_name])
+            elif property_name:  # arrays may not have a name
+                label = MetadataHandler._get_tkl_labels(context, lang, f"{property_name}{synt}")
+                if label:
+                    subschema[annotation_name] = label

geonode/metadata/handlers/base.py

@@ -184,8 +184,7 @@ def update_schema(self, jsonschema, context, lang=None):
             self.base_schema = json.load(f)
         # building the full base schema
         for property_name, subschema in self.base_schema.items():
-            self._localize_subschema_label(context, subschema, lang, "title")
-            self._localize_subschema_label(context, subschema, lang, "description")
+            self._localize_subschema_labels(context, subschema, lang, property_name)
 
             jsonschema["properties"][property_name] = subschema
 

geonode/metadata/handlers/sparse.py

@@ -49,24 +49,23 @@ class SparseHandler(MetadataHandler):
     Handles sparse in fields in the SparseField table
     """
 
-    def _recurse_localization(self, context, schema, lang):
-        self._localize_subschema_label(context, schema, lang, "title")
-        self._localize_subschema_label(context, schema, lang, "description")
+    def _recurse_localization(self, context, schema, lang, field_name=None):
+        self._localize_subschema_labels(context, schema, lang, field_name)
 
         match schema["type"]:
             case "object":
-                for subschema in schema["properties"].values():
-                    self._recurse_localization(context, subschema, lang)
+                for prop_name, subschema in schema["properties"].items():
+                    self._recurse_localization(context, subschema, lang, prop_name)
             case "array":
-                self._recurse_localization(context, schema["items"], lang)
+                self._recurse_localization(context, schema["items"], lang, None)
             case _:
                 pass
 
     def update_schema(self, jsonschema, context, lang=None):
         # add all registered fields
         for field_name, field_info in sparse_field_registry.fields().items():
             subschema = copy.deepcopy(field_info["schema"])
-            self._recurse_localization(context, subschema, lang)
+            self._recurse_localization(context, subschema, lang, field_name)
             self._add_subschema(jsonschema, field_name, subschema, after_what=field_info["after"])
 
             # add the handler info to the dictionary if it doesn't exist

geonode/metadata/i18n.py

@@ -15,24 +15,41 @@ def get_localized_tkeywords(lang, thesaurus_identifier: str):
         "	tk.id,"
         "	tk.about,"
         "	tk.alt_label,"
-        "	tkl.label"
+        "	tkl.label,"
+        "	tkl.lang"
         " from"
         "	base_thesaurus th,"
         "   base_thesauruskeyword tk"
         " left outer join "
         "  (select keyword_id, lang, label from base_thesauruskeywordlabel"
-        "   where lang = %s) as tkl"
+        "   where lang like %s) as tkl"
         " on (tk.id = tkl.keyword_id)"
         " where th.identifier = %s"
         " and tk.thesaurus_id = th.id"
         " order by label, alt_label"
     )
-    ret = []
+    ret = {}
+    ovr = {}
     with connection.cursor() as cursor:
-        cursor.execute(query, [lang, thesaurus_identifier])
-        for id, about, alt, label in cursor.fetchall():
-            ret.append({"id": id, "about": about, "label": label or alt})
-    return sorted(ret, key=lambda i: i["label"].lower())
+        cursor.execute(query, [f"{lang}%", thesaurus_identifier])
+        for id, about, alt, label, dblang in cursor.fetchall():
+            if not dblang or dblang == lang:
+                # this is a properly localized label or an altlabel (when dblang is null)
+                ret[id] = {"id": id, "about": about, "label": label or alt}
+            elif dblang and dblang.endswith("-ovr"):
+                # store overrides to be applied later
+                ovr[id] = {"id": id, "about": about, "label": label or alt}
+            else:
+                logger.warning(f"Found unexpected lang {dblang}")
+        for ovr_id, ovr_row in ovr.items():  # apply overrides
+            if ovr_id in ret:
+                logger.debug(f"overriding TK {ret[ovr_id]['about']}")
+                ret[ovr_id]["label"] = ovr_row["label"]
+            else:
+                logger.debug(f"Setting ovr TK {ovr_row}")
+                ret[ovr_id] = ovr_row
+
+    return sorted(ret.values(), key=lambda i: i["label"].lower())
 
 
 def get_localized_labels(lang, key="about"):

geonode/metadata/settings.py

@@ -1,9 +1,9 @@
 import os
-from geonode.settings import PROJECT_ROOT
+from geonode.settings import PROJECT_ROOT, SITEURL
 
 MODEL_SCHEMA = {
     "$schema": "https://json-schema.org/draft/2020-12/schema",
-    "$id": "{GEONODE_SITE}/resource.json",
+    "$id": f"{SITEURL}/resource.json",
     "title": "GeoNode resource",
     "type": "object",
     "properties": {},