Stream Correspondence attachments to support large file upload

src/Altinn.App.Core/Extensions/HttpClientExtension.cs

@@ -103,6 +103,36 @@ public static async Task<HttpResponseMessage> GetAsync(
         return await httpClient.SendAsync(request, HttpCompletionOption.ResponseContentRead, CancellationToken.None);
     }
 
+    /// <summary>
+    /// Extension that add authorization header to request
+    /// </summary>
+    /// <param name="httpClient">The HttpClient</param>
+    /// <param name="authorizationToken">the authorization token (jwt)</param>
+    /// <param name="requestUri">The request Uri</param>
+    /// <param name="platformAccessToken">The platformAccess tokens</param>
+    /// <returns>A HttpResponseMessage</returns>
+    public static async Task<HttpResponseMessage> GetStreamingAsync(
+        this HttpClient httpClient,
+        string authorizationToken,
+        string requestUri,
+        string? platformAccessToken = null
+    )
+    {
+        using HttpRequestMessage request = new(HttpMethod.Get, requestUri);
+
+        request.Headers.Authorization = new AuthenticationHeaderValue(
+            Constants.AuthorizationSchemes.Bearer,
+            authorizationToken
+        );
+
+        if (!string.IsNullOrEmpty(platformAccessToken))
+        {
+            request.Headers.Add(Constants.General.PlatformAccessTokenHeaderName, platformAccessToken);
+        }
+
+        return await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, CancellationToken.None);
+    }
+
     /// <summary>
     /// Extension that add authorization header to request
     /// </summary>

src/Altinn.App.Core/Features/Correspondence/Builder/CorrespondenceAttachmentBuilder.cs

@@ -10,6 +10,7 @@
     private string? _filename;
     private string? _sendersReference;
     private ReadOnlyMemory<byte>? _data;
+    private Stream? _streamedData;
     private bool? _isEncrypted;
     private CorrespondenceDataLocationType _dataLocationType =
         CorrespondenceDataLocationType.ExistingCorrespondenceAttachment;
@@ -40,11 +41,17 @@
     /// <inheritdoc/>
     public ICorrespondenceAttachmentBuilder WithData(ReadOnlyMemory<byte> data)
     {
-        BuilderUtils.NotNullOrEmpty(data, "Data cannot be empty");
         _data = data;
         return this;
     }
 
+    /// <inheritdoc/>
+    public ICorrespondenceAttachmentBuilder WithData(Stream data)
+    {
+        _streamedData = data;
+        return this;
+    }
+
     /// <inheritdoc/>
     public ICorrespondenceAttachmentBuilder WithIsEncrypted(bool isEncrypted)
     {
@@ -64,15 +71,31 @@
     {
         BuilderUtils.NotNullOrEmpty(_filename);
         BuilderUtils.NotNullOrEmpty(_sendersReference);
-        BuilderUtils.NotNullOrEmpty(_data);
+        BuilderUtils.RequireExactlyOneOf(_data, _streamedData);
 
-        return new CorrespondenceAttachment
+        if (_streamedData is not null)
+        {
+            BuilderUtils.NotNullOrEmpty(_streamedData);
+            return new CorrespondenceStreamedAttachment
+            {
+                Filename = _filename,
+                SendersReference = _sendersReference,
+                Data = _streamedData,
+                IsEncrypted = _isEncrypted,
+                DataLocationType = _dataLocationType,
+            };
+        }
+        else
         {
-            Filename = _filename,
-            SendersReference = _sendersReference,
-            Data = _data.Value,
-            IsEncrypted = _isEncrypted,
-            DataLocationType = _dataLocationType,
-        };
+            BuilderUtils.NotNullOrEmpty(_data);
+            return new CorrespondenceAttachmentInMemory
+            {
+                Filename = _filename,
+                SendersReference = _sendersReference,
+                Data = _data.Value,
+                IsEncrypted = _isEncrypted,
+                DataLocationType = _dataLocationType,
+            };
+        }
     }
 }

src/Altinn.App.Core/Features/Correspondence/Builder/ICorrespondenceAttachmentBuilder.cs

@@ -27,7 +27,7 @@ public interface ICorrespondenceAttachmentBuilderSendersReference
 }
 
 /// <summary>
-/// Indicates that the <see cref="CorrespondenceAttachmentBuilder"/> instance is on the <see cref="CorrespondenceAttachment.Data"/> step.
+/// Indicates that the <see cref="CorrespondenceAttachmentBuilder"/> instance is on the <see cref="CorrespondenceAttachmentInMemory.Data"/> and <see cref="CorrespondenceStreamedAttachment.Data"/> step.
 /// </summary>
 public interface ICorrespondenceAttachmentBuilderData
 {
@@ -36,6 +36,15 @@ public interface ICorrespondenceAttachmentBuilderData
     /// </summary>
     /// <param name="data">The data</param>
     ICorrespondenceAttachmentBuilder WithData(ReadOnlyMemory<byte> data);
+
+    /// <summary>
+    /// Sets the stream of the data content of the attachment.
+    /// Is more efficient if the attachment is large in size.
+    /// The stream must be open (not disposed) until the correspondence is sent.
+    /// The caller is responsible for disposing the stream after the correspondence has been sent.
+    /// </summary>
+    /// <param name="data">The data stream</param>
+    ICorrespondenceAttachmentBuilder WithData(Stream data);
 }
 
 /// <summary>

src/Altinn.App.Core/Features/Correspondence/CorrespondenceClient.cs

@@ -191,6 +191,11 @@ CancellationToken cancellationToken
     )
     {
         using HttpClient client = _httpClientFactory.CreateClient();
+
+        // Configure HttpClient for large file uploads
+        client.Timeout = TimeSpan.FromMinutes(30);
+        client.DefaultRequestHeaders.ExpectContinue = false;
+
         using HttpResponseMessage response = await client.SendAsync(request, cancellationToken);
         string responseBody = await response.Content.ReadAsStringAsync(cancellationToken);
 

src/Altinn.App.Core/Features/Correspondence/Models/CorrespondenceAttachment.cs

@@ -1,9 +1,9 @@
 namespace Altinn.App.Core.Features.Correspondence.Models;
 
 /// <summary>
-/// Represents an attachment to a correspondence.
+/// Represents a base attachment of a correspondence.
 /// </summary>
-public sealed record CorrespondenceAttachment : MultipartCorrespondenceItem
+public abstract record CorrespondenceAttachment : MultipartCorrespondenceItem
 {
     /// <summary>
     /// The filename of the attachment.
@@ -27,20 +27,7 @@ public sealed record CorrespondenceAttachment : MultipartCorrespondenceItem
         CorrespondenceDataLocationType.ExistingCorrespondenceAttachment;
 
     /// <summary>
-    /// The data content.
+    /// Serialise method
     /// </summary>
-    public required ReadOnlyMemory<byte> Data { get; init; }
-
-    internal void Serialise(MultipartFormDataContent content, int index, string? filenameOverride = null)
-    {
-        const string typePrefix = "Correspondence.Content.Attachments";
-        string prefix = $"{typePrefix}[{index}]";
-        string actualFilename = filenameOverride ?? Filename;
-
-        AddRequired(content, actualFilename, $"{prefix}.Filename");
-        AddRequired(content, SendersReference, $"{prefix}.SendersReference");
-        AddRequired(content, DataLocationType.ToString(), $"{prefix}.DataLocationType");
-        AddRequired(content, Data, "Attachments", actualFilename); // NOTE: No prefix!
-        AddIfNotNull(content, IsEncrypted?.ToString(), $"{prefix}.IsEncrypted");
-    }
+    internal abstract void Serialise(MultipartFormDataContent content, int index, string? filenameOverride = null);
 }

src/Altinn.App.Core/Features/Correspondence/Models/CorrespondenceAttachmentInMemory.cs

@@ -0,0 +1,25 @@
+namespace Altinn.App.Core.Features.Correspondence.Models;
+
+/// <summary>
+/// Represents an attachment to a correspondence.
+/// </summary>
+public record CorrespondenceAttachmentInMemory : CorrespondenceAttachment
+{
+    /// <summary>
+    /// The data content.
+    /// </summary>
+    public required ReadOnlyMemory<byte> Data { get; init; }
+
+    internal override void Serialise(MultipartFormDataContent content, int index, string? filenameOverride = null)
+    {
+        const string typePrefix = "Correspondence.Content.Attachments";
+        string prefix = $"{typePrefix}[{index}]";
+        string actualFilename = filenameOverride ?? Filename;
+
+        AddRequired(content, actualFilename, $"{prefix}.Filename");
+        AddRequired(content, SendersReference, $"{prefix}.SendersReference");
+        AddRequired(content, DataLocationType.ToString(), $"{prefix}.DataLocationType");
+        AddRequired(content, Data, "Attachments", actualFilename);
+        AddIfNotNull(content, IsEncrypted?.ToString(), $"{prefix}.IsEncrypted");
+    }
+}

src/Altinn.App.Core/Features/Correspondence/Models/CorrespondenceRequest.cs

@@ -41,6 +41,13 @@ string filename
         content.Add(new ReadOnlyMemoryContent(data), name, filename);
     }
 
+    internal static void AddRequired(MultipartFormDataContent content, Stream data, string name, string filename)
+    {
+        if (data is null)
+            throw new CorrespondenceArgumentException($"Required value is missing: {name}");
+        content.Add(new StreamContent(data), name, filename);
+    }
+
     internal static void AddIfNotNull(MultipartFormDataContent content, string? value, string name)
     {
         if (!string.IsNullOrWhiteSpace(value))

src/Altinn.App.Core/Features/Correspondence/Models/CorrespondenceStreamedAttachment.cs

@@ -0,0 +1,32 @@
+namespace Altinn.App.Core.Features.Correspondence.Models;
+
+/// <summary>
+/// Represents an attachment to a correspondence with streaming data support.
+/// Inherits from CorrespondenceAttachment and provides a Stream-based data property.
+/// Is more efficient if the attachment is large in size.
+/// The stream must be open (not disposed) until the correspondence is sent.
+/// The caller is responsible for disposing the stream after the correspondence has been sent.
+/// </summary>
+public record CorrespondenceStreamedAttachment : CorrespondenceAttachment
+{
+    /// <summary>
+    /// The data content as a stream.
+    /// Is more efficient if the attachment is large in size.
+    /// The stream must be open (not disposed) until the correspondence is sent.
+    /// The caller is responsible for disposing the stream after the correspondence has been sent.
+    /// </summary>
+    public required Stream Data { get; init; }
+
+    internal override void Serialise(MultipartFormDataContent content, int index, string? filenameOverride = null)
+    {
+        const string typePrefix = "Correspondence.Content.Attachments";
+        string prefix = $"{typePrefix}[{index}]";
+        string actualFilename = filenameOverride ?? Filename;
+
+        AddRequired(content, actualFilename, $"{prefix}.Filename");
+        AddRequired(content, SendersReference, $"{prefix}.SendersReference");
+        AddRequired(content, DataLocationType.ToString(), $"{prefix}.DataLocationType");
+        AddRequired(content, Data, "Attachments", actualFilename);
+        AddIfNotNull(content, IsEncrypted?.ToString(), $"{prefix}.IsEncrypted");
+    }
+}

src/Altinn.App.Core/Helpers/ResponseWrapperStream.cs

@@ -0,0 +1,114 @@
+namespace Altinn.App.Core.Helpers;
+
+/// <summary>
+/// A wrapper stream that ensures proper disposal of an HttpResponseMessage along with its content stream.
+/// </summary>
+internal sealed class ResponseWrapperStream : Stream
+{
+    private readonly HttpResponseMessage _response;
+    private readonly Stream _innerStream;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ResponseWrapperStream"/> class.
+    /// </summary>
+    /// <param name="response">The HTTP response message to be disposed when the stream is disposed.</param>
+    /// <param name="innerStream">The inner stream to wrap and delegate operations to.</param>
+    public ResponseWrapperStream(HttpResponseMessage response, Stream innerStream)
+    {
+        _response = response;
+        _innerStream = innerStream;
+    }
+
+    /// <summary>
+    /// Releases the unmanaged resources used by the <see cref="ResponseWrapperStream"/> and optionally releases the managed resources.
+    /// </summary>
+    /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            _response?.Dispose(); // This will also dispose the inner stream
+        }
+        base.Dispose(disposing);
+    }
+
+    // Delegate all Stream operations to _innerStream
+
+    /// <summary>
+    /// Gets a value indicating whether the current stream supports reading.
+    /// </summary>
+    public override bool CanRead => _innerStream.CanRead;
+
+    /// <summary>
+    /// Gets a value indicating whether the current stream supports seeking.
+    /// </summary>
+    public override bool CanSeek => _innerStream.CanSeek;
+
+    /// <summary>
+    /// Gets a value indicating whether the current stream supports writing.
+    /// </summary>
+    public override bool CanWrite => _innerStream.CanWrite;
+
+    /// <summary>
+    /// Gets the length in bytes of the stream.
+    /// </summary>
+    /// <exception cref="NotSupportedException">The stream does not support seeking.</exception>
+    public override long Length => _innerStream.Length;
+
+    /// <summary>
+    /// Gets or sets the position within the current stream.
+    /// </summary>
+    /// <exception cref="NotSupportedException">The stream does not support seeking.</exception>
+    public override long Position
+    {
+        get => _innerStream.Position;
+        set => _innerStream.Position = value;
+    }
+
+    /// <summary>
+    /// Clears all buffers for this stream and causes any buffered data to be written to the underlying device.
+    /// </summary>
+    public override void Flush() => _innerStream.Flush();
+
+    /// <summary>
+    /// Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
+    /// </summary>
+    /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
+    /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+    /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+    /// <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.</returns>
+    /// <exception cref="ArgumentNullException">buffer is null.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">offset or count is negative.</exception>
+    /// <exception cref="ArgumentException">The sum of offset and count is larger than the buffer length.</exception>
+    /// <exception cref="NotSupportedException">The stream does not support reading.</exception>
+    public override int Read(byte[] buffer, int offset, int count) => _innerStream.Read(buffer, offset, count);
+
+    /// <summary>
+    /// Sets the position within the current stream.
+    /// </summary>
+    /// <param name="offset">A byte offset relative to the origin parameter.</param>
+    /// <param name="origin">A value of type <see cref="SeekOrigin"/> indicating the reference point used to obtain the new position.</param>
+    /// <returns>The new position within the current stream.</returns>
+    /// <exception cref="NotSupportedException">The stream does not support seeking.</exception>
+    public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
+
+    /// <summary>
+    /// Sets the length of the current stream.
+    /// </summary>
+    /// <param name="value">The desired length of the current stream in bytes.</param>
+    /// <exception cref="NotSupportedException">The stream does not support both writing and seeking.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">value is negative.</exception>
+    public override void SetLength(long value) => _innerStream.SetLength(value);
+
+    /// <summary>
+    /// Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
+    /// </summary>
+    /// <param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream.</param>
+    /// <param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream.</param>
+    /// <param name="count">The number of bytes to be written to the current stream.</param>
+    /// <exception cref="ArgumentNullException">buffer is null.</exception>
+    /// <exception cref="ArgumentOutOfRangeException">offset or count is negative.</exception>
+    /// <exception cref="ArgumentException">The sum of offset and count is greater than the buffer length.</exception>
+    /// <exception cref="NotSupportedException">The stream does not support writing.</exception>
+    public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
+}

src/Altinn.App.Core/Infrastructure/Clients/Storage/DataClient.cs

@@ -179,14 +179,25 @@ Guid dataId
 
         string token = _userTokenProvider.GetUserToken();
 
-        HttpResponseMessage response = await _client.GetAsync(token, apiUrl);
+        HttpResponseMessage response = await _client.GetStreamingAsync(token, apiUrl);
 
         if (response.IsSuccessStatusCode)
         {
-            return await response.Content.ReadAsStreamAsync();
+            Stream? stream = null;
+            try
+            {
+                stream = await response.Content.ReadAsStreamAsync();
+                return new ResponseWrapperStream(response, stream);
+            }
+            catch (Exception)
+            {
+                response.Dispose();
+                throw;
+            }
         }
         else if (response.StatusCode == HttpStatusCode.NotFound)
         {
+            response.Dispose();
 #nullable disable
             return null;
 #nullable restore