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);
}
public override async Task TheTest()
{
await base.TheTest();
Markus = Result.OfType <IHydraResource>().Where(_ => _.Iri.ToString().Contains("/markus")).First();
Karol = Markus.Links.WithRelationOf(schema.knows).First().Target.ActLike <IHydraResource>();
}
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);
}
}
private static IEnumerable <IOperation> CreateTemplatedOperation(
IHydraResource owner,
IDereferencableLink relationResource,
IEntity @object,
Iri type)
{
foreach (var operation in relationResource.SupportedOperations)
{
var result = operation.Copy(GetNextIri("Operation"));
result.Type.AddIfNotExist(type);
result.Type.AddIfNotExist(hydra.IriTemplate);
var templatedOperation = result.ActLike <ITemplatedOperation>();
var proxy = templatedOperation.Unwrap();
proxy.SetProperty(IriTemplatePropertyInfo, @object.ActLike <IIriTemplate>());
result = templatedOperation;
owner.Operations.Add(result);
yield return(result);
}
}
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);
}
private static IEnumerable <IDereferencableLink> CreateLink(
IHydraResource owner,
IDereferencableLink relationResource,
IResource @object,
Iri type)
{
var result = relationResource.Copy(GetNextIri(type.ToString().Replace(hydra.Namespace, String.Empty)));
var proxy = result.Unwrap();
proxy.SetProperty(ResourceExtensions.TargetPropertyInfo, @object);
result.Type.AddIfNotExist(type);
result.Type.Remove(type == hydra.TemplatedLink ? hydra.Link : hydra.TemplatedLink);
if (type == hydra.TemplatedLink && @object != null)
{
var templatedLink = result.ActLike <ITemplatedLink>();
proxy.SetProperty(IriTemplatePropertyInfo, @object.ActLike <IIriTemplate>());
result = templatedLink;
}
owner.Links.Add(result);
return(new[] { result });
}
