public IResourceElementGroupConfigurer AddResource(Action<IResourceElementConfigurer> registration)
{
if (registration == null) throw new ArgumentNullException("registration");
ResourceElement resourceElement = new ResourceElement();
ResourceElementConfigurer resourceElementConfigurer = new ResourceElementConfigurer(resourceElement);
registration(resourceElementConfigurer);
return this;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="treeNodeGroup">Treenode group</param>
/// <param name="resourceElement">Resource element</param>
protected ResourceElementNode(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement)
{
this.treeNodeGroup = treeNodeGroup ?? throw new ArgumentNullException(nameof(treeNodeGroup));
this.resourceElement = resourceElement ?? throw new ArgumentNullException(nameof(resourceElement));
}
public BuiltInResourceElementNodeImpl(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement)
: base(treeNodeGroup, resourceElement)
{
}
public async Task <IActionResult> Metadata()
{
ResourceElement response = await _mediator.GetCapabilitiesAsync(HttpContext.RequestAborted);
return(FhirResult.Create(response));
}
public override void UpdateData(ResourceElement newResElem)
{
base.UpdateData(newResElem);
deserializedData = null;
DeserializeIfPossible();
}
/// <summary>
/// Executes a FHIRPath Patch Replace operation. Add operations will
/// replace the element located at operation.Path with a new value
/// specified at operation.Value.
///
/// Fhir package has a built-in "ReplaceWith" operation which
/// accomplishes this easily.
/// </summary>
/// <returns>Patched FHIR Resource as POCO.</returns>
internal override Resource Execute()
{
Target.ReplaceWith(Provider, ValueElementNode);
return(ResourceElement.ToPoco <Resource>());
}
public static Resource ToPoco(this ResourceElement resource)
{
return(ToPoco <Resource>(resource));
}
public Uri ResolveResourceUrl(ResourceElement resource, bool includeVersion = false)
{
throw new NotImplementedException();
}
public SerializedImageListStreamerResourceElementNodeImpl(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement, byte[] imageData)
: base(treeNodeGroup, resourceElement) => InitializeImageData(imageData);
public static async Task <SaveOutcome> UpsertResourceAsync(this IMediator mediator, ResourceElement resource, WeakETag weakETag = null, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(mediator, nameof(mediator));
EnsureArg.IsNotNull(resource, nameof(resource));
UpsertResourceResponse result = await mediator.Send <UpsertResourceResponse>(new UpsertResourceRequest(resource, weakETag), cancellationToken);
return(result.Outcome);
}
public IResourceElementNode Create(ModuleDef module, ResourceElement resourceElement, ITreeNodeGroup treeNodeGroup) => null;
public static async Task <ResourceElement> CreateResourceAsync(this IMediator mediator, ResourceElement resource, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(mediator, nameof(mediator));
EnsureArg.IsNotNull(resource, nameof(resource));
UpsertResourceResponse result = await mediator.Send <UpsertResourceResponse>(new CreateResourceRequest(resource), cancellationToken);
return(result.Outcome.Resource);
}
public ReindexSingleResourceResponse(ResourceElement parameter)
{
EnsureArg.IsNotNull(parameter, nameof(parameter));
ParameterResource = parameter;
}
public MemberMatchRequest(ResourceElement coverage, ResourceElement patient)
{
Coverage = coverage;
Patient = patient;
}
public SearchResourceResponse(ResourceElement bundle)
{
EnsureArg.IsNotNull(bundle, nameof(bundle));
Bundle = bundle;
}
protected SerializedResourceElementTreeNode(ResourceElement resElem)
: base(resElem)
{
Debug.Assert(resElem.ResourceData is BinaryResourceData);
DeserializeIfPossible();
}
public SerializedImageResourceElementNode(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement, byte[] imageData)
: base(treeNodeGroup, resourceElement)
{
InitializeImageData(imageData);
}
public UnknownSerializedResourceElementNode(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement)
: base(treeNodeGroup, resourceElement)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="treeNodeGroup">Treenode group</param>
/// <param name="resourceElement">Resource element</param>
protected SerializedImageResourceElementNode(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement)
: base(treeNodeGroup, resourceElement)
{
}
protected ResourceElementTreeNode(ResourceElement resElem)
{
this.resElem = resElem;
}
private async Task <IActionResult> PerformSearch(string type, IReadOnlyList <Tuple <string, string> > queries)
{
ResourceElement response = await _mediator.SearchResourceAsync(type, queries, HttpContext.RequestAborted);
return(FhirResult.Create(response));
}
public void GivenASearchResult_WhenCreateSearchBundle_ThenCorrectBundleShouldBeReturned()
{
_urlResolver.ResolveResourceWrapperUrl(Arg.Any <ResourceWrapper>()).Returns(x => new Uri(string.Format(_resourceUrlFormat, x.ArgAt <ResourceWrapper>(0).ResourceId)));
_urlResolver.ResolveRouteUrl(_unsupportedSearchParameters).Returns(_selfUrl);
ResourceElement observation1 = Samples.GetDefaultObservation().UpdateId("123");
ResourceElement observation2 = Samples.GetDefaultObservation().UpdateId("abc");
var resourceWrappers = new SearchResultEntry[]
{
new SearchResultEntry(CreateResourceWrapper(observation1)),
new SearchResultEntry(CreateResourceWrapper(observation2)),
};
var searchResult = new SearchResult(resourceWrappers, continuationToken: null, sortOrder: null, unsupportedSearchParameters: _unsupportedSearchParameters);
ResourceElement actual = null;
using (Mock.Property(() => ClockResolver.UtcNowFunc, () => _dateTime))
{
actual = _bundleFactory.CreateSearchBundle(searchResult);
}
// Since there is no continuation token, there should not be next link.
Assert.Null(actual.Scalar <string>("Bundle.link.where(relation='next').url"));
Assert.Collection(
actual.ToPoco <Bundle>().Entry,
async e => await ValidateEntry(observation1.ToPoco <Observation>(), e),
async e => await ValidateEntry(observation2.ToPoco <Observation>(), e));
ResourceWrapper CreateResourceWrapper(ResourceElement resourceElement)
{
return(new ResourceWrapper(
resourceElement,
new RawResource(_fhirJsonSerializer.SerializeToString(resourceElement.ToPoco <Observation>()), FhirResourceFormat.Json, isMetaSet: false),
null,
false,
null,
null,
null));
}
async Task ValidateEntry(Observation expected, Bundle.EntryComponent actualEntry)
{
Assert.NotNull(actualEntry);
var raw = actualEntry as RawBundleEntryComponent;
using (var ms = new MemoryStream())
using (var sr = new StreamReader(ms))
{
await raw?.ResourceElement?.SerializeToStreamAsUtf8Json(ms);
ms.Seek(0, SeekOrigin.Begin);
var resourceData = await sr.ReadToEndAsync();
Assert.NotNull(resourceData);
Resource resource;
resource = new FhirJsonParser().Parse(resourceData) as Resource;
Assert.Equal(expected.Id, resource.Id);
Assert.Equal(string.Format(_resourceUrlFormat, expected.Id), raw.FullUrl);
Assert.NotNull(raw.Search);
Assert.Equal(Bundle.SearchEntryMode.Match, raw.Search.Mode);
}
}
}
public async Task <IActionResult> BatchAndTransactions([FromBody] Resource bundle)
{
ResourceElement bundleResponse = await _mediator.PostBundle(bundle.ToResourceElement());
return(FhirResult.Create(bundleResponse));
}
public override void UpdateData(ResourceElement newResElem)
{
base.UpdateData(newResElem);
InitializeImageData();
}
protected SerializedResourceElementNode(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement)
: base(treeNodeGroup, resourceElement)
{
Debug.Assert(resourceElement.ResourceData is BinaryResourceData);
}
public RenameInfo(ResourceElement element, string newName)
{
this.element = element;
this.newName = newName;
this.foundInCode = false;
}
/// <summary> /// Updates the internal resource data. Must only be called if /// <see cref="CheckCanUpdateData"/> returned true. Used by the assembly /// editor. /// </summary> /// <param name="newResElem">New data</param> public virtual void UpdateData(ResourceElement newResElem) => resourceElement = newResElem;
public ResourceElementOptions(ResourceElement resEl)
{
Name = resEl.Name;
ResourceData = resEl.ResourceData;
}
public ImageResourceElementNode(ITreeNodeGroup treeNodeGroup, ResourceElement resourceElement)
: base(treeNodeGroup, resourceElement)
{
InitializeImageData();
}
public ResourceElement CopyTo(ResourceElement other)
{
other.Name = Name;
other.ResourceData = ResourceData;
return(other);
}
public ResourceElementConfigurer(ResourceElement resourceElement)
{
m_ResourceElement = resourceElement;
}
public static async Task <ResourceElement> PostBundle(this IMediator mediator, ResourceElement bundle, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(mediator, nameof(mediator));
EnsureArg.IsNotNull(bundle, nameof(bundle));
BundleResponse result = await mediator.Send <BundleResponse>(new BundleRequest(bundle), cancellationToken);
return(result.Bundle);
}
