fixtureqa 0.1.0__py3-none-any.whl

fixture/api/routers/sessions.py

@@ -0,0 +1,272 @@
+from typing import Annotated, Optional
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from ...core.session_manager import SessionManager
+from ...core.models import SessionConfig, ConnectionType, SessionRole
+from ...core.user_store import User, UserStore
+from ..schemas import SessionConfigRequest, SessionResponse, UpdateSessionRequest, SendMessageRequest, SeqNumRequest, SeqNumResponse
+from ..deps import get_session_manager, get_current_user, get_user_store
+
+router = APIRouter(tags=["sessions"])
+
+SM = Annotated[SessionManager, Depends(get_session_manager)]
+US = Annotated[UserStore, Depends(get_user_store)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+
+def _session_response(sm: SessionManager, session_id: str, us: Optional[UserStore] = None) -> SessionResponse:
+    cfg_list = [c for c in sm.list_sessions() if c.session_id == session_id]
+    if not cfg_list:
+        raise HTTPException(status_code=404, detail="Session not found")
+    cfg = cfg_list[0]
+    state = sm.get_state(session_id)
+    log = state.message_log
+    owner_username: Optional[str] = None
+    if us is not None:
+        owner = us.get_by_uid(cfg.owner_uid)
+        owner_username = owner.username if owner else None
+    return SessionResponse(
+        session_id=cfg.session_id,
+        display_name=cfg.display_name,
+        begin_string=cfg.begin_string,
+        sender_comp_id=cfg.sender_comp_id,
+        target_comp_id=cfg.target_comp_id,
+        connection_type=cfg.connection_type.value,
+        host=cfg.host,
+        port=cfg.port,
+        heartbeat_interval=cfg.heartbeat_interval,
+        reconnect_interval=cfg.reconnect_interval,
+        use_file_log=cfg.use_file_log,
+        start_time=cfg.start_time,
+        end_time=cfg.end_time,
+        reset_on_logon=cfg.reset_on_logon,
+        reset_on_logout=cfg.reset_on_logout,
+        session_role=cfg.session_role.value,
+        auto_ack=cfg.auto_ack,
+        auto_ack_delay_ms=cfg.auto_ack_delay_ms,
+        auto_fill=cfg.auto_fill,
+        auto_fill_delay_ms=cfg.auto_fill_delay_ms,
+        data_dictionary_path=cfg.data_dictionary_path,
+        status=state.status.name,
+        last_sent_seq_num=state.last_sent_seq_num,
+        last_recv_seq_num=state.last_recv_seq_num,
+        message_count=len(log) if log else 0,
+        status_changed_at=state.status_changed_at,
+        last_heartbeat_at=state.last_heartbeat_at,
+        owner_username=owner_username,
+    )
+
+
+def _check_ownership(sm: SessionManager, session_id: str, user: User) -> SessionConfig:
+    """Return the SessionConfig if the user owns it (or is admin). Raises 404/403 otherwise."""
+    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")
+    return cfg
+
+
+@router.get("/", response_model=list[SessionResponse])
+def list_sessions(sm: SM, us: US, user: CurrentUser):
+    configs = sm.list_sessions_for_user(user.uid, is_admin=user.is_admin)
+    user_store = us if user.is_admin else None
+    return [_session_response(sm, cfg.session_id, user_store) for cfg in configs]
+
+
+@router.post("/", response_model=SessionResponse, status_code=201)
+async def create_session(body: SessionConfigRequest, sm: SM, user: CurrentUser):
+    try:
+        ct = ConnectionType(body.connection_type)
+    except ValueError:
+        raise HTTPException(status_code=422, detail=f"Invalid connection_type: {body.connection_type!r}")
+    try:
+        role = SessionRole(body.session_role)
+    except ValueError:
+        raise HTTPException(status_code=422, detail=f"Invalid session_role: {body.session_role!r}")
+
+    cfg = SessionConfig(
+        display_name=body.display_name,
+        begin_string=body.begin_string,
+        sender_comp_id=body.sender_comp_id,
+        target_comp_id=body.target_comp_id,
+        connection_type=ct,
+        host=body.host,
+        port=body.port,
+        heartbeat_interval=body.heartbeat_interval,
+        reconnect_interval=body.reconnect_interval,
+        data_dictionary_path=body.data_dictionary_path,
+        use_file_log=body.use_file_log,
+        start_time=body.start_time,
+        end_time=body.end_time,
+        reset_on_logon=body.reset_on_logon,
+        reset_on_logout=body.reset_on_logout,
+        session_role=role,
+        auto_ack=body.auto_ack,
+        auto_ack_delay_ms=body.auto_ack_delay_ms,
+        auto_fill=body.auto_fill,
+        auto_fill_delay_ms=body.auto_fill_delay_ms,
+        owner_uid=user.uid,
+    )
+
+    try:
+        session_id = sm.add_session(cfg)
+    except (ValueError, KeyError) as e:
+        raise HTTPException(status_code=422, detail=str(e))
+
+    if body.auto_start:
+        try:
+            await sm.start_session(session_id)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Session added but failed to start: {e}")
+
+    return _session_response(sm, session_id)
+
+
+@router.post("/import", response_model=list[SessionResponse], status_code=201)
+def import_sessions(body: list[SessionConfigRequest], sm: SM, user: CurrentUser):
+    """
+    Bulk-create sessions from an exported config file.
+    Each entry is processed independently; invalid entries are skipped.
+    Returns the list of successfully created sessions.
+    """
+    created = []
+    for item in body:
+        try:
+            ct = ConnectionType(item.connection_type)
+            role = SessionRole(item.session_role)
+            cfg = SessionConfig(
+                display_name=item.display_name,
+                begin_string=item.begin_string,
+                sender_comp_id=item.sender_comp_id,
+                target_comp_id=item.target_comp_id,
+                connection_type=ct,
+                host=item.host,
+                port=item.port,
+                heartbeat_interval=item.heartbeat_interval,
+                reconnect_interval=item.reconnect_interval,
+                data_dictionary_path=item.data_dictionary_path,
+                use_file_log=item.use_file_log,
+                start_time=item.start_time,
+                end_time=item.end_time,
+                reset_on_logon=item.reset_on_logon,
+                reset_on_logout=item.reset_on_logout,
+                session_role=role,
+                auto_ack=item.auto_ack,
+                auto_ack_delay_ms=item.auto_ack_delay_ms,
+                auto_fill=item.auto_fill,
+                auto_fill_delay_ms=item.auto_fill_delay_ms,
+                owner_uid=user.uid,
+            )
+            session_id = sm.add_session(cfg)
+            created.append(_session_response(sm, session_id))
+        except Exception:
+            pass  # skip invalid / conflicting entries
+    return created
+
+
+@router.get("/{session_id}", response_model=SessionResponse)
+def get_session(session_id: str, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    return _session_response(sm, session_id)
+
+
+@router.patch("/{session_id}", response_model=SessionResponse)
+def update_session(session_id: str, body: UpdateSessionRequest, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    try:
+        sm.update_session(session_id, body)
+    except RuntimeError as e:
+        raise HTTPException(status_code=409, detail=str(e))
+    except (ValueError, KeyError) as e:
+        raise HTTPException(status_code=422, detail=str(e))
+    return _session_response(sm, session_id)
+
+
+@router.delete("/{session_id}", status_code=204)
+async def remove_session(session_id: str, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    try:
+        await sm.remove_session(session_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Session not found")
+
+
+@router.post("/{session_id}/start", response_model=SessionResponse)
+async def start_session(session_id: str, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    try:
+        await sm.start_session(session_id)
+    except RuntimeError as e:
+        raise HTTPException(status_code=409, detail=str(e))
+    return _session_response(sm, session_id)
+
+
+@router.post("/{session_id}/stop", response_model=SessionResponse)
+async def stop_session(
+    session_id: str,
+    sm: SM,
+    user: CurrentUser,
+    force: bool = Query(default=False),
+):
+    _check_ownership(sm, session_id, user)
+    await sm.stop_session(session_id, force=force)
+    return _session_response(sm, session_id)
+
+
+@router.post("/{session_id}/send")
+async def send_message(session_id: str, body: SendMessageRequest, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    from ...core.fix_parser import parse_raw
+    from fixcore.message.message import Message
+    from datetime import datetime, timezone
+
+    raw = body.raw
+    if "\x01" not in raw:
+        raw = raw.replace("|", "\x01")
+
+    fields = parse_raw(raw)  # {tag_int: value_str}
+    msg_type = fields.get(35)
+    if not msg_type:
+        raise HTTPException(status_code=422, detail="Missing MsgType (tag 35)")
+
+    if not body.no_auto_ts and 60 not in fields:
+        fields[60] = datetime.now(timezone.utc).strftime("%Y%m%d-%H:%M:%S")
+
+    SKIP = {8, 9, 10, 34, 35, 49, 52, 56}
+    msg = Message()
+    msg.header.set(35, msg_type)
+    for tag, value in fields.items():
+        if tag not in SKIP:
+            try:
+                msg.set_field(int(tag), str(value))
+            except Exception:
+                pass
+
+    ok = await sm.send_message(session_id, msg)
+    if not ok:
+        raise HTTPException(status_code=409, detail="Session not logged on")
+    return {"ok": True}
+
+
+@router.get("/{session_id}/seqnums", response_model=SeqNumResponse)
+def get_seqnums(session_id: str, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    try:
+        sender, target = sm.get_seqnums(session_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return SeqNumResponse(sender=sender, target=target)
+
+
+@router.patch("/{session_id}/seqnums", response_model=SeqNumResponse)
+def set_seqnums(session_id: str, body: SeqNumRequest, sm: SM, user: CurrentUser):
+    _check_ownership(sm, session_id, user)
+    if body.sender is None and body.target is None:
+        raise HTTPException(status_code=422, detail="Provide sender, target, or both")
+    try:
+        sender, target = sm.set_seqnums(session_id, body.sender, body.target)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return SeqNumResponse(sender=sender, target=target)

fixture/api/routers/setup.py

@@ -0,0 +1,42 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from ...core.auth import hash_password
+from ...core.user_store import UserStore
+from ..deps import get_user_store
+from ..schemas import CreateAdminRequest, SetupStatusResponse, TokenResponse, UserResponse
+from ...core.auth import create_token
+
+router = APIRouter(tags=["setup"])
+
+US = Annotated[UserStore, Depends(get_user_store)]
+
+
+@router.get("/status", response_model=SetupStatusResponse)
+def setup_status(us: US):
+    return SetupStatusResponse(setup_required=not us.has_any_users())
+
+
+@router.post("/create-admin", response_model=TokenResponse, status_code=201)
+def create_admin(body: CreateAdminRequest, us: US):
+    if us.has_any_users():
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Setup already complete",
+        )
+    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")
+
+    user = us.create_user(
+        username=body.username,
+        password_hash=hash_password(body.password),
+        role="platform_admin",
+    )
+    token = create_token(user)
+    return TokenResponse(
+        access_token=token,
+        user=UserResponse(uid=user.uid, username=user.username, role=user.role),
+    )

fixture/api/routers/templates.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+
+from ...core.template_store import TemplateStore
+from ...core.user_store import User
+from ..deps import get_current_user, get_template_store
+from ..schemas import TemplateRequest, TemplateResponse
+
+router = APIRouter(tags=["templates"])
+
+TS = Depends(get_template_store)
+CurrentUser = Depends(get_current_user)
+
+
+@router.get("", response_model=list[TemplateResponse])
+def list_templates(store: TemplateStore = TS, user: User = CurrentUser):
+    return store.list_templates(user.uid)
+
+
+@router.post("", response_model=TemplateResponse, status_code=status.HTTP_201_CREATED)
+def create_template(body: TemplateRequest, store: TemplateStore = TS, user: User = CurrentUser):
+    return store.create_template(user.uid, body.model_dump())
+
+
+@router.put("/{template_id}", response_model=TemplateResponse)
+def update_template(template_id: str, body: TemplateRequest, store: TemplateStore = TS, user: User = CurrentUser):
+    updated = store.update_template(user.uid, template_id, body.model_dump())
+    if updated is None:
+        raise HTTPException(status_code=404, detail="Template not found")
+    return updated
+
+
+@router.delete("/{template_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_template(template_id: str, store: TemplateStore = TS, user: User = CurrentUser):
+    if not store.delete_template(user.uid, template_id):
+        raise HTTPException(status_code=404, detail="Template not found")
+    return Response(status_code=status.HTTP_204_NO_CONTENT)

fixture/api/routers/ws.py

@@ -0,0 +1,129 @@
+import asyncio
+from typing import Annotated, Optional
+
+from fastapi import APIRouter, Depends, Query, WebSocket, WebSocketDisconnect
+from jose import JWTError
+
+from ...core.session_manager import SessionManager
+from ..connection_manager import ConnectionManager
+from ..deps import get_session_manager, get_conn_manager
+from ...core.auth import decode_token
+from ...core.user_store import UserStore
+
+router = APIRouter(tags=["websocket"])
+
+SM = Annotated[SessionManager, Depends(get_session_manager)]
+CM = Annotated[ConnectionManager, Depends(get_conn_manager)]
+
+
+async def _send_snapshot(websocket: WebSocket, sm: SessionManager, uid: str, is_admin: bool, session_id: str = "*") -> None:
+    """Send current state of all (or one) session(s) immediately on connect."""
+    configs = sm.list_sessions_for_user(uid, is_admin=is_admin)
+    if session_id != "*":
+        configs = [c for c in configs if c.session_id == session_id]
+
+    for cfg in configs:
+        state = sm.get_state(cfg.session_id)
+        log = state.message_log
+        await websocket.send_json({
+            "type": "session_status",
+            "session_id": cfg.session_id,
+            "status": state.status.name,
+            "last_sent_seq_num": state.last_sent_seq_num,
+            "last_recv_seq_num": state.last_recv_seq_num,
+            "message_count": len(log) if log else 0,
+            "status_changed_at": state.status_changed_at,
+            "last_heartbeat_at": state.last_heartbeat_at,
+        })
+
+
+def _authenticate_ws(websocket: WebSocket, token: Optional[str]) -> tuple[str, bool]:
+    """Validate JWT token from query param. Returns (uid, is_admin) or closes with 403."""
+    if not token:
+        return None, False
+    try:
+        payload = decode_token(token)
+        uid = payload.get("sub", "")
+        role = payload.get("role", "")
+        if not uid:
+            return None, False
+        return uid, role == "platform_admin"
+    except JWTError:
+        return None, False
+
+
+@router.websocket("/ws")
+async def ws_all_sessions(
+    websocket: WebSocket,
+    sm: SM,
+    conn_mgr: CM,
+    token: Optional[str] = Query(default=None),
+):
+    """Subscribe to events from all sessions."""
+    uid, is_admin = _authenticate_ws(websocket, token)
+    if not uid:
+        await websocket.close(code=4003, reason="Unauthorized")
+        return
+
+    # Also validate user is still active
+    store: UserStore = websocket.app.state.user_store
+    user = store.get_by_uid(uid)
+    if user is None or not user.is_active:
+        await websocket.close(code=4003, reason="Unauthorized")
+        return
+
+    await conn_mgr.connect(websocket, session_id="*", uid=uid, is_admin=is_admin)
+    try:
+        await _send_snapshot(websocket, sm, uid, is_admin)
+        while True:
+            await asyncio.sleep(15)
+            try:
+                await websocket.send_json({"type": "ping"})
+            except Exception:
+                break
+    except WebSocketDisconnect:
+        pass
+    finally:
+        conn_mgr.disconnect(websocket, session_id="*")
+
+
+@router.websocket("/ws/{session_id}")
+async def ws_single_session(
+    websocket: WebSocket,
+    session_id: str,
+    sm: SM,
+    conn_mgr: CM,
+    token: Optional[str] = Query(default=None),
+):
+    """Subscribe to events from a single session."""
+    uid, is_admin = _authenticate_ws(websocket, token)
+    if not uid:
+        await websocket.close(code=4003, reason="Unauthorized")
+        return
+
+    store: UserStore = websocket.app.state.user_store
+    user = store.get_by_uid(uid)
+    if user is None or not user.is_active:
+        await websocket.close(code=4003, reason="Unauthorized")
+        return
+
+    # Check ownership of this specific session
+    configs = sm.list_sessions()
+    cfg = next((c for c in configs if c.session_id == session_id), None)
+    if cfg is None or (not is_admin and cfg.owner_uid != uid):
+        await websocket.close(code=4003, reason="Access denied")
+        return
+
+    await conn_mgr.connect(websocket, session_id=session_id, uid=uid, is_admin=is_admin)
+    try:
+        await _send_snapshot(websocket, sm, uid, is_admin, session_id=session_id)
+        while True:
+            await asyncio.sleep(15)
+            try:
+                await websocket.send_json({"type": "ping"})
+            except Exception:
+                break
+    except WebSocketDisconnect:
+        pass
+    finally:
+        conn_mgr.disconnect(websocket, session_id=session_id)