fix(esg): honor the declared response charset in ReadBodyBoundedAsync with UTF-8 fallback (plan R2-06 T4)

src/ZB.MOM.WW.ScadaBridge.ExternalSystemGateway/ExternalSystemClient.cs

@@ -466,6 +466,12 @@ public class ExternalSystemClient : IExternalSystemClient
     /// into store-and-forward would defeat the cap. Cancellation
     /// (<see cref="OperationCanceledException"/>) is allowed to propagate so the
     /// caller's ordered timeout/cancellation catch filters classify it.
+    /// <para>
+    /// N4: the accumulated bytes are decoded using the response's declared charset
+    /// (<c>Content-Type: …; charset=…</c>) via <see cref="ResolveEncoding"/> — parity
+    /// with the pre-bounded-read <c>ReadAsStringAsync</c>. A null, empty, or
+    /// unrecognized charset falls back to UTF-8.
+    /// </para>
     /// </summary>
     private static async Task<string> ReadBodyBoundedAsync(
         HttpContent content, string systemName, long maxBytes, CancellationToken token)
@@ -498,7 +504,33 @@ public class ExternalSystemClient : IExternalSystemClient
             }
         }
 
-        return Encoding.UTF8.GetString(buffer.GetBuffer(), 0, (int)buffer.Length);
+        // N4: honor the response's declared charset (parity with the pre-bounded-read
+        // ReadAsStringAsync). Unknown/invalid charset → UTF-8 fallback: mojibake beats
+        // failing the call over a cosmetic header.
+        return ResolveEncoding(content.Headers.ContentType?.CharSet)
+            .GetString(buffer.GetBuffer(), 0, (int)buffer.Length);
+    }
+
+    /// <summary>
+    /// Resolves the declared response charset to an <see cref="Encoding"/>, tolerating
+    /// the quoted form some servers emit (<c>charset="iso-8859-1"</c>). Null, empty,
+    /// or unrecognized values fall back to UTF-8.
+    /// </summary>
+    private static Encoding ResolveEncoding(string? charset)
+    {
+        if (string.IsNullOrWhiteSpace(charset))
+        {
+            return Encoding.UTF8;
+        }
+
+        try
+        {
+            return Encoding.GetEncoding(charset.Trim().Trim('"'));
+        }
+        catch (ArgumentException)
+        {
+            return Encoding.UTF8;
+        }
     }
 
     private static string Truncate(string value, int maxChars)

tests/ZB.MOM.WW.ScadaBridge.ExternalSystemGateway.Tests/ExternalSystemClientTests.cs

@@ -1,5 +1,6 @@
 using System.Net;
 using System.Net.Http.Headers;
+using System.Text;
 using Microsoft.Data.Sqlite;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
@@ -1377,4 +1378,57 @@ public class ExternalSystemClientTests
 
         Assert.False(delivered);
     }
+
+    [Fact]
+    public async Task Call_Latin1Charset_DecodesUsingDeclaredCharset()
+    {
+        // Arch-review R2 N4: the bounded read must honor the declared charset —
+        // UTF-8-decoding an iso-8859-1 body turns every non-ASCII byte into U+FFFD.
+        var system = new ExternalSystemDefinition("TestAPI", "https://api.example.com", "none") { Id = 1 };
+        var method = new ExternalSystemMethod("getData", "GET", "/data") { Id = 1, ExternalSystemDefinitionId = 1 };
+        StubResolution(system, method);
+        var handler = new ByteBodyHandler(
+            HttpStatusCode.OK,
+            Encoding.Latin1.GetBytes("température 25°C"),
+            "text/plain; charset=iso-8859-1");
+        _httpClientFactory.CreateClient(Arg.Any<string>()).Returns(new HttpClient(handler));
+        var client = new ExternalSystemClient(
+            _httpClientFactory, _repository, NullLogger<ExternalSystemClient>.Instance);
+
+        var result = await client.CallAsync("TestAPI", "getData");
+
+        Assert.True(result.Success);
+        Assert.Contains("température 25°C", result.ResponseJson);
+    }
+
+    [Fact]
+    public async Task Call_UnknownCharset_FallsBackToUtf8()
+    {
+        var system = new ExternalSystemDefinition("TestAPI", "https://api.example.com", "none") { Id = 1 };
+        var method = new ExternalSystemMethod("getData", "GET", "/data") { Id = 1, ExternalSystemDefinitionId = 1 };
+        StubResolution(system, method);
+        var handler = new ByteBodyHandler(
+            HttpStatusCode.OK, Encoding.UTF8.GetBytes("ok"), "text/plain; charset=not-a-charset");
+        _httpClientFactory.CreateClient(Arg.Any<string>()).Returns(new HttpClient(handler));
+        var client = new ExternalSystemClient(
+            _httpClientFactory, _repository, NullLogger<ExternalSystemClient>.Instance);
+
+        var result = await client.CallAsync("TestAPI", "getData");
+
+        Assert.True(result.Success);
+        Assert.Contains("ok", result.ResponseJson);
+    }
+
+    /// <summary>Test helper: returns a fixed byte body with an explicit Content-Type.</summary>
+    private sealed class ByteBodyHandler(
+        HttpStatusCode statusCode, byte[] body, string contentType) : HttpMessageHandler
+    {
+        protected override Task<HttpResponseMessage> SendAsync(
+            HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            var response = new HttpResponseMessage(statusCode) { Content = new ByteArrayContent(body) };
+            response.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
+            return Task.FromResult(response);
+        }
+    }
 }