public async Task <UpsertResourceResponse> Handle(PatchResourceRequest request, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(request, nameof(request));
if (await AuthorizationService.CheckAccess(DataActions.Read | DataActions.Write, cancellationToken) != (DataActions.Read | DataActions.Write))
{
throw new UnauthorizedFhirActionException();
}
ResourceKey key = request.ResourceKey;
if (!string.IsNullOrEmpty(key.VersionId))
{
throw new MethodNotAllowedException(Core.Resources.DeleteVersionNotAllowed);
}
ResourceWrapper currentDoc = await FhirDataStore.GetAsync(key, cancellationToken);
if (currentDoc == null)
{
throw new ResourceNotFoundException(string.Format(Core.Resources.ResourceNotFoundById, key.ResourceType, key.Id));
}
var patchedResource = _patchService.Patch(currentDoc, request.PatchDocument, request.WeakETag);
return(await _mediator.Send <UpsertResourceResponse>(new UpsertResourceRequest(patchedResource), cancellationToken));
}
public async Task <DeleteResourceResponse> Handle(DeleteResourceRequest message, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(message, nameof(message));
var key = message.ResourceKey;
if (!string.IsNullOrEmpty(key.VersionId))
{
throw new MethodNotAllowedException(Core.Resources.DeleteVersionNotAllowed);
}
string version = null;
if (message.HardDelete)
{
await FhirDataStore.HardDeleteAsync(key, cancellationToken);
}
else
{
ResourceWrapper existing = await FhirDataStore.GetAsync(key, cancellationToken);
version = existing?.Version;
if (existing?.IsDeleted == false)
{
var emptyInstance = (Resource)Activator.CreateInstance(ModelInfo.GetTypeForFhirType(existing.ResourceTypeName));
emptyInstance.Id = existing.ResourceId;
ResourceWrapper deletedWrapper = CreateResourceWrapper(emptyInstance, deleted: true);
bool keepHistory = await ConformanceProvider.Value.CanKeepHistory(key.ResourceType, cancellationToken);
UpsertOutcome result = await FhirDataStore.UpsertAsync(
deletedWrapper,
WeakETag.FromVersionId(existing.Version),
allowCreate : true,
keepHistory : keepHistory,
cancellationToken : cancellationToken);
version = result.Wrapper.Version;
}
}
if (string.IsNullOrWhiteSpace(version))
{
return(new DeleteResourceResponse(new ResourceKey(key.ResourceType, key.Id)));
}
return(new DeleteResourceResponse(new ResourceKey(key.ResourceType, key.Id, version), WeakETag.FromVersionId(version)));
}
public async Task <PatchResourceResponse> Handle(PatchResourceRequest message, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(message, nameof(message));
if (await AuthorizationService.CheckAccess(DataActions.Write, cancellationToken) != DataActions.Write)
{
throw new UnauthorizedFhirActionException();
}
var key = message.ResourceKey;
if (!string.IsNullOrEmpty(key.VersionId))
{
throw new MethodNotAllowedException(Core.Resources.DeleteVersionNotAllowed);
}
ResourceWrapper currentDoc = await FhirDataStore.GetAsync(key, cancellationToken);
if (currentDoc == null)
{
throw new ResourceNotFoundException(string.Format(Core.Resources.ResourceNotFoundById, key.ResourceType, key.Id));
}
ResourceElement resource = _resourceDeserializer.Deserialize(currentDoc);
Resource resourceInstance = resource.Instance.ToPoco <Resource>();
message.PatchDocument.ApplyTo(resourceInstance);
ResourceWrapper resourceWrapper = CreateResourceWrapper(resourceInstance, deleted: false, keepMeta: true);
bool keepHistory = await ConformanceProvider.Value.CanKeepHistory(currentDoc.ResourceTypeName, cancellationToken);
UpsertOutcome result = await FhirDataStore.UpsertAsync(
resourceWrapper,
weakETag : message.WeakETag,
allowCreate : false,
keepHistory : keepHistory,
cancellationToken : cancellationToken);
resourceInstance.VersionId = result.Wrapper.Version;
return(new PatchResourceResponse(new SaveOutcome(new RawResourceElement(result.Wrapper), result.OutcomeType)));
}
public async Task <GetResourceResponse> Handle(GetResourceRequest request, CancellationToken cancellationToken)
{
EnsureArg.IsNotNull(request, nameof(request));
if (await AuthorizationService.CheckAccess(DataActions.Read, cancellationToken) != DataActions.Read)
{
throw new UnauthorizedFhirActionException();
}
var key = request.ResourceKey;
var currentDoc = await FhirDataStore.GetAsync(key, cancellationToken);
if (currentDoc == null)
{
if (string.IsNullOrEmpty(key.VersionId))
{
throw new ResourceNotFoundException(string.Format(Core.Resources.ResourceNotFoundById, key.ResourceType, key.Id));
}
else
{
throw new ResourceNotFoundException(string.Format(Core.Resources.ResourceNotFoundByIdAndVersion, key.ResourceType, key.Id, key.VersionId));
}
}
if (currentDoc.IsHistory &&
ConformanceProvider != null &&
await ConformanceProvider.Value.CanReadHistory(key.ResourceType, cancellationToken) == false)
{
throw new MethodNotAllowedException(string.Format(Core.Resources.ReadHistoryDisabled, key.ResourceType));
}
if (currentDoc.IsDeleted)
{
// As per FHIR Spec if the resource was marked as deleted on that version or the latest is marked as deleted then
// we need to return a resource gone message.
throw new ResourceGoneException(new ResourceKey(currentDoc.ResourceTypeName, currentDoc.ResourceId, currentDoc.Version));
}
return(new GetResourceResponse(new RawResourceElement(currentDoc)));
}
public async Task <ResourceWrapper> GetAsync(ResourceKey key, CancellationToken cancellationToken = default(CancellationToken))
{
return(await _dataStore.GetAsync(key, cancellationToken));
}