feat(backend): Phase 1-4 全新開發完成，37/37 TDD 通過

[Phase 0 Reset]
- 清除舊版 app/、alembic/versions/、雜亂測試腳本
- 新 requirements.txt (移除 caldav/redis/keycloak-lib，加入 apscheduler/croniter/docker/paramiko/ping3/dnspython)

[Phase 1 資料庫]
- 9 張資料表 SQLAlchemy Models：tenants / accounts / schedules / schedule_logs /
  tenant_schedule_results / account_schedule_results / servers / server_status_logs / system_status_logs
- Alembic migration 001_create_all_tables (已套用到 10.1.0.20:5433/virtual_mis)
- seed.py：schedules 初始 3 筆 / servers 初始 4 筆

[Phase 2 CRUD API]
- GET/POST/PUT/DELETE: /api/v1/tenants / accounts / servers / schedules
- /api/v1/system-status
- 帳號編碼自動產生 (prefix + seq_no 4碼左補0)
- 燈號 (lights) 從最新排程結果取得

[Phase 3 Watchdog]
- APScheduler interval 3分鐘，原子 UPDATE status=Going 防重複執行
- 手動觸發 API: POST /api/v1/schedules/{id}/run

[Phase 4 Service Clients]
- KeycloakClient：vmis-admin realm，REST API (不用 python-keycloak)
- MailClient：Docker Mailserver @ 10.1.0.254:8080，含 MX DNS 驗證
- DockerClient：docker-py 本機 + paramiko SSH 遠端 compose
- NextcloudClient：OCS API user/quota
- SystemChecker：功能驗證 (traefik routers>0 / keycloak token / SMTP EHLO / DB SELECT 1 / ping)

[TDD]
- 37 tests / 37 passed (2.11s)
- SQLite in-memory + StaticPool，無需外部 DB

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

backend/app/api/v1/accounts.py

@@ -0,0 +1,118 @@
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db
+from app.models.account import Account
+from app.models.tenant import Tenant
+from app.models.result import AccountScheduleResult
+from app.schemas.account import AccountCreate, AccountUpdate, AccountResponse, AccountStatusLight
+
+router = APIRouter(prefix="/accounts", tags=["accounts"])
+
+
+def _next_seq_no(db: Session, tenant_id: int) -> int:
+    max_seq = db.query(Account.seq_no).filter(Account.tenant_id == tenant_id).order_by(Account.seq_no.desc()).first()
+    return (max_seq[0] + 1) if max_seq else 1
+
+
+def _build_account_code(prefix: str, seq_no: int) -> str:
+    return f"{prefix}{str(seq_no).zfill(4)}"
+
+
+def _get_lights(db: Session, account_id: int) -> Optional[AccountStatusLight]:
+    result = (
+        db.query(AccountScheduleResult)
+        .filter(AccountScheduleResult.account_id == account_id)
+        .order_by(AccountScheduleResult.recorded_at.desc())
+        .first()
+    )
+    if not result:
+        return None
+    return AccountStatusLight(
+        sso_result=result.sso_result,
+        mailbox_result=result.mailbox_result,
+        nc_result=result.nc_result,
+        quota_usage=result.quota_usage,
+    )
+
+
+@router.get("", response_model=List[AccountResponse])
+def list_accounts(
+    tenant_id: Optional[int] = Query(None),
+    is_active: Optional[bool] = Query(None),
+    db: Session = Depends(get_db),
+):
+    q = db.query(Account)
+    if tenant_id is not None:
+        q = q.filter(Account.tenant_id == tenant_id)
+    if is_active is not None:
+        q = q.filter(Account.is_active == is_active)
+    accounts = q.order_by(Account.id).all()
+    result = []
+    for a in accounts:
+        resp = AccountResponse.model_validate(a)
+        resp.tenant_name = a.tenant.name if a.tenant else None
+        resp.lights = _get_lights(db, a.id)
+        result.append(resp)
+    return result
+
+
+@router.post("", response_model=AccountResponse, status_code=201)
+def create_account(payload: AccountCreate, db: Session = Depends(get_db)):
+    tenant = db.get(Tenant, payload.tenant_id)
+    if not tenant:
+        raise HTTPException(status_code=404, detail="Tenant not found")
+
+    seq_no = _next_seq_no(db, payload.tenant_id)
+    account_code = _build_account_code(tenant.prefix, seq_no)
+    email = f"{payload.sso_account}@{tenant.domain}"
+
+    account = Account(
+        **payload.model_dump(),
+        seq_no=seq_no,
+        account_code=account_code,
+        email=email,
+    )
+    db.add(account)
+    db.commit()
+    db.refresh(account)
+    resp = AccountResponse.model_validate(account)
+    resp.tenant_name = tenant.name
+    resp.lights = None
+    return resp
+
+
+@router.get("/{account_id}", response_model=AccountResponse)
+def get_account(account_id: int, db: Session = Depends(get_db)):
+    account = db.get(Account, account_id)
+    if not account:
+        raise HTTPException(status_code=404, detail="Account not found")
+    resp = AccountResponse.model_validate(account)
+    resp.tenant_name = account.tenant.name if account.tenant else None
+    resp.lights = _get_lights(db, account_id)
+    return resp
+
+
+@router.put("/{account_id}", response_model=AccountResponse)
+def update_account(account_id: int, payload: AccountUpdate, db: Session = Depends(get_db)):
+    account = db.get(Account, account_id)
+    if not account:
+        raise HTTPException(status_code=404, detail="Account not found")
+    for field, value in payload.model_dump(exclude_none=True).items():
+        setattr(account, field, value)
+    db.commit()
+    db.refresh(account)
+    resp = AccountResponse.model_validate(account)
+    resp.tenant_name = account.tenant.name if account.tenant else None
+    resp.lights = _get_lights(db, account_id)
+    return resp
+
+
+@router.delete("/{account_id}", status_code=204)
+def delete_account(account_id: int, db: Session = Depends(get_db)):
+    account = db.get(Account, account_id)
+    if not account:
+        raise HTTPException(status_code=404, detail="Account not found")
+    db.delete(account)
+    db.commit()

backend/app/api/v1/router.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+from app.api.v1 import tenants, accounts, schedules, servers, status
+
+api_router = APIRouter()
+api_router.include_router(tenants.router)
+api_router.include_router(accounts.router)
+api_router.include_router(schedules.router)
+api_router.include_router(servers.router)
+api_router.include_router(status.router)

backend/app/api/v1/schedules.py

@@ -0,0 +1,69 @@
+from typing import List
+from datetime import datetime
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
+from sqlalchemy.orm import Session
+from croniter import croniter
+
+from app.core.database import get_db
+from app.models.schedule import Schedule
+from app.schemas.schedule import ScheduleResponse, ScheduleUpdate, ScheduleLogResponse
+
+router = APIRouter(prefix="/schedules", tags=["schedules"])
+
+
+@router.get("", response_model=List[ScheduleResponse])
+def list_schedules(db: Session = Depends(get_db)):
+    return db.query(Schedule).order_by(Schedule.id).all()
+
+
+@router.get("/{schedule_id}", response_model=ScheduleResponse)
+def get_schedule(schedule_id: int, db: Session = Depends(get_db)):
+    s = db.get(Schedule, schedule_id)
+    if not s:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+    return s
+
+
+@router.put("/{schedule_id}", response_model=ScheduleResponse)
+def update_schedule_cron(schedule_id: int, payload: ScheduleUpdate, db: Session = Depends(get_db)):
+    s = db.get(Schedule, schedule_id)
+    if not s:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+    # Validate cron expression
+    try:
+        cron = croniter(payload.cron_timer, datetime.utcnow())
+        next_run = cron.get_next(datetime)
+    except Exception:
+        raise HTTPException(status_code=422, detail="Invalid cron expression")
+    s.cron_timer = payload.cron_timer
+    s.next_run_at = next_run
+    db.commit()
+    db.refresh(s)
+    return s
+
+
+@router.post("/{schedule_id}/run", status_code=202)
+def manual_run(schedule_id: int, background_tasks: BackgroundTasks, db: Session = Depends(get_db)):
+    """手動觸發排程（非同步執行）"""
+    s = db.get(Schedule, schedule_id)
+    if not s:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+    if s.status == "Going":
+        raise HTTPException(status_code=409, detail="Schedule is already running")
+
+    from app.services.scheduler.runner import dispatch_schedule
+    background_tasks.add_task(dispatch_schedule, schedule_id)
+    return {"message": f"Schedule '{s.name}' triggered", "schedule_id": schedule_id}
+
+
+@router.get("/{schedule_id}/logs", response_model=List[ScheduleLogResponse])
+def get_schedule_logs(schedule_id: int, limit: int = 20, db: Session = Depends(get_db)):
+    from app.models.schedule import ScheduleLog
+    logs = (
+        db.query(ScheduleLog)
+        .filter(ScheduleLog.schedule_id == schedule_id)
+        .order_by(ScheduleLog.started_at.desc())
+        .limit(limit)
+        .all()
+    )
+    return logs

backend/app/api/v1/servers.py

@@ -0,0 +1,104 @@
+from typing import List, Optional
+from datetime import datetime, timedelta
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy import func, case
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db
+from app.models.server import Server, ServerStatusLog
+from app.schemas.server import ServerCreate, ServerUpdate, ServerResponse, ServerAvailability
+
+router = APIRouter(prefix="/servers", tags=["servers"])
+
+
+def _calc_availability(db: Session, server_id: int, days: int) -> Optional[float]:
+    since = datetime.utcnow() - timedelta(days=days)
+    row = (
+        db.query(
+            func.count().label("total"),
+            func.sum(case((ServerStatusLog.result == True, 1), else_=0)).label("ok"),
+        )
+        .filter(ServerStatusLog.server_id == server_id, ServerStatusLog.recorded_at >= since)
+        .first()
+    )
+    if not row or not row.total:
+        return None
+    return round(row.ok * 100.0 / row.total, 2)
+
+
+def _get_last_status(db: Session, server_id: int):
+    return (
+        db.query(ServerStatusLog)
+        .filter(ServerStatusLog.server_id == server_id)
+        .order_by(ServerStatusLog.recorded_at.desc(), ServerStatusLog.id.desc())
+        .first()
+    )
+
+
+@router.get("", response_model=List[ServerResponse])
+def list_servers(db: Session = Depends(get_db)):
+    servers = db.query(Server).order_by(Server.sort_order).all()
+    result = []
+    for s in servers:
+        resp = ServerResponse.model_validate(s)
+        last = _get_last_status(db, s.id)
+        if last:
+            resp.last_result = last.result
+            resp.last_response_time = last.response_time
+        resp.availability = ServerAvailability(
+            availability_30d=_calc_availability(db, s.id, 30),
+            availability_90d=_calc_availability(db, s.id, 90),
+            availability_365d=_calc_availability(db, s.id, 365),
+        )
+        result.append(resp)
+    return result
+
+
+@router.post("", response_model=ServerResponse, status_code=201)
+def create_server(payload: ServerCreate, db: Session = Depends(get_db)):
+    if db.query(Server).filter(Server.ip_address == payload.ip_address).first():
+        raise HTTPException(status_code=409, detail="IP address already exists")
+    server = Server(**payload.model_dump())
+    db.add(server)
+    db.commit()
+    db.refresh(server)
+    return ServerResponse.model_validate(server)
+
+
+@router.get("/{server_id}", response_model=ServerResponse)
+def get_server(server_id: int, db: Session = Depends(get_db)):
+    server = db.get(Server, server_id)
+    if not server:
+        raise HTTPException(status_code=404, detail="Server not found")
+    resp = ServerResponse.model_validate(server)
+    last = _get_last_status(db, server_id)
+    if last:
+        resp.last_result = last.result
+        resp.last_response_time = last.response_time
+    resp.availability = ServerAvailability(
+        availability_30d=_calc_availability(db, server_id, 30),
+        availability_90d=_calc_availability(db, server_id, 90),
+        availability_365d=_calc_availability(db, server_id, 365),
+    )
+    return resp
+
+
+@router.put("/{server_id}", response_model=ServerResponse)
+def update_server(server_id: int, payload: ServerUpdate, db: Session = Depends(get_db)):
+    server = db.get(Server, server_id)
+    if not server:
+        raise HTTPException(status_code=404, detail="Server not found")
+    for field, value in payload.model_dump(exclude_none=True).items():
+        setattr(server, field, value)
+    db.commit()
+    db.refresh(server)
+    return ServerResponse.model_validate(server)
+
+
+@router.delete("/{server_id}", status_code=204)
+def delete_server(server_id: int, db: Session = Depends(get_db)):
+    server = db.get(Server, server_id)
+    if not server:
+        raise HTTPException(status_code=404, detail="Server not found")
+    db.delete(server)
+    db.commit()

backend/app/api/v1/status.py

@@ -0,0 +1,44 @@
+from typing import List
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+
+from app.core.database import get_db
+from app.models.server import SystemStatusLog
+
+router = APIRouter(tags=["status"])
+
+
+class SystemStatusItem(BaseModel):
+    id: int
+    environment: str
+    service_name: str
+    service_desc: Optional[str]
+    result: bool
+    fail_reason: Optional[str]
+    recorded_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+@router.get("/system-status", response_model=List[SystemStatusItem])
+def get_system_status(db: Session = Depends(get_db)):
+    """最新一次系統狀態 (8 筆: test/prod × traefik/keycloak/mail/db)"""
+    # Get latest schedule_log_id for schedule_id=3
+    from app.models.schedule import ScheduleLog
+    latest_log = (
+        db.query(ScheduleLog)
+        .filter(ScheduleLog.schedule_id == 3)
+        .order_by(ScheduleLog.started_at.desc())
+        .first()
+    )
+    if not latest_log:
+        return []
+    return (
+        db.query(SystemStatusLog)
+        .filter(SystemStatusLog.schedule_log_id == latest_log.id)
+        .all()
+    )

backend/app/api/v1/tenants.py

@@ -0,0 +1,94 @@
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy import text
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db
+from app.models.tenant import Tenant
+from app.models.result import TenantScheduleResult
+from app.schemas.tenant import TenantCreate, TenantUpdate, TenantResponse, TenantStatusLight
+
+router = APIRouter(prefix="/tenants", tags=["tenants"])
+
+
+def _get_lights(db: Session, tenant_id: int) -> Optional[TenantStatusLight]:
+    result = (
+        db.query(TenantScheduleResult)
+        .filter(TenantScheduleResult.tenant_id == tenant_id)
+        .order_by(TenantScheduleResult.recorded_at.desc())
+        .first()
+    )
+    if not result:
+        return None
+    return TenantStatusLight(
+        sso_result=result.sso_result,
+        mailbox_result=result.mailbox_result,
+        nc_result=result.nc_result,
+        office_result=result.office_result,
+        quota_usage=result.quota_usage,
+    )
+
+
+@router.get("", response_model=List[TenantResponse])
+def list_tenants(
+    is_active: Optional[bool] = Query(None),
+    db: Session = Depends(get_db),
+):
+    q = db.query(Tenant)
+    if is_active is not None:
+        q = q.filter(Tenant.is_active == is_active)
+    tenants = q.order_by(Tenant.id).all()
+    result = []
+    for t in tenants:
+        resp = TenantResponse.model_validate(t)
+        resp.lights = _get_lights(db, t.id)
+        result.append(resp)
+    return result
+
+
+@router.post("", response_model=TenantResponse, status_code=201)
+def create_tenant(payload: TenantCreate, db: Session = Depends(get_db)):
+    if db.query(Tenant).filter(Tenant.code == payload.code).first():
+        raise HTTPException(status_code=409, detail="Tenant code already exists")
+    if db.query(Tenant).filter(Tenant.domain == payload.domain).first():
+        raise HTTPException(status_code=409, detail="Domain already exists")
+    tenant = Tenant(**payload.model_dump())
+    db.add(tenant)
+    db.commit()
+    db.refresh(tenant)
+    resp = TenantResponse.model_validate(tenant)
+    resp.lights = None
+    return resp
+
+
+@router.get("/{tenant_id}", response_model=TenantResponse)
+def get_tenant(tenant_id: int, db: Session = Depends(get_db)):
+    tenant = db.get(Tenant, tenant_id)
+    if not tenant:
+        raise HTTPException(status_code=404, detail="Tenant not found")
+    resp = TenantResponse.model_validate(tenant)
+    resp.lights = _get_lights(db, tenant_id)
+    return resp
+
+
+@router.put("/{tenant_id}", response_model=TenantResponse)
+def update_tenant(tenant_id: int, payload: TenantUpdate, db: Session = Depends(get_db)):
+    tenant = db.get(Tenant, tenant_id)
+    if not tenant:
+        raise HTTPException(status_code=404, detail="Tenant not found")
+    for field, value in payload.model_dump(exclude_none=True).items():
+        setattr(tenant, field, value)
+    db.commit()
+    db.refresh(tenant)
+    resp = TenantResponse.model_validate(tenant)
+    resp.lights = _get_lights(db, tenant_id)
+    return resp
+
+
+@router.delete("/{tenant_id}", status_code=204)
+def delete_tenant(tenant_id: int, db: Session = Depends(get_db)):
+    tenant = db.get(Tenant, tenant_id)
+    if not tenant:
+        raise HTTPException(status_code=404, detail="Tenant not found")
+    db.delete(tenant)
+    db.commit()