feat: Set File Date to First Aired Date

app/services/session_service.py

@@ -10,6 +10,8 @@ from app.config import APP_DATA_DIR
 
 
 class SessionService:
+    FILE_DATE_SETTING_KEY = "set_file_date_to_first_aired_date"
+
     def __init__(self) -> None:
         self._db_path = Path(APP_DATA_DIR) / "session_state.sqlite3"
         self._db_path.parent.mkdir(parents=True, exist_ok=True)
@@ -110,6 +112,53 @@ class SessionService:
                 ON rename_run_items(run_id, item_index)
                 """
             )
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS app_settings (
+                    key TEXT PRIMARY KEY,
+                    value TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                )
+                """
+            )
+
+    def get_settings(self) -> dict:
+        with self._connect() as conn:
+            rows = conn.execute(
+                """
+                SELECT key, value
+                FROM app_settings
+                """
+            ).fetchall()
+
+        values = {str(row["key"]): str(row["value"]) for row in rows}
+        return {
+            self.FILE_DATE_SETTING_KEY: values.get(self.FILE_DATE_SETTING_KEY, "0") == "1",
+        }
+
+    def update_settings(self, settings: dict) -> dict:
+        if self.FILE_DATE_SETTING_KEY not in settings:
+            raise ValueError(f"missing required setting: {self.FILE_DATE_SETTING_KEY}")
+        setting_value = settings[self.FILE_DATE_SETTING_KEY]
+        if not isinstance(setting_value, bool):
+            raise ValueError(f"{self.FILE_DATE_SETTING_KEY} must be boolean")
+
+        stored_value = "1" if setting_value else "0"
+        updated_at = datetime.now(timezone.utc).isoformat()
+
+        with self._connect() as conn:
+            conn.execute(
+                """
+                INSERT INTO app_settings (key, value, updated_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(key) DO UPDATE SET
+                    value = excluded.value,
+                    updated_at = excluded.updated_at
+                """,
+                (self.FILE_DATE_SETTING_KEY, stored_value, updated_at),
+            )
+
+        return self.get_settings()
 
     def list_selected_episodes(self, session_id: str) -> list[dict]:
         with self._connect() as conn:
@@ -467,9 +516,15 @@ class SessionService:
 
         started_at = time.perf_counter()
         preview = self.build_filename_preview(session_id)
+        settings = self.get_settings()
+        set_file_date_to_first_aired = bool(settings.get(self.FILE_DATE_SETTING_KEY, False))
         allowed_roots = self._allowed_media_roots()
         preflight_items = []
         preflight_errors = 0
+        aired_by_index = {}
+
+        for preview_item in preview["items"]:
+            aired_by_index[int(preview_item["index"])] = preview_item["episode"].get("aired")
 
         for item in preview["items"]:
             source_path_str = str(item["file"].get("path") or "").strip()
@@ -499,6 +554,8 @@ class SessionService:
                     "proposed_filename": proposed_filename,
                     "status": status,
                     "errors": errors,
+                    "file_date_status": "file_date_skipped",
+                    "file_date_detail": "rename not executed due to preflight failure",
                 }
             )
 
@@ -523,11 +580,19 @@ class SessionService:
             source_path = Path(item["source_path"])
             destination_path = Path(item["destination_path"])
             os.replace(str(source_path), str(destination_path))
+
+            file_date_status, file_date_detail = self._apply_file_date_after_rename(
+                enabled=set_file_date_to_first_aired,
+                aired_value=aired_by_index.get(int(item["index"])),
+                destination_path=destination_path,
+            )
             results.append(
                 {
                     **item,
                     "status": "renamed",
                     "errors": [],
+                    "file_date_status": file_date_status,
+                    "file_date_detail": file_date_detail,
                 }
             )
 
@@ -546,6 +611,49 @@ class SessionService:
         )
         return result
 
+    def _apply_file_date_after_rename(
+        self,
+        enabled: bool,
+        aired_value,
+        destination_path: Path,
+    ) -> tuple[str, str]:
+        if not enabled:
+            return ("file_date_skipped", "setting disabled")
+
+        ts = self._aired_to_local_noon_timestamp(aired_value)
+        if ts is None:
+            return ("file_date_skipped", "aired date missing or invalid")
+
+        try:
+            os.utime(destination_path, (ts, ts))
+            return ("file_date_updated", "mtime+atime set to aired date at 12:00 local time")
+        except Exception as exc:
+            return ("file_date_error", str(exc))
+
+    def _aired_to_local_noon_timestamp(self, aired_value) -> float | None:
+        if aired_value is None:
+            return None
+
+        text = str(aired_value).strip()
+        if not text:
+            return None
+        date_text = text[:10]
+
+        try:
+            date_part = datetime.strptime(date_text, "%Y-%m-%d")
+        except ValueError:
+            return None
+
+        local_noon = datetime(
+            date_part.year,
+            date_part.month,
+            date_part.day,
+            12,
+            0,
+            0,
+        )
+        return local_noon.timestamp()
+
     def _log_rename_run(self, session_id: str, result: dict, duration_ms: int) -> None:
         created_at = datetime.now(timezone.utc).isoformat()
         counts = result.get("counts", {})