/// <inheritdoc/>
public void Synchronize(FhirTransactionContext context, ImagingStudy.InstanceComponent instance)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(context.ChangeFeedEntry, nameof(context.ChangeFeedEntry));
EnsureArg.IsNotNull(instance, nameof(instance));
DicomDataset dataset = context.ChangeFeedEntry.Metadata;
if (dataset == null)
{
return;
}
// Add sopclass to instance
if (dataset.TryGetSingleValue(DicomTag.SOPClassUID, out string sopClassUid) &&
!string.Equals(instance.SopClass?.Code, sopClassUid, StringComparison.Ordinal))
{
instance.SopClass = new Coding(null, sopClassUid);
}
// Add instancenumber to instance
if (dataset.TryGetSingleValue(DicomTag.InstanceNumber, out int instanceNumber))
{
instance.Number = instanceNumber;
}
}
public async Task SynchronizeSeriesPropertiesAsync(FhirTransactionContext context, ImagingStudy.SeriesComponent series, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(series, nameof(series));
await _imagingStudySeriesPropertySynchronizer.SynchronizeAsync(context, series, cancellationToken);
}
public void SynchronizeSeriesProperties(FhirTransactionContext context, ImagingStudy.SeriesComponent series)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(series, nameof(series));
_imagingStudySeriesPropertySynchronizer.Synchronize(context, series);
}
/// <inheritdoc/>
public void Synchronize(FhirTransactionContext context, ImagingStudy.SeriesComponent series)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(context.ChangeFeedEntry, nameof(context.ChangeFeedEntry));
EnsureArg.IsNotNull(series, nameof(series));
DicomDataset dataset = context.ChangeFeedEntry.Metadata;
if (dataset == null)
{
return;
}
// Add series number
AddSeriesNumber(series, dataset);
// Add description to series
AddDescription(series, dataset);
// Add modality to series
AddModalityToSeries(series, dataset);
// Add startedElement to series
AddStartedElement(series, dataset, context.UtcDateTimeOffset);
}
public void SynchronizeStudyProperties(FhirTransactionContext context, ImagingStudy imagingStudy)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(imagingStudy, nameof(imagingStudy));
_imagingStudyPropertySynchronizer.Synchronize(context, imagingStudy);
}
public async Task SynchronizeInstancePropertiesAsync(FhirTransactionContext context, ImagingStudy.InstanceComponent instance, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(instance, nameof(instance));
await _imagingStudyInstancePropertySynchronizer.SynchronizeAsync(context, instance, cancellationToken);
}
/// <inheritdoc/>
public async Task SynchronizeAsync(FhirTransactionContext context, Patient patient, bool isNewPatient, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(patient, nameof(patient));
DicomDataset dataset = context.ChangeFeedEntry.Metadata;
foreach (IPatientPropertySynchronizer patientPropertySynchronizer in _patientPropertySynchronizers)
{
try
{
patientPropertySynchronizer.Synchronize(dataset, patient, isNewPatient);
}
catch (DicomTagException ex)
{
if (_dicomCastconfiguration.Features.IgnoreSyncOfInvalidTagValue)
{
await _exceptionStore.WriteExceptionAsync(
context.ChangeFeedEntry,
ex,
ErrorType.DicomValidationError,
cancellationToken);
}
else
{
throw;
}
}
}
}
public static async Task SynchronizePropertiesAsync <T>(T component, FhirTransactionContext context, Action <T, FhirTransactionContext> synchronizeAction, bool requiredProperty, bool enforceAllFields, IExceptionStore exceptionStore, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(synchronizeAction, nameof(synchronizeAction));
EnsureArg.IsNotNull(exceptionStore, nameof(exceptionStore));
try
{
synchronizeAction(component, context);
}
catch (DicomTagException ex)
{
if (!enforceAllFields && !requiredProperty)
{
await exceptionStore.WriteExceptionAsync(
context.ChangeFeedEntry,
ex,
ErrorType.DicomValidationError,
cancellationToken);
}
else
{
throw;
}
}
}
public async Task SynchronizeStudyPropertiesAsync(FhirTransactionContext context, ImagingStudy imagingStudy, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(imagingStudy, nameof(imagingStudy));
await _imagingStudyPropertySynchronizer.SynchronizeAsync(context, imagingStudy, cancellationToken);
}
public void SynchronizeInstanceProperties(FhirTransactionContext context, ImagingStudy.InstanceComponent instance)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(instance, nameof(instance));
_imagingStudyInstancePropertySynchronizer.Synchronize(context, instance);
}
public async Task <IEnumerable <FhirTransactionRequestEntry> > BuildAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(context.ChangeFeedEntry, nameof(context.ChangeFeedEntry));
Identifier identifier = IdentifierUtility.CreateIdentifier(context.ChangeFeedEntry.StudyInstanceUid);
List <Observation> matchingObservations = (await _fhirService.RetrieveObservationsAsync(identifier, cancellationToken)).ToList();
// terminate early if no observation found
if (matchingObservations.Count == 0)
{
return(null);
}
var requests = new List <FhirTransactionRequestEntry>();
foreach (Observation observation in matchingObservations)
{
Bundle.RequestComponent request = new Bundle.RequestComponent()
{
Method = Bundle.HTTPVerb.DELETE,
Url = $"{ResourceType.Observation.GetLiteral()}/{observation.Id}"
};
requests.Add(new FhirTransactionRequestEntry(
FhirTransactionRequestMode.Delete,
request,
observation.ToServerResourceId(),
observation));
}
return(requests);
}
/// <inheritdoc/>
public async Task PrepareRequestAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
DicomDataset dataset = context.ChangeFeedEntry.Metadata;
if (dataset == null)
{
return;
}
if (!dataset.TryGetSingleValue(DicomTag.PatientID, out string patientId))
{
throw new MissingRequiredDicomTagException(nameof(DicomTag.PatientID));
}
var patientIdentifier = new Identifier(string.Empty, patientId);
FhirTransactionRequestMode requestMode = FhirTransactionRequestMode.None;
Patient existingPatient = await _fhirService.RetrievePatientAsync(patientIdentifier, cancellationToken);
Patient patient = (Patient)existingPatient?.DeepCopy();
if (existingPatient == null)
{
patient = new Patient();
patient.Identifier.Add(patientIdentifier);
requestMode = FhirTransactionRequestMode.Create;
}
_patientSynchronizer.Synchronize(dataset, patient);
if (requestMode == FhirTransactionRequestMode.None &&
!existingPatient.IsExactly(patient))
{
requestMode = FhirTransactionRequestMode.Update;
}
Bundle.RequestComponent request = requestMode switch
{
FhirTransactionRequestMode.Create => GenerateCreateRequest(patientIdentifier),
FhirTransactionRequestMode.Update => GenerateUpdateRequest(patient),
_ => null
};
IResourceId resourceId = requestMode switch
{
FhirTransactionRequestMode.Create => new ClientResourceId(),
_ => existingPatient.ToServerResourceId(),
};
context.Request.Patient = new FhirTransactionRequestEntry(
requestMode,
request,
resourceId,
patient);
}
/// <inheritdoc/>
public async Task ProcessAsync(ChangeFeedEntry changeFeedEntry, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(changeFeedEntry, nameof(changeFeedEntry));
// Create a context used throughout this process.
var context = new FhirTransactionContext(changeFeedEntry);
// Prepare all required objects for the transaction.
foreach (IFhirTransactionPipelineStep pipeline in _fhirTransactionPipelines)
{
await pipeline.PrepareRequestAsync(context, cancellationToken);
}
// Check to see if any resource needs to be created/updated.
var bundle = new Bundle()
{
Type = Bundle.BundleType.Transaction,
};
var usedPropertyAccessors = new List <FhirTransactionRequestResponsePropertyAccessor>(_requestResponsePropertyAccessors.Count);
foreach (FhirTransactionRequestResponsePropertyAccessor propertyAccessor in _requestResponsePropertyAccessors)
{
FhirTransactionRequestEntry requestEntry = propertyAccessor.RequestEntryGetter(context.Request);
if (requestEntry == null || requestEntry.RequestMode == FhirTransactionRequestMode.None)
{
// No associated request, skip it.
continue;
}
// There is a associated request, add to the list so it gets processed.
usedPropertyAccessors.Add(propertyAccessor);
bundle.Entry.Add(CreateRequestBundleEntryComponent(requestEntry));
}
if (!bundle.Entry.Any())
{
// Nothing to update.
return;
}
// Execute the transaction.
Bundle responseBundle = await _fhirTransactionExecutor.ExecuteTransactionAsync(bundle, cancellationToken);
// Process the response.
for (int i = 0; i < usedPropertyAccessors.Count; i++)
{
FhirTransactionResponseEntry responseEntry = CreateResponseEntry(responseBundle.Entry[i]);
usedPropertyAccessors[i].ResponseEntrySetter(context.Response, responseEntry);
}
// Execute any additional checks of the response.
foreach (IFhirTransactionPipelineStep pipeline in _fhirTransactionPipelines)
{
pipeline.ProcessResponse(context);
}
private void AddImagingStudyEndpoint(ImagingStudy imagingStudy, FhirTransactionContext context)
{
var endpointReference = context.Request.Endpoint.ResourceId.ToResourceReference();
if (!imagingStudy.Endpoint.Any(endpoint => endpointReference.IsExactly(endpoint)))
{
imagingStudy.Endpoint.Add(endpointReference);
}
}
/// <inheritdoc/>
public async Task <FhirTransactionRequestEntry> BuildAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(context.ChangeFeedEntry, nameof(context.ChangeFeedEntry));
EnsureArg.IsNotNull(context.Request, nameof(context.Request));
IResourceId patientId = context.Request.Patient.ResourceId;
ChangeFeedEntry changeFeedEntry = context.ChangeFeedEntry;
Identifier imagingStudyIdentifier = ImagingStudyIdentifierUtility.CreateIdentifier(changeFeedEntry.StudyInstanceUid);
ImagingStudy existingImagingStudy = await _fhirService.RetrieveImagingStudyAsync(imagingStudyIdentifier, cancellationToken);
ImagingStudy imagingStudy = (ImagingStudy)existingImagingStudy?.DeepCopy();
FhirTransactionRequestMode requestMode = FhirTransactionRequestMode.None;
if (existingImagingStudy == null)
{
imagingStudy = new ImagingStudy()
{
Status = ImagingStudy.ImagingStudyStatus.Available,
Subject = patientId.ToResourceReference(),
};
imagingStudy.Identifier.Add(imagingStudyIdentifier);
requestMode = FhirTransactionRequestMode.Create;
}
SynchronizeImagingStudyProperties(context, imagingStudy);
if (requestMode != FhirTransactionRequestMode.Create &&
!existingImagingStudy.IsExactly(imagingStudy))
{
requestMode = FhirTransactionRequestMode.Update;
}
Bundle.RequestComponent request = requestMode switch
{
FhirTransactionRequestMode.Create => ImagingStudyPipelineHelper.GenerateCreateRequest(imagingStudyIdentifier),
FhirTransactionRequestMode.Update => ImagingStudyPipelineHelper.GenerateUpdateRequest(imagingStudy),
_ => null,
};
IResourceId resourceId = requestMode switch
{
FhirTransactionRequestMode.Create => new ClientResourceId(),
_ => existingImagingStudy.ToServerResourceId(),
};
return(new FhirTransactionRequestEntry(
requestMode,
request,
resourceId,
imagingStudy));
}
/// <inheritdoc/>
public async Task <FhirTransactionRequestEntry> BuildAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(context.ChangeFeedEntry, nameof(context.ChangeFeedEntry));
ChangeFeedEntry changeFeedEntry = context.ChangeFeedEntry;
Identifier imagingStudyIdentifier = ImagingStudyIdentifierUtility.CreateIdentifier(changeFeedEntry.StudyInstanceUid);
ImagingStudy imagingStudy = await _fhirService.RetrieveImagingStudyAsync(imagingStudyIdentifier, cancellationToken);
// Returns null if imagingStudy does not exists for given studyInstanceUid
if (imagingStudy == null)
{
return(null);
}
string imagingStudySource = imagingStudy.Meta.Source;
ImagingStudy.SeriesComponent series = ImagingStudyPipelineHelper.GetSeriesWithinAStudy(changeFeedEntry.SeriesInstanceUid, imagingStudy.Series);
ImagingStudy.InstanceComponent instance = ImagingStudyPipelineHelper.GetInstanceWithinASeries(changeFeedEntry.SopInstanceUid, series);
// Return null if the given instance is not present in ImagingStudy
if (instance == null)
{
return(null);
}
// Removes instance from series collection
series.Instance.Remove(instance);
// Removes series from ImagingStudy if its instance collection is empty
if (series.Instance.Count == 0)
{
imagingStudy.Series.Remove(series);
}
if (imagingStudy.Series.Count == 0 && _dicomWebEndpoint.Equals(imagingStudySource, System.StringComparison.Ordinal))
{
return(new FhirTransactionRequestEntry(
FhirTransactionRequestMode.Delete,
ImagingStudyPipelineHelper.GenerateDeleteRequest(imagingStudy),
imagingStudy.ToServerResourceId(),
imagingStudy));
}
return(new FhirTransactionRequestEntry(
FhirTransactionRequestMode.Update,
ImagingStudyPipelineHelper.GenerateUpdateRequest(imagingStudy),
imagingStudy.ToServerResourceId(),
imagingStudy));
}
public void ProcessResponse(FhirTransactionContext context)
{
using (LogProcessingResponseDelegate(_logger, _pipelineStepName))
{
try
{
_fhirTransactionPipelineStep.ProcessResponse(context);
}
catch (Exception ex)
{
LogExceptionDelegate(_logger, ex);
throw;
}
}
}
/// <inheritdoc/>
public async Task PrepareRequestAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
ChangeFeedEntry changeFeedEntry = context.ChangeFeedEntry;
context.Request.ImagingStudy = changeFeedEntry.Action switch
{
ChangeFeedAction.Create => await _imagingStudyUpsertHandler.BuildAsync(context, cancellationToken),
ChangeFeedAction.Delete => await _imagingStudyDeleteHandler.BuildAsync(context, cancellationToken),
_ => throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
DicomCastCoreResource.NotSupportedChangeFeedAction,
changeFeedEntry.Action)),
};
}
public static void SetDateTimeOffSet(FhirTransactionContext context)
{
DicomDataset metadata = context.ChangeFeedEntry.Metadata;
if (metadata != null &&
metadata.TryGetSingleValue(DicomTag.TimezoneOffsetFromUTC, out string utcOffsetInString))
{
try
{
context.UtcDateTimeOffset = DateTimeOffset.ParseExact(utcOffsetInString, FhirTransactionConstants.UtcTimezoneOffsetFormat, CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces).Offset;
}
catch (FormatException)
{
throw new InvalidDicomTagValueException(nameof(DicomTag.TimezoneOffsetFromUTC), utcOffsetInString);
}
}
}
public async Task <IEnumerable <FhirTransactionRequestEntry> > BuildAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context?.ChangeFeedEntry, nameof(context.ChangeFeedEntry));
EnsureArg.IsNotNull(context.Request, nameof(context.Request));
IResourceId patientId = context.Request.Patient.ResourceId;
IResourceId imagingStudyId = context.Request.ImagingStudy.ResourceId;
ChangeFeedEntry changeFeedEntry = context.ChangeFeedEntry;
Identifier identifier = IdentifierUtility.CreateIdentifier(changeFeedEntry.StudyInstanceUid);
IReadOnlyCollection <Observation> observations = _observationParser.Parse(changeFeedEntry.Metadata, patientId.ToResourceReference(), imagingStudyId.ToResourceReference(), identifier);
if (observations.Count == 0)
{
return(Enumerable.Empty <FhirTransactionRequestEntry>());
}
Identifier imagingStudyIdentifier = imagingStudyId.ToResourceReference().Identifier;
IEnumerable <Observation> existingDoseSummariesAsync = imagingStudyIdentifier != null
? await _fhirService
.RetrieveObservationsAsync(
imagingStudyId.ToResourceReference().Identifier,
cancellationToken)
: new List <Observation>();
// TODO: Figure out a way to match existing observations with newly created ones.
List <FhirTransactionRequestEntry> fhirRequests = new List <FhirTransactionRequestEntry>();
foreach (var observation in observations)
{
fhirRequests.Add(new FhirTransactionRequestEntry(
FhirTransactionRequestMode.Create,
new Bundle.RequestComponent()
{
Method = Bundle.HTTPVerb.POST,
Url = ResourceType.Observation.GetLiteral()
},
new ClientResourceId(),
observation));
}
return(fhirRequests);
}
/// <inheritdoc/>
public void ProcessResponse(FhirTransactionContext context)
{
// If the Patient does not exist, we will use conditional create to create the resource
// to avoid duplicated resource being created. However, if the resource with the identifier
// was created externally between the retrieve and create, conditional create will return 200
// and might not contain the changes so we will need to try again.
if (context.Request.Patient?.RequestMode == FhirTransactionRequestMode.Create)
{
FhirTransactionResponseEntry patient = context.Response.Patient;
HttpStatusCode statusCode = patient.Response.Annotation <HttpStatusCode>();
if (statusCode == HttpStatusCode.OK)
{
throw new ResourceConflictException();
}
}
}
public async Task PrepareRequestAsync(FhirTransactionContext context, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(context, nameof(context));
if (_dicomCastConfiguration.Features.GenerateObservations)
{
ChangeFeedEntry changeFeedEntry = context.ChangeFeedEntry;
context.Request.Observation = changeFeedEntry.Action switch
{
ChangeFeedAction.Create => await _observationUpsertHandler.BuildAsync(context, cancellationToken),
ChangeFeedAction.Delete => await _observationDeleteHandler.BuildAsync(context, cancellationToken),
_ => throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
DicomCastCoreResource.NotSupportedChangeFeedAction,
changeFeedEntry.Action))
};
}
}
private async Task AddSeriesToImagingStudyAsync(FhirTransactionContext context, ImagingStudy imagingStudy, CancellationToken cancellationToken)
{
ChangeFeedEntry changeFeedEntry = context.ChangeFeedEntry;
List <ImagingStudy.SeriesComponent> existingSeriesCollection = imagingStudy.Series;
ImagingStudy.InstanceComponent instance = new ImagingStudy.InstanceComponent()
{
Uid = changeFeedEntry.SopInstanceUid,
};
// Checks if the given series already exists within a study
ImagingStudy.SeriesComponent series = ImagingStudyPipelineHelper.GetSeriesWithinAStudy(changeFeedEntry.SeriesInstanceUid, existingSeriesCollection);
if (series == null)
{
series = new ImagingStudy.SeriesComponent()
{
Uid = changeFeedEntry.SeriesInstanceUid,
};
series.Instance.Add(instance);
imagingStudy.Series.Add(series);
}
else
{
ImagingStudy.InstanceComponent existingInstance = ImagingStudyPipelineHelper.GetInstanceWithinASeries(changeFeedEntry.SopInstanceUid, series);
if (existingInstance == null)
{
series.Instance.Add(instance);
}
else
{
instance = existingInstance;
}
}
await _imagingStudySynchronizer.SynchronizeSeriesPropertiesAsync(context, series, cancellationToken);
await _imagingStudySynchronizer.SynchronizeInstancePropertiesAsync(context, instance, cancellationToken);
}
public async Task PrepareRequestAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
using (LogPreparingRequestDelegate(_logger, _pipelineStepName))
{
try
{
await _fhirTransactionPipelineStep.PrepareRequestAsync(context, cancellationToken);
}
catch (OperationCanceledException) when(cancellationToken.IsCancellationRequested)
{
// Cancel requested.
throw;
}
catch (Exception ex)
{
LogExceptionDelegate(_logger, ex);
throw;
}
}
}
/// <inheritdoc/>
public void ProcessResponse(FhirTransactionContext context)
{
EnsureArg.IsNotNull(context, nameof(context));
// If the ImagingStudy does not exist, we will use conditional create to create the resource
// to avoid duplicated resource being created. However, if the resource with the identifier
// was created externally between the retrieve and create, conditional create will return 200
// and might not contain the changes so we will need to try again.
if (context.Request.ImagingStudy?.RequestMode == FhirTransactionRequestMode.Create)
{
FhirTransactionResponseEntry imagingStudy = context.Response.ImagingStudy;
HttpStatusCode statusCode = imagingStudy.Response.Annotation <HttpStatusCode>();
if (statusCode == HttpStatusCode.OK)
{
throw new ResourceConflictException();
}
}
}
/// <inheritdoc/>
public void Synchronize(FhirTransactionContext context, ImagingStudy imagingStudy)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(imagingStudy, nameof(imagingStudy));
EnsureArg.IsNotNull(context.Request.Endpoint, nameof(context.Request.Endpoint));
EnsureArg.IsNotNull(context.ChangeFeedEntry, nameof(context.ChangeFeedEntry));
DicomDataset dataset = context.ChangeFeedEntry.Metadata;
if (dataset == null)
{
return;
}
ImagingStudyPipelineHelper.SetDateTimeOffSet(context);
AddStartedElement(imagingStudy, dataset, context.UtcDateTimeOffset);
AddImagingStudyEndpoint(imagingStudy, context);
AddModality(imagingStudy, dataset);
AddNote(imagingStudy, dataset);
}
public static async Task SynchronizePropertiesAsync <T>(T component, FhirTransactionContext context, Action <T, FhirTransactionContext> synchronizeAction, bool requiredProperty, bool partialValidation, IExceptionStore exceptionStore, CancellationToken cancellationToken = default)
{
try
{
synchronizeAction(component, context);
}
catch (DicomTagException ex)
{
if (partialValidation && !requiredProperty)
{
await exceptionStore.WriteExceptionAsync(
context.ChangeFeedEntry,
ex,
ErrorType.DicomValidationError,
cancellationToken);
}
else
{
throw;
}
}
}
public void ProcessResponse(FhirTransactionContext context)
{
EnsureArg.IsNotNull(context, nameof(context));
if (_dicomCastConfiguration.Features.GenerateObservations)
{
if (context.Response?.Observation == null)
{
return;
}
foreach (FhirTransactionResponseEntry observation in context.Response.Observation)
{
HttpStatusCode statusCode = observation.Response.Annotation <HttpStatusCode>();
// We are only currently doing POSTs/DELETEs which should result in a 201 or 204
if (statusCode != HttpStatusCode.Created && statusCode != HttpStatusCode.NoContent)
{
throw new ResourceConflictException();
}
}
}
}
public async Task PrepareRequestAsync(FhirTransactionContext context, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(context, nameof(context));
string queryParameter = $"name={FhirTransactionConstants.EndpointName}&connection-type={FhirTransactionConstants.EndpointConnectionTypeSystem}|{FhirTransactionConstants.EndpointConnectionTypeCode}";
Endpoint endpoint = await _fhirService.RetrieveEndpointAsync(queryParameter, cancellationToken);
FhirTransactionRequestMode requestMode = FhirTransactionRequestMode.None;
if (endpoint == null)
{
endpoint = new Endpoint()
{
Name = FhirTransactionConstants.EndpointName,
Status = Endpoint.EndpointStatus.Active,
ConnectionType = new Coding()
{
System = FhirTransactionConstants.EndpointConnectionTypeSystem,
Code = FhirTransactionConstants.EndpointConnectionTypeCode,
},
Address = _dicomWebEndpoint,
PayloadType = new List <CodeableConcept>
{
new CodeableConcept(string.Empty, string.Empty, FhirTransactionConstants.EndpointPayloadTypeText),
},
PayloadMimeType = new string[]
{
FhirTransactionConstants.DicomMimeType,
},
};
requestMode = FhirTransactionRequestMode.Create;
}
else
{
// Make sure the address matches.
if (!string.Equals(endpoint.Address, _dicomWebEndpoint, StringComparison.Ordinal))
{
// We have found an endpoint with matching name and connection-type but the address does not match.
throw new FhirResourceValidationException(DicomCastCoreResource.MismatchEndpointAddress);
}
}
Bundle.RequestComponent request = requestMode switch
{
FhirTransactionRequestMode.Create => new Bundle.RequestComponent()
{
Method = Bundle.HTTPVerb.POST,
IfNoneExist = queryParameter,
Url = ResourceType.Endpoint.GetLiteral(),
},
_ => null,
};
IResourceId resourceId = requestMode switch
{
FhirTransactionRequestMode.Create => new ClientResourceId(),
_ => endpoint.ToServerResourceId(),
};
context.Request.Endpoint = new FhirTransactionRequestEntry(
requestMode,
request,
resourceId,
endpoint);
}
private async Task SynchronizeImagingStudyPropertiesAsync(FhirTransactionContext context, ImagingStudy imagingStudy, CancellationToken cancellationToken)
{
await _imagingStudySynchronizer.SynchronizeStudyPropertiesAsync(context, imagingStudy, cancellationToken);
await AddSeriesToImagingStudyAsync(context, imagingStudy, cancellationToken);
}