private static async Task <IHydraResource> GatherLinks(
ITypedEntity resource,
Statement statement,
ProcessingState processingState,
IHydraResource hydraResource,
CancellationToken cancellationToken)
{
var relationResource = await resource.Context.Load <IDereferencableLink>(statement.Predicate, cancellationToken);
var @object = await resource.Context.Load <IResource>(statement.Object, cancellationToken);
var linkType = relationResource.GetLinkType() ?? @object.GetLinkType(processingState.LinksPolicy, processingState.Root);
if (linkType != null)
{
hydraResource = hydraResource ?? resource.ActLike <IHydraResource>();
var owner = hydraResource;
processingState.MarkAsOwned(relationResource.Iri);
processingState.MarkAsOwned(@object.Iri);
processingState.ProcessingCompleted +=
(sender, e) => CreateRelationHandler((ProcessingState)sender, owner, relationResource, @object, linkType);
}
return(hydraResource);
}
private static Task <IResource> PointingResourceInitializer(
ITypedEntity resource,
IHydraClient client,
ProcessingState processingState,
CancellationToken cancellationToken)
{
resource.Unwrap().SetProperty(ResourceExtensions.BaseUrlPropertyInfo, (Uri)processingState.BaseUrl);
return(ResourceInitializer(resource.ActLike <IHydraResource>(), client, processingState, cancellationToken));
}
private static Task <IResource> ClientInitializer(
ITypedEntity resource,
IHydraClient client,
ProcessingState processingState,
CancellationToken cancellationToken)
{
resource.Unwrap().SetProperty(ClientPropertyInfo, client);
return(ResourceInitializer(
resource.Is(hydra.ApiDocumentation) ? (ITypedEntity)resource.ActLike <IApiDocumentation>() : resource.ActLike <ICollection>(),
client,
processingState,
cancellationToken));
}
private static void GatherOperationTargets(IHydraResource resource, ProcessingState processingState)
{
IEnumerable <IOperation> operations = resource.Operations;
var supportedOperationsContainer = OperationContainers.Where(_ => resource.Type.Contains(_.Key)).Select(_ => _.Value).FirstOrDefault();
if (supportedOperationsContainer != null)
{
operations = operations.Concat(supportedOperationsContainer(resource));
}
foreach (var operation in operations)
{
var proxy = operation.Unwrap();
proxy.SetProperty(ResourceExtensions.TargetPropertyInfo, resource);
proxy.SetProperty(ResourceExtensions.OriginatingMediaTypeProperty, processingState.OriginatingMediaType);
}
}
private static void CreateRelationHandler(
ProcessingState processingState,
IHydraResource owner,
IDereferencableLink relationResource,
IResource @object,
Iri type)
{
var handlers = relationResource.SupportedOperations.Any() && @object != null
? CreateTemplatedOperation(owner, relationResource, @object, hydra.Operation)
: (IEnumerable)CreateLink(owner, relationResource, @object, type);
foreach (IResource handler in handlers)
{
var proxy = handler.Unwrap();
proxy.SetProperty(ResourceExtensions.BaseUrlPropertyInfo, (Uri)processingState.BaseUrl);
processingState.ForbiddenHypermeda.Add(handler.Iri);
}
}
/// <inheritdoc />
public async Task <IHypermediaContainer> Process(
IResponse response,
IHydraClient hydraClient,
IHypermediaProcessingOptions options,
CancellationToken cancellationToken)
{
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
if (hydraClient == null)
{
throw new ArgumentNullException(nameof(hydraClient));
}
var responseIri = options?.OriginalUrl ?? response.Url;
var context = EntityContextFactory.Value.Create();
IResource resource;
var hypermedia = new List <IResource>();
using (var processingState = new ProcessingState(
context,
_ontologyProvider,
responseIri,
options?.LinksPolicy ?? LinksPolicy.Strict,
response.Headers[HydraClient.ContentType].FirstOrDefault()))
{
var rdfReader = await CreateRdfReader(response, cancellationToken);
var serializableSource = (ISerializableEntitySource)context.EntitySource;
using (processingState.StartGatheringStatementsFor(serializableSource, _ => _.Object != null && !IsStandaloneControl(_.Predicate)))
using (var reader = new StreamReader(await response.GetBody(cancellationToken)))
{
await serializableSource.Read(reader, rdfReader, response.Url, cancellationToken);
}
resource = await ProcessResources(processingState, hydraClient, hypermedia, cancellationToken);
}
return(new HypermediaContainer(response, resource, hypermedia));
}
private async Task <IResource> ProcessResources(
ProcessingState processingState,
IHydraClient hydraClient,
List <IResource> hypermedia,
CancellationToken cancellationToken)
{
var resource = await processingState.Context.Load <IResource>(processingState.BaseUrl, cancellationToken);
foreach (var entity in processingState.Context.AsQueryable <ITypedEntity>())
{
Func <ITypedEntity, IHydraClient, ProcessingState, CancellationToken, Task <IResource> > initializer = Initializers[Untyped];
foreach (var type in entity.Type.Where(item => item.ToString().StartsWith(hydra.Namespace)))
{
if (!Initializers.TryGetValue(type, out initializer))
{
initializer = Initializers[Untyped];
continue;
}
break;
}
var currentResource = await initializer(entity, hydraClient, processingState, cancellationToken);
if (currentResource != null)
{
if (processingState.AllHypermedia.Contains(currentResource.Iri))
{
currentResource = EnsureTypeCastedFor(currentResource);
hypermedia.Add(currentResource);
}
if (currentResource.Iri == resource.Iri)
{
resource = currentResource;
}
}
}
return(resource);
}
private static async Task <IResource> ResourceInitializer(
ITypedEntity resource,
IHydraClient client,
ProcessingState processingState,
CancellationToken cancellationToken)
{
IHydraResource hydraResource = resource as IHydraResource
?? (resource.Is(hydra.Resource) ? resource.ActLike <IHydraResource>() : null);
bool hasView = false;
foreach (var statement in processingState.StatementsOf(resource.Iri))
{
hydraResource = await GatherLinks(resource, statement, processingState, hydraResource, cancellationToken);
if (statement.Predicate == hydra.view)
{
hasView = true;
}
}
if (hydraResource != null && processingState.NumberOfStatementsOf(resource.Iri) > 0)
{
GatherOperationTargets(hydraResource, processingState);
if (hasView)
{
hydraResource = hydraResource.ActLike <IResourceView>();
}
var addToHypermedia = !processingState.ForbiddenHypermeda.Contains(hydraResource.Iri) &&
(!hydraResource.Iri.IsBlank || IsHydraDependent(hydraResource));
if (addToHypermedia)
{
processingState.AllHypermedia.Add(hydraResource.Iri);
}
}
return(hydraResource);
}