Feat(preferences): Consolidated Preferences System: User, Collection, and Global Preferences Updates

.env

@@ -3,44 +3,22 @@ DATABASE_PORT=3306
 MYSQL_ROOT_PASSWORD=password
 DATABASE_NAME=specify
 
-# The following are database users with specific roles and privileges. 
-# If the migrator and app user are not defined, the system will use the master user credentials.
-# See documenation https://discourse.specifysoftware.org/t/new-blank-database-creation-database-user-levels/3023
-
-# MASTER Database User
-# Full database administrator, used for initial setup and migrations requiring elevated privileges. 
+# When running Specify 7 for the first time or during updates that
+# require migrations, ensure that the MASTER_NAME and MASTER_PASSWORD
+# are set to the root username and password. This will ensure proper
+# execution of Django migrations during the initial setup.
+# After launching Specify and verifying the update is complete, you can
+# safely replace these credentials with the master SQL user name and password.
 MASTER_NAME=root
 MASTER_PASSWORD=password
 
-# MIGRATOR Database User 
-# User with elevated privileges to perform migrations (create/drop/modify tables, etc.), for Django migration steps.
-MIGRATOR_NAME=specify_migrator
-MIGRATOR_PASSWORD=specify_migrator
-
-# APP Database User
-# Normal runtime database user that performs application-level operations.
-APP_USER_NAME=specify_user
-APP_USER_PASSWORD=specify_user
-
-# Enabling this option allows administrators with access to the
-# backend Specify instance to log in as any user for support
-# purposes without knowing their password.
-# https://discourse.specifysoftware.org/t/allow-support-login-documentation/2838
-ALLOW_SUPPORT_LOGIN=false
-# The amount of time in seconds each token is valid for
-SUPPORT_LOGIN_TTL = 180
-
 # Make sure to set the `SECRET_KEY` to a unique value
 SECRET_KEY=change_this_to_some_unique_random_string
 
 ASSET_SERVER_URL=http://host.docker.internal/web_asset_store.xml
 # Make sure to set the `ASSET_SERVER_KEY` to a unique value
 ASSET_SERVER_KEY=your_asset_server_access_key
 
-REDIS_HOST=redis
-REDIS_PORT=6379
-REDIS_DB_INDEX=0
-
 REPORT_RUNNER_HOST=report-runner
 REPORT_RUNNER_PORT=8080
 

specifyweb/backend/context/remote_prefs.py

@@ -15,6 +15,11 @@ def get_remote_prefs() -> str:
 
 def get_global_prefs() -> str:
     res = Spappresourcedata.objects.filter(
+        spappresource__name='GlobalPreferences')
+    if res.exists():
+        return '\n'.join(force_str(r.data) for r in res)
+
+    legacy_res = Spappresourcedata.objects.filter(
         spappresource__name='preferences',
         spappresource__spappresourcedir__usertype='Global Prefs')
-    return '\n'.join(force_str(r.data) for r in res)
+    return '\n'.join(force_str(r.data) for r in legacy_res)

specifyweb/backend/context/urls.py

@@ -31,6 +31,7 @@
     re_path(r'^app.resource$', views.app_resource),
     re_path(r'^available_related_searches.json$', views.available_related_searches),
     re_path(r'^remoteprefs.properties$', views.remote_prefs),
+    path('global-preferences-resource/', views.global_preferences_resource),
 
     re_path(r'^attachment_settings.json$', attachment_settings),
     re_path(r'^report_runner_status.json$', report_runner_status),

specifyweb/backend/context/views.py

@@ -26,8 +26,18 @@
     PermissionTargetAction, \
     check_permission_targets, skip_collection_access_check, query_pt, \
     CollectionAccessPT
-from specifyweb.specify.models import Collection, Collectionobject, Institution, \
-    Specifyuser, Spprincipal, Spversion, Collectionobjecttype
+from specifyweb.specify.models import (
+    Collection,
+    Collectionobject,
+    Institution,
+    Specifyuser,
+    Spprincipal,
+    Spversion,
+    Collectionobjecttype,
+    Spappresource,
+    Spappresourcedata,
+    Spappresourcedir,
+)
 from specifyweb.specify.models_utils.schema import base_schema
 from specifyweb.specify.models_utils.serialize_datamodel import datamodel_to_json
 from specifyweb.specify.api.serializers import uri_for_model
@@ -628,13 +638,131 @@ def view_helper(request, limit):
 
     return get_views(collection, request.specify_user, view_name, limit, table)
 
+ALLOWED_GLOBAL_PREFERENCE_KEYS = (
+    'auditing.do_audits',
+    'auditing.audit_field_updates',
+    'ui.formatting.scrdateformat',
+    'ui.formatting.scrmonthformat',
+    'attachment.preview_size',
+)
+
+
+def filter_global_preferences_text(data: str) -> str:
+    result = {}
+    for line in data.splitlines():
+        if not line or line.strip().startswith('#') or '=' not in line:
+            continue
+        key, value = line.split('=', 1)
+        result[key.strip()] = value.strip()
+
+    filtered = [
+        f'{key}={result[key]}'
+        for key in ALLOWED_GLOBAL_PREFERENCE_KEYS
+        if key in result
+    ]
+    return '\n'.join(filtered)
+
+
+def find_preferences_resource_data(collection, discipline, usertype: str) -> str:
+    directory = (
+        Spappresourcedir.objects.filter(
+            collection=collection,
+            discipline=discipline,
+            ispersonal=False,
+            specifyuser=None,
+            usertype=usertype,
+        )
+        .order_by('id')
+        .first()
+    )
+    if directory is None:
+        return ''
+
+    resource = (
+        Spappresource.objects.filter(name='preferences', spappresourcedir=directory)
+        .order_by('id')
+        .first()
+    )
+    if resource is None:
+        return ''
+
+    data = (
+        Spappresourcedata.objects.filter(spappresource=resource)
+        .order_by('id')
+        .first()
+    )
+    return data.data if data is not None else ''
+
 @require_http_methods(['GET', 'HEAD'])
 @login_maybe_required
 @cache_control(max_age=86400, private=True)
 def remote_prefs(request):
     "Return the 'remoteprefs' java properties file from the database."
     return HttpResponse(get_remote_prefs(), content_type='text/x-java-properties')
 
+@require_http_methods(['GET', 'PUT'])
+@login_maybe_required
+@cache_control(max_age=0, private=True)
+def global_preferences_resource(request):
+    "Update the legacy 'preferences' app resource that backs the App Resources editor."
+    data = request.body.decode('utf-8', 'replace')
+    collection = request.specify_collection
+    discipline = collection.discipline if collection is not None else None
+
+    if request.method == 'GET':
+        content = find_preferences_resource_data(collection, discipline, 'Global Prefs')
+        if not content:
+            content = find_preferences_resource_data(collection, discipline, 'Prefs')
+        filtered = filter_global_preferences_text(content)
+        return HttpResponse(filtered, content_type='text/plain')
+
+    def resolve_directory(usertype: str) -> Spappresourcedir:
+        queryset = Spappresourcedir.objects.filter(
+            collection=collection,
+            discipline=discipline,
+            ispersonal=False,
+            specifyuser=None,
+            usertype=usertype,
+        ).order_by('id')
+        directory = queryset.first()
+        if directory is not None:
+            return directory
+        return Spappresourcedir.objects.create(
+            collection=collection,
+            discipline=discipline,
+            ispersonal=False,
+            specifyuser=None,
+            usertype=usertype,
+        )
+
+    def upsert_preferences_resource(usertype: str) -> None:
+        directory = resolve_directory(usertype)
+        resource, _ = Spappresource.objects.get_or_create(
+            name='preferences',
+            spappresourcedir=directory,
+            defaults={
+                'level': 0,
+                'mimetype': 'text/x-java-properties',
+                'metadata': '',
+                'specifyuser': request.specify_user,
+            },
+        )
+        resource.mimetype = 'text/x-java-properties'
+        resource.metadata = ''
+        resource.save()
+
+        spappresourcedata, _ = Spappresourcedata.objects.get_or_create(
+            spappresource=resource,
+            defaults={'data': data},
+        )
+        spappresourcedata.data = data
+        spappresourcedata.save()
+
+    upsert_preferences_resource('Global Prefs')
+    upsert_preferences_resource('Prefs')
+
+    return HttpResponse('', content_type='text/plain', status=204)
+
 @require_http_methods(['GET', 'HEAD'])
 def get_server_time(request):
     return JsonResponse({"server_time": timezone.now().isoformat()})

specifyweb/backend/stored_queries/format.py

@@ -19,7 +19,7 @@
 from sqlalchemy import types
 
 import specifyweb.backend.context.app_resource as app_resource
-from specifyweb.backend.context.remote_prefs import get_remote_prefs
+from specifyweb.backend.context.remote_prefs import get_global_prefs, get_remote_prefs
 
 from specifyweb.specify.utils.agent_types import agent_types
 from specifyweb.specify.models import datamodel, Splocalecontainer
@@ -455,8 +455,14 @@ def _fieldformat(self, table: Table, specify_field: Field,
 
 
 def get_date_format() -> str:
-    match = re.search(r'ui\.formatting\.scrdateformat=(.+)', get_remote_prefs())
-    date_format = match.group(1).strip() if match is not None else 'yyyy-MM-dd'
+    date_format_text = 'yyyy-MM-dd'
+    for prefs in (get_global_prefs(), get_remote_prefs()):
+        match = re.search(r'ui\.formatting\.scrdateformat=(.+)', prefs)
+        if match is not None:
+            date_format_text = match.group(1).strip()
+            break
+
+    date_format = date_format_text
     mysql_date_format = LDLM_TO_MYSQL.get(date_format, "%Y-%m-%d")
     logger.debug("dateformat = %s = %s", date_format, mysql_date_format)
     return mysql_date_format

specifyweb/backend/workbench/upload/auditlog.py

@@ -26,6 +26,35 @@
 
 from . import auditcodes
 
+
+def _extract_pref_bool(pref_text: str | None, pref_key: str) -> bool | None:
+    """
+    Try to extract a boolean preference value from a preference file.
+    Returns None if the key is not present or the value is not boolean-like.
+    """
+    if not pref_text:
+        return None
+    match = re.search(rf'^{re.escape(pref_key)}\s*=\s*(.+)$', pref_text, re.MULTILINE)
+    if match:
+        value = match.group(1).strip().lower()
+        if value == 'true':
+            return True
+        if value == 'false':
+            return False
+    return None
+
+def _get_pref_bool(pref_key: str, default: bool = False) -> bool:
+    """
+    Return the preference value for the given key, preferring the new
+    GlobalPreferences resource and falling back to the legacy remote
+    preferences. When missing, default to the provided value.
+    """
+    for source in (get_global_prefs, get_remote_prefs):
+        value = _extract_pref_bool(source(), pref_key)
+        if value is not None:
+            return value
+    return default
+
 def str_to_bytes(string: str, max_length: int) -> bytes: 
     str_as_bytes = string.encode()
     return str_as_bytes[:max_length]
@@ -42,7 +71,8 @@ class AuditLog:
     _auditingFlds = None
     _auditing = None
     _lastCheck = None
-    _checkInterval = 900
+    # Re-check preferences frequently so UI changes (enable/disable) take effect quickly
+    _checkInterval = 5
 
     def isAuditingFlds(self):
         return self.isAuditing() and self._auditingFlds
@@ -51,16 +81,8 @@ def isAuditing(self):
         if settings.DISABLE_AUDITING:
             return False
         if self._auditing is None or self._lastCheck is None or time() - self._lastCheck > self._checkInterval:
-            match = re.search(r'auditing\.do_audits=(.+)', get_remote_prefs())
-            if match is None:
-                self._auditing = True
-            else:
-                self._auditing = False if match.group(1).lower() == 'false' else True
-            match = re.search(r'auditing\.audit_field_updates=(.+)', get_remote_prefs())
-            if match is None:
-                self._auditingFlds = True
-            else:
-                self._auditingFlds = False if match.group(1).lower() == 'false' else True
+            self._auditing = _get_pref_bool('auditing.do_audits', default=True)
+            self._auditingFlds = _get_pref_bool('auditing.audit_field_updates', default=True)
             self.purge()
             self._lastCheck = time()
         return self._auditing;

specifyweb/backend/workbench/upload/test_auditlog_prefs.py

@@ -0,0 +1,32 @@
+from django.test import SimpleTestCase
+from unittest.mock import patch
+
+from specifyweb.backend.workbench.upload.auditlog import _extract_pref_bool, _get_pref_bool
+
+
+class AuditLogPreferenceTests(SimpleTestCase):
+    def test_extract_pref_bool_parses_true_false(self) -> None:
+        self.assertTrue(_extract_pref_bool("auditing.do_audits=true", "auditing.do_audits"))
+        self.assertFalse(_extract_pref_bool("auditing.do_audits=false", "auditing.do_audits"))
+        self.assertIsNone(_extract_pref_bool("auditing.do_audits=maybe", "auditing.do_audits"))
+        self.assertIsNone(_extract_pref_bool("", "auditing.do_audits"))
+
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_global_prefs', return_value="auditing.do_audits=false")
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_remote_prefs', return_value="auditing.do_audits=true")
+    def test_prefers_global_preferences_when_present(self, _mock_remote, _mock_global) -> None:
+        self.assertFalse(_get_pref_bool("auditing.do_audits"))
+
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_global_prefs', return_value="")
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_remote_prefs', return_value="auditing.audit_field_updates=false")
+    def test_uses_remote_when_global_missing(self, _mock_remote, _mock_global) -> None:
+        self.assertFalse(_get_pref_bool("auditing.audit_field_updates"))
+
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_global_prefs', return_value="")
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_remote_prefs', return_value="")
+    def test_default_false_when_missing_everywhere(self, _mock_remote, _mock_global) -> None:
+        self.assertFalse(_get_pref_bool("auditing.do_audits"))
+
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_global_prefs', return_value="")
+    @patch('specifyweb.backend.workbench.upload.auditlog.get_remote_prefs', return_value="")
+    def test_default_value_used_when_requested(self, _mock_remote, _mock_global) -> None:
+        self.assertTrue(_get_pref_bool("auditing.do_audits", default=True))