[Fixes #13646] : Use multilang entries in ISO19115

geonode/catalogue/templates/catalogue/full_metadata.xml

@@ -1,11 +1,14 @@
 {% load thesaurus %}
 {% load l10n %}
+{% load multilang %}
 <gmd:MD_Metadata xmlns:gmd="http://www.isotc211.org/2005/gmd" xmlns:gml="http://www.opengis.net/gml" xmlns:gmx="http://www.isotc211.org/2005/gmx" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gco="http://www.isotc211.org/2005/gco" xsi:schemaLocation="http://www.isotc211.org/2005/gmd http://www.isotc211.org/2005/gmd/gmd.xsd">
    <gmd:fileIdentifier>
      <gco:CharacterString>{{layer.uuid}}</gco:CharacterString>
    </gmd:fileIdentifier>
+   {% language_info layer.language as resource_language %}
+   {% languages_info metadata as locales %}
    <gmd:language>
-     <gco:CharacterString>{{layer.language}}</gco:CharacterString>
+     <gmd:LanguageCode codeList="http://www.loc.gov/standards/iso639-2/" codeListValue="{{ resource_language.iso639_2 }}">{{ resource_language.label }}</gmd:LanguageCode>
    </gmd:language>
    <gmd:characterSet>
      <gmd:MD_CharacterSetCode codeSpace="ISOTC211/19115" codeList="http://www.isotc211.org/2005/resources/Codelist/gmxCodelists.xml#MD_CharacterSetCode" codeListValue="utf8">utf8</gmd:MD_CharacterSetCode>
@@ -91,6 +94,18 @@
    <gmd:metadataStandardVersion>
      <gco:CharacterString>ISO 19115:2003</gco:CharacterString>
    </gmd:metadataStandardVersion>
+   {% for locale in locales %}
+   <gmd:locale>
+     <gmd:PT_Locale id="{{ locale.id }}">
+       <gmd:languageCode>
+         <gmd:LanguageCode codeList="http://www.loc.gov/standards/iso639-2/" codeListValue="{{ locale.iso639_2 }}">{{ locale.label }}</gmd:LanguageCode>
+       </gmd:languageCode>
+       <gmd:characterEncoding>
+         <gmd:MD_CharacterSetCode codeList="http://www.isotc211.org/2005/resources/Codelist/gmxCodelists.xml#MD_CharacterSetCode" codeListValue="{{ locale.encoding }}">{{ locale.encoding }}</gmd:MD_CharacterSetCode>
+       </gmd:characterEncoding>
+     </gmd:PT_Locale>
+   </gmd:locale>
+   {% endfor %}
    <gmd:spatialRepresentationInfo />
    <gmd:referenceSystemInfo>
      <gmd:MD_ReferenceSystem>
@@ -114,8 +129,18 @@
      <gmd:MD_DataIdentification>
        <gmd:citation>
          <gmd:CI_Citation>
-           <gmd:title>
+           {% multilang_values "title" metadata as title_translations %}
+           <gmd:title{% if title_translations %} xsi:type="gmd:PT_FreeText_PropertyType"{% endif %}>
              <gco:CharacterString>{{layer.title}}</gco:CharacterString>
+             {% if title_translations %}
+             <gmd:PT_FreeText>
+               {% for t in title_translations %}
+               <gmd:textGroup>
+                 <gmd:LocalisedCharacterString locale="#locale-{{ t.locale }}">{{ t.text }}</gmd:LocalisedCharacterString>
+               </gmd:textGroup>
+               {% endfor %}
+             </gmd:PT_FreeText>
+             {% endif %}
            </gmd:title>
            {% if layer.alternate %}
            <gmd:alternateTitle>
@@ -149,8 +174,18 @@
            </gmd:presentationForm>
          </gmd:CI_Citation>
        </gmd:citation>
-       <gmd:abstract>
+       {% multilang_values "abstract" metadata as abstract_translations %}
+       <gmd:abstract{% if abstract_translations %} xsi:type="gmd:PT_FreeText_PropertyType"{% endif %}>
          <gco:CharacterString>{{layer.raw_abstract}}</gco:CharacterString>
+         {% if abstract_translations %}
+         <gmd:PT_FreeText>
+           {% for t in abstract_translations %}
+           <gmd:textGroup>
+             <gmd:LocalisedCharacterString locale="#locale-{{ t.locale }}">{{ t.text }}</gmd:LocalisedCharacterString>
+           </gmd:textGroup>
+           {% endfor %}
+         </gmd:PT_FreeText>
+         {% endif %}
        </gmd:abstract>
        <gmd:purpose {% if not layer.raw_purpose %}gco:nilReason="missing"{% endif %}>
              {% if layer.raw_purpose %}<gco:CharacterString>{{layer.raw_purpose}}</gco:CharacterString>{% endif %}
@@ -370,7 +405,7 @@
        </gmd:spatialRepresentationType>
        {% endif %}
        <gmd:language>
-         <gco:CharacterString>{{layer.language}}</gco:CharacterString>
+         <gmd:LanguageCode codeList="http://www.loc.gov/standards/iso639-2/" codeListValue="{{ resource_language.iso639_2 }}">{{ resource_language.label }}</gmd:LanguageCode>
        </gmd:language>
        <gmd:characterSet>
          <gmd:MD_CharacterSetCode codeSpace="ISOTC211/19115" codeList="http://www.isotc211.org/2005/resources/Codelist/gmxCodelists.xml#MD_CharacterSetCode" codeListValue="utf8">utf8</gmd:MD_CharacterSetCode>

geonode/catalogue/templatetags/multilang.py

@@ -0,0 +1,144 @@
+#########################################################################
+#
+# Copyright (C) 2026 OSGeo
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+#########################################################################
+
+import logging
+
+from django import template
+from django.conf import settings
+
+from geonode.metadata.multilang.utils import (
+    get_default_language,
+    get_3_from_2,
+    get_2_from_3,
+    get_multilang_field_names,
+    get_all_multilang_fields,
+)
+
+register = template.Library()
+logger = logging.getLogger(__name__)
+
+
+def _language_label(language_code_2, fallback):
+    """
+    Return the display label for a configured language.
+    """
+    language_labels = {code.split("-")[0]: label for code, label in settings.LANGUAGES}
+
+    return language_labels.get(language_code_2, fallback)
+
+
+def _language_descriptor(lang_2, lang_3):
+    """Build the language descriptor used by the ISO template."""
+    return {
+        "id": f"locale-{lang_2}",
+        "iso639_2": lang_3,
+        "label": _language_label(lang_2, lang_3),
+        "encoding": "utf8",
+    }
+
+
+@register.filter(name="is_multilang")
+def is_multilang(field_name):
+    """Return whether the field is configured as multilingual."""
+    return field_name in getattr(settings, "MULTILANG_FIELDS", ())
+
+
+@register.simple_tag(name="multilang_values")
+def multilang_values(field_name, metadata):
+    """
+    Return all translations for a multilingual field except the default
+    language.
+    """
+    if not isinstance(metadata, dict) or not is_multilang(field_name):
+        return []
+
+    return [
+        {
+            "locale": language_code,
+            "text": metadata[translated_field],
+        }
+        for language_code, translated_field in get_multilang_field_names(field_name)
+        if metadata.get(translated_field)
+    ]
+
+
+@register.simple_tag(name="language_info")
+def language_info(lang_3):
+    """
+    Return information about a single ISO639-2 language.
+    """
+    if not lang_3:
+        lang_2 = get_default_language()
+        lang_3 = get_3_from_2(lang_2)
+        if lang_3 is None:
+            logger.warning(
+                "No ISO639-2 language found for '%s'; using 'eng' as the default.",
+                lang_2,
+            )
+            lang_3 = "und"
+    elif len(lang_3) == 2:
+        lang_2 = lang_3
+        lang_3 = get_3_from_2(lang_2) or "und"
+    else:
+        lang_2 = get_2_from_3(lang_3)
+
+        if lang_2 is None:
+            logger.warning(
+                "No ISO639-1 language found for '%s'; using the ISO639-2 code as the label.",
+                lang_3,
+            )
+
+    return _language_descriptor(
+        lang_2,
+        lang_3,
+    )
+
+
+@register.simple_tag(name="languages_info")
+def languages_info(metadata, fields=None):
+    """
+    Return descriptors for all translated languages present in the metadata.
+    """
+    if not isinstance(metadata, dict):
+        return []
+
+    multilingual_fields = set(fields or settings.MULTILANG_FIELDS)
+
+    languages = set()
+
+    for (field_name, language_code), multilang_field_name in get_all_multilang_fields().items():
+        if field_name not in multilingual_fields or not metadata.get(multilang_field_name):
+            continue
+
+        languages.add(language_code)
+
+    descriptors = []
+    for language_code in sorted(languages):
+        lang_3 = get_3_from_2(language_code)
+
+        if lang_3 is None:
+            logger.warning(
+                "No entry in settings.LANGUAGE_MAPPINGS for language '%s'; skipping this entry.",
+                language_code,
+            )
+            continue
+
+        descriptors.append(_language_descriptor(language_code, lang_3))
+
+    return descriptors

geonode/catalogue/tests.py

@@ -21,11 +21,12 @@
 
 from django.db.models import Q
 from django.template.loader import get_template
-from django.test import RequestFactory
+from django.test import RequestFactory, override_settings
 from django.http.response import Http404
 from django.core.exceptions import PermissionDenied
 from geonode.layers.models import Dataset
 from geonode.catalogue import get_catalogue
+from geonode.catalogue.templatetags import multilang as tags
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import AnonymousUser
 
@@ -208,3 +209,123 @@ def test_localized_keyword_in_metadata(self):
         rendered_xml = template.render(context)
         self.assertIn(self.keyword_label.label, rendered_xml)
         self.assertNotIn(self.keyword.alt_label, rendered_xml)
+
+
+@override_settings(MULTILANG_FIELDS=["title", "abstract"])
+class IsMultilangFilterTest(GeoNodeBaseTestSupport):
+
+    def test_configured_field(self):
+        self.assertTrue(tags.is_multilang("title"))
+        self.assertTrue(tags.is_multilang("abstract"))
+
+    def test_unconfigured_field(self):
+        self.assertFalse(tags.is_multilang("purpose"))
+
+    @override_settings(MULTILANG_FIELDS=())
+    def test_feature_off(self):
+        self.assertFalse(tags.is_multilang("title"))
+
+
+@override_settings(MULTILANG_FIELDS=["title", "abstract"])
+class MultilangValuesTagTests(GeoNodeBaseTestSupport):
+
+    def test_field_not_configured(self):
+        metadata = {"purpose": "x", "purpose_multilang_it": "scopo"}
+        self.assertEqual([], tags.multilang_values("purpose", metadata))
+
+    def test_configured_field_no_translations(self):
+        self.assertEqual([], tags.multilang_values("title", {"title": "Hello"}))
+
+    def test_excludes_empty_string_translation(self):
+        metadata = {
+            "title": "Hello",
+            "title_multilang_de": "",
+            "title_multilang_it": "Ciao",
+        }
+        self.assertEqual([{"locale": "it", "text": "Ciao"}], tags.multilang_values("title", metadata))
+
+    def test_multiple_translations(self):
+        metadata = {
+            "title": "Hello",
+            "title_multilang_de": "Hallo",
+            "title_multilang_es": "Hola",
+            "title_multilang_fr": "Bonjour",
+            "title_multilang_it": "Ciao",
+        }
+        result = {t["locale"]: t["text"] for t in tags.multilang_values("title", metadata)}
+        self.assertEqual({"de": "Hallo", "es": "Hola", "fr": "Bonjour", "it": "Ciao"}, result)
+
+    def test_empty_or_missing_metadata(self):
+        self.assertEqual([], tags.multilang_values("title", {}))
+        self.assertEqual([], tags.multilang_values("title", None))
+
+
+@override_settings(MULTILANG_FIELDS=["title", "abstract"])
+class LanguageTemplateTagTests(GeoNodeBaseTestSupport):
+
+    def test_language_info_known_code(self):
+        result = tags.language_info("ita")
+        self.assertEqual(
+            {
+                "id": "locale-it",
+                "iso639_2": "ita",
+                "label": "Italiano",
+                "encoding": "utf8",
+            },
+            result,
+        )
+
+    def test_language_info_code_with_bibliographic_terminological_variant(self):
+        result = tags.language_info("fra")
+        self.assertEqual("locale-fr", result["id"])
+        self.assertEqual("fra", result["iso639_2"])
+        self.assertEqual("Français", result["label"])
+
+    def test_languages_info_empty_or_missing_metadata(self):
+        self.assertEqual([], tags.languages_info({}))
+        self.assertEqual([], tags.languages_info(None))
+
+    def test_languages_info_no_translations(self):
+        metadata = {"title": "Hello", "abstract": "An abstract"}
+        self.assertEqual([], tags.languages_info(metadata))
+
+    def test_languages_info_across_fields(self):
+        metadata = {
+            "title": "Hello",
+            "title_multilang_it": "Ciao",
+            "title_multilang_de": "Hallo",
+            "abstract": "An abstract",
+            "abstract_multilang_fr": "Un résumé",
+            "abstract_multilang_de": "Eine Zusammenfassung",
+        }
+        result = {d["id"]: d for d in tags.languages_info(metadata)}
+        self.assertEqual({"locale-it", "locale-de", "locale-fr"}, set(result.keys()))
+        self.assertEqual(
+            {
+                "id": "locale-it",
+                "iso639_2": "ita",
+                "label": "Italiano",
+                "encoding": "utf8",
+            },
+            result["locale-it"],
+        )
+
+    def test_languages_info_respects_explicit_fields_argument(self):
+        metadata = {
+            "title": "Hello",
+            "title_multilang_it": "Ciao",
+            "abstract": "x",
+            "abstract_multilang_fr": "Un résumé",
+        }
+        result = tags.languages_info(metadata, fields=["title"])
+        self.assertEqual(["locale-it"], [d["id"] for d in result])
+
+    @override_settings(LANGUAGE_MAPPINGS=(("en", "eng"), ("it", "ita")))
+    def test_languages_info_missing_iso_mapping_is_skipped_and_warns(self):
+        metadata = {
+            "title": "Hello",
+            "title_multilang_it": "Ciao",
+            "title_multilang_de": "Hallo",
+        }
+        result = tags.languages_info(metadata)
+        self.assertEqual(["locale-it"], [d["id"] for d in result])

geonode/metadata/multilang/utils.py

@@ -59,3 +59,32 @@ def get_all_multilang_fields():
         for field in settings.MULTILANG_FIELDS
         for lang in get_2letters_languages()
     }
+
+
+def get_3_from_2(lang_2):
+    """
+    Return the preferred ISO 639-2 (3-letter) code for an ISO 639-1 code.
+    """
+    mappings = getattr(settings, "LANGUAGE_MAPPINGS", ())
+    if not isinstance(mappings, dict):
+        mappings = dict(mappings)
+
+    code = mappings.get(lang_2)
+    if isinstance(code, (list, tuple)):
+        return code[0] if code else None
+    return code
+
+
+def get_2_from_3(lang_3):
+    """
+    Return the ISO 639-1 (2-letter) code for a given ISO 639-2 (3-letter) code.
+    """
+    mappings = getattr(settings, "LANGUAGE_MAPPINGS", ())
+    if isinstance(mappings, dict):
+        mappings = mappings.items()
+
+    for lang_2, lang_3_codes in mappings:
+        codes = lang_3_codes if isinstance(lang_3_codes, (list, tuple)) else (lang_3_codes,)
+        if lang_3 in codes:
+            return lang_2
+    return None