Updated LegacyFileController with new method that takes multiple file… (#784)

tomshag · web-flow · commit 7ba28fcde968 · 2025-09-19T10:39:04.000+02:00
* Updated LegacyFileController with new method that takes multiple filereferences and returns multiple files

* update based on automated comments

* ensuring distinctids
diff --git a/src/Altinn.Broker.API/Controllers/LegacyFileController.cs b/src/Altinn.Broker.API/Controllers/LegacyFileController.cs
@@ -65,6 +65,7 @@ CancellationToken cancellationToken
         {
             return Problem("Content-length header is required");
         }
+        
         var commandResult = await handler.Process(new UploadFileRequest()
         {
             FileTransferId = fileTransferId,
@@ -79,6 +80,38 @@ CancellationToken cancellationToken
         );
     }
 
+    [HttpPost]
+    [Route("overviews")]
+    public async Task<ActionResult<List<LegacyFileOverviewExt>>> GetFileOverviews(
+        [FromBody] List<Guid> fileTransferIds,
+        [FromQuery] string onBehalfOfConsumer,
+        [FromServices] GetFileTransferOverviewHandler handler,
+        CancellationToken cancellationToken)
+    {
+        if (fileTransferIds is null || fileTransferIds.Count == 0)
+        {
+            return Problem("At least one fileTransferId must be provided.", statusCode: 400);
+        }
+        if (string.IsNullOrWhiteSpace(onBehalfOfConsumer))
+        {
+            return Problem("Query parameter 'onBehalfOfConsumer' is required.", statusCode: 400);
+        }
+
+        var distinctIds = fileTransferIds.Distinct().ToList();
+        logger.LogInformation("Legacy - Getting file overviews for {Count}, starting with {FirstId}", distinctIds.Count, distinctIds[0]);
+        var queryResult = await handler.ProcessMultiple(new GetFileTransferOverviewRequest()
+        {
+            FileTransferIds = distinctIds,
+            IsLegacy = true,
+            OnBehalfOfConsumer = onBehalfOfConsumer
+        }, HttpContext.User, cancellationToken);
+        return queryResult.Match(
+            result => Ok(LegacyFileStatusOverviewExtMapper.MapToExternalModels(result.FileTransfers)),
+            Problem
+        );
+    }
+    
+
     /// <summary>
     /// Get information about the file and its current status
     /// </summary>
diff --git a/src/Altinn.Broker.API/Mappers/LegacyFileStatusOverviewExtMapper.cs b/src/Altinn.Broker.API/Mappers/LegacyFileStatusOverviewExtMapper.cs
@@ -9,6 +9,11 @@ namespace Altinn.Broker.Mappers;
 
 internal static class LegacyFileStatusOverviewExtMapper
 {
+    internal static List<LegacyFileOverviewExt> MapToExternalModels(IReadOnlyList<FileTransferEntity> fileTransfers)
+    {
+        return [.. fileTransfers.Select(MapToExternalModel)];
+    }
+
     internal static LegacyFileOverviewExt MapToExternalModel(FileTransferEntity fileTransfer)
     {
         return new LegacyFileOverviewExt()
diff --git a/src/Altinn.Broker.Application/GetFileTransferOverview/GetFileTransferOverviewHandler.cs b/src/Altinn.Broker.Application/GetFileTransferOverview/GetFileTransferOverviewHandler.cs
@@ -39,4 +39,33 @@ public async Task<OneOf<GetFileTransferOverviewResponse, Error>> Process(GetFile
             FileTransfer = fileTransfer
         };
     }
+
+    public async Task<OneOf<GetFileTransferOverviewsResponse, Error>> ProcessMultiple(GetFileTransferOverviewRequest request, ClaimsPrincipal? user, CancellationToken cancellationToken)
+    {
+        var ids = request.FileTransferIds ?? [];
+        logger.LogInformation("Retrieving file overview for {Transfers} file transfers. Legacy: {Legacy}", ids.Count, request.IsLegacy);
+        var fileTransfers = await TransactionWithRetriesPolicy.Execute(
+        async (cancellationToken) => await fileTransferRepository.GetFileTransfers(ids, cancellationToken),
+             logger,
+             cancellationToken);
+        if (fileTransfers is null)
+        {
+            return Errors.FileTransferNotFound;
+        }
+        var accessChecks = await Task.WhenAll(
+        fileTransfers.Select(ft => authorizationService.CheckAccessAsSenderOrRecipient(user, ft, request.IsLegacy, cancellationToken)));
+        if (accessChecks.Any(allowed => !allowed))
+        {
+            return Errors.NoAccessToResource;
+        }
+        if (request.IsLegacy && !string.IsNullOrWhiteSpace(request.OnBehalfOfConsumer)
+            && fileTransfers.Any(ft => !ft.IsSenderOrRecipient(request.OnBehalfOfConsumer!)))
+        {
+            return Errors.NoAccessToResource;
+        }
+        return new GetFileTransferOverviewsResponse()
+        {
+            FileTransfers = fileTransfers
+        };
+    }
 }
diff --git a/src/Altinn.Broker.Application/GetFileTransferOverview/GetFileTransferOverviewRequest.cs b/src/Altinn.Broker.Application/GetFileTransferOverview/GetFileTransferOverviewRequest.cs
@@ -4,6 +4,7 @@ namespace Altinn.Broker.Application.GetFileTransferOverview;
 
 public class GetFileTransferOverviewRequest
 {
+    public List<Guid>? FileTransferIds { get; set; }
     public Guid FileTransferId { get; set; }
     public bool IsLegacy { get; set; }
     public string? OnBehalfOfConsumer { get; set; }
diff --git a/src/Altinn.Broker.Application/GetFileTransferOverview/GetFileTransferOverviewsResponse.cs b/src/Altinn.Broker.Application/GetFileTransferOverview/GetFileTransferOverviewsResponse.cs
@@ -0,0 +1,8 @@
+using Altinn.Broker.Core.Domain;
+
+namespace Altinn.Broker.Application.GetFileTransferOverview;
+
+public class GetFileTransferOverviewsResponse
+{
+    public required IReadOnlyList<FileTransferEntity> FileTransfers { get; set; }
+}
diff --git a/src/Altinn.Broker.Core/Repositories/IFileTransferRepository.cs b/src/Altinn.Broker.Core/Repositories/IFileTransferRepository.cs
@@ -17,6 +17,7 @@ Task<Guid> AddFileTransfer(
         bool useVirusScan,
         CancellationToken cancellationToken);
     Task<Domain.FileTransferEntity?> GetFileTransfer(Guid fileTransferId, CancellationToken cancellationToken);
+    Task<IReadOnlyList<FileTransferEntity>> GetFileTransfers(IReadOnlyCollection<Guid> fileTransferIds, CancellationToken cancellationToken);
     Task<List<Guid>> GetFileTransfersAssociatedWithActor(FileTransferSearchEntity fileTransferSearch, CancellationToken cancellationToken);
     Task<List<Guid>> GetFileTransfersForRecipientWithRecipientStatus(FileTransferSearchEntity fileTransferSearch, CancellationToken cancellationToken);
     Task<List<Guid>> LegacyGetFilesForRecipientsWithRecipientStatus(LegacyFileSearchEntity fileTransferSearch, CancellationToken cancellationToken);
diff --git a/src/Altinn.Broker.Persistence/Repositories/FileTransferRepository.cs b/src/Altinn.Broker.Persistence/Repositories/FileTransferRepository.cs
@@ -15,10 +15,54 @@ namespace Altinn.Broker.Persistence.Repositories;
 
 public class FileTransferRepository(NpgsqlDataSource dataSource, IActorRepository actorRepository, ExecuteDBCommandWithRetries commandExecutor) : IFileTransferRepository
 {
-    public async Task<FileTransferEntity?> GetFileTransfer(Guid fileTransferId, CancellationToken cancellationToken)
-    {
-        await using var command = dataSource.CreateCommand(
-            @"
+    #region constants
+    const string overviewCommandMultiple = @"
+                SELECT 
+                    f.file_transfer_id_pk, 
+                    f.resource_id, 
+                    f.filename, 
+                    f.checksum, 
+                    f.sender_actor_id_fk, 
+                    f.external_file_transfer_reference, 
+                    f.created, 
+                    f.file_location,
+                    f.file_transfer_size,
+                    f.expiration_time, 
+                    f.hangfire_job_id,
+                    f.use_virus_scan,
+                    sender.actor_external_id as senderActorExternalReference,
+                    fs_latest.file_transfer_status_description_id_fk, 
+                    fs_latest.file_transfer_status_date, 
+                    fs_latest.file_transfer_status_detailed_description
+                FROM 
+                    broker.file_transfer f
+                INNER JOIN 
+                    broker.actor sender ON sender.actor_id_pk = f.sender_actor_id_fk
+                LEFT JOIN 
+                    (
+                        SELECT 
+                            fs.file_transfer_id_fk,
+                            fs.file_transfer_status_description_id_fk,
+                            fs.file_transfer_status_date,
+                            fs.file_transfer_status_detailed_description
+                        FROM 
+                            broker.file_transfer_status fs
+                        INNER JOIN 
+                            (
+                                SELECT 
+                                    file_transfer_id_fk, 
+                                    MAX(file_transfer_status_date) as max_date
+                                FROM 
+                                    broker.file_transfer_status 
+                                GROUP BY 
+                                    file_transfer_id_fk
+                            ) fs_max ON fs.file_transfer_id_fk = fs_max.file_transfer_id_fk AND fs.file_transfer_status_date = fs_max.max_date
+                        WHERE 
+                            fs.file_transfer_id_fk IN (select unnest(@fileTransferIds))
+                    ) fs_latest ON f.file_transfer_id_pk = fs_latest.file_transfer_id_fk
+                WHERE 
+                    f.file_transfer_id_pk IN (select unnest(@fileTransferIds));";
+    const string overviewCommandSingle = @"
                 SELECT 
                     f.file_transfer_id_pk, 
                     f.resource_id, 
@@ -63,16 +107,82 @@ GROUP BY
                             fs.file_transfer_id_fk = @fileTransferId
                     ) fs_latest ON f.file_transfer_id_pk = fs_latest.file_transfer_id_fk
                 WHERE 
-                    f.file_transfer_id_pk = @fileTransferId;");
+                    f.file_transfer_id_pk = @fileTransferId;";
+    #endregion
+    public async Task<IReadOnlyList<FileTransferEntity>> GetFileTransfers(IReadOnlyCollection<Guid> fileTransferIds, CancellationToken cancellationToken)
+    {
+        if (fileTransferIds is null || fileTransferIds.Count == 0)
+        {
+            return new List<FileTransferEntity>(0);
+        }
         
+        await using var command = dataSource.CreateCommand(overviewCommandMultiple);
+
+        var parameter = new NpgsqlParameter("@fileTransferIds", NpgsqlDbType.Array | NpgsqlDbType.Uuid)
+        {
+            Value = fileTransferIds.ToArray()
+        };
+
+        command.Parameters.Add(parameter);
+        return await commandExecutor.ExecuteWithRetry(async (ct) =>
+        {
+            List<FileTransferEntity> fileTransferEntities = new List<FileTransferEntity>();
+            FileTransferEntity? fileTransfer = null;
+
+            await using var reader = await command.ExecuteReaderAsync(ct);
+            while (await reader.ReadAsync(ct))
+            {
+                var fileTransferId = reader.GetGuid(reader.GetOrdinal("file_transfer_id_pk"));
+                fileTransfer = new FileTransferEntity
+                {
+                    FileTransferId = fileTransferId,
+                    ResourceId = reader.GetString(reader.GetOrdinal("resource_id")),
+                    FileName = reader.GetString(reader.GetOrdinal("filename")),
+                    Checksum = reader.IsDBNull(reader.GetOrdinal("checksum")) ? null : reader.GetString(reader.GetOrdinal("checksum")),
+                    SendersFileTransferReference = reader.GetString(reader.GetOrdinal("external_file_transfer_reference")),
+                    HangfireJobId = reader.IsDBNull(reader.GetOrdinal("hangfire_job_id")) ? null : reader.GetString(reader.GetOrdinal("hangfire_job_id")),
+                    FileTransferStatusEntity = new FileTransferStatusEntity()
+                    {
+                        FileTransferId = fileTransferId,
+                        Status = (FileTransferStatus)reader.GetInt32(reader.GetOrdinal("file_transfer_status_description_id_fk")),
+                        Date = reader.GetDateTime(reader.GetOrdinal("file_transfer_status_date")),
+                        DetailedStatus = reader.IsDBNull(reader.GetOrdinal("file_transfer_status_detailed_description")) ? null : reader.GetString(reader.GetOrdinal("file_transfer_status_detailed_description"))
+                    },
+                    FileTransferStatusChanged = reader.GetDateTime(reader.GetOrdinal("file_transfer_status_date")),
+                    Created = reader.GetDateTime(reader.GetOrdinal("created")),
+                    ExpirationTime = reader.GetDateTime(reader.GetOrdinal("expiration_time")),
+                    FileLocation = reader.IsDBNull(reader.GetOrdinal("file_location")) ? null : reader.GetString(reader.GetOrdinal("file_location")),
+                    FileTransferSize = reader.IsDBNull(reader.GetOrdinal("file_transfer_size")) ? 0 : reader.GetInt64(reader.GetOrdinal("file_transfer_size")),
+                    Sender = new ActorEntity()
+                    {
+                        ActorId = reader.GetInt64(reader.GetOrdinal("sender_actor_id_fk")),
+                        ActorExternalId = reader.GetString(reader.GetOrdinal("senderActorExternalReference"))
+                    },
+                    RecipientCurrentStatuses = await GetLatestRecipientFileTransferStatuses(fileTransferId, ct),
+                    PropertyList = await GetMetadata(fileTransferId, ct),
+                    UseVirusScan = reader.GetBoolean(reader.GetOrdinal("use_virus_scan"))
+                };
+
+                fileTransferEntities.Add(fileTransfer);
+                EnrichLogs(fileTransfer);
+            }
+
+            return fileTransferEntities;
+        }, cancellationToken);
+    }
+
+    public async Task<FileTransferEntity?> GetFileTransfer(Guid fileTransferId, CancellationToken cancellationToken)
+    {
+        await using var command = dataSource.CreateCommand(overviewCommandSingle);
+
         command.Parameters.AddWithValue("@fileTransferId", fileTransferId);
-        
-        return await commandExecutor.ExecuteWithRetry(async (ct) => 
+
+        return await commandExecutor.ExecuteWithRetry(async (ct) =>
         {
             FileTransferEntity? fileTransfer = null;
-            
+
             await using var reader = await command.ExecuteReaderAsync(ct);
-            
+
             if (await reader.ReadAsync(ct))
             {
                 fileTransfer = new FileTransferEntity
@@ -104,7 +214,7 @@ GROUP BY
                     PropertyList = await GetMetadata(fileTransferId, ct),
                     UseVirusScan = reader.GetBoolean(reader.GetOrdinal("use_virus_scan"))
                 };
-                
+
                 EnrichLogs(fileTransfer);
             }
 
diff --git a/tests/Altinn.Broker.Tests/LegacyFileControllerTests.cs b/tests/Altinn.Broker.Tests/LegacyFileControllerTests.cs
@@ -317,6 +317,70 @@ public async Task GetFileOverview_SentByA3Sender_Success()
         Assert.Equal(fileTransferId, fileData.FileId.ToString());
     }
 
+    [Fact]
+    public async Task GetFileOverview_MultipleSentByA3Sender_Success()
+    {
+        // Arrange
+        var file = FileTransferInitializeExtTestFactory.BasicFileTransfer();
+        var initializeFileResponse = await _senderClient.PostAsJsonAsync("broker/api/v1/filetransfer", FileTransferInitializeExtTestFactory.BasicFileTransfer());
+        Assert.True(initializeFileResponse.IsSuccessStatusCode, await initializeFileResponse.Content.ReadAsStringAsync());
+        var initializeFileResponse2 = await _senderClient.PostAsJsonAsync("broker/api/v1/filetransfer", FileTransferInitializeExtTestFactory.BasicFileTransfer());
+        Assert.True(initializeFileResponse2.IsSuccessStatusCode, await initializeFileResponse.Content.ReadAsStringAsync());
+        var initializeFileResponse3 = await _senderClient.PostAsJsonAsync("broker/api/v1/filetransfer", FileTransferInitializeExtTestFactory.BasicFileTransfer());
+        Assert.True(initializeFileResponse3.IsSuccessStatusCode, await initializeFileResponse.Content.ReadAsStringAsync());
+        var initializeFileResponse4 = await _senderClient.PostAsJsonAsync("broker/api/v1/filetransfer", FileTransferInitializeExtTestFactory.BasicFileTransfer());
+        Assert.True(initializeFileResponse4.IsSuccessStatusCode, await initializeFileResponse.Content.ReadAsStringAsync());
+        var fileTransferResponse = await initializeFileResponse.Content.ReadFromJsonAsync<FileTransferInitializeResponseExt>();
+        var fileTransferResponse2 = await initializeFileResponse2.Content.ReadFromJsonAsync<FileTransferInitializeResponseExt>();
+        var fileTransferResponse3 = await initializeFileResponse3.Content.ReadFromJsonAsync<FileTransferInitializeResponseExt>();
+        var fileTransferResponse4 = await initializeFileResponse4.Content.ReadFromJsonAsync<FileTransferInitializeResponseExt>();        
+        Assert.NotNull(fileTransferResponse);
+        Assert.NotNull(fileTransferResponse2);
+        Assert.NotNull(fileTransferResponse3);
+        Assert.NotNull(fileTransferResponse4);
+        var fileTransferId = fileTransferResponse.FileTransferId.ToString();
+        var fileTransferId2 = fileTransferResponse2.FileTransferId.ToString();
+        var fileTransferId3 = fileTransferResponse3.FileTransferId.ToString();
+        var fileTransferId4 = fileTransferResponse4.FileTransferId.ToString();
+        var initializedFile = await _senderClient.GetFromJsonAsync<FileTransferOverviewExt>($"broker/api/v1/filetransfer/{fileTransferId}", _responseSerializerOptions);
+        Assert.NotNull(initializedFile);
+        var uploadedFileBytes = Encoding.UTF8.GetBytes("This is the contents of the uploaded file");
+        using (var content = new ByteArrayContent(uploadedFileBytes))
+        using (var content2 = new ByteArrayContent(uploadedFileBytes))
+        using (var content3 = new ByteArrayContent(uploadedFileBytes))
+        using (var content4 = new ByteArrayContent(uploadedFileBytes))
+        {
+            content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+            content2.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+            content3.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+            content4.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
+            var uploadResponse = await _senderClient.PostAsync($"broker/api/v1/filetransfer/{fileTransferId}/upload", content);
+            var uploadResponse2 = await _senderClient.PostAsync($"broker/api/v1/filetransfer/{fileTransferId2}/upload", content2);
+            var uploadResponse3 = await _senderClient.PostAsync($"broker/api/v1/filetransfer/{fileTransferId3}/upload", content3);
+            var uploadResponse4 = await _senderClient.PostAsync($"broker/api/v1/filetransfer/{fileTransferId4}/upload", content4);
+            Assert.True(uploadResponse.IsSuccessStatusCode, await uploadResponse.Content.ReadAsStringAsync());
+            Assert.True(uploadResponse2.IsSuccessStatusCode, await uploadResponse.Content.ReadAsStringAsync());
+            Assert.True(uploadResponse3.IsSuccessStatusCode, await uploadResponse.Content.ReadAsStringAsync());
+            Assert.True(uploadResponse4.IsSuccessStatusCode, await uploadResponse.Content.ReadAsStringAsync());
+        }
+
+        List<Guid> ids = [fileTransferResponse.FileTransferId, fileTransferResponse2.FileTransferId, fileTransferResponse3.FileTransferId, fileTransferResponse4.FileTransferId];
+
+        // Act
+        var getResponse = await _legacyClient.PostAsJsonAsync($"broker/api/v1/legacy/file/overviews?onBehalfOfConsumer={file.Recipients[0]}", ids);
+        Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);
+        var fileData = await getResponse.Content.ReadFromJsonAsync<List<LegacyFileOverviewExt>>(_responseSerializerOptions);
+
+        // Assert        
+        Assert.Equal(HttpStatusCode.OK, getResponse.StatusCode);
+        Assert.NotNull(fileData);
+        var resultIds = fileData.Select(fd => fd.FileId.ToString());
+        Assert.Contains(fileTransferId, resultIds);
+        Assert.Contains(fileTransferId2, resultIds);
+        Assert.Contains(fileTransferId3, resultIds);
+        Assert.Contains(fileTransferId4, resultIds);
+    }
+
     [Fact]
     public async Task GetFileOverview_2FilesInitiated_1Published_StandardRequestRetrievesOnlyPublished_Success()
     {

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,11 @@ namespace Altinn.Broker.Mappers;`
`9`	`9`
`10`	`10`	`internal static class LegacyFileStatusOverviewExtMapper`
`11`	`11`	`{`
	`12`	`+ internal static List<LegacyFileOverviewExt> MapToExternalModels(IReadOnlyList<FileTransferEntity> fileTransfers)`
	`13`	`+ {`
	`14`	`+ return [.. fileTransfers.Select(MapToExternalModel)];`
	`15`	`+ }`
	`16`	`+`
`12`	`17`	`internal static LegacyFileOverviewExt MapToExternalModel(FileTransferEntity fileTransfer)`
`13`	`18`	`{`
`14`	`19`	`return new LegacyFileOverviewExt()`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ namespace Altinn.Broker.Application.GetFileTransferOverview;`
`4`	`4`
`5`	`5`	`public class GetFileTransferOverviewRequest`
`6`	`6`	`{`
	`7`	`+ public List<Guid>? FileTransferIds { get; set; }`
`7`	`8`	`public Guid FileTransferId { get; set; }`
`8`	`9`	`public bool IsLegacy { get; set; }`
`9`	`10`	`public string? OnBehalfOfConsumer { get; set; }`