save paths in db + clear cache when they change

Redbot · Redbot · commit 53a743763f76 · 2026-02-14T09:35:17.000-06:00
diff --git a/src/redfetch/main.py b/src/redfetch/main.py
@@ -59,7 +59,7 @@ def initialize_db_only():
     auth.initialize_keyring()
     auth.authorize()
     db_name = f"{config.settings.ENV}_resources.db"
-    store.initialize_db(db_name)
+    store.initialize_db(db_name, config.settings.ENV)
     db_path = store.get_db_path(db_name)
     return db_name, db_path
 
@@ -349,6 +349,9 @@ def config_command(
     config.initialize_config()
     setting_path_list = path.split('.')
     config.update_setting(setting_path_list, value, server.value if server else None)
+    settings_env = server.value if server else config.settings.ENV
+    db_name = f"{settings_env}_resources.db"
+    store.reconcile_install_signature(db_name, settings_env)
     console.print(f"Updated setting {path} to {value}{' for server ' + server.value if server else ''}.")
 
 
diff --git a/src/redfetch/store.py b/src/redfetch/store.py
@@ -1,11 +1,13 @@
 from collections.abc import Iterable
+import json
 import os
 import sqlite3
 import aiosqlite
 
 from redfetch import config
 from redfetch.models import DownloadTask, Resource
 from redfetch import meta
+from redfetch import utils
 
 # Unified schema version marker
 SCHEMA_VERSION = 1
@@ -44,15 +46,19 @@ def get_db_path(db_name: str) -> str:
     return os.path.join(_get_cache_dir(), db_name)
 
 
-def initialize_db(db_name: str) -> None:
+def initialize_db(db_name: str, settings_env: str):
     """Ensure unified schema; reset once to unified schema if version is outdated."""
     with get_db_connection(db_name) as conn:
         cursor = conn.cursor()
-        _ensure_metadata(cursor)
-        _ensure_downloads_table(cursor)
-        _normalize_parent_ids(cursor)
-        _ensure_indexes(cursor)
-        _ensure_navmesh_tables(cursor)
+        _initialize_schema(cursor)
+        return _reconcile_install_signature(cursor, settings_env)
+
+
+def reconcile_install_signature(db_name: str, settings_env: str):
+    with get_db_connection(db_name) as conn:
+        cursor = conn.cursor()
+        _initialize_schema(cursor)
+        return _reconcile_install_signature(cursor, settings_env)
 
 
 def _ensure_downloads_table(cursor) -> None:
@@ -99,6 +105,8 @@ def _ensure_metadata(cursor) -> None:
     if 'schema_version' not in cols:
         cursor.execute("ALTER TABLE metadata ADD COLUMN schema_version INTEGER")
         cursor.execute("UPDATE metadata SET schema_version=0 WHERE id=1")
+    if 'install_signature' not in cols:
+        cursor.execute("ALTER TABLE metadata ADD COLUMN install_signature TEXT")
     # Check current version and reset schema if outdated
     cursor.execute("SELECT schema_version FROM metadata WHERE id=1")
     row = cursor.fetchone()
@@ -107,6 +115,109 @@ def _ensure_metadata(cursor) -> None:
         _reset_to_unified_schema(cursor)
 
 
+def _initialize_schema(cursor) -> None:
+    _ensure_metadata(cursor)
+    _ensure_downloads_table(cursor)
+    _normalize_parent_ids(cursor)
+    _ensure_indexes(cursor)
+    _ensure_navmesh_tables(cursor)
+
+
+def _get_vvmq_id_for_env(settings_env: str) -> str | None:
+    for resource_id, env in config.VANILLA_MAP.items():
+        if env.upper() == settings_env.upper():
+            return str(resource_id)
+    return None
+
+
+def _compute_install_signature(settings_env: str) -> dict:
+    settings_for_env = config.settings.from_env(settings_env)
+    download_folder = os.path.normpath(settings_for_env.DOWNLOAD_FOLDER)
+    eqpath = os.path.normpath(settings_for_env.EQPATH) if settings_for_env.EQPATH else ""
+
+    vvmq_id = _get_vvmq_id_for_env(settings_env)
+    vvmq_path = None
+    if vvmq_id:
+        vvmq_resource = settings_for_env.SPECIAL_RESOURCES.get(vvmq_id)
+        vvmq_path = utils.resolve_special_destination(vvmq_resource, download_folder)
+
+    base_path = vvmq_path if vvmq_path else download_folder
+
+    special_destinations: dict[str, str] = {}
+    for resource_id, resource_info in settings_for_env.SPECIAL_RESOURCES.items():
+        destination = utils.resolve_special_destination(resource_info, download_folder)
+        if destination:
+            special_destinations[str(resource_id)] = destination
+
+    return {
+        "base_path": base_path,
+        "download_folder": download_folder,
+        "eqpath": eqpath,
+        "special_destinations": special_destinations,
+    }
+
+
+def _load_install_signature(cursor) -> dict | None:
+    cursor.execute("SELECT install_signature FROM metadata WHERE id = 1")
+    row = cursor.fetchone()
+    if not row or row[0] is None:
+        return None
+    return json.loads(row[0])
+
+
+def _save_install_signature(cursor, signature: dict) -> None:
+    cursor.execute(
+        "UPDATE metadata SET install_signature = ? WHERE id = 1",
+        (json.dumps(signature, sort_keys=True),),
+    )
+
+
+def _diff_special_destinations(before: dict | None, after: dict) -> list[str]:
+    before_map = before.get("special_destinations", {}) if before else {}
+    after_map = after.get("special_destinations", {})
+    changed = []
+    for resource_id in set(before_map) | set(after_map):
+        if before_map.get(resource_id) != after_map.get(resource_id):
+            changed.append(str(resource_id))
+    return sorted(changed)
+
+
+def _reset_download_dates_for_special_resource(cursor, resource_id: str) -> None:
+    rid_int = int(resource_id)
+    cursor.execute(
+        "UPDATE downloads SET version_local=0 WHERE parent_id = 0 AND resource_id = ?",
+        (rid_int,),
+    )
+    cursor.execute(
+        "UPDATE downloads SET version_local=0 WHERE parent_id = ?",
+        (rid_int,),
+    )
+
+
+def _reconcile_install_signature(cursor, settings_env: str) -> dict | None:
+    before = _load_install_signature(cursor)
+    after = _compute_install_signature(settings_env)
+
+    if before is None:
+        _save_install_signature(cursor, after)
+        return None
+
+    if before == after:
+        return None
+
+    if before.get("base_path") != after.get("base_path"):
+        reset_download_dates(cursor)
+        _save_install_signature(cursor, after)
+        return {"global_reset": True, "changed_ids": []}
+
+    changed_ids = _diff_special_destinations(before, after)
+    for resource_id in changed_ids:
+        _reset_download_dates_for_special_resource(cursor, resource_id)
+
+    _save_install_signature(cursor, after)
+    return {"global_reset": False, "changed_ids": changed_ids}
+
+
 def _ensure_indexes(cursor) -> None:
     """Create indexes."""
     try:
diff --git a/src/redfetch/terminal_ui.py b/src/redfetch/terminal_ui.py
@@ -1362,6 +1362,7 @@ def handle_input_update(self, input_id: str, input_value: str) -> None:
                 settings_tab = main_screen.query_one(SettingsTab)
                 settings_tab.update_vvmq_path_display()
                 self.notify("Download folder updated" if input_value else "Download folder cleared")
+                self._queue_signature_reconcile()
             except ValidationError as e:
                 self.notify(f"Invalid Download Folder: {e}", severity="error")
         elif input_id == "eq_path_input":
@@ -1374,6 +1375,7 @@ def handle_input_update(self, input_id: str, input_value: str) -> None:
                     eq_maps_select = main_screen.query_one("#eq_maps", Select)
                     eq_maps_select.disabled = not bool(input_value)
                     eq_maps_select.value = self.get_current_eq_maps_value()
+                    self._queue_signature_reconcile()
 
                 except ValidationError as e:
                     self.notify(f"Invalid EverQuest Path: {e}", severity="error")
@@ -1385,6 +1387,7 @@ def handle_input_update(self, input_id: str, input_value: str) -> None:
                 try:
                     config.update_setting(['SPECIAL_RESOURCES', vvmq_id, 'custom_path'], input_value, env=self.current_env)
                     self.notify("Very Vanilla MQ folder updated" if input_value else "Very Vanilla MQ folder cleared")
+                    self._queue_signature_reconcile()
                 except ValidationError as e:
                     self.notify(f"Invalid VVMQ Path: {e}", severity="error")
 
@@ -1425,6 +1428,22 @@ def update_selected_directory(self, selected_path: Path | None, input_id: str) -
         else:
             self.notify("No directory selected", severity="warning")
 
+    def _queue_signature_reconcile(self) -> None:
+        if self.is_updating:
+            return
+        self._reconcile_signature_worker()
+
+    @work(exclusive=True, group="signature_reconcile")
+    async def _reconcile_signature_worker(self) -> None:
+        db_name = f"{self.current_env}_resources.db"
+        result = await asyncio.to_thread(store.reconcile_install_signature, db_name, self.current_env)
+        if result:
+            if result.get("global_reset"):
+                message = f"Cache cleared for {self.current_env}; next update will re-download into the new path."
+            else:
+                message = f"Cache cleared for {self.current_env}; next update will re-download updated destinations."
+            self.notify(message)
+
     #
     # Toggle handlers
     #
@@ -1863,7 +1882,7 @@ def _process_sync_event(self, event_type: str, resource_id: str | int, details:
     async def run_synchronization(self, resource_ids=None, navmesh_override=None):
         try:
             db_name = f"{self.current_env}_resources.db"
-            await asyncio.to_thread(store.initialize_db, db_name)
+            await asyncio.to_thread(store.initialize_db, db_name, self.current_env)
             db_path = store.get_db_path(db_name)
             headers = await api.get_api_headers()
             if resource_ids:
diff --git a/src/redfetch/utils.py b/src/redfetch/utils.py
@@ -58,6 +58,19 @@ def ensure_directory_exists(path):
         raise
 
 
+def resolve_special_destination(special_resource: dict, download_folder: str) -> str | None:
+    """Resolve a special resource destination path without side effects."""
+    if not special_resource:
+        return None
+    custom_path = special_resource.get("custom_path")
+    if custom_path:
+        return os.path.normpath(os.path.realpath(custom_path))
+    default_path = special_resource.get("default_path")
+    if default_path:
+        return os.path.normpath(os.path.join(download_folder, default_path))
+    return None
+
+
 def get_special_resource_path(resource_id):
     """Get the path for special resources."""
     special_resource = config.settings.from_env(config.settings.ENV).SPECIAL_RESOURCES.get(resource_id)
diff --git a/tests/test_path_reset.py b/tests/test_path_reset.py
@@ -0,0 +1,138 @@
+import os
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+from redfetch import config, store, main
+
+
+def _set_env_settings(download_folder: str, eqpath: str, special_resources: dict) -> None:
+    env_settings = SimpleNamespace(
+        DOWNLOAD_FOLDER=download_folder,
+        EQPATH=eqpath,
+        SPECIAL_RESOURCES=special_resources,
+    )
+    config.settings = MagicMock()
+    config.settings.ENV = "LIVE"
+    config.settings.from_env.return_value = env_settings
+
+
+def test_reconcile_global_reset_on_base_path_change(tmp_path):
+    config.config_dir = str(tmp_path)
+    db_name = "LIVE_resources.db"
+
+    download_folder_1 = str(tmp_path / "downloads1")
+    _set_env_settings(download_folder_1, "", {})
+    store.initialize_db(db_name, "LIVE")
+
+    with store.get_db_connection(db_name) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO downloads (resource_id, parent_id, version_local) VALUES (?, ?, ?)",
+            (153, 0, 5),
+        )
+
+    download_folder_2 = str(tmp_path / "downloads2")
+    _set_env_settings(download_folder_2, "", {})
+    store.initialize_db(db_name, "LIVE")
+
+    with store.get_db_connection(db_name) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT version_local FROM downloads WHERE resource_id = ? AND parent_id = 0",
+            (153,),
+        )
+        row = cursor.fetchone()
+    assert row[0] == 0
+
+
+def test_reconcile_targeted_reset_on_special_destination_change(tmp_path):
+    config.config_dir = str(tmp_path)
+    db_name = "LIVE_resources.db"
+
+    download_folder = str(tmp_path / "downloads")
+    eqpath_1 = str(tmp_path / "eq1")
+    eqpath_2 = str(tmp_path / "eq2")
+
+    special_resources_1 = {
+        "153": {"default_path": os.path.join(eqpath_1, "maps"), "custom_path": ""},
+        "1865": {"default_path": "MySEQ", "custom_path": ""},
+    }
+    _set_env_settings(download_folder, eqpath_1, special_resources_1)
+    store.initialize_db(db_name, "LIVE")
+
+    with store.get_db_connection(db_name) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT INTO downloads (resource_id, parent_id, version_local) VALUES (?, ?, ?)",
+            (153, 0, 9),
+        )
+        cursor.execute(
+            "INSERT INTO downloads (resource_id, parent_id, version_local) VALUES (?, ?, ?)",
+            (999, 153, 7),
+        )
+        cursor.execute(
+            "INSERT INTO downloads (resource_id, parent_id, version_local) VALUES (?, ?, ?)",
+            (1865, 0, 8),
+        )
+        cursor.execute(
+            "INSERT INTO downloads (resource_id, parent_id, version_local) VALUES (?, ?, ?)",
+            (153, 151, 6),
+        )
+
+    special_resources_2 = {
+        "153": {"default_path": os.path.join(eqpath_2, "maps"), "custom_path": ""},
+        "1865": {"default_path": "MySEQ", "custom_path": ""},
+    }
+    _set_env_settings(download_folder, eqpath_2, special_resources_2)
+    store.initialize_db(db_name, "LIVE")
+
+    with store.get_db_connection(db_name) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT version_local FROM downloads WHERE resource_id = ? AND parent_id = 0",
+            (153,),
+        )
+        row_153_root = cursor.fetchone()
+        cursor.execute(
+            "SELECT version_local FROM downloads WHERE resource_id = ? AND parent_id = ?",
+            (999, 153),
+        )
+        row_153_dep = cursor.fetchone()
+        cursor.execute(
+            "SELECT version_local FROM downloads WHERE resource_id = ? AND parent_id = 0",
+            (1865,),
+        )
+        row_1865_root = cursor.fetchone()
+        cursor.execute(
+            "SELECT version_local FROM downloads WHERE resource_id = ? AND parent_id = ?",
+            (153, 151),
+        )
+        row_153_as_dep = cursor.fetchone()
+
+    assert row_153_root[0] == 0
+    assert row_153_dep[0] == 0
+    assert row_1865_root[0] == 8
+    assert row_153_as_dep[0] == 6
+
+
+def test_config_command_reconciles_signature_for_server(monkeypatch):
+    called = {}
+
+    def fake_init():
+        return None
+
+    def fake_update(setting_path, value, env=None):
+        return None
+
+    def fake_reconcile(db_name, settings_env):
+        called["db_name"] = db_name
+        called["settings_env"] = settings_env
+        return None
+
+    monkeypatch.setattr(config, "initialize_config", fake_init)
+    monkeypatch.setattr(config, "update_setting", fake_update)
+    monkeypatch.setattr(store, "reconcile_install_signature", fake_reconcile)
+
+    main.config_command("EQPATH", "C:\\Games\\EverQuest", server=main.Env.TEST)
+
+    assert called == {"db_name": "TEST_resources.db", "settings_env": "TEST"}
diff --git a/tests/test_special_resources_e2e.py b/tests/test_special_resources_e2e.py
