"""Schema versioning + one-time import of a legacy config.json deployment. Hand-rolled on purpose (vs alembic): single worker, single SQLite file, ~30 lines of runner. Each migration is (version, fn(connection)); v1 is just create_all. DDL stays dialect-neutral so a future move to Postgres is a DATABASE_URL change, not a rewrite. Run at import time from main.py, before any request is served. """ from __future__ import annotations import logging import secrets import shutil import time from sqlalchemy import select, text from . import config from .db import SessionLocal, engine from .models import Base, BatteryLog, Frame, ServerSettings logger = logging.getLogger(__name__) def _migration_1(conn) -> None: Base.metadata.create_all(bind=conn) def _migration_2(conn) -> None: """Adds email (users) and battery-alert threshold (frames) columns, plus the new server_settings/password_reset_tokens tables. ALTER TABLE ADD COLUMN with a default is safe on SQLite against a live, already-populated database -- existing rows just get the default.""" conn.execute(text("ALTER TABLE users ADD COLUMN email TEXT NOT NULL DEFAULT ''")) conn.execute(text("ALTER TABLE frames ADD COLUMN battery_alert_threshold_pct INTEGER NOT NULL DEFAULT -1")) conn.execute(text("ALTER TABLE frames ADD COLUMN battery_alert_sent INTEGER NOT NULL DEFAULT 0")) Base.metadata.create_all(bind=conn) # creates the two new tables only; existing ones untouched MIGRATIONS = [ (1, _migration_1), (2, _migration_2), ] def run_migrations() -> None: with engine.begin() as conn: conn.execute(text("CREATE TABLE IF NOT EXISTS schema_version (version INTEGER NOT NULL)")) row = conn.execute(text("SELECT version FROM schema_version")).fetchone() current = row[0] if row else 0 for version, fn in MIGRATIONS: if version > current: logger.info("Applying schema migration %d", version) fn(conn) if row is None: conn.execute( text("INSERT INTO schema_version (version) VALUES (:v)"), {"v": version} ) row = (version,) else: conn.execute(text("UPDATE schema_version SET version = :v"), {"v": version}) _ensure_frame_one() _ensure_server_settings() def new_device_token() -> str: return secrets.token_urlsafe(32) def new_manage_token() -> str: return secrets.token_urlsafe(16) def _ensure_frame_one() -> None: """First boot only (frames table empty): create frame #1 -- imported verbatim from a legacy config.json if one exists, otherwise fresh defaults. Either way it's the legacy-token frame: the deployed firmware sends no device id and (at most) the shared MANAGEMENT_TOKEN, and require_device resolves those requests here. The frames-nonempty guard makes this idempotent; config.json is left untouched as the rollback path.""" with SessionLocal() as db: if db.scalars(select(Frame).limit(1)).first() is not None: return cfg = config.load() # all defaults if the file doesn't exist had_file = config.CONFIG_PATH.exists() frame = Frame( name="Frame 1", device_id=None, device_token=new_device_token(), manage_token=new_manage_token(), legacy_token_enabled=True, created_at=time.time(), immich_url=cfg.immich_url, immich_api_key=cfg.immich_api_key, album_id=cfg.album_id, order=cfg.order, refresh_interval_s=cfg.refresh_interval_s, quiet_hours_enabled=cfg.quiet_hours_enabled, quiet_hours_start=cfg.quiet_hours_start, quiet_hours_end=cfg.quiet_hours_end, timezone=cfg.timezone, smart_crop_faces=cfg.smart_crop_faces, orientation=cfg.orientation, queue_target_len=cfg.queue_target_len, current_asset_id=cfg.current_asset_id, current_asset_set_at=cfg.current_asset_set_at, queue=list(cfg.queue), queue_cursor=cfg.queue_cursor, history=list(cfg.history), excluded_asset_ids=list(cfg.excluded_asset_ids), battery_percent=cfg.battery_percent, battery_as_of=cfg.battery_as_of, battery_history=[list(pair) for pair in cfg.battery_history], last_seen=cfg.last_seen, device_firmware_version=cfg.device_firmware_version, device_board_variant=cfg.device_board_variant, firmware_available_version=cfg.firmware_available_version, firmware_update_repo_url=cfg.firmware_update_repo_url, firmware_auto_update=cfg.firmware_auto_update, firmware_update_token=cfg.firmware_update_token, firmware_update_checked_at=cfg.firmware_update_checked_at, firmware_gitea_latest_version=cfg.firmware_gitea_latest_version, stats_first_seen=cfg.stats.first_seen, stats_device_wakes=cfg.stats.device_wakes, stats_photos_displayed=cfg.stats.photos_displayed, stats_photos_removed=cfg.stats.photos_removed, stats_battery_reports=cfg.stats.battery_reports, stats_recharge_cycles=cfg.stats.recharge_cycles, stats_ota_updates_applied=cfg.stats.ota_updates_applied, stats_config_saves=cfg.stats.config_saves, ) db.add(frame) db.flush() # assign frame.id for the battery log rows for pair in cfg.battery_log: db.add(BatteryLog(frame_id=frame.id, ts=pair[0], percent=pair[1])) db.commit() # The single legacy firmware slot becomes frame #1's per-frame slot. legacy_bin = config.CONFIG_PATH.parent / "firmware.bin" if legacy_bin.exists(): per_frame_dir = config.CONFIG_PATH.parent / "firmware" per_frame_dir.mkdir(parents=True, exist_ok=True) shutil.copy2(legacy_bin, per_frame_dir / f"{frame.id}.bin") if had_file: logger.info( "Imported legacy config.json as frame #%d (%d battery log entries)", frame.id, len(cfg.battery_log), ) else: logger.info("Fresh install: created default frame #%d", frame.id) def _ensure_server_settings() -> None: """The SMTP config singleton (id=1) -- created with everything blank (email sending disabled) the first time this runs; /admin edits it in place from then on.""" with SessionLocal() as db: if db.get(ServerSettings, 1) is None: db.add(ServerSettings(id=1)) db.commit()