Use streaming endpoints for streams in Correspondence

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

@@ -6,6 +6,7 @@
 using Altinn.App.Core.Constants;
 using Altinn.App.Core.Features.Correspondence.Exceptions;
 using Altinn.App.Core.Features.Correspondence.Models;
+using Altinn.App.Core.Features.Correspondence.Models.Response;
 using Altinn.App.Core.Models;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
@@ -50,6 +51,72 @@
 
         try
         {
+            if (
+                payload.CorrespondenceRequest.Content.Attachments?.Count > 0
+                && payload.CorrespondenceRequest.Content.Attachments.All(a => a is CorrespondenceStreamedAttachment)
+            )
+            {
+                var pollingJobs = new List<Task>();
+                var premadeAttachments = new List<Guid>();
+                foreach (
+                    CorrespondenceStreamedAttachment attachment in payload.CorrespondenceRequest.Content.Attachments
+                )
+                {
+                    var initializeAttachmentPayload = new AttachmentPayload
+                    {
+                        DisplayName = attachment.Filename,
+                        FileName = attachment.Filename,
+                        IsEncrypted = attachment.IsEncrypted ?? false,
+                        ResourceId = payload.CorrespondenceRequest.ResourceId,
+                        SendersReference = payload.CorrespondenceRequest.SendersReference + " - " + attachment.Filename,
+                    };
+                    var initializeAttachmentRequest = await AuthenticatedHttpRequestFactory(
+                        method: HttpMethod.Post,
+                        uri: GetUri("attachment"),
+                        content: new StringContent(
+                            JsonSerializer.Serialize(initializeAttachmentPayload),
+                            new MediaTypeHeaderValue("application/json")
+                        ),
+                        payload: payload
+                    );
+                    var initializeAttachmentResponse = await HandleServerCommunication<string>(
+                        initializeAttachmentRequest,
+                        cancellationToken
+                    );
+                    var initializeAttachmentContent = initializeAttachmentResponse;
+                    if (initializeAttachmentContent is null)
+                    {
+                        throw new CorrespondenceRequestException(
+                            "Attachment initialization request did not return content.",
+                            null,
+                            HttpStatusCode.InternalServerError,
+                            "No content returned from attachment initialization"
+                        );
+                    }
+                    var attachmentId = initializeAttachmentContent.Trim('"');
+                    HttpContent attachmentDataContent = new StreamContent(attachment.Data);
+                    attachmentDataContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+                    attachmentDataContent.Headers.TryAddWithoutValidation("Transfer-Encoding", "Chunked");
+                    var uploadAttachmentRequest = await AuthenticatedHttpRequestFactory(
+                        method: HttpMethod.Post,
+                        uri: GetUri($"attachment/{attachmentId}/upload"),
+                        content: attachmentDataContent,
+                        payload: payload
+                    );
+                    var uploadAttachmentResponse = await HandleServerCommunication<AttachmentOverview>(
+                        uploadAttachmentRequest,
+                        cancellationToken
+                    );
+                    if (Guid.TryParse(attachmentId, out var guidId))
+                    {
+                        premadeAttachments.Add(guidId);
+                        pollingJobs.Add(PollAttachmentStatus(guidId, payload, cancellationToken));
+                    }
+                }
+                await Task.WhenAll(pollingJobs);
+                payload.CorrespondenceRequest.ExistingAttachments = premadeAttachments;
+                payload.CorrespondenceRequest.Content.Attachments = [];
+            }
             using MultipartFormDataContent content = payload.CorrespondenceRequest.Serialise();
             using HttpRequestMessage request = await AuthenticatedHttpRequestFactory(
                 method: HttpMethod.Post,
@@ -88,6 +155,45 @@
         }
     }
 
+    /// <inheritdoc />
+    private async Task PollAttachmentStatus(
+        Guid attachmentId,
+        CorrespondencePayloadBase payload,
+        CancellationToken cancellationToken
+    )
+    {
+        const int maxAttempts = 3;
+        const int delaySeconds = 5;
+
+        for (int attempt = 1; attempt <= maxAttempts; attempt++)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(delaySeconds), cancellationToken);
+
+            var statusRequest = await AuthenticatedHttpRequestFactory(
+                method: HttpMethod.Get,
+                uri: GetUri($"attachment/{attachmentId}"),
+                content: null,
+                payload: payload
+            );
+            var statusResponse = await HandleServerCommunication<AttachmentOverview>(statusRequest, cancellationToken);
+
+            if (statusResponse is null)
+            {
+                break;
+            }
+            if (statusResponse.Status == "Published")
+            {
+                return;
+            }
+        }
+        throw new CorrespondenceRequestException(
+            $"Failure when uploading attachment. Attachment was not published in time.",
+            null,
+            HttpStatusCode.InternalServerError,
+            "Polling failed"
+        );
+    }
+
     /// <inheritdoc/>
     public async Task<GetCorrespondenceStatusResponse> GetStatus(
         GetCorrespondenceStatusPayload payload,
@@ -191,6 +297,7 @@
     )
     {
         using HttpClient client = _httpClientFactory.CreateClient();
+
         using HttpResponseMessage response = await client.SendAsync(request, cancellationToken);
         string responseBody = await response.Content.ReadAsStringAsync(cancellationToken);
 

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

@@ -0,0 +1,32 @@
+namespace Altinn.App.Core.Features.Correspondence.Models;
+
+/// <summary>
+/// Represents the payload for sending an attachment.
+/// </summary>
+internal class AttachmentPayload
+{
+    /// <summary>
+    /// Gets or sets the Resource Id for the correspondence service.
+    /// </summary>
+    public required string ResourceId { get; set; }
+
+    /// <summary>
+    /// The name of the attachment file.
+    /// </summary>
+    public string? FileName { get; set; }
+
+    /// <summary>
+    /// A logical name for the file, which will be shown in Altinn Inbox.
+    /// </summary>
+    public string? DisplayName { get; set; }
+
+    /// <summary>
+    /// A value indicating whether the attachment is encrypted or not.
+    /// </summary>
+    public required bool IsEncrypted { get; set; }
+
+    /// <summary>
+    /// A reference value given to the attachment by the creator.
+    /// </summary>
+    public required string SendersReference { get; set; }
+}

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/CorrespondenceContent.cs

@@ -30,7 +30,7 @@ public sealed record CorrespondenceContent : MultipartCorrespondenceItem
     /// <summary>
     /// File attachments to associate with this correspondence.
     /// </summary>
-    public IReadOnlyList<CorrespondenceAttachment>? Attachments { get; init; }
+    public IReadOnlyList<CorrespondenceAttachment>? Attachments { get; set; }
 
     internal void Serialise(MultipartFormDataContent content)
     {

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))
@@ -301,7 +308,7 @@ public sealed record CorrespondenceRequest : MultipartCorrespondenceItem
     /// <summary>
     /// Existing attachments that should be added to the correspondence.
     /// </summary>
-    public IReadOnlyList<Guid>? ExistingAttachments { get; init; }
+    public IReadOnlyList<Guid>? ExistingAttachments { get; set; }
 
     /// <summary>
     /// Serialises the entire <see cref="CorrespondenceRequest"/> object to a provided <see cref="MultipartFormDataContent"/> instance.
@@ -321,7 +328,7 @@ internal void Serialise(MultipartFormDataContent content)
         AddIfNotNull(content, IgnoreReservation?.ToString(), "Correspondence.IgnoreReservation");
         AddIfNotNull(content, IsConfirmationNeeded?.ToString(), "Correspondence.IsConfirmationNeeded");
         AddDictionaryItems(content, PropertyList, x => x, key => $"Correspondence.PropertyList.{key}");
-        AddListItems(content, ExistingAttachments, x => x.ToString(), i => $"Correspondence.ExistingAttachments[{i}]");
+        AddListItems(content, ExistingAttachments, x => x.ToString(), i => $"ExistingAttachments[{i}]");
         AddListItems(content, Recipients, x => x.ToUrnFormattedString(), i => $"Recipients[{i}]");
 
         Content.Serialise(content);