adding tag list to configuration

Signed-off-by: Neil South <[email protected]>

Author: neildsouth

src/Api/Storage/RemoteAppExecution.cs

@@ -28,7 +28,7 @@ public class RemoteAppExecution
         public string WorkflowInstanceId { get; set; } = string.Empty;
         public string CorrelationId { get; set; } = string.Empty;
         public string? StudyUid { get; set; }
-        public string? OutgoingStudyUid { get; set; }
+        public string? OutgoingUid { get; set; }
         public List<DestinationApplicationEntity> ExportDetails { get; set; } = new();
         public List<string> Files { get; set; } = new();
         public FileExportStatus Status { get; set; }

src/Configuration/PluginConfiguration.cs

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2021-2023 MONAI Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Generic;
+
+namespace Monai.Deploy.InformaticsGateway.Configuration
+{
+    public class PluginConfiguration
+    {
+        public Dictionary<string, string> Configuration { get; set; } = new();
+    }
+}

src/Database/EntityFramework/Repositories/RemoteAppExecutionRepository.cs

@@ -38,6 +38,10 @@ public class RemoteAppExecutionRepository : IRemoteAppExecutionRepository, IDisp
         private readonly DbSet<RemoteAppExecution> _dataset;
         private bool _disposedValue;
 
+
+        // Note. this implementaion (unlike the Mongo one) Does not delete the entries
+        // so a cleanup routine will have to be implemented to peridoically remove old entries !
+
         public RemoteAppExecutionRepository(
             IServiceScopeFactory serviceScopeFactory,
             ILogger<PayloadRepository> logger,
@@ -74,7 +78,7 @@ public async Task<int> RemoveAsync(string OriginalStudyUid, CancellationToken ca
 
             return await _retryPolicy.ExecuteAsync(async () =>
             {
-                var result = await _dataset.SingleOrDefaultAsync(p => p.OutgoingStudyUid == OriginalStudyUid).ConfigureAwait(false);
+                var result = await _dataset.SingleOrDefaultAsync(p => p.OutgoingUid == OriginalStudyUid).ConfigureAwait(false);
                 if (result is not null)
                 {
                     _dataset.Remove(result);
@@ -91,7 +95,7 @@ public async Task<int> RemoveAsync(string OriginalStudyUid, CancellationToken ca
 
             return await _retryPolicy.ExecuteAsync(async () =>
             {
-                var result = await _dataset.SingleOrDefaultAsync(p => p.OutgoingStudyUid == OutgoingStudyUid).ConfigureAwait(false);
+                var result = await _dataset.SingleOrDefaultAsync(p => p.OutgoingUid == OutgoingStudyUid).ConfigureAwait(false);
                 if (result is not null)
                 {
                     return result;

src/Database/MongoDB/Repositories/RemoteAppExecutionRepository.cs

@@ -62,7 +62,7 @@ public RemoteAppExecutionRepository(IServiceScopeFactory serviceScopeFactory,
         private void CreateIndexes()
         {
             var options = new CreateIndexOptions { Unique = true, ExpireAfter = TimeSpan.FromDays(7), Name = "RequestTime" };
-            var indexDefinitionState = Builders<RemoteAppExecution>.IndexKeys.Ascending(_ => _.OutgoingStudyUid);
+            var indexDefinitionState = Builders<RemoteAppExecution>.IndexKeys.Ascending(_ => _.OutgoingUid);
             var indexModel = new CreateIndexModel<RemoteAppExecution>(indexDefinitionState, options);
 
             _collection.Indexes.CreateOne(indexModel);
@@ -83,7 +83,7 @@ public async Task<int> RemoveAsync(string OutgoingStudyUid, CancellationToken ca
         {
             return await _retryPolicy.ExecuteAsync(async () =>
             {
-                var results = await _collection.DeleteManyAsync(Builders<RemoteAppExecution>.Filter.Where(p => p.OutgoingStudyUid == OutgoingStudyUid), cancellationToken).ConfigureAwait(false);
+                var results = await _collection.DeleteManyAsync(Builders<RemoteAppExecution>.Filter.Where(p => p.OutgoingUid == OutgoingStudyUid), cancellationToken).ConfigureAwait(false);
                 return Convert.ToInt32(results.DeletedCount);
             }).ConfigureAwait(false);
         }
@@ -92,7 +92,7 @@ public async Task<int> RemoveAsync(string OutgoingStudyUid, CancellationToken ca
         {
             return await _retryPolicy.ExecuteAsync(async () =>
             {
-                return await _collection.Find(p => p.OutgoingStudyUid == OutgoingStudyUid).FirstOrDefaultAsync().ConfigureAwait(false);
+                return await _collection.Find(p => p.OutgoingUid == OutgoingStudyUid).FirstOrDefaultAsync().ConfigureAwait(false);
             }).ConfigureAwait(false);
         }
 

src/InformaticsGateway/Common/IDicomToolkit.cs

@@ -15,7 +15,9 @@
  * limitations under the License.
  */
 
+using System;
 using System.IO;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using FellowOakDicom;
 
@@ -28,5 +30,7 @@ public interface IDicomToolkit
         DicomFile Load(byte[] fileContent);
 
         StudySerieSopUids GetStudySeriesSopInstanceUids(DicomFile dicomFile);
+
+        static DicomTag GetDicomTagByName(string tag) => DicomDictionary.Default[tag] ?? DicomDictionary.Default[Regex.Replace(tag, @"\s+", "", RegexOptions.None, TimeSpan.FromSeconds(1))];
     }
 }

src/InformaticsGateway/ExecutionPlugins/ExternalAppIncoming.cs

@@ -15,12 +15,16 @@
  */
 
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using FellowOakDicom;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using Monai.Deploy.InformaticsGateway.Api;
 using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Common;
+using Monai.Deploy.InformaticsGateway.Configuration;
 using Monai.Deploy.InformaticsGateway.Database.Api.Repositories;
 
 namespace Monai.Deploy.InformaticsGateway.ExecutionPlugins
@@ -29,21 +33,27 @@ public class ExternalAppIncoming : IInputDataPlugin
     {
         private readonly ILogger<ExternalAppIncoming> _logger;
         private readonly IServiceScopeFactory _serviceScopeFactory;
+        private readonly PluginConfiguration _options;
 
         public ExternalAppIncoming(
             ILogger<ExternalAppIncoming> logger,
-            IServiceScopeFactory serviceScopeFactory)
+            IServiceScopeFactory serviceScopeFactory,
+            IOptions<PluginConfiguration> configuration)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _serviceScopeFactory = serviceScopeFactory ?? throw new ArgumentNullException(nameof(serviceScopeFactory));
+            _options = configuration.Value ?? throw new ArgumentNullException(nameof(configuration));
+            if (_options.Configuration.ContainsKey("ReplaceTags") is false) { throw new ArgumentNullException(nameof(configuration)); }
         }
 
         public async Task<(DicomFile dicomFile, FileStorageMetadata fileMetadata)> Execute(DicomFile dicomFile, FileStorageMetadata fileMetadata)
         {
             var scope = _serviceScopeFactory.CreateScope();
             var repository = scope.ServiceProvider.GetRequiredService<IRemoteAppExecutionRepository>();
 
-            var incommingStudyUid = dicomFile.Dataset.GetString(DicomTag.StudyInstanceUID);
+            var tagUsedAsKey = GetTags(_options.Configuration["ReplaceTags"]).First();
+
+            var incommingStudyUid = dicomFile.Dataset.GetString(tagUsedAsKey);
             var remoteAppExecution = await repository.GetAsync(incommingStudyUid);
             if (remoteAppExecution is null)
             {
@@ -54,11 +64,17 @@ public ExternalAppIncoming(
             {
                 dicomFile.Dataset.AddOrUpdate(key, remoteAppExecution.OriginalValues[key]);
             }
-            dicomFile.Dataset.AddOrUpdate(DicomTag.StudyInstanceUID, remoteAppExecution.StudyUid);
+            //dicomFile.Dataset.AddOrUpdate(DicomTag.StudyInstanceUID, remoteAppExecution.StudyUid);
             fileMetadata.WorkflowInstanceId = remoteAppExecution.WorkflowInstanceId;
             fileMetadata.TaskId = remoteAppExecution.ExportTaskId;
 
             return (dicomFile, fileMetadata);
         }
+
+        private static DicomTag[] GetTags(string values)
+        {
+            var names = values.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+            return names.Select(n => IDicomToolkit.GetDicomTagByName(n)).ToArray();
+        }
     }
 }

src/InformaticsGateway/ExecutionPlugins/ExternalAppOutgoing.cs

@@ -15,13 +15,16 @@
  */
 
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using FellowOakDicom;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using Monai.Deploy.InformaticsGateway.Api;
 using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Common;
 using Monai.Deploy.InformaticsGateway.Configuration;
 using Monai.Deploy.InformaticsGateway.Database.Api.Repositories;
 
@@ -31,44 +34,74 @@ public class ExternalAppOutgoing : IOutputDataPlugin
     {
         private readonly ILogger<ExternalAppOutgoing> _logger;
         private readonly IServiceScopeFactory _serviceScopeFactory;
+        private readonly PluginConfiguration _options;
 
         public ExternalAppOutgoing(
             ILogger<ExternalAppOutgoing> logger,
-            IServiceScopeFactory serviceScopeFactory)
+            IServiceScopeFactory serviceScopeFactory,
+            IOptions<PluginConfiguration> configuration)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _serviceScopeFactory = serviceScopeFactory ?? throw new ArgumentNullException(nameof(serviceScopeFactory));
+            _options = configuration.Value ?? throw new ArgumentNullException(nameof(configuration));
+            if (_options.Configuration.ContainsKey("ReplaceTags") is false) { throw new ArgumentNullException(nameof(configuration)); }
         }
 
         public async Task<(DicomFile dicomFile, ExportRequestDataMessage exportRequestDataMessage)> Execute(DicomFile dicomFile, ExportRequestDataMessage exportRequestDataMessage)
         {
-            //these are the standard tags, but this needs moving into config.
-            DicomTag[] tags = { DicomTag.StudyInstanceUID, DicomTag.AccessionNumber, DicomTag.SeriesInstanceUID, DicomTag.SOPInstanceUID };
+            var tags = GetTags(_options.Configuration["ReplaceTags"]);
 
             var scope = _serviceScopeFactory.CreateScope();
             var repository = scope.ServiceProvider.GetRequiredService<IRemoteAppExecutionRepository>();
 
             var remoteAppExecution = await GetRemoteAppExecution(exportRequestDataMessage, tags).ConfigureAwait(false);
             remoteAppExecution.StudyUid = dicomFile.Dataset.GetString(DicomTag.StudyInstanceUID);
 
-            await repository.AddAsync(remoteAppExecution).ConfigureAwait(false);
-            _logger.LogStudyUidChanged(remoteAppExecution.StudyUid, remoteAppExecution.OutgoingStudyUid);
-
             foreach (var tag in tags)
             {
-                if (tag.Equals(DicomTag.StudyInstanceUID) is false &&
-                    dicomFile.Dataset.TryGetString(tag, out var value))
+                if (dicomFile.Dataset.TryGetString(tag, out var value))
                 {
                     remoteAppExecution.OriginalValues.Add(tag, value);
-                    dicomFile.Dataset.AddOrUpdate(tag, DicomUIDGenerator.GenerateDerivedFromUUID());
+                    SetTag(dicomFile, tag);
                 }
             }
 
-            dicomFile.Dataset.AddOrUpdate(DicomTag.StudyInstanceUID, remoteAppExecution.OutgoingStudyUid);
+            remoteAppExecution.OutgoingUid = dicomFile.Dataset.GetString(tags.First());
+
+            await repository.AddAsync(remoteAppExecution).ConfigureAwait(false);
+            _logger.LogStudyUidChanged(remoteAppExecution.StudyUid, remoteAppExecution.OutgoingUid);
 
             return (dicomFile, exportRequestDataMessage);
         }
 
+        private static void SetTag(DicomFile dicomFile, DicomTag tag)
+        {
+            // partial implementation for now see
+            // https://dicom.nema.org/dicom/2013/output/chtml/part05/sect_6.2.html
+            // for full list
+
+            switch (tag.DictionaryEntry.ValueRepresentations.First().Code)
+            {
+                case "UI":
+                case "LO":
+                case "LT":
+                {
+                    dicomFile.Dataset.AddOrUpdate(tag, DicomUIDGenerator.GenerateDerivedFromUUID());
+                    break;
+                }
+                case "SH":
+                case "AE":
+                case "CS":
+                case "PN":
+                case "ST":
+                case "UT":
+                {
+                    dicomFile.Dataset.AddOrUpdate(tag, "no Value");
+                    break;
+                }
+            }
+        }
+
         private async Task<RemoteAppExecution> GetRemoteAppExecution(ExportRequestDataMessage request, DicomTag[] tags)
         {
             var remoteAppExecution = new RemoteAppExecution
@@ -82,12 +115,12 @@ private async Task<RemoteAppExecution> GetRemoteAppExecution(ExportRequestDataMe
 
 
             var outgoingStudyUid = DicomUIDGenerator.GenerateDerivedFromUUID().UID;
-            remoteAppExecution.OutgoingStudyUid = outgoingStudyUid;
+            remoteAppExecution.OutgoingUid = outgoingStudyUid;
 
 
             foreach (var destination in request.Destinations)
             {
-                remoteAppExecution.ExportDetails.Add(await LookupDestinationAsync(destination, new CancellationToken()));
+                remoteAppExecution.ExportDetails.Add(await LookupDestinationAsync(destination, new CancellationToken()).ConfigureAwait(false));
             }
 
             return remoteAppExecution;
@@ -111,5 +144,12 @@ private async Task<DestinationApplicationEntity> LookupDestinationAsync(string d
 
             return destination;
         }
+
+        private static DicomTag[] GetTags(string values)
+        {
+            var names = values.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+            return names.Select(n => IDicomToolkit.GetDicomTagByName(n)).ToArray();
+        }
+
     }
 }

src/InformaticsGateway/Program.cs

@@ -98,6 +98,7 @@ internal static IHostBuilder CreateHostBuilder(string[] args) =>
                     services.AddOptions<MessageBrokerServiceConfiguration>().Bind(hostContext.Configuration.GetSection("InformaticsGateway:messaging"));
                     services.AddOptions<StorageServiceConfiguration>().Bind(hostContext.Configuration.GetSection("InformaticsGateway:storage"));
                     services.AddOptions<AuthenticationOptions>().Bind(hostContext.Configuration.GetSection("MonaiDeployAuthentication"));
+                    services.AddOptions<PluginConfiguration>().Bind(hostContext.Configuration.GetSection("InformaticsGateway:PluginConfiguration"));
                     services.TryAddEnumerable(ServiceDescriptor.Singleton<IValidateOptions<InformaticsGatewayConfiguration>, ConfigurationValidator>());
 
                     services.ConfigureDatabase(hostContext.Configuration?.GetSection("ConnectionStrings"));