fixtureqa 0.1.0__py3-none-any.whl

fixture/api/routers/admin.py

@@ -0,0 +1,178 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from ...core.auth import hash_password
+from ...core.housekeeping import HousekeepingService
+from ...core.user_store import UserStore
+from ..deps import get_housekeeping, get_user_store, require_platform_admin
+from ..schemas import (
+    AdminSettingsRequest,
+    BrandingRequest,
+    BrandingResponse,
+    CreateUserRequest,
+    HousekeepingRunResponse,
+    HousekeepingSettingsRequest,
+    HousekeepingSettingsResponse,
+    RegistrationStatusResponse,
+    UpdateUserRequest,
+    UserDetailResponse,
+)
+from .branding import _branding_response
+
+router = APIRouter(tags=["admin"])
+
+US = Annotated[UserStore, Depends(get_user_store)]
+HK = Annotated[HousekeepingService, Depends(get_housekeeping)]
+Admin = Annotated[object, Depends(require_platform_admin)]
+
+_VALID_ROLES = {"user", "user_admin", "platform_admin"}
+
+
+def _user_detail(user) -> UserDetailResponse:
+    return UserDetailResponse(
+        uid=user.uid,
+        username=user.username,
+        role=user.role,
+        is_active=user.is_active,
+        created_at=user.created_at,
+    )
+
+
+@router.get("/users", response_model=list[UserDetailResponse])
+def list_users(us: US, _admin=Depends(require_platform_admin)):
+    return [_user_detail(u) for u in us.list_users()]
+
+
+@router.post("/users", response_model=UserDetailResponse, status_code=201)
+def create_user(body: CreateUserRequest, us: US, _admin=Depends(require_platform_admin)):
+    if body.role not in _VALID_ROLES:
+        raise HTTPException(status_code=422, detail=f"Invalid role: {body.role!r}")
+    if len(body.password) < 8:
+        raise HTTPException(status_code=422, detail="Password must be at least 8 characters")
+    if us.get_by_username(body.username):
+        raise HTTPException(status_code=409, detail="Username already taken")
+    user = us.create_user(body.username, hash_password(body.password), role=body.role)
+    return _user_detail(user)
+
+
+@router.patch("/users/{uid}", response_model=UserDetailResponse)
+def update_user(uid: str, body: UpdateUserRequest, us: US, admin=Depends(require_platform_admin)):
+    target = us.get_by_uid(uid)
+    if target is None:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    fields: dict = {}
+    if body.is_active is not None:
+        # Prevent admin from deactivating their own account
+        if not body.is_active and uid == admin.uid:
+            raise HTTPException(status_code=400, detail="Cannot deactivate your own account")
+        fields["is_active"] = body.is_active
+    if body.role is not None:
+        if body.role not in _VALID_ROLES:
+            raise HTTPException(status_code=422, detail=f"Invalid role: {body.role!r}")
+        fields["role"] = body.role
+    if body.password is not None:
+        if len(body.password) < 8:
+            raise HTTPException(status_code=422, detail="Password must be at least 8 characters")
+        fields["password_hash"] = hash_password(body.password)
+
+    updated = us.update_user(uid, **fields)
+    return _user_detail(updated)
+
+
+@router.delete("/users/{uid}", status_code=204)
+def delete_user(uid: str, us: US, admin=Depends(require_platform_admin)):
+    if uid == admin.uid:
+        raise HTTPException(status_code=400, detail="Cannot delete your own account")
+    if us.get_by_uid(uid) is None:
+        raise HTTPException(status_code=404, detail="User not found")
+    us.delete_user(uid)
+
+
+@router.get("/settings", response_model=RegistrationStatusResponse)
+def get_settings(us: US, _admin=Depends(require_platform_admin)):
+    return RegistrationStatusResponse(
+        enabled=us.get_setting("registration_enabled", "0") == "1",
+        max_users=int(us.get_setting("max_users", "50")),
+        current_users=us.count_users(),
+    )
+
+
+@router.patch("/settings", response_model=RegistrationStatusResponse)
+def update_settings(body: AdminSettingsRequest, us: US, _admin=Depends(require_platform_admin)):
+    if body.registration_enabled is not None:
+        us.set_setting("registration_enabled", "1" if body.registration_enabled else "0")
+    if body.max_users is not None:
+        if body.max_users < 1:
+            raise HTTPException(status_code=422, detail="max_users must be at least 1")
+        us.set_setting("max_users", str(body.max_users))
+    return RegistrationStatusResponse(
+        enabled=us.get_setting("registration_enabled", "0") == "1",
+        max_users=int(us.get_setting("max_users", "50")),
+        current_users=us.count_users(),
+    )
+
+
+def _housekeeping_response(us: UserStore) -> HousekeepingSettingsResponse:
+    return HousekeepingSettingsResponse(
+        enabled=us.get_setting("housekeeping_enabled", "1") == "1",
+        msg_retention_days=int(us.get_setting("msg_retention_days", "90")),
+        log_retention_days=int(us.get_setting("log_retention_days", "30")),
+    )
+
+
+@router.get("/housekeeping", response_model=HousekeepingSettingsResponse)
+def get_housekeeping_settings(us: US, _admin=Depends(require_platform_admin)):
+    return _housekeeping_response(us)
+
+
+@router.patch("/housekeeping", response_model=HousekeepingSettingsResponse)
+def update_housekeeping_settings(
+    body: HousekeepingSettingsRequest, us: US, _admin=Depends(require_platform_admin)
+):
+    if body.enabled is not None:
+        us.set_setting("housekeeping_enabled", "1" if body.enabled else "0")
+    if body.msg_retention_days is not None:
+        us.set_setting("msg_retention_days", str(body.msg_retention_days))
+    if body.log_retention_days is not None:
+        us.set_setting("log_retention_days", str(body.log_retention_days))
+    return _housekeeping_response(us)
+
+
+@router.post("/housekeeping/run", response_model=HousekeepingRunResponse)
+def run_housekeeping(hk: HK, _admin=Depends(require_platform_admin)):
+    result = hk.run_now()
+    return HousekeepingRunResponse(**result)
+
+
+_MAX_BRANDING_FIELD_BYTES = 2 * 1024 * 1024  # 2 MB
+
+
+@router.get("/branding", response_model=BrandingResponse)
+def get_branding_settings(us: US, _admin=Depends(require_platform_admin)):
+    return _branding_response(us)
+
+
+@router.patch("/branding", response_model=BrandingResponse)
+def update_branding_settings(body: BrandingRequest, us: US, _admin=Depends(require_platform_admin)):
+    for field in ("logo_dark", "logo_light", "favicon"):
+        val = getattr(body, field)
+        if val is not None and len(val.encode()) > _MAX_BRANDING_FIELD_BYTES:
+            raise HTTPException(status_code=422, detail=f"{field} exceeds 2 MB limit")
+    for key, val in (
+        ("branding_prefix",  body.prefix.strip()  if body.prefix  is not None else None),
+        ("branding_accent",  body.accent.strip()  if body.accent  is not None else None),
+        ("branding_bg",      body.bg.strip()      if body.bg      is not None else None),
+        ("branding_bg2",     body.bg2.strip()     if body.bg2     is not None else None),
+        ("branding_bg3",     body.bg3.strip()     if body.bg3     is not None else None),
+        ("branding_border",  body.border.strip()  if body.border  is not None else None),
+        ("branding_text",    body.text.strip()    if body.text    is not None else None),
+        ("branding_text2",   body.text2.strip()   if body.text2   is not None else None),
+        ("branding_logo_dark",  body.logo_dark),
+        ("branding_logo_light", body.logo_light),
+        ("branding_favicon",    body.favicon),
+    ):
+        if val is not None:
+            us.set_setting(key, val)
+    return _branding_response(us)

fixture/api/routers/auth.py

@@ -0,0 +1,74 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from ...core.auth import create_token, hash_password, verify_password
+from ...core.user_store import User, UserStore
+from ..deps import get_current_user, get_user_store
+from ..schemas import (
+    LoginRequest,
+    RegisterRequest,
+    RegistrationStatusResponse,
+    TokenResponse,
+    UserResponse,
+)
+
+router = APIRouter(tags=["auth"])
+
+US = Annotated[UserStore, Depends(get_user_store)]
+
+
+@router.post("/login", response_model=TokenResponse)
+def login(body: LoginRequest, us: US):
+    user = us.get_by_username(body.username)
+    if user is None or not user.is_active or not verify_password(body.password, user.password_hash):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid username or password",
+        )
+    token = create_token(user)
+    return TokenResponse(
+        access_token=token,
+        user=UserResponse(uid=user.uid, username=user.username, role=user.role),
+    )
+
+
+@router.get("/me", response_model=UserResponse)
+def me(user: User = Depends(get_current_user)):
+    return UserResponse(uid=user.uid, username=user.username, role=user.role)
+
+
+@router.get("/register/status", response_model=RegistrationStatusResponse)
+def register_status(us: US):
+    return RegistrationStatusResponse(
+        enabled=us.get_setting("registration_enabled", "0") == "1",
+        max_users=int(us.get_setting("max_users", "50")),
+        current_users=us.count_users(),
+    )
+
+
+@router.post("/register", response_model=TokenResponse, status_code=201)
+def register(body: RegisterRequest, us: US):
+    if us.get_setting("registration_enabled", "0") != "1":
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Registration is currently closed",
+        )
+    max_users = int(us.get_setting("max_users", "50"))
+    if us.count_users() >= max_users:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Registration limit reached",
+        )
+    if not body.username or not body.password:
+        raise HTTPException(status_code=422, detail="Username and password are required")
+    if len(body.password) < 8:
+        raise HTTPException(status_code=422, detail="Password must be at least 8 characters")
+    if us.get_by_username(body.username):
+        raise HTTPException(status_code=409, detail="Username already taken")
+    user = us.create_user(body.username, hash_password(body.password), role="user")
+    token = create_token(user)
+    return TokenResponse(
+        access_token=token,
+        user=UserResponse(uid=user.uid, username=user.username, role=user.role),
+    )

fixture/api/routers/branding.py

@@ -0,0 +1,33 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
+
+from ...core.user_store import UserStore
+from ..deps import get_user_store
+from ..schemas import BrandingResponse
+
+router = APIRouter(tags=["branding"])
+
+US = Annotated[UserStore, Depends(get_user_store)]
+
+
+def _branding_response(us: UserStore) -> BrandingResponse:
+    return BrandingResponse(
+        prefix=us.get_setting("branding_prefix", ""),
+        accent=us.get_setting("branding_accent", ""),
+        bg=us.get_setting("branding_bg", ""),
+        bg2=us.get_setting("branding_bg2", ""),
+        bg3=us.get_setting("branding_bg3", ""),
+        border=us.get_setting("branding_border", ""),
+        text=us.get_setting("branding_text", ""),
+        text2=us.get_setting("branding_text2", ""),
+        logo_dark=us.get_setting("branding_logo_dark", ""),
+        logo_light=us.get_setting("branding_logo_light", ""),
+        favicon=us.get_setting("branding_favicon", ""),
+    )
+
+
+@router.get("/branding", response_model=BrandingResponse)
+def get_branding(us: US):
+    """Public endpoint — no auth required (needed for login page styling)."""
+    return _branding_response(us)

fixture/api/routers/fix_spec.py

@@ -0,0 +1,41 @@
+from fastapi import APIRouter, HTTPException, Query
+
+from ...core.fix_spec_parser import get_messages, get_message
+from ..schemas import MessageSummaryResponse, MessageDefResponse, FieldRefResponse
+
+router = APIRouter(tags=["fix-spec"])
+
+SUPPORTED = {"FIX.4.2", "FIX.4.4"}
+
+
+def _validate_begin_string(begin_string: str) -> None:
+    if begin_string not in SUPPORTED:
+        raise HTTPException(status_code=400, detail=f"Unsupported begin_string '{begin_string}'. Use: {sorted(SUPPORTED)}")
+
+
+@router.get("/messages", response_model=list[MessageSummaryResponse])
+def list_messages(begin_string: str = Query("FIX.4.2")):
+    _validate_begin_string(begin_string)
+    return [
+        MessageSummaryResponse(msg_type=m.msg_type, name=m.name, category=m.category)
+        for m in get_messages(begin_string)
+    ]
+
+
+@router.get("/messages/{msg_type}", response_model=MessageDefResponse)
+def get_message_def(msg_type: str, begin_string: str = Query("FIX.4.2")):
+    _validate_begin_string(begin_string)
+    msg = get_message(begin_string, msg_type)
+    if msg is None:
+        raise HTTPException(status_code=404, detail=f"Message type '{msg_type}' not found in {begin_string}")
+    return MessageDefResponse(
+        msg_type=msg.msg_type,
+        name=msg.name,
+        category=msg.category,
+        fields=[
+            FieldRefResponse(
+                tag=f.tag, name=f.name, type=f.type, required=f.required, values=f.values
+            )
+            for f in msg.fields
+        ],
+    )

fixture/api/routers/messages.py

@@ -0,0 +1,137 @@
+import csv
+import io
+from typing import Annotated, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi.responses import StreamingResponse
+
+from ...core.session_manager import SessionManager
+from ...core.user_store import User
+from ..schemas import MessageEntryResponse
+from ..deps import get_session_manager, get_current_user
+
+router = APIRouter(tags=["messages"])
+
+SM = Annotated[SessionManager, Depends(get_session_manager)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+
+def _check_ownership(sm: SessionManager, session_id: str, user: User) -> None:
+    configs = sm.list_sessions()
+    cfg = next((c for c in configs if c.session_id == session_id), None)
+    if cfg is None:
+        raise HTTPException(status_code=404, detail="Session not found")
+    if not user.is_admin and cfg.owner_uid != user.uid:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+
+@router.get("/{session_id}/messages", response_model=list[MessageEntryResponse])
+def get_messages(
+    session_id: str,
+    sm: SM,
+    user: CurrentUser,
+    direction: Optional[str] = Query(default=None, description="IN or OUT"),
+    admin: Optional[bool] = Query(default=None),
+    msg_type: Optional[str] = Query(default=None),
+    limit: int = Query(default=200, ge=1, le=5000),
+    before_id: Optional[int] = Query(default=None, description="Cursor: return rows with id < before_id"),
+):
+    _check_ownership(sm, session_id, user)
+    try:
+        state = sm.get_state(session_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    log = state.message_log
+    if log is None:
+        return []
+
+    entries = log.get_entries(
+        direction=direction,
+        admin=admin,
+        msg_type=msg_type,
+        limit=limit,
+        before_id=before_id,
+    )
+
+    return [
+        MessageEntryResponse(
+            id=e.id,
+            direction=e.direction,
+            admin=e.admin,
+            seq_num=e.seq_num,
+            msg_type=e.msg_type,
+            msg_type_name=e.msg_type_name,
+            ts=e.timestamp.isoformat(),
+            fields={str(k): v for k, v in e.fields.items()},
+            raw=e.raw,
+        )
+        for e in entries
+    ]
+
+
+@router.get("/{session_id}/messages/export")
+def export_messages(
+    session_id: str,
+    sm: SM,
+    user: CurrentUser,
+    fmt: str = Query(default="csv", description="Export format: csv or fix"),
+):
+    _check_ownership(sm, session_id, user)
+    try:
+        state = sm.get_state(session_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+    log = state.message_log
+    entries = log.get_entries() if log is not None else []
+
+    safe_id = session_id.replace("/", "_")
+
+    if fmt == "fix":
+        def generate_fix():
+            for e in entries:
+                yield e.raw.replace("\x01", "|") + "\n"
+
+        return StreamingResponse(
+            generate_fix(),
+            media_type="text/plain",
+            headers={"Content-Disposition": f'attachment; filename="{safe_id}.fix"'},
+        )
+
+    # Default: CSV
+    def generate_csv():
+        buf = io.StringIO()
+        writer = csv.writer(buf)
+        writer.writerow(["id", "ts", "direction", "admin", "seq_num", "msg_type", "msg_type_name", "raw"])
+        yield buf.getvalue()
+        for e in entries:
+            buf = io.StringIO()
+            writer = csv.writer(buf)
+            writer.writerow([
+                e.id,
+                e.timestamp.isoformat(),
+                e.direction,
+                "Y" if e.admin else "N",
+                e.seq_num,
+                e.msg_type,
+                e.msg_type_name,
+                e.raw.replace("\x01", "|"),
+            ])
+            yield buf.getvalue()
+
+    return StreamingResponse(
+        generate_csv(),
+        media_type="text/csv",
+        headers={"Content-Disposition": f'attachment; filename="{safe_id}.csv"'},
+    )
+
+
+@router.delete("/{session_id}/messages", status_code=204)
+def clear_messages(session_id: str, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    try:
+        state = sm.get_state(session_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Session not found")
+    if state.message_log:
+        state.message_log.clear()

fixture/api/routers/scenarios.py

@@ -0,0 +1,65 @@
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from typing import Annotated
+
+from ...core.scenario_store import ScenarioStore
+from ...core.scenario_runner import ScenarioRunner
+from ...core.user_store import User
+from ..deps import get_current_user, get_scenario_store, get_scenario_runner
+from ..schemas import ScenarioRequest, ScenarioResponse
+
+router = APIRouter(tags=["scenarios"])
+
+SS = Depends(get_scenario_store)
+SR = Depends(get_scenario_runner)
+CurrentUser = Depends(get_current_user)
+
+
+@router.get("", response_model=list[ScenarioResponse])
+def list_scenarios(store: ScenarioStore = SS, user: User = CurrentUser):
+    return store.list_scenarios(user.uid)
+
+
+@router.post("", response_model=ScenarioResponse, status_code=status.HTTP_201_CREATED)
+def create_scenario(body: ScenarioRequest, store: ScenarioStore = SS, user: User = CurrentUser):
+    data = body.model_dump()
+    return store.create_scenario(user.uid, data)
+
+
+@router.put("/{scenario_id}", response_model=ScenarioResponse)
+def update_scenario(
+    scenario_id: str,
+    body: ScenarioRequest,
+    store: ScenarioStore = SS,
+    user: User = CurrentUser,
+):
+    updated = store.update_scenario(user.uid, scenario_id, body.model_dump())
+    if updated is None:
+        raise HTTPException(status_code=404, detail="Scenario not found")
+    return updated
+
+
+@router.delete("/{scenario_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_scenario(scenario_id: str, store: ScenarioStore = SS, user: User = CurrentUser):
+    if not store.delete_scenario(user.uid, scenario_id):
+        raise HTTPException(status_code=404, detail="Scenario not found")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+
+@router.post("/{scenario_id}/run")
+def run_scenario(
+    scenario_id: str,
+    store: ScenarioStore = SS,
+    runner: ScenarioRunner = SR,
+    user: User = CurrentUser,
+):
+    scenario = store.get_scenario(user.uid, scenario_id)
+    if scenario is None:
+        raise HTTPException(status_code=404, detail="Scenario not found")
+    run_id = runner.run(scenario, user.uid)
+    return {"run_id": run_id}
+
+
+@router.delete("/runs/{run_id}", status_code=status.HTTP_204_NO_CONTENT)
+def abort_run(run_id: str, runner: ScenarioRunner = SR, user: User = CurrentUser):
+    runner.abort(run_id)
+    return Response(status_code=status.HTTP_204_NO_CONTENT)