308 lines
12 KiB
C#
308 lines
12 KiB
C#
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Options;
|
|
|
|
/// <summary>
|
|
/// In-app scenario catalogue and run control for clinical testing sessions.
|
|
/// </summary>
|
|
[ApiController]
|
|
[Route("api/v1/simulation")]
|
|
[Produces("application/json")]
|
|
[Authorize]
|
|
public class SimulationController : ControllerBase
|
|
{
|
|
private readonly SimulationOptions _options;
|
|
private readonly ISimulationRunner? _runner;
|
|
private readonly IScenarioCatalog? _catalog;
|
|
private readonly ISessionCatalog? _sessions;
|
|
private readonly ISimulationPurgeService? _purge;
|
|
private readonly ICurrentUserService _currentUser;
|
|
private readonly IAuditService _audit;
|
|
|
|
public SimulationController(
|
|
IOptions<SimulationOptions> options,
|
|
IServiceProvider services,
|
|
ICurrentUserService currentUser,
|
|
IAuditService audit)
|
|
{
|
|
_options = options.Value;
|
|
_runner = services.GetService<ISimulationRunner>();
|
|
_catalog = services.GetService<IScenarioCatalog>();
|
|
_sessions = services.GetService<ISessionCatalog>();
|
|
_purge = services.GetService<ISimulationPurgeService>();
|
|
_currentUser = currentUser;
|
|
_audit = audit;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Feature-detect simulation availability without requiring simulation:run.
|
|
/// Returns enabled=false when the feature is off (never 404).
|
|
/// </summary>
|
|
[HttpGet("config")]
|
|
[AuthorizePermission(ClinicalPermissions.AlertsRead)]
|
|
[ProducesResponseType(typeof(ApiResponse<SimulationConfigResponse>), StatusCodes.Status200OK)]
|
|
public IActionResult GetConfig()
|
|
{
|
|
if (!_options.Enabled)
|
|
return Ok(ApiResponse<SimulationConfigResponse>.Ok(new SimulationConfigResponse(Enabled: false)));
|
|
|
|
return Ok(ApiResponse<SimulationConfigResponse>.Ok(new SimulationConfigResponse(
|
|
Enabled: true,
|
|
MaxSpeed: _options.MaxSpeed,
|
|
MaxConcurrentRuns: _options.MaxConcurrentRuns)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lists available scenario files from the configured scenario directory.
|
|
/// </summary>
|
|
[HttpGet("scenarios")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<List<ScenarioSummaryResponse>>), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
public IActionResult ListScenarios()
|
|
{
|
|
EnsureEnabled();
|
|
var items = _catalog!.ListScenarios()
|
|
.Select(ToScenarioSummary)
|
|
.ToList();
|
|
return Ok(ApiResponse<List<ScenarioSummaryResponse>>.Ok(items));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lists session presets with resolved scenario summaries.
|
|
/// </summary>
|
|
[HttpGet("sessions")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<List<SessionPresetResponse>>), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
public IActionResult ListSessions()
|
|
{
|
|
EnsureEnabled();
|
|
var items = _sessions!.ListSessions()
|
|
.Select(preset => new SessionPresetResponse(
|
|
preset.Id,
|
|
preset.Name,
|
|
preset.Goal,
|
|
preset.EstimatedMinutes,
|
|
preset.DefaultSpeed,
|
|
preset.Scenarios
|
|
.Select(id => _catalog!.GetById(id))
|
|
.Where(s => s is not null)
|
|
.Select(s => ToScenarioSummary(s!))
|
|
.ToList()))
|
|
.ToList();
|
|
return Ok(ApiResponse<List<SessionPresetResponse>>.Ok(items));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts every scenario in a session preset (all-or-nothing admission, staggered launch).
|
|
/// </summary>
|
|
[HttpPost("sessions/{sessionId}/start")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<SimulationSessionResponse>), StatusCodes.Status201Created)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status409Conflict)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status422UnprocessableEntity)]
|
|
public async Task<IActionResult> StartSession(
|
|
string sessionId,
|
|
[FromBody] StartSimulationSessionRequest? req,
|
|
CancellationToken ct)
|
|
{
|
|
EnsureEnabled();
|
|
|
|
var userId = _currentUser.UserId?.ToString()
|
|
?? throw new ValidationException("Authenticated user id is required.", "SIMULATION_USER_REQUIRED");
|
|
|
|
var state = await _runner!.StartSessionAsync(sessionId, req?.Speed, userId, ct);
|
|
|
|
await _audit.WriteAsync(
|
|
AuditAction.SimulationRunStarted,
|
|
"SimulationSession",
|
|
Guid.NewGuid(),
|
|
newValue: new
|
|
{
|
|
state.SessionId,
|
|
state.Name,
|
|
state.RunIds,
|
|
Speed = req?.Speed,
|
|
StartedBy = userId,
|
|
});
|
|
|
|
return StatusCode(201, ApiResponse<SimulationSessionResponse>.Created(
|
|
new SimulationSessionResponse(state.SessionId, state.Name, state.StartedAt, state.RunIds)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts a background scenario replay.
|
|
/// </summary>
|
|
[HttpPost("runs")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<SimulationRunResponse>), StatusCodes.Status201Created)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status409Conflict)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status422UnprocessableEntity)]
|
|
public async Task<IActionResult> StartRun(
|
|
[FromBody] StartSimulationRunRequest req, CancellationToken ct)
|
|
{
|
|
EnsureEnabled();
|
|
|
|
var userId = _currentUser.UserId?.ToString()
|
|
?? throw new ValidationException("Authenticated user id is required.", "SIMULATION_USER_REQUIRED");
|
|
|
|
var state = await _runner!.StartAsync(req.ScenarioId, req.Speed, userId, ct);
|
|
|
|
await _audit.WriteAsync(
|
|
AuditAction.SimulationRunStarted,
|
|
"SimulationRun",
|
|
state.RunId,
|
|
newValue: new
|
|
{
|
|
state.ScenarioId,
|
|
state.ScenarioName,
|
|
state.Speed,
|
|
StartedBy = userId,
|
|
});
|
|
|
|
return StatusCode(201, ApiResponse<SimulationRunResponse>.Created(ToResponse(state)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lists active and recent simulation runs from the in-memory registry.
|
|
/// </summary>
|
|
[HttpGet("runs")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<List<SimulationRunResponse>>), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
public IActionResult ListRuns()
|
|
{
|
|
EnsureEnabled();
|
|
var items = _runner!.ListRuns().Select(ToResponse).ToList();
|
|
return Ok(ApiResponse<List<SimulationRunResponse>>.Ok(items));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets one simulation run by id.
|
|
/// </summary>
|
|
[HttpGet("runs/{runId:guid}")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<SimulationRunResponse>), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
public IActionResult GetRun(Guid runId)
|
|
{
|
|
EnsureEnabled();
|
|
var state = _runner!.GetRun(runId)
|
|
?? throw new NotFoundException($"Simulation run '{runId}' was not found.");
|
|
return Ok(ApiResponse<SimulationRunResponse>.Ok(ToResponse(state)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stops an in-flight run. Idempotent — stopping a finished run succeeds as a no-op.
|
|
/// </summary>
|
|
[HttpPost("runs/{runId:guid}/stop")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<SimulationRunResponse>), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
public async Task<IActionResult> StopRun(Guid runId)
|
|
{
|
|
EnsureEnabled();
|
|
|
|
if (!_runner!.Cancel(runId))
|
|
throw new NotFoundException($"Simulation run '{runId}' was not found.");
|
|
|
|
var state = _runner.GetRun(runId)
|
|
?? throw new NotFoundException($"Simulation run '{runId}' was not found.");
|
|
|
|
await _audit.WriteAsync(
|
|
AuditAction.SimulationRunStopped,
|
|
"SimulationRun",
|
|
runId,
|
|
newValue: new
|
|
{
|
|
state.ScenarioId,
|
|
state.Status,
|
|
StoppedBy = _currentUser.UserId?.ToString(),
|
|
});
|
|
|
|
return Ok(ApiResponse<SimulationRunResponse>.Ok(ToResponse(state)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Counts simulated patients and dependents currently on the ward.
|
|
/// </summary>
|
|
[HttpGet("data/summary")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<SimulationDataSummaryResponse>), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
public async Task<IActionResult> GetDataSummary(CancellationToken ct)
|
|
{
|
|
EnsureEnabled();
|
|
var summary = await _purge!.GetSummaryAsync(ct);
|
|
return Ok(ApiResponse<SimulationDataSummaryResponse>.Ok(
|
|
new SimulationDataSummaryResponse(
|
|
summary.SimulatedPatients,
|
|
summary.Encounters,
|
|
summary.Observations,
|
|
summary.Alerts,
|
|
summary.ActiveRuns)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Purges all simulated patients and dependents. Refuses while runs are active.
|
|
/// </summary>
|
|
[HttpDelete("data")]
|
|
[AuthorizePermission(ClinicalPermissions.SimulationRun)]
|
|
[ProducesResponseType(typeof(ApiResponse<SimulationPurgeResponse>), StatusCodes.Status200OK)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(typeof(ApiResponse<object>), StatusCodes.Status409Conflict)]
|
|
public async Task<IActionResult> PurgeData(CancellationToken ct)
|
|
{
|
|
EnsureEnabled();
|
|
var result = await _purge!.PurgeAsync(ct);
|
|
return Ok(ApiResponse<SimulationPurgeResponse>.Ok(
|
|
new SimulationPurgeResponse(
|
|
result.PatientsDeleted,
|
|
result.EncountersDeleted,
|
|
result.AlertsDeleted,
|
|
result.RunsCleared)));
|
|
}
|
|
|
|
private void EnsureEnabled()
|
|
{
|
|
if (!_options.Enabled || _runner is null || _catalog is null
|
|
|| _sessions is null || _purge is null)
|
|
throw new NotFoundException("Simulation endpoints are not available.");
|
|
}
|
|
|
|
private static ScenarioSummaryResponse ToScenarioSummary(VigilCare.Simulation.ScenarioFile s) =>
|
|
new(
|
|
s.Scenario.Id,
|
|
s.Scenario.Name,
|
|
s.Scenario.Description,
|
|
s.Scenario.DurationMinutes,
|
|
s.Scenario.Tags,
|
|
s.Encounter.Department,
|
|
s.Events.Count,
|
|
s.ExpectedOutcomes?.Count ?? 0);
|
|
|
|
private static SimulationRunResponse ToResponse(SimulationRunState state) =>
|
|
new(
|
|
state.RunId,
|
|
state.ScenarioId,
|
|
state.ScenarioName,
|
|
state.Status.ToDbString(),
|
|
state.Speed,
|
|
state.PatientId,
|
|
state.EncounterId,
|
|
state.SessionId,
|
|
state.PatientDisplayName,
|
|
state.StartedAt,
|
|
state.ElapsedRealSeconds,
|
|
state.LastOffsetMinutes,
|
|
state.TotalOffsetMinutes,
|
|
state.ProgressPercent,
|
|
state.ObservationsSent,
|
|
state.MedicationsSent,
|
|
state.OrdersPlaced,
|
|
state.FailureReason);
|
|
}
|