from fastapi import APIRouter, Form, HTTPException, Request from fastapi.responses import HTMLResponse, RedirectResponse from sqlalchemy import func, select from app.auth.admin import require_admin from app.auth.csrf import ensure_csrf_token, validate_csrf from app.db.models import Activity from app.db.repositories import ActivityRepository, SchedulerSettingsRepository, SystemLogRepository, UserRepository from app.sync.manager import SyncAlreadyRunning from app.web.routes import templates router = APIRouter() APP_VERSION = "1.0.0" def _toast_html(message: str, level: str) -> str: return templates.get_template("fragments/toast.html").render(message=message, level=level) def _outcome_toast(outcome, label: str) -> tuple[str, str]: if outcome.status in ("success", "partial"): return f"{label}: {outcome.imported} imported, {outcome.failed} failed", "success" return f"{label}: sync failed — {outcome.message or 'unknown error'}", "danger" def _normalize_outcome(item): if isinstance(item, Exception): return { "status": "error", "user_id": None, "discovered": 0, "imported": 0, "skipped": 0, "failed": 0, "message": str(item), } return { "status": item.status, "user_id": item.user_id, "discovered": item.discovered, "imported": item.imported, "skipped": item.skipped, "failed": item.failed, "message": item.message, } @router.post("/users/{user_id}/sync", response_class=HTMLResponse) async def manual_sync(request: Request, user_id: int, csrf_token: str = Form(...)): require_admin(request) validate_csrf(request, csrf_token) token = ensure_csrf_token(request) try: outcome = await request.app.state.sync_manager.sync_user(user_id) with request.app.state.session_factory() as session: row = UserRepository(session).dashboard_row(user_id) label = row.name if row is not None else f"Rider #{user_id}" message, level = _outcome_toast(outcome, label) except SyncAlreadyRunning: with request.app.state.session_factory() as session: row = UserRepository(session).dashboard_row(user_id) label = row.name if row is not None else f"Rider #{user_id}" message, level = f"{label}: sync already running", "info" row_html = ( templates.get_template("fragments/user_row.html").render(row=row, csrf_token=token, oob=False) if row is not None else "" ) return HTMLResponse(row_html + _toast_html(message, level)) @router.post("/sync-all", response_class=HTMLResponse) async def manual_sync_all(request: Request, csrf_token: str = Form(...)): require_admin(request) validate_csrf(request, csrf_token) outcomes = await request.app.state.sync_manager.sync_all_enabled() token = ensure_csrf_token(request) parts = [templates.get_template("fragments/sync_all_form.html").render(csrf_token=token)] ok = 0 failed = 0 with request.app.state.session_factory() as session: repository = UserRepository(session) for item in outcomes: normalized = _normalize_outcome(item) if normalized["status"] in ("success", "partial"): ok += 1 else: failed += 1 outcome_user_id = normalized["user_id"] if outcome_user_id is not None: row = repository.dashboard_row(outcome_user_id) if row is not None: parts.append( templates.get_template("fragments/user_row.html").render(row=row, csrf_token=token, oob=True) ) if not outcomes: parts.append(_toast_html("No riders to sync", "info")) else: level = "success" if failed == 0 else "danger" parts.append(_toast_html(f"Synced {len(outcomes)} riders — {ok} ok, {failed} failed", level)) return HTMLResponse("".join(parts)) @router.post("/users/{user_id}/garmin-mfa", response_class=HTMLResponse) async def garmin_mfa(request: Request, user_id: int, csrf_token: str = Form(...), code: str = Form(...)): require_admin(request) validate_csrf(request, csrf_token) stripped = code.strip() if not stripped or len(stripped) > 20: raise HTTPException(status_code=400, detail="Invalid MFA code") try: outcome = await request.app.state.sync_manager.sync_user(user_id, mfa_code=stripped) except SyncAlreadyRunning: return HTMLResponse("Sync already running for this user", status_code=409) return templates.TemplateResponse( request, "fragments/sync_result.html", {"outcomes": [_normalize_outcome(outcome)]} ) @router.post("/activities/{activity_id}/retry", response_class=HTMLResponse) async def retry_activity(request: Request, activity_id: int, csrf_token: str = Form(...)): require_admin(request) validate_csrf(request, csrf_token) with request.app.state.session_factory() as session: activity_repo = ActivityRepository(session) try: activity = activity_repo.reset_retryable_failure(activity_id) except ValueError: return HTMLResponse("Activity is not retryable", status_code=409) user_id = activity.user_id try: outcome = await request.app.state.sync_manager.sync_user(user_id) except SyncAlreadyRunning: return HTMLResponse("Sync already running for this user", status_code=409) return templates.TemplateResponse( request, "fragments/sync_result.html", {"outcomes": [_normalize_outcome(outcome)]} ) @router.get("/system", response_class=HTMLResponse) def system_page(request: Request): require_admin(request) settings = request.app.state.settings scheduler = request.app.state.scheduler with request.app.state.session_factory() as session: user_count = len(UserRepository(session).list_all()) activity_count = session.scalar(select(func.count()).select_from(Activity)) or 0 log_entries = SystemLogRepository(session).list_recent(limit=50) scheduler_settings = SchedulerSettingsRepository(session).get_or_create( default_minutes=settings.sync_interval_minutes ) return templates.TemplateResponse(request, "system.html", { "csrf_token": ensure_csrf_token(request), "app_version": APP_VERSION, "last_tick": scheduler.last_tick, "next_tick": scheduler.next_tick, "user_count": user_count, "activity_count": activity_count, "log_entries": log_entries, "scheduler_settings": scheduler_settings, }) @router.post("/system/scheduler-settings") def update_scheduler_settings( request: Request, csrf_token: str = Form(...), day_start_hour: int = Form(...), night_start_hour: int = Form(...), day_interval_minutes: int = Form(...), night_interval_minutes: int = Form(...), ): require_admin(request) validate_csrf(request, csrf_token) if not (0 <= day_start_hour <= 23) or not (0 <= night_start_hour <= 23): raise HTTPException(status_code=400, detail="Hours must be between 0 and 23") if day_interval_minutes < 1 or night_interval_minutes < 1: raise HTTPException(status_code=400, detail="Intervals must be at least 1 minute") settings = request.app.state.settings with request.app.state.session_factory() as session: repository = SchedulerSettingsRepository(session) row = repository.get_or_create(default_minutes=settings.sync_interval_minutes) repository.update( row, day_start_hour=day_start_hour, night_start_hour=night_start_hour, day_interval_minutes=day_interval_minutes, night_interval_minutes=night_interval_minutes, ) return RedirectResponse("/system", status_code=303)