rapid interations of server side app and firefox extension

backend/app/api/settings.py

@@ -0,0 +1,165 @@
+"""Settings API endpoints."""
+
+import json
+from pathlib import Path
+from quart import Blueprint, request, jsonify, current_app
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.setting import Setting, DEFAULT_SETTINGS, EXTENSION_API_KEY_SETTING, generate_api_key
+from app.config import get_settings
+
+bp = Blueprint("settings", __name__)
+
+
+async def get_or_create_extension_api_key(session: AsyncSession) -> str:
+    """Get the extension API key, creating one if it doesn't exist."""
+    result = await session.execute(
+        select(Setting).where(Setting.key == EXTENSION_API_KEY_SETTING)
+    )
+    setting = result.scalar()
+
+    if setting:
+        return setting.value
+
+    # Generate new key
+    new_key = generate_api_key()
+    setting = Setting(key=EXTENSION_API_KEY_SETTING, value=new_key)
+    session.add(setting)
+    await session.commit()
+
+    return new_key
+
+
+@bp.route("", methods=["GET"])
+async def get_all_settings():
+    """Get all application settings."""
+    async with current_app.db_engine.connect() as conn:
+        session = AsyncSession(bind=conn)
+
+        result = await session.execute(select(Setting))
+        settings = result.scalars().all()
+
+        # Build settings dict with defaults
+        settings_dict = dict(DEFAULT_SETTINGS)
+        for s in settings:
+            settings_dict[s.key] = s.value
+
+        # Ensure extension API key exists
+        api_key = await get_or_create_extension_api_key(session)
+        settings_dict[EXTENSION_API_KEY_SETTING] = api_key
+
+        return jsonify({"settings": settings_dict})
+
+
+@bp.route("", methods=["PATCH"])
+async def update_settings():
+    """Update application settings."""
+    data = await request.get_json()
+
+    if not data:
+        return jsonify({"error": "No settings provided"}), 400
+
+    async with current_app.db_engine.connect() as conn:
+        session = AsyncSession(bind=conn)
+
+        for key, value in data.items():
+            # Check if setting exists
+            result = await session.execute(select(Setting).where(Setting.key == key))
+            setting = result.scalar()
+
+            if setting:
+                setting.value = value
+            else:
+                setting = Setting(key=key, value=value)
+                session.add(setting)
+
+        await session.commit()
+
+        # Return updated settings
+        result = await session.execute(select(Setting))
+        settings = result.scalars().all()
+        settings_dict = dict(DEFAULT_SETTINGS)
+        for s in settings:
+            settings_dict[s.key] = s.value
+
+        current_app.logger.info(f"Updated settings: {list(data.keys())}")
+        return jsonify({"settings": settings_dict})
+
+
+@bp.route("/api-key", methods=["GET"])
+async def get_extension_api_key():
+    """Get the extension API key."""
+    async with current_app.db_engine.connect() as conn:
+        session = AsyncSession(bind=conn)
+        api_key = await get_or_create_extension_api_key(session)
+        return jsonify({"api_key": api_key})
+
+
+@bp.route("/api-key/regenerate", methods=["POST"])
+async def regenerate_extension_api_key():
+    """Regenerate the extension API key."""
+    async with current_app.db_engine.connect() as conn:
+        session = AsyncSession(bind=conn)
+
+        # Find existing key
+        result = await session.execute(
+            select(Setting).where(Setting.key == EXTENSION_API_KEY_SETTING)
+        )
+        setting = result.scalar()
+
+        # Generate new key
+        new_key = generate_api_key()
+
+        if setting:
+            setting.value = new_key
+        else:
+            setting = Setting(key=EXTENSION_API_KEY_SETTING, value=new_key)
+            session.add(setting)
+
+        await session.commit()
+
+        current_app.logger.info("Extension API key regenerated")
+        return jsonify({"api_key": new_key, "message": "API key regenerated"})
+
+
+@bp.route("/gallery-dl", methods=["GET"])
+async def get_gallery_dl_config():
+    """Get gallery-dl configuration."""
+    config = get_settings()
+    config_path = Path(config.config_path) / "gallery-dl.conf"
+
+    if not config_path.exists():
+        return jsonify({"config": {}, "message": "No configuration file found"})
+
+    try:
+        with open(config_path) as f:
+            gallery_dl_config = json.load(f)
+        return jsonify({"config": gallery_dl_config})
+    except json.JSONDecodeError as e:
+        return jsonify({"error": f"Invalid JSON in config file: {e}"}), 500
+
+
+@bp.route("/gallery-dl", methods=["PUT"])
+async def update_gallery_dl_config():
+    """Update gallery-dl configuration."""
+    data = await request.get_json()
+
+    if not data.get("config"):
+        return jsonify({"error": "Config object is required"}), 400
+
+    config = get_settings()
+    config_path = Path(config.config_path) / "gallery-dl.conf"
+
+    # Ensure config directory exists
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        with open(config_path, "w") as f:
+            json.dump(data["config"], f, indent=4)
+
+        current_app.logger.info("Updated gallery-dl configuration")
+        return jsonify({"message": "Configuration updated", "config": data["config"]})
+    except Exception as e:
+        current_app.logger.error(f"Failed to write gallery-dl config: {e}")
+        return jsonify({"error": f"Failed to write config: {e}"}), 500