Merge pull request #752 from Project-MONAI/AC-1979

AC-1979 added endpoint for get by AE Title

Author: neildsouth

src/WorkflowManager/Common/Interfaces/IWorkflowService.cs

@@ -50,5 +50,21 @@ public interface IWorkflowService : IPaginatedApi<WorkflowRevision>
         /// </summary>
         /// <param name="workflow">Workflow to delete.</param>
         Task<DateTime> DeleteWorkflowAsync(WorkflowRevision workflow);
+
+        /// <summary>
+        /// get all workflows with AeTitle
+        /// </summary>
+        /// <param name="aeTitle">the title to get</param>
+        /// <param name="skip">skip x num of records</param>
+        /// <param name="limit">limit to x number</param>
+        /// <returns></returns>
+        Task<IEnumerable<WorkflowRevision>> GetByAeTitleAsync(string aeTitle, int? skip = null, int? limit = null);
+
+        /// <summary>
+        /// returns the number of workflows with this aetitle
+        /// </summary>
+        /// <param name="aeTitle">the title to count</param>
+        /// <returns></returns>
+        Task<long> GetCountByAeTitleAsync(string aeTitle);
     }
 }

src/WorkflowManager/Common/Services/WorkflowService.cs

@@ -88,5 +88,13 @@ public Task<DateTime> DeleteWorkflowAsync(WorkflowRevision workflow)
 
         public async Task<IList<WorkflowRevision>> GetAllAsync(int? skip = null, int? limit = null)
             => await _workflowRepository.GetAllAsync(skip, limit);
+
+
+        public async Task<IEnumerable<WorkflowRevision>> GetByAeTitleAsync(string aeTitle, int? skip = null, int? limit = null)
+        => await _workflowRepository.GetAllByAeTitleAsync(aeTitle, skip, limit);
+
+        public async Task<long> GetCountByAeTitleAsync(string aeTitle)
+         => await _workflowRepository.GetCountByAeTitleAsync(aeTitle);
+
     }
 }

src/WorkflowManager/Database/Interfaces/IWorkflowRepository.cs

@@ -52,6 +52,15 @@ public interface IWorkflowRepository
         /// <param name="aeTitle">An aeTitle to retrieve.</param>
         Task<WorkflowRevision> GetByAeTitleAsync(string aeTitle);
 
+        Task<IEnumerable<WorkflowRevision>> GetAllByAeTitleAsync(string aeTitle, int? skip, int? limit);
+
+        /// <summary>
+        /// Retrieves a count of workflows based on an aeTitle.
+        /// </summary>
+        /// <param name="aeTitle"></param>
+        /// <returns></returns>
+        Task<long> GetCountByAeTitleAsync(string aeTitle);
+
         /// <summary>
         /// Retrieves a list of workflows based on an aeTitle.
         /// </summary>

src/WorkflowManager/Database/Repositories/WorkflowRepository.cs

@@ -43,6 +43,33 @@ public WorkflowRepository(
 
             var mongoDatabase = client.GetDatabase(databaseSettings.Value.DatabaseName);
             _workflowCollection = mongoDatabase.GetCollection<WorkflowRevision>("Workflows");
+            EnsureIndex().GetAwaiter().GetResult();
+        }
+
+        private async Task EnsureIndex()
+        {
+            Guard.Against.Null(_workflowCollection, "WorkflowCollection");
+
+            var asyncCursor = (await _workflowCollection.Indexes.ListAsync());
+            var bsonDocuments = (await asyncCursor.ToListAsync());
+            var indexes = bsonDocuments.Select(_ => _.GetElement("name").Value.ToString()).ToList();
+
+            // If index not present create it else skip.
+            if (!indexes.Any(i => i is not null && i.Equals("AeTitleIndex")))
+            {
+                // Create Index here
+
+                var options = new CreateIndexOptions()
+                {
+                    Name = "AeTitleIndex"
+                };
+                var model = new CreateIndexModel<WorkflowRevision>(
+                    Builders<WorkflowRevision>.IndexKeys.Ascending(s => s.Workflow.InformaticsGateway.AeTitle),
+                    options
+                    );
+
+                await _workflowCollection.Indexes.CreateOneAsync(model);
+            }
         }
 
         public List<WorkflowRevision> GetWorkflowsList()
@@ -123,6 +150,29 @@ public async Task<WorkflowRevision> GetByAeTitleAsync(string aeTitle)
             return workflow;
         }
 
+        public async Task<IEnumerable<WorkflowRevision>> GetAllByAeTitleAsync(string aeTitle, int? skip, int? limit)
+        {
+            Guard.Against.NullOrWhiteSpace(aeTitle, nameof(aeTitle));
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+            var workflows = await _workflowCollection
+                .Find(x => x.Workflow.InformaticsGateway.AeTitle == aeTitle && x.Deleted == null)
+                .Skip(skip)
+                .Limit(limit)
+                .ToListAsync();
+
+            return workflows
+                .GroupBy(w => w.WorkflowId)
+                .Select(g => g.First())
+                .ToList(); ;
+        }
+
+        public async Task<long> GetCountByAeTitleAsync(string aeTitle)
+        {
+            Guard.Against.NullOrWhiteSpace(aeTitle, nameof(aeTitle));
+            return await _workflowCollection
+                .CountDocumentsAsync(x => x.Workflow.InformaticsGateway.AeTitle == aeTitle && x.Deleted == null);
+        }
+
         public async Task<IList<WorkflowRevision>> GetWorkflowsByAeTitleAsync(List<string> aeTitles)
         {
             Guard.Against.NullOrEmpty(aeTitles, nameof(aeTitles));

src/WorkflowManager/Logging/Log.100000.Http.cs

@@ -61,5 +61,8 @@ public static partial class Log
 
         [LoggerMessage(EventId = 100013, Level = LogLevel.Information, Message = "BYpass authentication.")]
         public static partial void BypassAuthentication(this ILogger logger);
+
+        [LoggerMessage(EventId = 100014, Level = LogLevel.Error, Message = "Unexpected error occurred in get /workflows/aetitle API.")]
+        public static partial void WorkflowGetAeTitleAsyncError(this ILogger logger, Exception ex);
     }
 }

src/WorkflowManager/WorkflowManager/Controllers/WorkflowsController.cs

@@ -295,5 +295,52 @@ public async Task<IActionResult> DeleteAsync([FromRoute] string id)
                     InternalServerError);
             }
         }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="title"></param>
+        /// <param name="filter"></param>
+        /// <returns>A <see cref="Task{TResult}"/> representing the result of the asynchronous operation.</returns>
+        [HttpGet("aetitle/{title}")]
+        [ProducesResponseType(typeof(WorkflowRevision), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status500InternalServerError)]
+        public async Task<IActionResult> GetByAeTitle([FromRoute] string title, [FromQuery] PaginationFilter filter)
+        {
+            if (string.IsNullOrWhiteSpace(title))
+            {
+                _logger.LogDebug($"{nameof(GetByAeTitle)} - Failed to validate {nameof(title)}");
+
+                return Problem($"Failed to validate {nameof(title)}, not a valid AE title", $"/workflows/aetitle/{title}", BadRequest);
+            }
+
+            try
+            {
+                var route = Request?.Path.Value ?? string.Empty;
+                var pageSize = filter.PageSize ?? _options.Value.EndpointSettings.DefaultPageSize;
+                var validFilter = new PaginationFilter(filter.PageNumber, pageSize, _options.Value.EndpointSettings.MaxPageSize);
+
+                var pagedData = await _workflowService.GetByAeTitleAsync(
+                    title,
+                    (validFilter.PageNumber - 1) * validFilter.PageSize,
+                    validFilter.PageSize);
+
+                var dataTotal = await _workflowService.GetCountByAeTitleAsync(title);
+                var pagedReponse = CreatePagedReponse(pagedData.ToList(), validFilter, dataTotal, _uriService, route);
+
+                return Ok(pagedReponse);
+            }
+            catch (Exception e)
+            {
+                _logger.WorkflowGetAeTitleAsyncError(e);
+
+                return Problem(
+                    $"Unexpected error occurred: {e.Message}",
+                    $"/workflows/aetitle",
+                    InternalServerError);
+            }
+        }
     }
 }

tests/UnitTests/Common.Tests/Services/WorkflowServiceTests.cs

@@ -53,6 +53,24 @@ public async Task WorkflowService_NoExistingWorkflow_ReturnsNull()
             Assert.Null(result);
         }
 
+        [Fact]
+        public async Task WorkflowService_GetAsync_With_Empty()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() => WorkflowService.GetAsync(string.Empty));
+        }
+
+        [Fact]
+        public async Task WorkflowService_GetByNameAsync_With_Empty()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() => WorkflowService.GetByNameAsync(string.Empty));
+        }
+
+        [Fact]
+        public async Task WorkflowService_CreateAsync_With_Empty()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => WorkflowService.CreateAsync(null));
+        }
+
         [Fact]
         public async Task WorkflowService_WorkflowExists_ReturnsWorkflowId()
         {
@@ -88,5 +106,39 @@ public async Task WorkflowService_WorkflowExists_ReturnsWorkflowId()
 
             Assert.Equal(workflowRevision.WorkflowId, result);
         }
+
+        [Fact]
+        public async Task WorkflowService_DeleteWorkflow_With_Empty()
+        {
+            await Assert.ThrowsAsync<ArgumentNullException>(() => WorkflowService.DeleteWorkflowAsync(null));
+        }
+
+        [Fact]
+        public async Task WorkflowService_DeleteWorkflow_Calls_SoftDelete()
+        {
+            var result = await WorkflowService.DeleteWorkflowAsync(new WorkflowRevision());
+            _workflowRepository.Verify(r => r.SoftDeleteWorkflow(It.IsAny<WorkflowRevision>()), Times.Once());
+        }
+
+        [Fact]
+        public async Task WorkflowService_Count_Calls_Count()
+        {
+            var result = await WorkflowService.CountAsync();
+            _workflowRepository.Verify(r => r.CountAsync(), Times.Once());
+        }
+
+        [Fact]
+        public async Task WorkflowService_GetCountByAeTitleAsync_Calls_Count()
+        {
+            var result = await WorkflowService.GetCountByAeTitleAsync("string");
+            _workflowRepository.Verify(r => r.GetCountByAeTitleAsync(It.IsAny<string>()), Times.Once());
+        }
+
+        [Fact]
+        public async Task WorkflowService_GetAllAsync_Calls_GetAllAsync()
+        {
+            var result = await WorkflowService.GetAllAsync(1, 2);
+            _workflowRepository.Verify(r => r.GetAllAsync(It.IsAny<int>(), It.IsAny<int>()), Times.Once());
+        }
     }
 }

tests/UnitTests/TaskManager.Tests/TaskExecutionStatsRepositoryTests.cs

@@ -114,7 +114,6 @@ public async Task TaskExecutionStatsRepository_Insert_Should_Check_For_Null_Even
             await Assert.ThrowsAsync<ArgumentNullException>(() => service.CreateAsync(default));
         }
 
-
         [Fact]
         public async Task TaskExecutionStatsRepository_update_Should_Check_For_Null_Event()
         {

tests/UnitTests/WorkflowManager.Tests/Controllers/WorkflowsControllerTests.cs

@@ -32,6 +32,7 @@
 using Moq;
 using Xunit;
 using Monai.Deploy.WorkflowManager.Shared.Filter;
+using Monai.Deploy.WorkflowManager.Common.Services;
 
 namespace Monai.Deploy.WorkflowManager.Test.Controllers
 {
@@ -48,7 +49,7 @@ public class WorkflowsControllerTests
 
         public WorkflowsControllerTests()
         {
-            _options = Options.Create(new WorkflowManagerOptions());
+            _options = Options.Create(new WorkflowManagerOptions { EndpointSettings = new EndpointSettings { MaxPageSize = 99 } });
             _workflowService = new Mock<IWorkflowService>();
 
             _logger = new Mock<ILogger<WorkflowsController>>();
@@ -883,5 +884,68 @@ public async Task DeleteAsync_WorkflowsGivenInvalidId_ShouldBadRequest()
             const string expectedInstance = "/workflows";
             Assert.StartsWith(expectedInstance, ((ProblemDetails)objectResult.Value).Instance);
         }
+
+        [Fact]
+        public async Task GetByAeTitle_WorkflowsGivenEmptyTitle_ShouldBadRequest()
+        {
+
+            var result = await WorkflowsController.GetByAeTitle(string.Empty, null);
+
+            var objectResult = Assert.IsType<ObjectResult>(result);
+            Assert.Equal("Failed to validate title, not a valid AE title", result.As<ObjectResult>().Value.As<ProblemDetails>().Detail);
+
+            Assert.Equal(400, objectResult.StatusCode);
+
+            const string expectedInstance = "/workflows";
+            Assert.StartsWith(expectedInstance, ((ProblemDetails)objectResult.Value).Instance);
+        }
+
+        [Fact]
+        public async Task GetByAeTitle_ShouldCall_GetByAeTitleAsync()
+        {
+
+            var result = await WorkflowsController.GetByAeTitle("test", new PaginationFilter());
+            var objectResult = Assert.IsType<OkObjectResult>(result);
+
+            _workflowService.Verify(x => x.GetByAeTitleAsync("test", It.IsAny<int>(), It.IsAny<int>()), Times.Once);
+
+            Assert.Equal(200, objectResult.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetByAeTitle_ShouldCall_GetByAeTitleAsync_With_Skip()
+        {
+
+            var result = await WorkflowsController.GetByAeTitle("test", new PaginationFilter { PageSize = 2, PageNumber = 2 });
+            var objectResult = Assert.IsType<OkObjectResult>(result);
+
+            _workflowService.Verify(x => x.GetByAeTitleAsync("test", 2, It.IsAny<int>()), Times.Once);
+
+            Assert.Equal(200, objectResult.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetByAeTitle_ShouldCall_GetByAeTitleAsync_With_Limit()
+        {
+
+            var result = await WorkflowsController.GetByAeTitle("test", new PaginationFilter { PageNumber = 2, PageSize = 45 });
+            var objectResult = Assert.IsType<OkObjectResult>(result);
+
+            _workflowService.Verify(x => x.GetByAeTitleAsync("test", It.IsAny<int>(), 45), Times.Once);
+
+            Assert.Equal(200, objectResult.StatusCode);
+        }
+
+        [Fact]
+        public async Task GetByAeTitle_ShouldCall_GetCountByAeTitleAsync()
+        {
+
+            var result = await WorkflowsController.GetByAeTitle("test", new PaginationFilter());
+            var objectResult = Assert.IsType<OkObjectResult>(result);
+
+            _workflowService.Verify(x => x.GetCountByAeTitleAsync("test"), Times.Once);
+
+            Assert.Equal(200, objectResult.StatusCode);
+        }
     }
 }