367 lines
16 KiB
Python
367 lines
16 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
import sqlite3
|
|
import uuid
|
|
from datetime import UTC, datetime
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
DEFAULT_DB = ROOT / "data" / "streamdeck.sqlite"
|
|
|
|
|
|
def utc_now() -> str:
|
|
return datetime.now(UTC).isoformat(timespec="seconds").replace("+00:00", "Z")
|
|
|
|
|
|
class Database:
|
|
def __init__(self, path: Path = DEFAULT_DB):
|
|
self.path = path
|
|
self.path.parent.mkdir(parents=True, exist_ok=True)
|
|
self.conn = sqlite3.connect(self.path, check_same_thread=False)
|
|
self.conn.row_factory = sqlite3.Row
|
|
self.conn.execute("PRAGMA foreign_keys = ON")
|
|
self.migrate()
|
|
self.ensure_defaults()
|
|
|
|
def migrate(self) -> None:
|
|
self.conn.executescript(
|
|
"""
|
|
CREATE TABLE IF NOT EXISTS settings (
|
|
key TEXT PRIMARY KEY,
|
|
value TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS profiles (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS folders (
|
|
id TEXT PRIMARY KEY,
|
|
profile_id TEXT NOT NULL,
|
|
parent_id TEXT,
|
|
name TEXT NOT NULL,
|
|
is_root INTEGER NOT NULL DEFAULT 0,
|
|
created_at TEXT NOT NULL,
|
|
FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE,
|
|
FOREIGN KEY(parent_id) REFERENCES folders(id) ON DELETE CASCADE
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS buttons (
|
|
id TEXT PRIMARY KEY,
|
|
profile_id TEXT NOT NULL,
|
|
folder_id TEXT NOT NULL,
|
|
position INTEGER NOT NULL,
|
|
physical_button INTEGER NOT NULL,
|
|
label TEXT NOT NULL DEFAULT '',
|
|
color TEXT NOT NULL DEFAULT '#111827',
|
|
icon TEXT NOT NULL DEFAULT '',
|
|
trigger_mode TEXT NOT NULL DEFAULT 'down',
|
|
action_type TEXT NOT NULL DEFAULT 'noop',
|
|
action_config TEXT NOT NULL DEFAULT '{}',
|
|
updated_at TEXT NOT NULL,
|
|
UNIQUE(folder_id, position),
|
|
UNIQUE(folder_id, physical_button),
|
|
FOREIGN KEY(profile_id) REFERENCES profiles(id) ON DELETE CASCADE,
|
|
FOREIGN KEY(folder_id) REFERENCES folders(id) ON DELETE CASCADE
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS manual_apps (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT NOT NULL,
|
|
path TEXT NOT NULL,
|
|
args TEXT,
|
|
created_at TEXT NOT NULL
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS event_history (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
created_at TEXT NOT NULL,
|
|
event_type TEXT NOT NULL,
|
|
payload TEXT NOT NULL
|
|
);
|
|
"""
|
|
)
|
|
self.conn.commit()
|
|
|
|
def ensure_defaults(self) -> None:
|
|
if not self.get_setting("click_check"):
|
|
self.set_setting("click_check", False)
|
|
if not self.get_setting("serial_port"):
|
|
self.set_setting("serial_port", None)
|
|
profile = self.conn.execute("SELECT * FROM profiles LIMIT 1").fetchone()
|
|
if profile is None:
|
|
profile_id = self.create_profile("Default", make_active=False)
|
|
self.set_setting("active_profile_id", profile_id)
|
|
root_id = self.get_root_folder(profile_id)["id"]
|
|
self.set_setting("active_folder_id", root_id)
|
|
else:
|
|
active_profile = self.get_setting("active_profile_id") or profile["id"]
|
|
self.set_setting("active_profile_id", active_profile)
|
|
active_folder = self.get_setting("active_folder_id") or self.get_root_folder(active_profile)["id"]
|
|
self.set_setting("active_folder_id", active_folder)
|
|
self.sync_physical_layouts()
|
|
|
|
def row_to_dict(self, row: sqlite3.Row | None) -> dict[str, Any] | None:
|
|
return dict(row) if row else None
|
|
|
|
def get_setting(self, key: str) -> Any:
|
|
row = self.conn.execute("SELECT value FROM settings WHERE key = ?", (key,)).fetchone()
|
|
return json.loads(row["value"]) if row else None
|
|
|
|
def set_setting(self, key: str, value: Any) -> None:
|
|
self.conn.execute(
|
|
"INSERT INTO settings(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value",
|
|
(key, json.dumps(value)),
|
|
)
|
|
self.conn.commit()
|
|
|
|
def settings(self) -> dict[str, Any]:
|
|
rows = self.conn.execute("SELECT key, value FROM settings").fetchall()
|
|
return {row["key"]: json.loads(row["value"]) for row in rows}
|
|
|
|
def create_profile(self, name: str, make_active: bool = True) -> str:
|
|
profile_id = str(uuid.uuid4())
|
|
self.conn.execute(
|
|
"INSERT INTO profiles(id, name, created_at) VALUES(?, ?, ?)",
|
|
(profile_id, name, utc_now()),
|
|
)
|
|
root_id = str(uuid.uuid4())
|
|
self.conn.execute(
|
|
"INSERT INTO folders(id, profile_id, parent_id, name, is_root, created_at) VALUES(?, ?, NULL, ?, 1, ?)",
|
|
(root_id, profile_id, "Root", utc_now()),
|
|
)
|
|
self._seed_buttons(profile_id, root_id)
|
|
self.conn.commit()
|
|
self.sync_physical_layouts()
|
|
if make_active:
|
|
self.set_setting("active_profile_id", profile_id)
|
|
self.set_setting("active_folder_id", root_id)
|
|
return profile_id
|
|
|
|
def update_profile(self, profile_id: str, name: str | None = None, active: bool | None = None) -> None:
|
|
if name is not None:
|
|
self.conn.execute("UPDATE profiles SET name = ? WHERE id = ?", (name, profile_id))
|
|
if active:
|
|
self.set_setting("active_profile_id", profile_id)
|
|
self.set_setting("active_folder_id", self.get_root_folder(profile_id)["id"])
|
|
self.conn.commit()
|
|
|
|
def delete_profile(self, profile_id: str) -> None:
|
|
if profile_id == self.first_profile()["id"]:
|
|
raise ValueError("Cannot delete the first profile because it owns the hardware layout.")
|
|
count = self.conn.execute("SELECT COUNT(*) AS count FROM profiles").fetchone()["count"]
|
|
if count <= 1:
|
|
raise ValueError("Cannot delete the only profile.")
|
|
self.conn.execute("DELETE FROM profiles WHERE id = ?", (profile_id,))
|
|
if self.get_setting("active_profile_id") == profile_id:
|
|
next_profile = self.conn.execute("SELECT id FROM profiles LIMIT 1").fetchone()["id"]
|
|
self.set_setting("active_profile_id", next_profile)
|
|
self.set_setting("active_folder_id", self.get_root_folder(next_profile)["id"])
|
|
self.conn.commit()
|
|
|
|
def create_folder(self, profile_id: str, parent_id: str | None, name: str) -> str:
|
|
parent_id = parent_id or self.get_root_folder(profile_id)["id"]
|
|
folder_id = str(uuid.uuid4())
|
|
self.conn.execute(
|
|
"INSERT INTO folders(id, profile_id, parent_id, name, is_root, created_at) VALUES(?, ?, ?, ?, 0, ?)",
|
|
(folder_id, profile_id, parent_id, name, utc_now()),
|
|
)
|
|
self._seed_buttons(profile_id, folder_id)
|
|
self.conn.commit()
|
|
self.sync_physical_layouts()
|
|
return folder_id
|
|
|
|
def update_folder(self, folder_id: str, name: str | None = None, parent_id: str | None = None) -> None:
|
|
if name is not None:
|
|
self.conn.execute("UPDATE folders SET name = ? WHERE id = ?", (name, folder_id))
|
|
if parent_id is not None:
|
|
self.conn.execute("UPDATE folders SET parent_id = ? WHERE id = ? AND is_root = 0", (parent_id, folder_id))
|
|
self.conn.commit()
|
|
|
|
def delete_folder(self, folder_id: str) -> None:
|
|
row = self.conn.execute("SELECT is_root, profile_id FROM folders WHERE id = ?", (folder_id,)).fetchone()
|
|
if not row:
|
|
return
|
|
if row["is_root"]:
|
|
raise ValueError("Cannot delete the root folder.")
|
|
self.conn.execute("DELETE FROM folders WHERE id = ?", (folder_id,))
|
|
if self.get_setting("active_folder_id") == folder_id:
|
|
self.set_setting("active_folder_id", self.get_root_folder(row["profile_id"])["id"])
|
|
self.conn.commit()
|
|
|
|
def update_button(self, button_id: str, changes: dict[str, Any]) -> dict[str, Any]:
|
|
physical_button = changes.pop("physical_button", None)
|
|
current = self.get_button(button_id)
|
|
if physical_button is not None and int(physical_button) != current["physical_button"]:
|
|
if not self.can_edit_physical_layout(current["folder_id"]):
|
|
raise ValueError("Physical button layout can only be changed in the first profile's root folder.")
|
|
allowed = {"label", "color", "icon", "trigger_mode", "action_type"}
|
|
sets: list[str] = []
|
|
values: list[Any] = []
|
|
for key in allowed:
|
|
if key in changes and changes[key] is not None:
|
|
sets.append(f"{key} = ?")
|
|
values.append(changes[key])
|
|
if "action_config" in changes and changes["action_config"] is not None:
|
|
sets.append("action_config = ?")
|
|
values.append(json.dumps(changes["action_config"]))
|
|
if sets:
|
|
sets.append("updated_at = ?")
|
|
values.append(utc_now())
|
|
values.append(button_id)
|
|
self.conn.execute(f"UPDATE buttons SET {', '.join(sets)} WHERE id = ?", values)
|
|
self.conn.commit()
|
|
if physical_button is not None and int(physical_button) != current["physical_button"]:
|
|
self.move_physical_button(current["folder_id"], current["position"], int(physical_button))
|
|
return self.get_button(button_id)
|
|
|
|
def move_physical_button(self, folder_id: str, position: int, physical_button: int) -> None:
|
|
if not self.can_edit_physical_layout(folder_id):
|
|
raise ValueError("Physical button layout can only be changed in the first profile's root folder.")
|
|
if position < 1 or position > 10 or physical_button < 1 or physical_button > 10:
|
|
raise ValueError("Position and physical button must be between 1 and 10.")
|
|
|
|
mapping = self.physical_layout_mapping()
|
|
old_physical = mapping[position]
|
|
old_position = next((slot for slot, physical in mapping.items() if physical == physical_button), None)
|
|
mapping[position] = physical_button
|
|
if old_position and old_position != position:
|
|
mapping[old_position] = old_physical
|
|
self.sync_physical_layouts(mapping)
|
|
|
|
def get_button(self, button_id: str) -> dict[str, Any]:
|
|
row = self.conn.execute("SELECT * FROM buttons WHERE id = ?", (button_id,)).fetchone()
|
|
button = dict(row)
|
|
button["action_config"] = json.loads(button["action_config"])
|
|
return button
|
|
|
|
def find_button_for_event(self, profile_id: str, folder_id: str, physical_button: int) -> dict[str, Any] | None:
|
|
row = self.conn.execute(
|
|
"SELECT * FROM buttons WHERE profile_id = ? AND folder_id = ? AND physical_button = ?",
|
|
(profile_id, folder_id, physical_button),
|
|
).fetchone()
|
|
if not row:
|
|
return None
|
|
button = dict(row)
|
|
button["action_config"] = json.loads(button["action_config"])
|
|
return button
|
|
|
|
def add_manual_app(self, name: str, path: str, args: str | None = None) -> dict[str, Any]:
|
|
app_id = str(uuid.uuid4())
|
|
self.conn.execute(
|
|
"INSERT INTO manual_apps(id, name, path, args, created_at) VALUES(?, ?, ?, ?, ?)",
|
|
(app_id, name, path, args, utc_now()),
|
|
)
|
|
self.conn.commit()
|
|
return {"id": app_id, "name": name, "path": path, "args": args, "source": "manual"}
|
|
|
|
def manual_apps(self) -> list[dict[str, Any]]:
|
|
return [dict(row) | {"source": "manual"} for row in self.conn.execute("SELECT * FROM manual_apps ORDER BY name").fetchall()]
|
|
|
|
def add_event(self, event_type: str, payload: dict[str, Any]) -> None:
|
|
self.conn.execute(
|
|
"INSERT INTO event_history(created_at, event_type, payload) VALUES(?, ?, ?)",
|
|
(utc_now(), event_type, json.dumps(payload)),
|
|
)
|
|
self.conn.commit()
|
|
|
|
def state(self) -> dict[str, Any]:
|
|
settings = self.settings()
|
|
profiles = [dict(row) for row in self.conn.execute("SELECT * FROM profiles ORDER BY created_at").fetchall()]
|
|
folders = [dict(row) for row in self.conn.execute("SELECT * FROM folders ORDER BY is_root DESC, created_at").fetchall()]
|
|
buttons = []
|
|
for row in self.conn.execute("SELECT * FROM buttons ORDER BY folder_id, position").fetchall():
|
|
button = dict(row)
|
|
button["action_config"] = json.loads(button["action_config"])
|
|
buttons.append(button)
|
|
return {
|
|
"settings": settings,
|
|
"profiles": profiles,
|
|
"folders": folders,
|
|
"buttons": buttons,
|
|
"layout": {
|
|
"canonical_profile_id": self.first_profile()["id"],
|
|
"canonical_folder_id": self.canonical_layout_folder()["id"],
|
|
"mapping": self.physical_layout_mapping(),
|
|
},
|
|
}
|
|
|
|
def get_root_folder(self, profile_id: str) -> dict[str, Any]:
|
|
row = self.conn.execute("SELECT * FROM folders WHERE profile_id = ? AND is_root = 1", (profile_id,)).fetchone()
|
|
return dict(row)
|
|
|
|
def first_profile(self) -> dict[str, Any]:
|
|
row = self.conn.execute("SELECT * FROM profiles ORDER BY created_at LIMIT 1").fetchone()
|
|
if row is None:
|
|
raise ValueError("No profiles exist.")
|
|
return dict(row)
|
|
|
|
def canonical_layout_folder(self) -> dict[str, Any]:
|
|
return self.get_root_folder(self.first_profile()["id"])
|
|
|
|
def can_edit_physical_layout(self, folder_id: str) -> bool:
|
|
return folder_id == self.canonical_layout_folder()["id"]
|
|
|
|
def physical_layout_mapping(self) -> dict[int, int]:
|
|
folder_id = self.canonical_layout_folder()["id"]
|
|
rows = self.conn.execute(
|
|
"SELECT position, physical_button FROM buttons WHERE folder_id = ? ORDER BY position",
|
|
(folder_id,),
|
|
).fetchall()
|
|
mapping = {int(row["position"]): int(row["physical_button"]) for row in rows}
|
|
for position in range(1, 11):
|
|
mapping.setdefault(position, position)
|
|
return mapping
|
|
|
|
def sync_physical_layouts(self, mapping: dict[int, int] | None = None) -> None:
|
|
if self.conn.execute("SELECT COUNT(*) AS count FROM profiles").fetchone()["count"] == 0:
|
|
return
|
|
mapping = mapping or self.physical_layout_mapping()
|
|
now = utc_now()
|
|
folders = self.conn.execute("SELECT id FROM folders").fetchall()
|
|
for folder in folders:
|
|
folder_id = folder["id"]
|
|
for position in range(1, 11):
|
|
self.conn.execute(
|
|
"UPDATE buttons SET physical_button = ?, updated_at = ? WHERE folder_id = ? AND position = ?",
|
|
(-position, now, folder_id, position),
|
|
)
|
|
for position, physical_button in mapping.items():
|
|
self.conn.execute(
|
|
"UPDATE buttons SET physical_button = ?, updated_at = ? WHERE folder_id = ? AND position = ?",
|
|
(physical_button, now, folder_id, position),
|
|
)
|
|
self.conn.commit()
|
|
|
|
def next_folder_id(self, profile_id: str, current_folder_id: str, direction: str = "next") -> str | None:
|
|
rows = self.conn.execute(
|
|
"SELECT id FROM folders WHERE profile_id = ? ORDER BY is_root DESC, created_at, name",
|
|
(profile_id,),
|
|
).fetchall()
|
|
folder_ids = [row["id"] for row in rows]
|
|
if not folder_ids:
|
|
return None
|
|
if current_folder_id not in folder_ids:
|
|
return folder_ids[0]
|
|
offset = -1 if direction == "previous" else 1
|
|
current_index = folder_ids.index(current_folder_id)
|
|
return folder_ids[(current_index + offset) % len(folder_ids)]
|
|
|
|
def _seed_buttons(self, profile_id: str, folder_id: str) -> None:
|
|
now = utc_now()
|
|
for position in range(1, 11):
|
|
self.conn.execute(
|
|
"""
|
|
INSERT INTO buttons(
|
|
id, profile_id, folder_id, position, physical_button, label,
|
|
color, icon, trigger_mode, action_type, action_config, updated_at
|
|
) VALUES(?, ?, ?, ?, ?, ?, ?, ?, 'down', 'noop', '{}', ?)
|
|
""",
|
|
(str(uuid.uuid4()), profile_id, folder_id, position, position, f"Button {position}", "#111827", "", now),
|
|
)
|