Add endpoint to retrieve snapshot by ID

src/TransitPulse.API/Contracts/Requests/GenerateReliabilitySnapshotRequestDTO.cs

@@ -0,0 +1,8 @@
+namespace TransitPulse.API.Contracts.Requests;
+
+public record GenerateReliabilitySnapshotRequest(
+    Guid RouteId,
+    DateTime PeriodStart,
+    DateTime PeriodEnd
+
+);

src/TransitPulse.API/Contracts/Responses/GenerateReliabilitySnapshotResponse.cs

@@ -0,0 +1,7 @@
+namespace TransitPulse.API.Contracts.Responses;
+
+public record GenerateReliabilitySnapshotResponse(
+    Guid SnapshotId,
+    double Score,
+    double AverageDelay,
+    double CancellationRate);

src/TransitPulse.API/Contracts/Responses/GetReliabilitySnapshotResponse.cs

@@ -0,0 +1,10 @@
+namespace TransitPulse.API.Contracts.Responses;
+
+public record GetReliabilitySnapshotResponse(
+   Guid SnapshotId,
+   double Score,
+   double AverageDelay,
+   double CancellationRate,
+   double OnTimePercentage,
+   DateTime CalculatedAt
+);

src/TransitPulse.API/Controllers/ReliabilityController.cs

@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.Mvc;
-using TransitPulse.API.Contracts;
+using TransitPulse.API.Contracts.Requests;
+using TransitPulse.API.Contracts.Responses;
 using TransitPulse.Application.Features.Reliability.GenerateReliabilitySnapshot;
+using TransitPulse.Application.Features.Reliability.GetReliabilitySnapshot;
 using TransitPulse.Application.Features.Reliability.GetReliabilitySnapshots;
 
 namespace TransitPulse.API.Controllers;
@@ -11,14 +13,19 @@ public class ReliabilityController : ControllerBase
 {
     private readonly GenerateReliabilitySnapshotHandler _generateHandler;
     private readonly GetReliabilitySnapshotsHandler _getSnapshotsHandler;
-    public ReliabilityController(GenerateReliabilitySnapshotHandler handler, GetReliabilitySnapshotsHandler getSnapshotsHandler)
+
+    private readonly GetReliabilitySnapshotHandler _getSnapshotHandler;
+    public ReliabilityController(GenerateReliabilitySnapshotHandler handler,
+            GetReliabilitySnapshotsHandler getSnapshotsHandler,
+            GetReliabilitySnapshotHandler getSnapshotHandler)
     {
         _generateHandler = handler;
         _getSnapshotsHandler = getSnapshotsHandler;
+        _getSnapshotHandler = getSnapshotHandler;
     }
 
-    [HttpPost("snapshots/generate")]
-    public async Task<IActionResult> GenerateSnapshot(GenerateReliabilitySnapshotRequestDTO request,
+    [HttpPost("snapshots")]
+    public async Task<IActionResult> GenerateSnapshot(GenerateReliabilitySnapshotRequest request,
         CancellationToken cancellationToken)
     {
         var command = new GenerateReliabilitySnapshotCommand(
@@ -28,17 +35,59 @@ public async Task<IActionResult> GenerateSnapshot(GenerateReliabilitySnapshotReq
 
         var result = await _generateHandler.HandleAsync(command, cancellationToken);
 
-        return Ok(result);
+        var response = new GenerateReliabilitySnapshotResponse(
+
+            result.SnapshotId,
+            result.Score,
+            result.AverageDelay,
+            result.CancellationRate);
 
+        return CreatedAtAction(
+            nameof(GetSnapshots),
+            new { routeId = request.RouteId },
+            response);
 
+        //return Ok(result);
     }
 
     [HttpGet("routes/{routeId}/snapshots")]
     public async Task<IActionResult> GetSnapshots(Guid routeId, CancellationToken cancellationToken)
     {
-        var result = await _getSnapshotsHandler.HandleAsync(routeId, cancellationToken);
+        var snapshots = await _getSnapshotsHandler.HandleAsync(routeId, cancellationToken);
+
+        var response = snapshots.Select(snapshot =>
+            new GetReliabilitySnapshotResponse(
+                snapshot.SnapshotId,
+                snapshot.Score,
+                snapshot.AverageDelay,
+                snapshot.CancellationRate,
+                snapshot.OnTimePercentage,
+                snapshot.CalculatedAt))
+            .ToList();
+
+        return Ok(response);
+    }
+
+    [HttpGet("snapshots/{snapshotId}")]
+
+    public async Task<IActionResult> Getsnapshot(Guid snapshotId,
+    CancellationToken cancellationToken)
+    {
+        var snapshot = await _getSnapshotHandler.HandleAsync(snapshotId, cancellationToken);
+
+        var response = new GetReliabilitySnapshotResponse(
+                        snapshot.SnapshotId,
+                        snapshot.Score,
+                        snapshot.AverageDelay,
+                        snapshot.CancellationRate,
+                        snapshot.OnTimePercentage,
+                        snapshot.CalculatedAt);
+
+        return Ok(response);
+
+
+
 
-        return Ok(result);
     }
 
     [HttpGet("health")]

src/TransitPulse.Application/Features/Reliability/GetReliabilitySnapshot/GetReliabilitySnapshotHandler.cs

@@ -0,0 +1,38 @@
+using TransitPulse.Application.Exceptions;
+using TransitPulse.Application.Interfaces;
+
+namespace TransitPulse.Application.Features.Reliability.GetReliabilitySnapshot;
+
+public class GetReliabilitySnapshotHandler
+{
+    private readonly IReliabilitySnapshotRepository _snapshotRepository;
+
+    public GetReliabilitySnapshotHandler(
+        IReliabilitySnapshotRepository snapshotRepository)
+    {
+        _snapshotRepository = snapshotRepository;
+    }
+
+    public async Task<GetReliabilitySnapshotResult> HandleAsync(
+        Guid snapshotId,
+        CancellationToken cancellationToken)
+    {
+        var snapshot = await _snapshotRepository.GetByIdAsync(
+            snapshotId,
+            cancellationToken);
+
+        if (snapshot is null)
+        {
+            throw new NotFoundException(
+                $"Snapshot {snapshotId} was not found.");
+        }
+
+        return new GetReliabilitySnapshotResult(
+            snapshot.Id,
+            snapshot.Score,
+            snapshot.AverageDelay,
+            snapshot.CancellationRate,
+            snapshot.OnTimePercentage,
+            snapshot.CalculatedAt);
+    }
+}

src/TransitPulse.Application/Features/Reliability/GetReliabilitySnapshot/GetReliabilitySnapshotResult.cs

@@ -0,0 +1,9 @@
+namespace TransitPulse.Application.Features.Reliability.GetReliabilitySnapshot;
+
+public record GetReliabilitySnapshotResult(
+    Guid SnapshotId,
+    double Score,
+    double AverageDelay,
+    double CancellationRate,
+    double OnTimePercentage,
+    DateTime CalculatedAt);

src/TransitPulse.Application/Interfaces/IReliabilitySnapshotRepository.cs

@@ -7,4 +7,8 @@ public interface IReliabilitySnapshotRepository
     Task AddAsync(ReliabilitySnapshot snapshot, CancellationToken cancellationToken);
     Task<IReadOnlyList<ReliabilitySnapshot>> GetByRouteAsync(Guid routeId, CancellationToken cancellationToken);
 
+    Task<ReliabilitySnapshot?> GetByIdAsync(
+        Guid snapshotId,
+        CancellationToken cancellationToken);
+
 }

src/TransitPulse.Infrastructure/Repositories/InMemoryReliabilitySnapshotRepository.cs

@@ -15,10 +15,25 @@ public Task AddAsync(
 
         return Task.CompletedTask;
     }
-
-    public Task<IReadOnlyList<ReliabilitySnapshot>> GetByRouteAsync(Guid routeId,
+    public Task<IReadOnlyList<ReliabilitySnapshot>> GetByRouteAsync(
+        Guid routeId,
         CancellationToken cancellationToken)
     {
-        throw new NotImplementedException();
+        IReadOnlyList<ReliabilitySnapshot> snapshots = _snapshots
+            .Where(snapshot => snapshot.RouteId == routeId)
+            .OrderByDescending(snapshot => snapshot.CalculatedAt)
+            .ToList();
+
+        return Task.FromResult(snapshots);
+    }
+
+    public Task<ReliabilitySnapshot?> GetByIdAsync(
+    Guid snapshotId,
+    CancellationToken cancellationToken)
+    {
+        var snapshot = _snapshots.FirstOrDefault(
+            snapshot => snapshot.Id == snapshotId);
+
+        return Task.FromResult(snapshot);
     }
 }

src/TransitPulse.Infrastructure/Repositories/ReliabilitySnapshotRepository.cs

@@ -27,4 +27,14 @@ public async Task<IReadOnlyList<ReliabilitySnapshot>> GetByRouteAsync(Guid route
         .OrderByDescending(snapshot => snapshot.CalculatedAt)
         .ToListAsync(cancellationToken);
     }
+
+    public async Task<ReliabilitySnapshot?> GetByIdAsync(
+    Guid snapshotId,
+    CancellationToken cancellationToken)
+    {
+        return await _context.ReliabilitySnapshots
+            .FirstOrDefaultAsync(
+                snapshot => snapshot.Id == snapshotId,
+                cancellationToken);
+    }
 }