merge with master

Author: mattiagiupponi

docs/src/admin/thesauri/thesauri.md

@@ -92,6 +92,7 @@ GeoNode provides a single command (``thesaurus``) with multiple actions:
 * ``list``: list existing thesauri
 * ``load``: load a RDF file
 * ``dump``: dump a thesaurus into a file
+* ``autoload``: automatically discover and load all thesauri shipped by installed apps
 
 .. code-block:: 
 
@@ -102,12 +103,13 @@ GeoNode provides a single command (``thesaurus``) with multiple actions:
                                [--format {json-ld,n3,nt,pretty-xml,sorted-xml,trig,ttl,xml}] [--default-lang LANG] [--version]
                                [-v {0,1,2,3}] [--settings SETTINGS] [--pythonpath PYTHONPATH] [--traceback] [--no-color]
                                [--force-color] [--skip-checks]
-                               [{list,load,dump}]
+                               [{list,load,dump,autoload}]
 
-    Handles thesaurus commands ['list', 'load', 'dump']
+    Handles thesaurus commands ['list', 'load', 'dump', 'autoload']
 
     positional arguments:
-      {list,load,dump}      thesaurus operation to run
+      {list,load,dump,autoload}
+                            thesaurus operation to run
 
     options:
       -h, --help            show this help message and exit
@@ -227,6 +229,63 @@ In order to only export the entries we edited, we'll issue the command::
     python manage.py thesaurus dump -i labels-i18n --include "proj1_*" --include "*_ovr" -f labels-i18n.proj1.rdf
 
 
+### Auto-loading thesauri: ``thesaurus autoload``
+
+The ``autoload`` subcommand scans every installed Django app for a ``thesauri/`` directory
+at the top level of the app package, then loads all ``.rdf`` files it finds there.
+This is how GeoNode and third-party apps can ship thesauri that are loaded automatically at start-up.
+
+```bash
+python manage.py thesaurus autoload
+```
+
+For each ``.rdf`` file discovered, the command runs the equivalent of ``thesaurus load --action update``,
+so the operation is **idempotent**: running it multiple times will not create duplicates; instead,
+existing records are updated and missing ones are created.
+
+**Convention for app-provided thesauri**
+
+Place one or more ``.rdf`` files inside a ``thesauri/`` directory at the root of your app package:
+
+```
+my_geonode_app/
+    thesauri/
+        my_vocabulary.rdf
+        another_vocab.rdf
+    models.py
+    ...
+```
+
+All ``.rdf`` files in that directory are picked up automatically whenever ``thesaurus autoload``
+(or ``invoke loadthesauri``) is executed.
+
+!!! note
+    The ``autoload`` command is automatically run during GeoNode's Docker container start-up sequence (see [Initialization at boot](#initialization-at-boot)).
+
+
+## Initialization at boot { #initialization-at-boot }
+
+When GeoNode starts (e.g. via the Docker entrypoint), the following initialization steps are executed in order:
+
+1. **Database migrations** – applies any pending schema migrations.
+2. **Fixtures** – loads default OAuth2 apps, admin user, and site data (only on first boot or when ``FORCE_REINIT=true``).
+3. **Static files** – collects static assets.
+4. **Thesauri autoload** – runs ``thesaurus autoload`` to load or update all ``.rdf`` files found in any installed app's ``thesauri/`` directory. This step runs on **every** boot so that thesaurus updates shipped with an upgraded app are applied automatically.
+
+To run the thesaurus autoload step manually:
+
+```bash
+# Inside the GeoNode container
+python manage.py thesaurus autoload
+```
+
+Or using the invoke task:
+
+```bash
+invoke loadthesauri
+```
+
+
 ## Configuring a Thesaurus
 
 

docs/src/setup/docker/vanilla-docker-installation.md

@@ -81,6 +81,15 @@ Executing UWSGI server uwsgi --ini /usr/src/app/uwsgi.ini for Production
 [uWSGI] getting INI configuration from /usr/src/app/uwsgi.ini
 ```
 
+The container performs these initialization steps before starting the application server:
+
+1. **Database migrations** – applies any pending schema migrations.
+2. **Fixtures** – loads default OAuth2 apps, admin user and site data (only on first boot or when ``FORCE_REINIT=true``).
+3. **Static files** – collects static assets.
+4. **Thesauri autoload** – scans all installed apps for a ``thesauri/`` directory and loads (or updates) any ``.rdf`` files found there. This makes sure thesauri shipped by GeoNode apps are always up-to-date.
+
+See [Thesauri – Initialization at boot](../../../admin/thesauri/thesauri.md#initialization-at-boot) for more details on the thesaurus autoload step.
+
 To exit just hit `CTRL+C`.
 
 This message means that the GeoNode containers have been started. Browsing to `http://localhost/` will show the GeoNode home page. You should be able to successfully log with the credentials of admin user which are defined in the .env file and start using it right away.

entrypoint.sh

@@ -56,6 +56,7 @@ else
     fi
 
     invoke statics
+    invoke loadthesauri
 
     echo "Executing UWSGI server $cmd for Production"
 fi

geonode/base/api/exceptions.py

@@ -32,14 +32,18 @@ def geonode_exception_handler(exc, context):
     # to get the standard error response.
     response = exception_handler(exc, context)
 
-    if response is not None and isinstance(exc, APIException):
-        # for the upload exception we need a custom response
-        detail = _extract_detail(exc)
-        response.data = {
-            "success": False,
-            "errors": [str(detail)],
-            "code": exc.code if hasattr(exc, "code") else exc.default_code,
-        }
+    if response is not None:
+        if response.status_code == 401:
+            response.headers.pop("WWW-Authenticate", None)
+
+        if isinstance(exc, APIException):
+            # for the upload exception we need a custom response
+            detail = _extract_detail(exc)
+            response.data = {
+                "success": False,
+                "errors": [str(detail)],
+                "code": exc.code if hasattr(exc, "code") else exc.default_code,
+            }
     return response
 
 

geonode/base/api/tests.py

@@ -3742,6 +3742,21 @@ def test_metadata_uploaded_preserve_can_be_updated(self):
         self.assertTrue(doc.metadata_uploaded_preserve)
         self.assertTrue(response.json()["resource"]["metadata_uploaded_preserve"])
 
+    def test_www_authenticate_header_is_removed_for_401_responses(self):
+        """
+        Ensure WWW-Authenticate header is removed for 401 responses to prevent browsers from showing a login prompt
+        """
+        try:
+            user = get_user_model().objects.create_user(
+                username="user_test_delete", email="user_test_delete@geonode.org", password="user"
+            )
+            url = reverse("users-detail", kwargs={"pk": user.pk})
+            # Anonymous can't read
+            response = self.client.get(url, format="json")
+            self.assertNotIn("WWW-Authenticate", response.headers)
+        finally:
+            user.delete()
+
 
 class TestExtraMetadataBaseApi(GeoNodeBaseTestSupport):
     def setUp(self):

geonode/base/management/commands/thesaurus.py

@@ -2,6 +2,7 @@
 from django.core.management.base import BaseCommand, CommandError
 
 from geonode.base.management.command_utils import setup_logger
+from geonode.base.management.commands.thesaurus_subcommands.autoload import autoload_thesauri
 from geonode.base.management.commands.thesaurus_subcommands.dump import (
     dump_thesaurus,
     DUMP_FORMATS,
@@ -16,7 +17,8 @@
 COMMAND_LIST = "list"
 COMMAND_DUMP = "dump"
 COMMAND_LOAD = "load"
-COMMANDS = [COMMAND_LIST, COMMAND_LOAD, COMMAND_DUMP]
+COMMAND_AUTOLOAD = "autoload"
+COMMANDS = [COMMAND_LIST, COMMAND_LOAD, COMMAND_DUMP, COMMAND_AUTOLOAD]
 
 
 class Command(BaseCommand):
@@ -41,6 +43,12 @@ def add_arguments(self, parser):
             choices=ACTIONS,
             help="Actions to run upon data loading (default: create)",
         )
+        load_group.add_argument(
+            "--langs",
+            dest="langs",
+            action="append",
+            help="Only import labels for the requested languages; can be repeated",
+        )
 
         dump_group = parser.add_argument_group('Params for "dump" subcommand')
         dump_group.add_argument("-o", "--out", nargs="?", help="Full path to the output file to be created")
@@ -99,6 +107,8 @@ def handle(self, *args, **options):
             input_file = options.get("file")
             action = options.get("action")
             identifier = options.get("identifier")
+            lang = options.get("lang")
+            langs = options.get("langs") or []
 
             if not input_file:
                 raise CommandError("'load' command requires the <file> parameter.")
@@ -107,7 +117,10 @@ def handle(self, *args, **options):
                 action = ACTION_CREATE
                 logger.info(f"Missing action param: setting actions as '{action}'")
 
-            load_thesaurus(input_file, identifier, action)
+            load_thesaurus(input_file, identifier, action, default_lang=lang, langs=langs)
+
+        elif subcommand == COMMAND_AUTOLOAD:
+            autoload_thesauri()
 
         else:
             raise CommandError(f"Unknown subcommand: {subcommand}")

geonode/base/management/commands/thesaurus_subcommands/autoload.py

@@ -0,0 +1,39 @@
+import os
+
+from django.apps import apps
+
+from geonode.base.management.command_utils import setup_logger
+from geonode.base.management.commands.thesaurus_subcommands.load import load_thesaurus, ACTION_UPDATE
+
+logger = setup_logger()
+
+
+def autoload_thesauri():
+    """
+    Discover and load all thesauri (.rdf files) found in a `thesauri/` directory
+    within each installed Django app. Uses the `update` action so existing entries
+    are updated and new ones are created without duplicates.
+    """
+    loaded = 0
+    for app_config in apps.get_app_configs():
+        thesauri_dir = os.path.join(app_config.path, "thesauri")
+        logger.debug(f"Looking for auto thesaurus in app '{app_config.name}' path: {thesauri_dir}")
+        if not os.path.isdir(thesauri_dir):
+            continue
+        try:
+            rdf_files = [f for f in os.listdir(thesauri_dir) if f.lower().endswith(".rdf")]
+        except OSError as e:
+            logger.error(
+                f"Failed to scan thesauri directory for app '{app_config.name}' at '{thesauri_dir}': {e}",
+                exc_info=True,
+            )
+            continue
+        for rdf_file in sorted(rdf_files):
+            rdf_path = os.path.join(thesauri_dir, rdf_file)
+            logger.info(f"Autoloading thesaurus from app '{app_config.name}': {rdf_path}")
+            try:
+                load_thesaurus(rdf_path, identifier=None, action=ACTION_UPDATE, log_details=False)
+                loaded += 1
+            except Exception as e:
+                logger.error(f"Failed to load thesaurus '{rdf_path}': {e}", exc_info=True)
+    logger.info(f"Autoload complete: {loaded} thesaurus file(s) loaded.")