Persist dashboard risk history and expose case-management APIs; wire dashboard/cases UI to backend data

[Copilot]

The dashboard was effectively stateless: it only showed transient websocket events, so initial page loads appeared empty and case management used hardcoded data. This change adds server-side event/case persistence in dashboard-api and switches dashboard/cases UI to hydrate from REST APIs while keeping live stream updates.

• Backend: history + stats APIs in dashboard-api

  • Added in-memory risk event history ingestion from Kafka consumer path.
  • Added GET /api/history/recent-alerts to return latest non-APPROVE events.
  • Added GET /api/history/dashboard-stats to compute aggregate metrics (liveEvents, fraudRate, activeAlerts, etc.) from persisted history.

• Backend: case lifecycle APIs

  • Added in-memory case store keyed by transaction/event ingestion.
  • Auto-creates cases for REVIEW/REJECT events.
  • Added GET /api/cases and PATCH /api/cases/{case_id} for listing and status updates.

• Frontend: dashboard hydration + live stream coexistence

  • Dashboard.tsx now fetches historical alerts/stats on mount, then continues real-time updates via websocket.
  • Replaced hardcoded localhost URLs with env-configurable endpoints (VITE_API_BASE_URL, VITE_WS_URL fallback behavior).

• Frontend: cases page backed by API

  • Cases.tsx now loads case rows from GET /api/cases instead of static mock data.
  • Added status actions using PATCH /api/cases/{id} with response-aware refresh behavior.

• Targeted API contract coverage

  • Replaced placeholder dashboard-api test with focused tests for:
    • recent alerts + dashboard stats calculations
    • case listing and case status transitions via PATCH

# dashboard-api ingestion now powers both history and case state
def ingest_risk_event(payload: dict):
    event = dict(payload)
    risk_history.append(event)

    if str(event.get("decision", "APPROVE")).upper() in {"REVIEW", "REJECT"}:
        # create/update case in cases_store
        ...
    return event

Original prompt

complete the remaining tasks

[Chronological Review: The conversation began with the user encountering a `ModuleNotFoundError` when trying to run an integration test due to a missing `httpx` module. The user then expressed concerns about the dashboard not being fully integrated with Kafka, leading to an empty dashboard. The user described issues with the dashboard displaying transactions only temporarily and not storing them, prompting a detailed diagnosis of three main problems related to the dashboard's functionality. The conversation included proposed solutions for each problem, focusing on enhancing the dashboard's data persistence and case management features. The user requested to continue and commit changes, indicating a desire to finalize the discussed improvements.]

[Intent Mapping:

1. "i think dashboard is not fully integrated with kafka" - User suspects integration issues.
2. "my dashboard is empty" - User reports a critical issue with the dashboard's functionality.
3. "continue" - User requests to proceed with the conversation.
4. "Commit Changes and Delegate: 'Delegate to cloud agent'" - User wants to finalize changes and delegate tasks.
5. "complete the remaining tasks given" - User seeks to ensure all tasks are addressed.]

[Technical Inventory:

• Technologies: FastAPI, PostgreSQL, SQLAlchemy, Kafka, WebSocket.
• Architectural Decisions: Implementing REST endpoints for historical data retrieval and case management, ensuring data persistence in PostgreSQL, and using WebSocket for real-time alerts.
• Key Patterns: Asynchronous programming with FastAPI, data modeling with SQLAlchemy, and integration of Kafka for message brokering.]

[Code Archaeology:

• File: services/dashboard-api/app/routes/history.py - New REST endpoints for recent alerts and dashboard stats.
• File: services/risk-engine/app/models.py - Added models for RiskScoreRecord and Case.
• File: services/risk-engine/app/consumer.py - Modified consumer loop to persist data to PostgreSQL.
• File: services/dashboard-api/app/routes/cases.py - New REST API for case management.
• File: frontend/src/hooks/useDashboardData.ts - Updated to load historical data on mount.
• File: frontend/src/pages/Cases.tsx - Adjusted to read from REST API instead of WebSocket.]

[Progress Assessment:

• Completed Tasks: Proposed solutions for dashboard integration issues, including REST API endpoints and data persistence mechanisms.
• Partially Complete Work: Implementation of the discussed changes is pending, including finalizing code and testing.
• Validated Outcomes: None yet, as the changes have not been fully implemented or tested.]

[Context Validation: All critical information for continuation is captured, including the need for data persistence, case management, and the integration of REST APIs with the dashboard.]

[Recent Commands Analysis:

• Last Agent Commands: User requested to "continue," "commit changes," and "complete the remaining tasks given."
• Tool Results Summary: No specific tool results were returned as the conversation focused on discussing changes and improvements rather than executing commands.
• Pre-Summary State: The agent was actively discussing the implementation of proposed changes to the dashboard and risk engine when the token budget was exceeded.
• Operation Context: These commands were executed in the context of finalizing the integration of the dashboard with Kafka and ensuring data persistence.]

1. Conversation Overview: - Primary Objectives: The user aimed to resolve issues with the dashboard integration with Kafka, specifically addressing the empty dashboard and lack of data persistence. The user expressed a desire to finalize changes and delegate tasks. - Session Context: The conversation flowed from identifying integration issues to diagnosing problems with the dashboard, proposing solutions, and discussing implementation steps. - User Intent Evolution: The user transitioned from reporting issues to seeking solutions and finally requesting to commit changes and delegate tasks.

2. Technical Foundation:

• FastAPI: Used for building the REST API endpoints for dashboard functionality.
• PostgreSQL: Chosen for data persistence to store risk scores and case information.
• SQLAlchemy: Utilized for ORM to manage database interactions.
• Kafka: Employed for real-time message brokering between the risk engine and dashboard.

3. Codebase Status:

• File Name: services/dashboard-api/app/routes/history.py
  • Purpose: To provide recent alerts and dashboard statistics.
  • Current State: New endpoints added for fetching historical data.
  • Key Code Segments: get_recent_alerts and get_dashboard_stats functions.
• File Name: services/risk-engine/app/models.py
  • Purpose: To define data models for risk scores and cases.
  • Current State: New models created for RiskScoreRecord and Case.
  • Key Code Segments: Class definitions for RiskScoreRecord and Case.
• Fi...

Created from VS Code.