public async Task Series(
[Option("r", "Uniform Resource Locator (URL) of the DICOMweb service")] string rootUrl,
[Option("u", "username for authentication with the DICOMweb service")] string username,
[Option("p", "password for authentication with the DICOMweb service")] string password,
[Option("s", "unique study identifier; Study Instance UID")] string studyInstanceUid,
[Option("e", "unique series identifier; Series Instance UID")] string seriesInstanceUid,
[Option("f", "output format: json, dicom")] OutputFormat format = OutputFormat.Dicom,
[Option("o", "output directory, default: current directory(.)", DefaultValue = ".")] string outputDir = ".",
[Option("t", "transfer syntaxes, separated by comma")] string transferSyntaxes = "*"
)
{
Uri rootUri;
List <DicomTransferSyntax> dicomTransferSyntaxes;
ValidateOptions(rootUrl, transferSyntaxes, out rootUri, out dicomTransferSyntaxes);
ValidateOutputDirectory(ref outputDir);
var client = new DicomWebClient(rootUri, Utils.GenerateFromUsernamePassword(username, password));
_logger.LogInformation($"Retrieving series {seriesInstanceUid} from");
_logger.LogInformation($"\tStudy Instance UID: {studyInstanceUid}");
if (format == OutputFormat.Dicom)
{
await SaveFiles(outputDir, client.Wado.Retrieve(studyInstanceUid, seriesInstanceUid, transferSyntaxes: dicomTransferSyntaxes.ToArray()));
}
else
{
await SaveJson(outputDir, client.Wado.RetrieveMetadata <string>(studyInstanceUid, seriesInstanceUid));
}
}
public async Task Bulk(
[Option("r", "Uniform Resource Locator (URL) of the DICOMweb service")] string rootUrl,
[Option("u", "username for authentication with the DICOMweb service")] string username,
[Option("p", "password for authentication with the DICOMweb service")] string password,
[Option("s", "unique study identifier; Study Instance UID")] string studyInstanceUid,
[Option("e", "unique series identifier; Series Instance UID")] string seriesInstanceUid,
[Option("i", "unique instance identifier; SOP Instance UID")] string sopInstanceUid,
[Option("g", "DICOM tag containing the bulkdata")] string tag,
[Option("o", "output filename", DefaultValue = ".")] string filename = "bulkdata.bin",
[Option("t", "transfer syntaxes, separated by comma")] string transferSyntaxes = "*"
)
{
Uri rootUri;
List <DicomTransferSyntax> dicomTransferSyntaxes;
ValidateOptions(rootUrl, transferSyntaxes, out rootUri, out dicomTransferSyntaxes);
ValidateOutputFilename(ref filename);
var dicomTag = DicomTag.Parse(tag);
var client = new DicomWebClient(rootUri, Utils.GenerateFromUsernamePassword(username, password));
_logger.LogInformation($"Retrieving {dicomTag} from");
_logger.LogInformation($"\tStudy Instance UID: {studyInstanceUid}");
_logger.LogInformation($"\tSeries Instance UID: {seriesInstanceUid}");
_logger.LogInformation($"\tSOP Instance UID: {sopInstanceUid}");
var data = await client.Wado.Retrieve(studyInstanceUid, seriesInstanceUid, sopInstanceUid, dicomTag, transferSyntaxes : dicomTransferSyntaxes.ToArray());
_logger.LogInformation($"Saving data to {filename}....");
await File.WriteAllBytesAsync(filename, data);
}
private static void SetupDicomWebClient()
{
var httpClient = new HttpClient
{
BaseAddress = new Uri(KnownApplicationUrls.DicomServerUrl),
};
client = new DicomWebClient(httpClient);
}
private async Task RetrieveViaDicomWeb(InferenceRequest inferenceRequest, RequestInputDataResource source, Dictionary <string, InstanceStorageInfo> retrievedInstance)
{
Guard.Against.Null(inferenceRequest, nameof(inferenceRequest));
Guard.Against.Null(retrievedInstance, nameof(retrievedInstance));
var authenticationHeaderValue = AuthenticationHeaderValueExtensions.ConvertFrom(source.ConnectionDetails.AuthType, source.ConnectionDetails.AuthId);
var dicomWebClient = new DicomWebClient(_httpClientFactory.CreateClient("dicomweb"), _loggerFactory.CreateLogger <DicomWebClient>());
dicomWebClient.ConfigureServiceUris(new Uri(source.ConnectionDetails.Uri, UriKind.Absolute));
if (!(authenticationHeaderValue is null))
{
dicomWebClient.ConfigureAuthentication(authenticationHeaderValue);
}
foreach (var input in inferenceRequest.InputMetadata.Inputs)
{
switch (input.Type)
{
case InferenceRequestType.DicomUid:
await RetrieveStudies(dicomWebClient, input.Studies, _fileSystem.Path.GetDicomStoragePath(inferenceRequest.StoragePath), retrievedInstance);
break;
case InferenceRequestType.DicomPatientId:
await QueryStudies(dicomWebClient, inferenceRequest, retrievedInstance, $"{DicomTag.PatientID.Group:X4}{DicomTag.PatientID.Element:X4}", input.PatientId);
break;
case InferenceRequestType.AccessionNumber:
foreach (var accessionNumber in input.AccessionNumber)
{
await QueryStudies(dicomWebClient, inferenceRequest, retrievedInstance, $"{DicomTag.AccessionNumber.Group:X4}{DicomTag.AccessionNumber.Element:X4}", accessionNumber);
}
break;
case InferenceRequestType.FhireResource:
continue;
default:
throw new InferenceRequestException($"The 'inputMetadata' type '{input.Type}' specified is not supported.");
}
}
}
public DicomWebClient GetDicomWebClient(TestApplication clientApplication)
{
EnsureArg.IsNotNull(clientApplication, nameof(clientApplication));
HttpMessageHandler messageHandler = TestDicomWebServer.CreateMessageHandler();
if (AuthenticationSettings.SecurityEnabled && !clientApplication.Equals(TestApplications.InvalidClient))
{
if (_authenticationHandlers.ContainsKey(clientApplication.ClientId))
{
messageHandler = _authenticationHandlers[clientApplication.ClientId];
}
else
{
var credentialConfiguration = new OAuth2ClientCredentialConfiguration(
AuthenticationSettings.TokenUri,
AuthenticationSettings.Resource,
AuthenticationSettings.Scope,
clientApplication.ClientId,
clientApplication.ClientSecret);
var credentialProvider = new OAuth2ClientCredentialProvider(Options.Create(credentialConfiguration), new HttpClient(messageHandler));
var authHandler = new AuthenticationHttpMessageHandler(credentialProvider)
{
InnerHandler = messageHandler,
};
_authenticationHandlers.Add(clientApplication.ClientId, authHandler);
messageHandler = authHandler;
}
}
var httpClient = new HttpClient(messageHandler)
{
BaseAddress = TestDicomWebServer.BaseAddress
};
var dicomWebClient = new DicomWebClient(httpClient)
{
GetMemoryStream = () => RecyclableMemoryStreamManager.GetStream(),
};
return(dicomWebClient);
}
private async Task QueryStudies(DicomWebClient dicomWebClient, InferenceRequest inferenceRequest, Dictionary <string, InstanceStorageInfo> retrievedInstance, string dicomTag, string queryValue)
{
Guard.Against.Null(dicomWebClient, nameof(dicomWebClient));
Guard.Against.Null(inferenceRequest, nameof(inferenceRequest));
Guard.Against.Null(retrievedInstance, nameof(retrievedInstance));
Guard.Against.NullOrWhiteSpace(dicomTag, nameof(dicomTag));
Guard.Against.NullOrWhiteSpace(queryValue, nameof(queryValue));
_logger.Log(LogLevel.Information, $"Performing QIDO with {dicomTag}={queryValue}.");
var queryParams = new Dictionary <string, string>();
queryParams.Add(dicomTag, queryValue);
var studies = new List <RequestedStudy>();
await foreach (var result in dicomWebClient.Qido.SearchForStudies <DicomDataset>(queryParams))
{
if (result.Contains(DicomTag.StudyInstanceUID))
{
var studyInstanceUid = result.GetString(DicomTag.StudyInstanceUID);
studies.Add(new RequestedStudy
{
StudyInstanceUid = studyInstanceUid
});
_logger.Log(LogLevel.Debug, $"Study {studyInstanceUid} found with QIDO query {dicomTag}={queryValue}.");
}
else
{
_logger.Log(LogLevel.Warning, $"Instance {result.GetSingleValueOrDefault(DicomTag.SOPInstanceUID, "UKNOWN")} does not contain StudyInstanceUid.");
}
}
if (studies.Count != 0)
{
await RetrieveStudies(dicomWebClient, studies, _fileSystem.Path.GetDicomStoragePath(inferenceRequest.StoragePath), retrievedInstance);
}
else
{
_logger.Log(LogLevel.Warning, $"No studies found with specified query parameter {dicomTag}={queryValue}.");
}
}
protected override async Task <OutputJob> ExportDataBlockCallback(OutputJob outputJob, CancellationToken cancellationToken)
{
using var loggerScope = _logger.BeginScope(new LogginDataDictionary <string, object> { { "TaskId", outputJob.TaskId }, { "JobId", outputJob.JobId }, { "PayloadId", outputJob.PayloadId } });
using var scope = _serviceScopeFactory.CreateScope();
var repository = scope.ServiceProvider.GetRequiredService <IInferenceRequestRepository>();
var inferenceRequest = repository.Get(outputJob.JobId, outputJob.PayloadId);
if (inferenceRequest is null)
{
_logger.Log(LogLevel.Error, "The specified job cannot be found in the inference request store and will not be exported.");
await ReportFailure(outputJob, cancellationToken);
return(null);
}
var destinations = inferenceRequest.OutputResources.Where(p => p.Interface == API.Rest.InputInterfaceType.DicomWeb);
if (destinations.Count() == 0)
{
_logger.Log(LogLevel.Error, "The inference request contains no `outputResources` nor any DICOMweb export destinations.");
await ReportFailure(outputJob, cancellationToken);
return(null);
}
foreach (var destination in destinations)
{
var authenticationHeader = AuthenticationHeaderValueExtensions.ConvertFrom(destination.ConnectionDetails.AuthType, destination.ConnectionDetails.AuthId);
var dicomWebClient = new DicomWebClient(_httpClientFactory.CreateClient("dicomweb"), _loggerFactory.CreateLogger <DicomWebClient>());
dicomWebClient.ConfigureServiceUris(new Uri(destination.ConnectionDetails.Uri, UriKind.Absolute));
dicomWebClient.ConfigureAuthentication(authenticationHeader);
_logger.Log(LogLevel.Debug, $"Exporting data to {destination.ConnectionDetails.Uri}.");
await ExportToDicomWebDestination(dicomWebClient, outputJob, destination, cancellationToken);
}
return(outputJob);
}
public DeleteTests(HttpIntegrationTestFixture <Startup> fixture)
{
_client = fixture.Client;
_recyclableMemoryStreamManager = fixture.RecyclableMemoryStreamManager;
}
public QueryTransactionTests(HttpIntegrationTestFixture <Startup> fixture)
{
_client = fixture.Client;
}
public DicomRetrieveMetadataTransactionTests(HttpIntegrationTestFixture <Startup> fixture)
{
_client = fixture.Client;
}
public ChangeFeedTests(HttpIntegrationTestFixture <Startup> fixture)
{
_client = fixture.Client;
}
