How etzel92/eventcontrolsystem works
Tipo y propósito del proyecto (qué debes reflejar en el diagrama)
EventControlSystem es una solución distribuida con control remoto y monitoreo en tiempo real. Concretamente:
• Admin Web (React) envía comandos (abrir/cerrar formularios) y consulta bitácora.
• Backend (ASP.NET Core) expone REST (bitácora/edición) y un Hub SignalR (comandos/tiempo real).
• Clientes WinForms (.NET 8) se conectan por SignalR, ejecutan comandos (mostrar/cerrar forms) y registran eventos.
• SQL Server persiste los eventos (README menciona SPs; el código muestra EF Core DbContext).
Tu diagrama debe capturar dos flujos principales:
Frontend: EventControl.UI/
Indicadores claros:
• src/services/signalRService.js → conexión al Hub SignalR del backend.
• src/services/eventLogService.js → llamadas REST para bitácora.
• src/components/RemoteControl.jsx → UI para mandar comandos.
• src/components/EventLogTable.jsx → UI para visualizar/editar bitácora.
En el diagrama: un bloque “EventControl.UI (React + Vite)” con dos flechas salientes: REST y SignalR.
Backend: EventControl/EventControl.API/
Piezas:
• Controllers/EventLogController.cs → capa REST para bitácora (consulta/edición).
• Hubs/WinFormsHub.cs → Hub SignalR para mensajes en tiempo real hacia clientes.
• Data/EventLogDbContext.cs + Models/EventLog.cs → persistencia con EF Core.
• Program.cs → composición (DI), mapeo de endpoints, configuración de SignalR, CORS, etc.
En el diagrama: un bloque “EventControl.API (ASP.NET Core)” subdividido (opcional) en:
• “REST Controllers”
• “SignalR Hub”
• “EF Core / DbContext”
y una dependencia a “SQL Server”.
Cliente escritorio: EventClient/EventClient.App/
Piezas:
• SignalR/SignalRClient.cs → conexión al Hub; recibe comandos.
• Service/EventService.cs → lógica para ejecutar acciones/registrar (probable).
• Data/EventLogger.cs → registro local/llamadas de logging (probable).
• MainForm.cs, SecondaryForm.cs → superficies UI que se abren/cierran remotamente.
En el diagrama: un bloque “EventClient.App (WinForms .NET 8)” con:
• sub-bloque “SignalR Client”
• sub-bloque “Forms (Main/Secondary)”
• sub-bloque “Event Logging”
(A) Diagrama C4–Nivel 2 (Container) — el “sistema real”
Incluye:
• EventControl.UI (React/Vite) — navegador del admin
• EventControl.API (ASP.NET Core) — REST + SignalR
• EventClient.App (WinForms .NET 8) — múltiples instancias (N clientes)
• SQL Server — base de datos de eventos
Conecta:
• UI → API: HTTPS REST (EventLogController)
• UI ⇄ API: SignalR (WebSockets/LongPolling) (WinFormsHub)
• WinForms ⇄ API: SignalR (SignalRClient.cs ↔ WinFormsHub.cs)
• API → SQL Server: EF Core (EventLogDbContext)
• (si aplica en tu implementación) WinForms → API REST (o directo a DB) para registrar eventos. *La README dice “registra eventos en base de datos”; por seguridad/arquitectura típica, modela WinForms registrando vía API, y anota como “según implementación”.*
Admin abre formulario remoto
• Admin (UI) → SignalR Hub: OpenSecondaryForm(clientId|machine)
• Hub → WinForms clients: broadcast/target
• Cliente objetivo → abre SecondaryForm
• Cliente/Backend → registra EventLog (y retorna ack opcional)
Admin consulta/edita bitácora
• UI → REST /eventlog (GET)
• UI → REST /eventlog/{id} (PUT/PATCH comentario)
• API → DB
(C) Diagrama interno del Backend (componentes)
• REST Controller → Service/Repository (si existe; si no, Controller → DbContext)
• Hub → (opcional) servicio de routing/targeting de clientes
• DbContext → SQL Server
Esto aterriza el código a runtime.
EventControl.UI
• RemoteControl (UI)
• EventLogTable (UI)
• signalRService.js
• eventLogService.js
EventControl.API
• EventLogController (REST)
• WinFormsHub (SignalR)
• EventLogDbContext (EF Core)
SQL Server
• Tabla EventLog (y nota: “Stored procedures (según README)”)
EventClient.App (xN)
• SignalRClient
• MainForm / SecondaryForm
• EventLogger / EventService
Flechas (dirección y protocolo)
• EventControl.UI → EventControl.API: HTTPS REST (bitácora)
• EventControl.UI ⇄ EventControl.API: SignalR (comandos/estado)
• EventClient.App ⇄ EventControl.API: SignalR (recepción de comandos + notificaciones)
• EventControl.API → SQL Server: EF Core / TCP (persistencia)
• (Opcional/si aplica) EventClient.App → EventControl.API: REST (registrar evento/heartbeat)
Patrones/decisiones arquitectónicas a resaltar
• Arquitectura “3 capas / 3 componentes” (UI Web, API, Cliente).
• Event-driven en tiempo real con SignalR (pub/sub-like).
• Separación de canales:
• SignalR para “control/telemetría”
• REST para “consulta/edición” de bitácora
• Escalabilidad de clientes: WinForms como N instancias conectadas a un Hub.
• Persistencia centralizada en SQL Server (auditabilidad).
Cómo “hacerlo muy detallado” sin complicarte
Descompón cada bloque en sub-bloques directamente rastreables en el árbol:
• Para UI: referencia explícita a services/* y components/*.
• Para API: separa Controllers, Hubs, Data/Models.
• Para WinForms: separa SignalR, Forms, Service/Data.
Si algo no está en el árbol (por ejemplo “Repository”), no lo inventes: o lo omites, o lo dibujas como “(implícito / en Controller)”.
Convenciones visuales (para que el diagrama sea legible y “engineering-grade”)
• Rectángulos: procesos/servicios (UI, API, WinForms)
• Cilindro: SQL Server
• Paquetes/containers: subcomponentes dentro de cada proceso
• Frontend (React): azul
• Backend (.NET): verde
• Client desktop: naranja
• Data store: gris
• Etiquetas en flechas:
• “HTTPS/REST”
• “SignalR (WebSockets)”
• “EF Core”
• Cardinalidad:
• Marca WinForms como 1..N clients
• Notas:
• URLs/puertos (README menciona localhost:7290 por defecto): añade como anotación en API/UI si te ayuda a depurar.
Checklist final (lo que no debe faltar)
• [ ] UI Web con dos integraciones (REST + SignalR)
• [ ] API con Controller + Hub + DbContext
• [ ] WinForms con SignalRClient y Forms
• [ ] SQL Server como persistencia de bitácora
• [ ] Dos flujos: comandos en tiempo real y consulta/edición de bitácora
• [ ] Indicar N clientes conectados al Hub
Con esto tu diagrama quedará lo más fiel posible al repo: cada caja corresponde a carpetas/archivos reales, y cada flecha a un mecanismo explícito (REST/SignalR/EF Core).