Merge branch 'master' of github.com:GeoNode/geonode into modular

Author: mattiagiupponi

geonode/base/api/filters.py

@@ -138,6 +138,10 @@ def filter_queryset(self, request, queryset, view):
         # advertised
         # if superuser, all resources will be visible, otherwise only the advertised one and
         # the resource which the user is owner will be returned
+
+        if getattr(view, "action", None) == "retrieve":
+            return queryset
+
         user = request.user
         try:
             _filter = request.query_params.get("advertised", "None")

geonode/base/apps.py

@@ -42,3 +42,11 @@ class BaseAppConfig(NotificationsAppConfigBase, AppConfig):
             _("Resource is created"),
         ),
     )
+
+    def ready(self):
+        """Finalize setup"""
+        from geonode.base.signals import connect_signals
+
+        connect_signals()
+
+        super(BaseAppConfig, self).ready()

geonode/base/fixtures/test_xml.xml

@@ -251,9 +251,18 @@
            </gmd:role>
          </gmd:CI_ResponsibleParty>
        </gmd:pointOfContact>
-       
 
-       
+       <gmd:resourceMaintenance>
+         <gmd:MD_MaintenanceInformation>
+           <gmd:maintenanceAndUpdateFrequency>
+             <gmd:MD_MaintenanceFrequencyCode
+                     codeSpace="ISOTC211/19115"
+                     codeList="http://www.isotc211.org/2005/resources/Codelist/gmxCodelists.xml#MD_MaintenanceFrequencyCode"
+                     codeListValue="daily">daily</gmd:MD_MaintenanceFrequencyCode>
+           </gmd:maintenanceAndUpdateFrequency>
+         </gmd:MD_MaintenanceInformation>
+       </gmd:resourceMaintenance>
+
        <gmd:graphicOverview>
          <gmd:MD_BrowseGraphic>
            <gmd:fileName>

geonode/metadata/i18n.py geonode/base/i18n.pygeonode/metadata/i18n.py renamed to geonode/base/i18n.py

@@ -1,12 +1,10 @@
 import logging
-from datetime import datetime
 
-from cachetools import FIFOCache
 from django.db import connection
+from django.utils.translation import get_language, gettext as _
 
 from geonode.base.models import ThesaurusKeywordLabel, Thesaurus
 
-
 logger = logging.getLogger(__name__)
 
 I18N_THESAURUS_IDENTIFIER = "labels-i18n"
@@ -47,6 +45,7 @@ def get_localized_tkeywords(lang, thesaurus_identifier: str):
     return sorted(ret.values(), key=lambda i: i["about"].lower())
 
 
+# TODO: deprecate and use LabelResolver.gettext()
 def get_localized_label(lang, about):
     # look for override
     ovr_qs = ThesaurusKeywordLabel.objects.filter(
@@ -65,41 +64,46 @@ def get_localized_label(lang, about):
     )
 
 
-class I18nCache:
+class I18nCacheEntry:
+    def __init__(self):
+        # the date field of the thesaurus when it was last loaded, it's used for the expiration check
+        self.date: str | None = None
+        self.caches: dict = {}  # the caches for this language
 
-    DATA_KEY_SCHEMA = "schema"
-    DATA_KEY_LABELS = "labels"
+
+class I18nCache:
+    """
+    Caches language related data.
+    Synch is performed via date field in the "labels-i18n" thesaurus.
+    """
 
     def __init__(self):
-        # the cache has the lang as key, and various info in the dict value:
-        # - date: the date field of the thesaurus when it was last loaded, it's used for the expiration check
-        # - labels: the keyword labels from the i18n thesaurus
-        # - schema: the localized json schema
-        # FIFO bc we want to renew the data once in a while
-        self.cache = FIFOCache(16)
+        # the cache has the lang as key, and I18nCacheEntry as a value:
+        self.lang_cache = {}
 
     def get_entry(self, lang, data_key):
         """
         returns date:str, data
         date is needed for checking the entry freshness when setting info
         data may be None if not cached or expired
         """
-        cached_entry = self.cache.get(lang, None)
+        cached_entry: I18nCacheEntry = self.lang_cache.get(lang, None)
 
+        # TODO: thesaurus date check should be done only after a given time interval from last check
         thesaurus_date = (  # may be none if thesaurus does not exist
             Thesaurus.objects.filter(identifier=I18N_THESAURUS_IDENTIFIER).values_list("date", flat=True).first()
         )
         if cached_entry:
-            if thesaurus_date == cached_entry["date"]:
+            if thesaurus_date == cached_entry.date:
                 # only return cached data if thesaurus has not been modified
-                return thesaurus_date, cached_entry.get(data_key, None)
+                return thesaurus_date, cached_entry.caches.get(data_key, None)
             else:
                 logger.info(f"Schema for {lang}:{data_key} needs to be recreated")
 
         return thesaurus_date, None
 
     def set(self, lang: str, data_key: str, data: dict, request_date: str):
-        cached_entry: dict = self.cache.setdefault(lang, {})
+        cached_entry: I18nCacheEntry = self.lang_cache.setdefault(lang, I18nCacheEntry())
 
         latest_date = (
             Thesaurus.objects.filter(identifier=I18N_THESAURUS_IDENTIFIER).values_list("date", flat=True).first()
@@ -108,60 +112,48 @@ def set(self, lang: str, data_key: str, data: dict, request_date: str):
         if request_date == latest_date:
             # no changes after processing, set the info right away
             logger.debug(f"Caching lang:{lang} key:{data_key} date:{request_date}")
-            cached_entry.update({"date": latest_date, data_key: data})
+            cached_entry.date = latest_date
+            cached_entry.caches[data_key] = data
         else:
             logger.warning(
                 f"Cache will not be updated for lang:{lang} key:{data_key} reqdate:{request_date} latest:{latest_date}"
             )
 
-    def get_labels(self, lang):
-        date, labels = self.get_entry(lang, self.DATA_KEY_LABELS)
-        if labels is None:
-            labels = {}
-            for i in get_localized_tkeywords(lang, I18N_THESAURUS_IDENTIFIER):
-                about = i["about"]
-                if about.endswith(OVR_SUFFIX) and not i["label"]:
-                    # we don't want default values for override entries
-                    continue
-                labels[about] = i["label"] or i["default"]
-            self.set(lang, self.DATA_KEY_LABELS, labels, date)
-        return labels
-
-    def clear_schema_cache(self):
+    def clear(self):
         logger.info("Clearing schema cache")
-        while True:
-            try:
-                self.cache.popitem()
-            except KeyError:
-                return
+        self.lang_cache.clear()
 
 
-def thesaurus_changed(sender, instance, **kwargs):
-    if instance.identifier == I18N_THESAURUS_IDENTIFIER:
-        if hasattr(instance, "_signal_handled"):  # avoid signal recursion
-            return
-        logger.debug(f"Thesaurus changed: {instance.identifier}")
-        _update_thesaurus_date()
+class LabelResolver:
+    CACHE_KEY_LABELS = "labels"
 
+    def gettext(self, key, lang=None, fallback=True):
+        """
+        Return the translated text in the label Thesaurus, falling back to the PO/MO translation.
+        If fallback=False only search in the label Thesaurus, and may return None if not found
+        """
+        lang = lang or get_language()
+        # TODO: implement the OVR search
+        return self.get_labels(lang).get(key, None) or (_(key) if fallback else None)
 
-def thesaurusk_changed(sender, instance, **kwargs):
-    if instance.thesaurus.identifier == I18N_THESAURUS_IDENTIFIER:
-        logger.debug(f"ThesaurusKeyword changed: {instance.about} ALT:{instance.alt_label}")
-        _update_thesaurus_date()
-
+    def get_labels(self, lang):
+        date, labels = i18nCache.get_entry(lang, self.CACHE_KEY_LABELS)
+        if labels is None:
+            labels = self._create_labels_cache(lang)
+            i18nCache.set(lang, self.CACHE_KEY_LABELS, labels, date)
+        return labels
 
-def thesauruskl_changed(sender, instance, **kwargs):
-    if instance.keyword.thesaurus.identifier == I18N_THESAURUS_IDENTIFIER:
-        logger.debug(
-            f"ThesaurusKeywordLabel changed: {instance.keyword.about} ALT:{instance.keyword.alt_label} L:{instance.lang}"
-        )
-        _update_thesaurus_date()
+    def _create_labels_cache(self, lang):
+        labels = {}
+        for i in get_localized_tkeywords(lang, I18N_THESAURUS_IDENTIFIER):
+            about = i["about"]
+            if about.endswith(OVR_SUFFIX) and not i["label"]:
+                # we don't want default values for override entries
+                continue
+            labels[about] = i["label"] or i["default"]
+        return labels
 
 
-def _update_thesaurus_date():
-    logger.debug("Updating label thesaurus date")
-    # update timestamp to invalidate other processes also
-    i18n_thesaurus = Thesaurus.objects.get(identifier=I18N_THESAURUS_IDENTIFIER)
-    i18n_thesaurus.date = datetime.now().replace(microsecond=0).isoformat()
-    i18n_thesaurus._signal_handled = True
-    i18n_thesaurus.save()
+i18nCache = I18nCache()
+labelResolver = LabelResolver()
+gettext = labelResolver.gettext

geonode/base/signals.py

@@ -0,0 +1,48 @@
+import logging
+from datetime import datetime
+
+from django.db.models.signals import post_save
+
+from geonode.base.i18n import I18N_THESAURUS_IDENTIFIER
+from geonode.base.models import Thesaurus, ThesaurusKeyword, ThesaurusKeywordLabel
+
+logger = logging.getLogger(__name__)
+
+
+def connect_signals():
+    logger.debug("Setting up signal connections...")
+    post_save.connect(thesaurus_changed, sender=Thesaurus, weak=False, dispatch_uid="metadata_reset_t")
+    post_save.connect(thesaurusk_changed, sender=ThesaurusKeyword, weak=False, dispatch_uid="metadata_reset_tk")
+    post_save.connect(thesauruskl_changed, sender=ThesaurusKeywordLabel, weak=False, dispatch_uid="metadata_reset_tkl")
+    logger.debug("Signal connections set")
+
+
+def thesaurus_changed(sender, instance, **kwargs):
+    if instance.identifier == I18N_THESAURUS_IDENTIFIER:
+        if hasattr(instance, "_signal_handled"):  # avoid signal recursion
+            return
+        logger.debug(f"Thesaurus changed: {instance.identifier}")
+        _update_thesaurus_date()
+
+
+def thesaurusk_changed(sender, instance, **kwargs):
+    if instance.thesaurus.identifier == I18N_THESAURUS_IDENTIFIER:
+        logger.debug(f"ThesaurusKeyword changed: {instance.about} ALT:{instance.alt_label}")
+        _update_thesaurus_date()
+
+
+def thesauruskl_changed(sender, instance, **kwargs):
+    if instance.keyword.thesaurus.identifier == I18N_THESAURUS_IDENTIFIER:
+        logger.debug(
+            f"ThesaurusKeywordLabel changed: {instance.keyword.about} ALT:{instance.keyword.alt_label} L:{instance.lang}"
+        )
+        _update_thesaurus_date()
+
+
+def _update_thesaurus_date():
+    logger.debug("Updating label thesaurus date")
+    # update timestamp to invalidate other processes also
+    i18n_thesaurus = Thesaurus.objects.get(identifier=I18N_THESAURUS_IDENTIFIER)
+    i18n_thesaurus.date = datetime.now().replace(microsecond=0).isoformat()
+    i18n_thesaurus._signal_handled = True
+    i18n_thesaurus.save()