Drop confidence threshold for CLOE timeseries upload

The sara-constant-level-oiler analysis already gates on its own
configurable confidence threshold, so re-gating in SARA is
redundant. Upload whenever oilLevel and confidence are both
non-null.

Author: aeshub

api.Tests/Mocks/RecordingTimeseriesService.cs

@@ -0,0 +1,34 @@
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using api.Services;
+
+namespace Api.Test.Mocks;
+
+/// <summary>
+/// Test fake for <see cref="ITimeseriesService"/> that records every upload
+/// request for later inspection by tests. CO2 fetches return null.
+/// </summary>
+public class RecordingTimeseriesService : ITimeseriesService
+{
+    private readonly ConcurrentQueue<TriggerTimeseriesUploadRequest> _uploads = new();
+
+    public IReadOnlyCollection<TriggerTimeseriesUploadRequest> Uploads => _uploads.ToArray();
+
+    public Task TriggerTimeseriesUpload(TriggerTimeseriesUploadRequest uploadRequest)
+    {
+        _uploads.Enqueue(uploadRequest);
+        return Task.CompletedTask;
+    }
+
+    public Task<double?> FetchCO2ConcentrationFromTimeseries(FetchCO2MeasurementRequest fetchRequest)
+    {
+        return Task.FromResult<double?>(null);
+    }
+
+    public void Reset()
+    {
+        _uploads.Clear();
+    }
+}

api.Tests/Services/ResultHandlers/WorkflowResultHandlers/CLOEResultHandlerTests.cs

@@ -75,6 +75,9 @@ public async Task OnWorkflowCompleted_ValidResultForSingleRecord_PublishesAnalys
         var published = Assert.Single(_factory.MqttPublisher.AnalysisResultMessages);
         Assert.Equal(oilLevel.ToString("F2"), published.Value);
         Assert.Equal(confidence * 100, published.Confidence);
+
+        var upload = Assert.Single(_factory.TimeseriesService.Uploads);
+        Assert.Equal(oilLevel, upload.Value);
     }
 
     [Fact]
@@ -185,4 +188,44 @@ public async Task OnWorkflowCompleted_ResultWithWarning_PublishesWarning()
         Assert.Equal(confidence * 100, published.Confidence);
         Assert.Equal(warning, published.Warning);
     }
+
+    [Fact]
+    public async Task OnWorkflowCompleted_NullOilLevel_DoesNotUploadTimeseries()
+    {
+        var record = await _db.NewInspectionRecord(inspectionId: "insp-123");
+        var analysis = await _db.NewAnalysis(inspectionRecords: [record]);
+        var run = await _db.NewAnalysisRun(analysis);
+        var workflow = await _db.NewWorkflow(run, workflowType: "cloe");
+        workflow.ResultJson = JsonSerializer.Serialize(
+            new { oilLevel = (float?)null, confidence = 0.9f }
+        );
+        await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+        using var scope = _factory.Services.CreateScope();
+        var handler = ResolveHandler(scope);
+
+        await handler.OnWorkflowCompleted(workflow);
+
+        Assert.Empty(_factory.TimeseriesService.Uploads);
+    }
+
+    [Fact]
+    public async Task OnWorkflowCompleted_NullConfidence_DoesNotUploadTimeseries()
+    {
+        var record = await _db.NewInspectionRecord(inspectionId: "insp-123");
+        var analysis = await _db.NewAnalysis(inspectionRecords: [record]);
+        var run = await _db.NewAnalysisRun(analysis);
+        var workflow = await _db.NewWorkflow(run, workflowType: "cloe");
+        workflow.ResultJson = JsonSerializer.Serialize(
+            new { oilLevel = 0.42f, confidence = (float?)null }
+        );
+        await _context.SaveChangesAsync(TestContext.Current.CancellationToken);
+
+        using var scope = _factory.Services.CreateScope();
+        var handler = ResolveHandler(scope);
+
+        await handler.OnWorkflowCompleted(workflow);
+
+        Assert.Empty(_factory.TimeseriesService.Uploads);
+    }
 }

api.Tests/TestWebApplicationFactory.cs

@@ -34,6 +34,7 @@ public class TestWebApplicationFactory<TProgram>(string postgresConnectionString
     public RecordingMqttPublisher MqttPublisher { get; } = new();
     public RecordingHttpMessageHandler ArgoHttpHandler { get; } = new();
     public RecordingEmailService EmailService { get; } = new();
+    public RecordingTimeseriesService TimeseriesService { get; } = new();
 
     /// <summary>
     /// Returns the configured Argo trigger URL for the given workflow type.
@@ -71,6 +72,7 @@ protected override void ConfigureWebHost(IWebHostBuilder builder)
             ReplaceMqttPublisher(services);
             ReplaceArgoHttpClient(services);
             ReplaceEmailService(services);
+            ReplaceTimeseriesService(services);
             ReplaceAuthentication(services);
             RegisterMqttEventHandler(services);
             RemoveHostedServices(services);
@@ -127,6 +129,16 @@ private void ReplaceEmailService(IServiceCollection services)
         services.AddSingleton<IEmailService>(EmailService);
     }
 
+    private void ReplaceTimeseriesService(IServiceCollection services)
+    {
+        var existing = services.Where(d => d.ServiceType == typeof(ITimeseriesService)).ToList();
+        foreach (var descriptor in existing)
+        {
+            services.Remove(descriptor);
+        }
+        services.AddSingleton<ITimeseriesService>(TimeseriesService);
+    }
+
     private static void RemoveHostedServices(IServiceCollection services)
     {
         var hostedDescriptors = services

api.Tests/appsettings.Test.json

@@ -28,6 +28,7 @@
   "Frontend": {
     "Enabled": false
   },
+  "SARATimeseriesBaseUrl": "",
   "OpenTelemetry": {
     "Enabled": false
   },

api/Services/ResultHandlers/WorkflowResultHandlers/CLOEResultHandler.cs

@@ -1,3 +1,4 @@
+using System.Globalization;
 using api.Database.Context;
 using api.Database.Models;
 using api.MQTT;
@@ -15,6 +16,7 @@ internal sealed class CLOEResult
 public class CLOEResultHandler(
     SaraDbContext context,
     IMqttPublisherService mqttPublisherService,
+    ITimeseriesService timeseriesService,
     ILogger<CLOEResultHandler> logger
 ) : IWorkflowResultHandler
 {
@@ -72,5 +74,54 @@ public async Task OnWorkflowCompleted(Workflow workflow)
         }
 
         await mqttPublisherService.PublishSaraAnalysisResultAvailable(message);
+
+        await TryUploadTimeseries(workflow, inspectionRecord, result);
+    }
+
+    private async Task TryUploadTimeseries(
+        Workflow workflow,
+        InspectionRecord inspectionRecord,
+        CLOEResult? result
+    )
+    {
+        if (result?.OilLevel is not { } oilLevel || result.Confidence is not { } confidence)
+        {
+            logger.LogWarning(
+                "Skipping CLOE timeseries upload for workflow {WorkflowId}: oilLevel or confidence is null",
+                workflow.Id
+            );
+            return;
+        }
+
+        var uploadRequest = new TriggerTimeseriesUploadRequest
+        {
+            Name =
+                $"{inspectionRecord.InstallationCode}_{inspectionRecord.Tag}_{inspectionRecord.InspectionDescription}",
+            Facility = inspectionRecord.InstallationCode,
+            ExternalId = "",
+            Description = "CLOE-oil-level",
+            Unit = "percentage",
+            AssetId = inspectionRecord.InstallationCode,
+            Value = oilLevel,
+            Timestamp = inspectionRecord.Timestamp ?? DateTime.UtcNow,
+            Step = true,
+            Metadata = new Dictionary<string, string>
+            {
+                { "Confidence", confidence.ToString(CultureInfo.InvariantCulture) },
+            },
+        };
+
+        try
+        {
+            await timeseriesService.TriggerTimeseriesUpload(uploadRequest);
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(
+                ex,
+                "Failed to upload CLOE oil-level datapoint to Timeseries for workflow {WorkflowId}",
+                workflow.Id
+            );
+        }
     }
 }

api/appsettings.json

@@ -82,8 +82,5 @@
     "Fencilla": {
       "Installations": {}
     }
-  },
-  "Thresholds": {
-    "CLOETimeseriesUploadConfidenceThreshold": 0.6
   }
 }