New experiment

Author: Ceredron

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

@@ -1,12 +1,17 @@
+using System;
 using System.Diagnostics;
 using System.Net;
 using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Net.Mail;
 using System.Text.Json;
 using Altinn.App.Core.Configuration;
 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 Altinn.App.Core.Models.Notifications.Email;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -50,6 +55,70 @@ public async Task<SendCorrespondenceResponse> Send(
 
         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<SendCorrespondenceResponse>(
+                        initializeAttachmentRequest,
+                        cancellationToken
+                    );
+                    var initializeAttachmentContent = initializeAttachmentRequest.Content;
+                    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 = await initializeAttachmentContent.ReadAsStringAsync(cancellationToken);
+                    attachmentId = attachmentId.Trim('"');
+                    var attachmentDataContent = new StreamContent(attachment.Data);
+                    attachmentDataContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+                    var uploadAttachmentRequest = await AuthenticatedHttpRequestFactory(
+                        method: HttpMethod.Post,
+                        uri: GetUri("attachment/upload"),
+                        content: attachmentDataContent,
+                        payload: payload
+                    );
+                    var uploadAttachmentResponse = await HandleServerCommunication<SendCorrespondenceResponse>(
+                        uploadAttachmentRequest,
+                        cancellationToken
+                    );
+                    if (Guid.TryParse(attachmentId, out var guidId))
+                    {
+                        pollingJobs.Add(PollAttachmentStatus(guidId, payload, cancellationToken));
+                    }
+                }
+                await Task.WhenAll(pollingJobs);
+                payload.CorrespondenceRequest.ExistingAttachments = premadeAttachments;
+            }
             using MultipartFormDataContent content = payload.CorrespondenceRequest.Serialise();
             using HttpRequestMessage request = await AuthenticatedHttpRequestFactory(
                 method: HttpMethod.Post,
@@ -88,6 +157,47 @@ public async Task<SendCorrespondenceResponse> Send(
         }
     }
 
+    /// <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 statusResponse = await AuthenticatedHttpRequestFactory(
+                method: HttpMethod.Get,
+                uri: GetUri($"attachment/{attachmentId}"),
+                content: null,
+                payload: payload
+            );
+            var pollContent = statusResponse.Content;
+
+            if (pollContent is null)
+            {
+                break;
+            }
+
+            var statusContent = await pollContent.ReadFromJsonAsync<AttachmentOverview>(cancellationToken);
+            if (statusContent?.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,

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

@@ -308,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.

src/Altinn.App.Core/Features/Correspondence/Models/Response/AttachmentOverview.cs

@@ -0,0 +1,27 @@
+namespace Altinn.App.Core.Features.Correspondence.Models.Response;
+
+/// <summary>
+/// Status of an attachment
+/// </summary>
+internal class AttachmentOverview
+{
+    /// <summary>
+    /// Unique Id for this attachment
+    /// </summary>
+    public required Guid AttachmentId { get; set; }
+
+    /// <summary>
+    /// Current attachment status
+    /// </summary>
+    public required string Status { get; set; }
+
+    /// <summary>
+    /// Current attachment status text description
+    /// </summary>
+    public required string StatusText { get; set; }
+
+    /// <summary>
+    /// Timestamp for when the Current Attachment Status was changed
+    /// </summary>
+    public required DateTimeOffset StatusChanged { get; set; }
+}

test/Altinn.App.Core.Tests/PublicApiTests.PublicApi_ShouldNotChange_Unintentionally.verified.txt

@@ -1009,7 +1009,7 @@ namespace Altinn.App.Core.Features.Correspondence.Models
         public required System.DateTimeOffset? AllowSystemDeleteAfter { get; init; }
         public required Altinn.App.Core.Features.Correspondence.Models.CorrespondenceContent Content { get; init; }
         public System.DateTimeOffset? DueDateTime { get; init; }
-        public System.Collections.Generic.IReadOnlyList<System.Guid>? ExistingAttachments { get; init; }
+        public System.Collections.Generic.IReadOnlyList<System.Guid>? ExistingAttachments { get; set; }
         public System.Collections.Generic.IReadOnlyList<Altinn.App.Core.Features.Correspondence.Models.CorrespondenceExternalReference>? ExternalReferences { get; init; }
         public bool? IgnoreReservation { get; init; }
         public bool? IsConfirmationNeeded { get; init; }