/// <inheritdoc /> public Task <IHypermediaContainer> Process( IResponse response, IHydraClient hydraClient, CancellationToken cancellationToken) { return(Process(response, hydraClient, null, cancellationToken)); }
/// <inheritdoc /> public Task <IHypermediaContainer> Process( IResponse response, IHydraClient hydraClient, IHypermediaProcessingOptions options = null) { return(Process(response, hydraClient, options, CancellationToken.None)); }
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)); }
/// <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); }
public async Task Setup() { Client = ConfigureClient(HydraClientFactory.Configure().WithDefaults()).AndCreate(); ScenarioSetup(); await TheTest(); }
internal PartialCollectionIterator(ICollection collection, IHydraClient hydraClient) { _hydraClient = hydraClient; Update(_collectionIri = collection.Iri, collection.View); }