/// <inheritdoc/>
public async Task RenderAsync(TextWriter output, Content parentContent, IContentPayload currentPayload, PropertyBag context)
{
if (!context.TryGet(PublicationStateContextKey, out PublicationStateToRender stateToRender))
{
throw new InvalidOperationException($"The context must contain the '{PublicationStateContextKey}' property");
}
if (currentPayload is PublicationWorkflowContentPayload payload)
{
ContentState contentState = await this.contentStore.GetContentStateForWorkflowAsync(payload.Slug, WellKnownWorkflowId.ContentPublication).ConfigureAwait(false);
if (CanRender(contentState, stateToRender))
{
Content content = await this.contentStore.GetContentAsync(contentState.ContentId, contentState.Slug).ConfigureAwait(false);
IContentRenderer renderer = this.contentRendererFactory.GetRendererFor(content.ContentPayload);
await renderer.RenderAsync(output, content, content.ContentPayload, context).ConfigureAwait(false);
}
else
{
// TODO: How are we rendering error/invalid/missing states?
}
}
else
{
throw new ArgumentException(nameof(currentPayload));
}
}
/// <inheritdoc/>
public async Task RenderAsync(TextWriter output, Content parentContent, IContentPayload currentPayload, PropertyBag context)
{
if (currentPayload is CompoundPayload compoundPayload)
{
foreach (IContentPayload child in compoundPayload.Children)
{
IContentRenderer renderer = this.contentRendererFactory.GetRendererFor(child);
await renderer.RenderAsync(output, parentContent, child, context).ConfigureAwait(false);
}
}
else
{
throw new ArgumentException(nameof(currentPayload));
}
}
public async Task WhenIRenderTheContentCalledToWithTheContext(string contentName, string outputName, string contextJson)
{
Content content = this.scenarioContext.Get <Content>(contentName);
IContentRendererFactory rendererFactory = ContainerBindings.GetServiceProvider(this.featureContext).GetService <IContentRendererFactory>();
IContentRenderer renderer = rendererFactory.GetRendererFor(content.ContentPayload);
using var stream = new MemoryStream();
using var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true);
await renderer.RenderAsync(writer, content, content.ContentPayload, new PropertyBag(JObject.Parse("{" + contextJson + "}"))).ConfigureAwait(false);
await writer.FlushAsync().ConfigureAwait(false);
stream.Position = 0;
using var reader = new StreamReader(stream, Encoding.UTF8, true, 1024, true);
this.scenarioContext.Set(await reader.ReadToEndAsync().ConfigureAwait(false), outputName);
}
/// <inheritdoc/>
public async Task RenderAsync(TextWriter output, Content parentContent, IContentPayload currentPayload, PropertyBag context)
{
if (!context.TryGet(AbTestIdContextKey, out string abTestId))
{
throw new InvalidOperationException($"The context must contain the '{AbTestIdContextKey}' property");
}
if (currentPayload is AbTestSetPayload testSet)
{
Content content = await testSet.GetContentForAbGroupAsync(abTestId).ConfigureAwait(false);
IContentRenderer renderer = this.contentRendererFactory.GetRendererFor(content.ContentPayload);
await renderer.RenderAsync(output, content, content.ContentPayload, context).ConfigureAwait(false);
}
else
{
throw new ArgumentException(nameof(currentPayload));
}
}
public virtual async Task <GetRecommendationsResponse> Handle(GetRecommendationsRequest request, CancellationToken cancellationToken)
{
var scenario = _options.Scenarios.FirstOrDefault(x => x.Name.EqualsInvariant(request.Scenario ?? _options.DefaultScenario));
if (scenario == null)
{
throw new OperationCanceledException($"scenario {request.Scenario} not found");
}
var content = await _contentRenderer.RenderAsync(scenario.Connection.RequestContentTemplate, request);
var downsteamRequest = new DownstreamRequestBuilder().WithContentString(content, scenario.Connection.ContentType)
.WithScenario(scenario)
.WithUrl(scenario.Connection.Url)
.WithMethod(scenario.Connection.Method ?? "GET")
.WithHeaders(scenario.Connection.Headers)
.Build();
var response = await _sender.SendRequestAsync(downsteamRequest) as GetRecommendationsResponse;
return(response);
}