private async Task <ExecutionResult <TResponse> > ExecuteTyped <TResponse>(IExecutionRequest <TResponse> request)
where TResponse : class, IExecutionResponse
{
var untypedResult = await ExecuteCore(request).ConfigureAwait(false);
return(untypedResult.Cast <TResponse>());
}
#pragma warning disable 1998
public async Task <ExecutionResult> Execute(IExecutionRequest request,
#pragma warning restore 1998
IReadOnlyDictionary <string, object> items,
CancellationToken cancellationToken)
{
throw new System.NotImplementedException();
}
public void Execute(IExecutionRequest request)
{
var context = new WebHookContext(
request.Adapter,
null,
request.GetDataSource <HttpListenerContext>());
_contextCallback(context);
}
public void Execute(IExecutionRequest request)
{
var context = new WebHookContext(
request.Adapter,
null,
request.GetDataSource<HttpListenerContext>());
_contextCallback(context);
}
public ExecutionResponseTransformContext(string branchId,
IExecutionRequest request,
TContext context,
IServiceProvider services,
CancellationToken cancellationToken)
{
BranchId = branchId;
Request = request ?? throw new ArgumentNullException(nameof(request));
Context = context ?? throw new ArgumentNullException(nameof(context));
Services = services ?? throw new ArgumentNullException(nameof(services));
CancellationToken = cancellationToken;
}
public void Execute(IExecutionRequest request)
{
var dataSource = (T)request.DataSource;
var parameters = _filter.GetOutput(dataSource);
var context = new SourcedContext <T>(
request.Adapter,
dataSource,
parameters);
_contextCallback(context);
}
public async Task <ExecutionResult> Execute(
IExecutionRequest request,
IReadOnlyDictionary <string, object> items,
CancellationToken cancellationToken)
{
var logger = serviceProvider.ResolveRequired <ILogger>();
var context = new ExecutionContext(serviceProvider, logger, request, items, cancellationToken);
await pipeline.Invoke(context).ConfigureAwait(false);
return(new ExecutionResult(context.Response, context.Errors));
}
protected async Task <IActionResult> Execute(IExecutionRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var executor = HttpContext.RequestServices.GetRequiredService <IExecutor>();
var response = await executor.Execute(BranchId, request, HttpContext.RequestAborted);
return(await response.TransformToOutput <Controller, IActionResult>(
new ExecutionResponseTransformContext <Controller>(BranchId, request, this,
this.HttpContext.RequestServices, HttpContext.RequestAborted)));
}
public ExecutionContext(
IServiceProvider services,
ILogger logger,
IExecutionRequest request,
IReadOnlyDictionary <string, object> items,
CancellationToken cancellationToken)
{
Services = services;
Log = logger;
Request = request;
CancellationToken = cancellationToken;
Items = new Dictionary <string, object>(items);
Errors = new ExecutionErrorCollection();
}
private void OnEntryExecuting(IExecutionRequest executionRequest)
{
_rfqUpdateSubject.OnNext(new RfqUpdate(RfqState.Executing, null, null));
_executionSubscription.Disposable = _rfqService.Execute(executionRequest)
.Timeout(TimeSpan.FromSeconds(5))
.ObserveOn(_concurrencyService.Dispatcher)
.SubscribeOn(_concurrencyService.TaskPool)
.Subscribe(
// /!\ we are only allowed to transition the state machine here, no other code!
// This applies to all server callbacks
executionReport => _stateMachine.Fire(_rfqEventServerSendsExecutionReport, executionReport),
ex => _stateMachine.Fire(_rfqEventServerExecutionError, ex));
}
private async Task <ExecutionResult> ExecuteCore(IExecutionRequest request, CancellationToken cancellationToken = default)
{
if (request is IPagingExecutionRequest listRequest)
{
//listRequest.Limit = int.Parse(HttpContext.Request.Query.GetValueOrDefault("limit", "8"));
//listRequest.Offset = int.Parse(HttpContext.Request.Query.GetValueOrDefault("offset", "0"));
}
var response = await ExecutionEngine.Execute(
request,
OnGetExecutionItems(),
cancellationToken)
.ConfigureAwait(false);
return(response);
}
public async Task <IExecutionResponse> Execute(string branchId, IExecutionRequest request, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var context = new DefaultExecutionContext(branchId, cancellationToken, serviceProvider)
{
Request = request
};
await middlewarePipeline.Execute(context).ConfigureAwait(false);
return(context.Response);
}
private async Task <ExecutionResult> ExecuteCore(IExecutionRequest request)
{
var executionEngine = HttpContext.RequestServices.GetRequiredService <IExecutionEngine>();
if (request is IPagingExecutionRequest listRequest)
{
listRequest.PagingParameters = PagingParameters.Create(
HttpContext.Request.Query.GetIntValueNullable("offset"),
HttpContext.Request.Query.GetIntValueNullable("limit")
);
}
var response = await executionEngine.Execute(
request,
OnGetExecutionItems(),
HttpContext.RequestAborted)
.ConfigureAwait(false);
return(response);
}
public IObservable<IExecutionReport> Execute(IExecutionRequest executionRequest)
{
return ExecuteSubject;
}
public void Execute(IExecutionRequest executionRequest)
{
_stateMachine.Fire(_rfqEventUserExecutes, executionRequest);
}
public void Execute(IExecutionRequest request)
{
var context = new Context(request.Adapter);
_contextCallback(context);
}
public IObservable <IExecutionReport> Execute(IExecutionRequest executionRequest)
{
return(ExecuteSubject);
}
private void OnEntryExecuting(IExecutionRequest executionRequest)
{
_rfqUpdateSubject.OnNext(new RfqUpdate(RfqState.Executing, null, null));
_executionSubscription.Disposable = _rfqService.Execute(executionRequest)
.Timeout(TimeSpan.FromSeconds(5))
.ObserveOn(_concurrencyService.Dispatcher)
.SubscribeOn(_concurrencyService.TaskPool)
.Subscribe(
// /!\ we are only allowed to transition the state machine here, no other code!
// This applies to all server callbacks
executionReport => _stateMachine.Fire(_rfqEventServerSendsExecutionReport, executionReport),
ex => _stateMachine.Fire(_rfqEventServerExecutionError, ex));
}
public void Execute(IExecutionRequest executionRequest)
{
_stateMachine.Fire(_rfqEventUserExecutes, executionRequest);
}
protected SingleResponseTransformer <TResponse> Execute <TResponse>(
IExecutionRequest <TResponse> request)
where TResponse : class, IExecutionResponse
{
return(new SingleResponseTransformer <TResponse>(ExecuteTyped(request), this));
}
public void Execute(IExecutionRequest request)
{
var context = new Context(request.Adapter);
_contextCallback(context);
}
