Implement FHIR server (#118)

* gh-29 Implement FHIR server
* gh-29 Unit test for FHIR service
* gh-29 Test feature for FHIR
* Update API doc & changelog


Signed-off-by: Victor Chang <[email protected]>

Author: mocsharp

.github/.gitversion.yml

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+next-version: 0.2.0
 assembly-versioning-scheme: MajorMinorPatchTag
 mode: ContinuousDelivery
 branches:

.github/workflows/ci.yml

@@ -205,7 +205,7 @@ jobs:
     needs: [build]
     strategy:
       matrix:
-        feature: [AcrApi, DicomDimseScp, DicomDimseScu, DicomWebExport, DicomWebStow, HealthLevel7]
+        feature: [AcrApi, DicomDimseScp, DicomDimseScu, DicomWebExport, DicomWebStow, HealthLevel7, Fhir]
       fail-fast: false
     env:
       TAG: ${{ needs.build.outputs.TAG }}

.licenserc.yaml

@@ -33,6 +33,7 @@ header:
     - 'demos/**/.env/**'
     - 'docs/templates/**'
     - 'tests/Integration.Test/*.dev'
+    - 'tests/Integration.Test/data/**'
 
   comment: on-failure
 

.vscode/launch.json

@@ -12,13 +12,11 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build-cli",
-            "program": "${workspaceFolder}/src/CLI/bin/Debug/net5.0/linux-x64/mig-cli",
+            "program": "${workspaceFolder}/src/CLI/bin/Debug/net6.0/linux-x64/mig-cli",
             "args": [
-                "config",
-                "endpoint",
-                "http://localhost:4500"
+                "start"
             ],
-            "cwd": "${workspaceFolder}/src/CLI/bin/Debug/net5.0/linux-x64",
+            "cwd": "${workspaceFolder}/src/CLI/bin/Debug/net6.0/linux-x64",
             "stopAtEntry": true,
             "console": "internalConsole"
         },

docs/api/rest/fhir.md

@@ -0,0 +1,66 @@
+<!--
+  ~ Copyright 2022 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.
+-->
+
+# DICOMWeb STOW-RS APIs
+
+The `fhir/` endpoint implements the specifications defined in [section 3.1.0 RESTful API](http://hl7.org/implement/standards/fhir/http.html)
+defined by HL7 (Health Level 7 International) to enable triggering new workflows. The FHIR service supports multiple versions of the Fast Healthcare Interoperability Resources (FHIR) specifications published by Health Level 7 International (HL7).
+
+[!Note]
+The service does not support `CapabilityStatement` at this moment and does not group the incoming FHIR resources. Therefore, each incoming FHIR resource will trigger a new workflow request.
+
+The *FHIR* service provides the following endpoint.
+
+## POST /fhir/[resource]
+
+Triggers a new workflow request with the posted FHIR resource.
+
+> [!IMPORTANT]
+> Refer to [section 1.2 Resource Index](http://hl7.org/fhir/resourcelist.html) for a list of HL7 resources. The endpoint is designed to accept any resource and provides only syntax validation either in XML or JSON.
+
+### Parameters
+
+#### Query Parameters:
+
+| Name     | Type   | Description                                                                                                                                                                                |
+| -------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| resource | string | (Optional) resouce type of the FHIR document. The services reject the request if the `Resource` value in the URL differs from the `Resource` value described in the posted document. |
+
+#### Request Body: 
+
+Supported Content-Types:
+
+- `application/fhir+json`
+- `application/fhir+xml`
+
+### Responses
+
+Depending on the `Accept` header or the original document, the response supports the following content types: 
+
+- `application/fhir+json`
+- `application/fhir+xml`
+
+If the `Accept` header is missing or a none supported value exists, the service will return the same type as the posted document.
+
+| Code | Data Type                                                     | Description                                                           |
+| ---- | ------------------------------------------------------------- | --------------------------------------------------------------------- |
+| 201  | Original JSON or XML document.                                | Resource created & stored successfully.                               |
+| 400  | [OperationOutcome](http://hl7.org/fhir/operationoutcome.html) | Unable to parse the resource or mismatching resource type specified.. |
+| 415  | `none`                                                        | Unsupported media type                                                |
+| 500  | [OperationOutcome](http://hl7.org/fhir/operationoutcome.html) | Server error.                                                         |
+
+[!Note]
+The `Location` header in the response given that the resources created are for inference only.

docs/changelog.md

@@ -16,6 +16,11 @@
 
 
 # Changelog
+## 0.3.0
+
+[GitHub Milestone 0.3.0](https://github.com/Project-MONAI/monai-deploy-informatics-gateway/milestone/3)
+
+- Adds a basic [FHIR service](api/rest/config.md) to accept any versions of FHIR.
 
 ## 0.2.0
 

src/CLI/Services/DockerRunner.cs

@@ -135,10 +135,6 @@ public async Task<bool> StartApplication(ImageVersion imageVersion, Cancellation
             _fileSystem.Directory.CreateDirectoryIfNotExists(_configurationService.Configurations.HostDatabaseStorageMount);
             createContainerParams.HostConfig.Mounts.Add(new Mount { Type = "bind", ReadOnly = false, Source = _configurationService.Configurations.HostDatabaseStorageMount, Target = Common.MountedDatabasePath });
 
-            _logger.DockerMountTempDirectory(_configurationService.Configurations.HostDataStorageMount, _configurationService.Configurations.TempStoragePath);
-            _fileSystem.Directory.CreateDirectoryIfNotExists(_configurationService.Configurations.HostDataStorageMount);
-            createContainerParams.HostConfig.Mounts.Add(new Mount { Type = "bind", ReadOnly = false, Source = _configurationService.Configurations.HostDataStorageMount, Target = _configurationService.Configurations.TempStoragePath });
-
             _logger.DockerMountAppLogs(_configurationService.Configurations.HostLogsStorageMount, _configurationService.Configurations.LogStoragePath);
             _fileSystem.Directory.CreateDirectoryIfNotExists(_configurationService.Configurations.HostLogsStorageMount);
             createContainerParams.HostConfig.Mounts.Add(new Mount { Type = "bind", ReadOnly = false, Source = _configurationService.Configurations.HostLogsStorageMount, Target = _configurationService.Configurations.LogStoragePath });

src/CLI/Test/DockerRunnerTest.cs

@@ -176,7 +176,6 @@ public async Task StartApplication()
                         c.ExposedPorts.ContainsKey("200/tcp") &&
                         c.HostConfig.Mounts.Count(m => m.ReadOnly && m.Source == Common.ConfigFilePath && m.Target == Common.MountedConfigFilePath) == 1 &&
                         c.HostConfig.Mounts.Count(m => !m.ReadOnly && m.Source == "/database" && m.Target == Common.MountedDatabasePath) == 1 &&
-                        c.HostConfig.Mounts.Count(m => !m.ReadOnly && m.Source == "/storage" && m.Target == "/tempdata") == 1 &&
                         c.HostConfig.Mounts.Count(m => !m.ReadOnly && m.Source == "/logs" && m.Target == "/templogs") == 1), It.IsAny<CancellationToken>()), Times.Exactly(2));
 
             _logger.VerifyLogging("Warnings: warning1", LogLevel.Warning, Times.Once());

src/Database/Test/StorageMetadataWrapperTest.cs

@@ -38,7 +38,7 @@ public void GivenAFhirFileStorageMetadataObject_WhenInitializedWithStorageMetada
 
             var unwrapped = wrapper.GetObject() as FhirFileStorageMetadata;
 
-            Assert.Equal(metadata.CorrelationId, unwrapped.CorrelationId);
+            Assert.Equal(metadata.CorrelationId, unwrapped!.CorrelationId);
             Assert.Equal(metadata.Id, unwrapped.Id);
             Assert.Equal(metadata.DataTypeDirectoryName, unwrapped.DataTypeDirectoryName);
             Assert.Equal(metadata.DateReceived, unwrapped.DateReceived);
@@ -79,7 +79,7 @@ public void GivenADicomFileStorageMetadataObject_WhenInitializedWithStorageMetad
 
             var unwrapped = wrapper.GetObject() as DicomFileStorageMetadata;
 
-            Assert.Equal(metadata.CalledAeTitle, unwrapped.CalledAeTitle);
+            Assert.Equal(metadata.CalledAeTitle, unwrapped!.CalledAeTitle);
             Assert.Equal(metadata.CallingAeTitle, unwrapped.CallingAeTitle);
             Assert.Equal(metadata.CorrelationId, unwrapped.CorrelationId);
             Assert.Equal(metadata.Id, unwrapped.Id);

src/InformaticsGateway/Logging/Log.8000.HttpServices.cs

@@ -112,12 +112,29 @@ public static partial class Log
         public static partial void StowFailedWithNoSpace(this ILogger logger, Exception ex = null);
 
         [LoggerMessage(EventId = 8108, Level = LogLevel.Information, Message = "STOW instance queued.")]
-        public static partial void QueuedInstanceUsingCorrelationId(this ILogger logger);
+        public static partial void QueuedStowInstance(this ILogger logger);
 
         [LoggerMessage(EventId = 8109, Level = LogLevel.Information, Message = "Saving {count} DICOMWeb STOW-RS streams.")]
         public static partial void SavingStream(this ILogger logger, int count);
 
         [LoggerMessage(EventId = 8110, Level = LogLevel.Warning, Message = "Ignoring zero length stream.")]
         public static partial void ZeroLengthDicomWebStowStream(this ILogger logger);
+
+        // FHIR Serer
+
+        [LoggerMessage(EventId = 8200, Level = LogLevel.Debug, Message = "Parsing FHIR as JSON.")]
+        public static partial void ParsingFhirJson(this ILogger logger);
+
+        [LoggerMessage(EventId = 8201, Level = LogLevel.Debug, Message = "Parsing FHIR as XML.")]
+        public static partial void ParsingFhirXml(this ILogger logger);
+
+        [LoggerMessage(EventId = 8202, Level = LogLevel.Information, Message = "FHIR instance queued.")]
+        public static partial void QueueFhirInstance(this ILogger logger);
+
+        [LoggerMessage(EventId = 8203, Level = LogLevel.Error, Message = "Error storing FHIR object.")]
+        public static partial void FhirStoreException(this ILogger logger, Exception ex);
+
+        [LoggerMessage(EventId = 8204, Level = LogLevel.Error, Message = "Failed to store FHIR resource.")]
+        public static partial void ErrorStoringFhirResource(this ILogger logger, Exception ex);
     }
 }

src/InformaticsGateway/Program.cs

@@ -34,6 +34,7 @@
 using Monai.Deploy.InformaticsGateway.Services.Connectors;
 using Monai.Deploy.InformaticsGateway.Services.DicomWeb;
 using Monai.Deploy.InformaticsGateway.Services.Export;
+using Monai.Deploy.InformaticsGateway.Services.Fhir;
 using Monai.Deploy.InformaticsGateway.Services.HealthLevel7;
 using Monai.Deploy.InformaticsGateway.Services.Http;
 using Monai.Deploy.InformaticsGateway.Services.Scp;
@@ -103,6 +104,7 @@ internal static IHostBuilder CreateHostBuilder(string[] args) =>
                     services.AddTransient<IFileSystem, FileSystem>();
                     services.AddTransient<IDicomToolkit, DicomToolkit>();
                     services.AddTransient<IStowService, StowService>();
+                    services.AddTransient<IFhirService, FhirService>();
                     services.AddTransient<IStreamsWriter, StreamsWriter>();
                     services.AddTransient<IApplicationEntityHandler, ApplicationEntityHandler>();
 

src/InformaticsGateway/Services/DicomWeb/IStreamsWriter.cs

@@ -170,7 +170,7 @@ private async Task SaveInstance(Stream stream, string studyInstanceUid, string w
 
             // for DICOMweb, use correlation ID as the grouping key
             await _payloadAssembler.Queue(correlationId, dicomInfo, _configuration.Value.DicomWeb.Timeout).ConfigureAwait(false);
-            _logger.QueuedInstanceUsingCorrelationId();
+            _logger.QueuedStowInstance();
 
             AddSuccess(null, uids);
 

src/InformaticsGateway/Services/Fhir/ContentTypes.cs

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2022 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.
+ */
+
+namespace Monai.Deploy.InformaticsGateway.Services.Fhir
+{
+    internal static class ContentTypes
+    {
+        public const string ApplicationFhirXml = "application/fhir+xml";
+        public const string ApplicationFhirJson = "application/fhir+json";
+    }
+}

src/InformaticsGateway/Services/Fhir/FhirFormatters.cs

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2022 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.Text.Json;
+using Microsoft.AspNetCore.Mvc.Formatters;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Fhir
+{
+    internal class FhirJsonFormatters : SystemTextJsonOutputFormatter
+    {
+        public FhirJsonFormatters(JsonSerializerOptions jsonSerializerOptions) : base(jsonSerializerOptions)
+        {
+            SupportedMediaTypes.Clear();
+            SupportedMediaTypes.Add(ContentTypes.ApplicationFhirJson);
+        }
+    }
+
+    internal class FhirXmlFormatters : XmlDataContractSerializerOutputFormatter
+
+    {
+        public FhirXmlFormatters()
+        {
+            SupportedMediaTypes.Clear();
+            SupportedMediaTypes.Add(ContentTypes.ApplicationFhirXml);
+        }
+    }
+}

src/InformaticsGateway/Services/Fhir/FhirJsonReader.cs

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2022 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;
+using System.IO;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Threading;
+using System.Threading.Tasks;
+using Ardalis.GuardClauses;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Microsoft.Net.Http.Headers;
+using Monai.Deploy.InformaticsGateway.Api.Storage;
+using Monai.Deploy.InformaticsGateway.Common;
+using Monai.Deploy.InformaticsGateway.Logging;
+
+namespace Monai.Deploy.InformaticsGateway.Services.Fhir
+{
+    internal class FhirJsonReader : IFHirRequestReader
+    {
+        private readonly ILogger<FhirJsonReader> _logger;
+
+        public FhirJsonReader(ILogger<FhirJsonReader> logger)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }
+
+        public async Task<FhirStoreResult> GetContentAsync(HttpRequest request, string correlationId, string resourceType, MediaTypeHeaderValue mediaTypeHeaderValue, CancellationToken cancellationToken)
+        {
+            Guard.Against.Null(request, nameof(request));
+            Guard.Against.NullOrWhiteSpace(correlationId, nameof(correlationId));
+            Guard.Against.NullOrInvalidInput(mediaTypeHeaderValue, nameof(mediaTypeHeaderValue), (value) =>
+            {
+                return value.MediaType.Value.Equals(ContentTypes.ApplicationFhirJson, StringComparison.OrdinalIgnoreCase);
+            });
+
+            _logger.ParsingFhirJson();
+
+            var result = new FhirStoreResult
+            {
+                ResourceType = resourceType,
+                RawData = await new StreamReader(request.Body).ReadToEndAsync().ConfigureAwait(false)
+            };
+
+            var jsonDoc = JsonNode.Parse(result.RawData);
+
+            if (jsonDoc[Resources.PropertyResourceType] is not null)
+            {
+                result.InternalResourceType = jsonDoc[Resources.PropertyResourceType].GetValue<string>();
+            }
+
+            var resourceId = SetIdIfMIssing(correlationId, jsonDoc);
+
+            result.RawData = jsonDoc.ToJsonString(new JsonSerializerOptions { WriteIndented = true });
+
+            var fileMetadata = new FhirFileStorageMetadata(correlationId, result.InternalResourceType, resourceId, Api.Rest.FhirStorageFormat.Json);
+            fileMetadata.SetDataStream(result.RawData);
+
+            result.Metadata = fileMetadata;
+            return result;
+        }
+
+        private static string SetIdIfMIssing(string correlationId, JsonNode jsonDoc)
+        {
+            Guard.Against.NullOrWhiteSpace(correlationId, nameof(correlationId));
+            Guard.Against.Null(jsonDoc, nameof(jsonDoc));
+
+            if (string.IsNullOrWhiteSpace(jsonDoc[Resources.PropertyId]?.GetValue<string>()))
+            {
+                jsonDoc[Resources.PropertyId] = correlationId;
+            }
+
+            return jsonDoc[Resources.PropertyId].GetValue<string>();
+        }
+    }
+}