public RequestHandler(
IArgumentBinder <RequestInfo> argumentBinder,
IDelegateMapper <RequestInfo> delegateMapper,
IResponseComposer responseComposer,
IEnumerable <IPreRequestHandler> preRequestHandlers,
IEnumerable <IPostRequestHandler> postRequestHandlers,
IEnumerable <IModelTransformer> modelTransformers)
{
if (argumentBinder == null)
{
throw new ArgumentNullException("argumentBinder");
}
if (delegateMapper == null)
{
throw new ArgumentNullException("delegateMapper");
}
if (responseComposer == null)
{
throw new ArgumentNullException("responseComposer");
}
_responseComposer = responseComposer;
_argumentBinder = argumentBinder;
_handlerMapper = delegateMapper;
_preRequestHandlers = new List <IPreRequestHandler>();
_postRequestHandlers = new List <IPostRequestHandler>();
_authenticationProviders = new List <IPreRequestHandler>();
_modelTransformers = modelTransformers ?? new IModelTransformer[0];
_defaultAuthenticationScheme = Initialize(preRequestHandlers, postRequestHandlers);
}
public async Task <TActionResult> Evaluate <TPage>(
TPage page,
IResponseComposer responseComposer,
Func <TResult, TPage, TActionResult>?onSuccess = null,
Func <IResponse <TResult>, TPage, TActionResult>?onError = null)
where TPage : IPageModelBase <TActionResult>
{
var onSuccessAsync = onSuccess != null ? new Func <TResult, TPage, Task <TActionResult> >((r, p) => Task.FromResult(onSuccess(r, p))) : null;
var onErrorAsync = onError != null ? new Func <IResponse <TResult>, TPage, Task <TActionResult> >((r, p) => Task.FromResult(onError(r, p))) : null;
return(await this.EvaluateAsync(page, responseComposer, onSuccessAsync, onErrorAsync));
}
public async Task <TActionResult> EvaluateAsync <TPage>(TPage page,
IResponseComposer responseComposer,
Func <TResult, TPage, Task <TActionResult> >?onSuccess = null,
Func <IResponse <TResult>, TPage, Task <TActionResult> >?onError = null)
where TPage : IPageModelBase <TActionResult>
{
Debug.Assert(page != null);
var result = await this.GetResult(page.Logger, responseComposer);
Debug.Assert(result != null);
return(await this.ApplyToPage(result, page, onSuccess, onError));
}
public async Task <IResponse> Execute(
IObjectLogger logger,
IResponseComposer responseComposer,
Func <TResult, IResponse>?onSuccess = null,
Func <IResponse <TResult>, IResponse>?onError = null)
{
var response = await this.GetResult(logger, responseComposer);
Debug.Assert(response != null);
if (response.Succeeded && onSuccess != null)
{
return(onSuccess(response.Payload));
}
if (!response.Succeeded && onError != null)
{
return(onError(response));
}
return(response);
}
private static IResponse <TCombineResult> GetCombineResult <TCombineResult>(
Func <TFrom, TRequestResult, TCombineResult> combine, IResponse <TFrom> first,
IResponse <TRequestResult> second, IResponseComposer composer)
{
if (!first.Succeeded)
{
return(composer.From <TCombineResult>(second));
}
if (!second.Succeeded)
{
return(composer.From <TCombineResult>(second));
}
try
{
return(composer.Success(combine(first.Payload, second.Payload)));
}
catch (Exception ex)
{
return(composer.Error <TCombineResult>(ex));
}
}
private async Task <IResponse <TRequestResult> > GetResponse(IObjectLogger logger, IResponseComposer responseComposer)
{
try
{
return(await this.Request());
}
catch (Exception e)
{
logger.LogCritical(e);
return(responseComposer.Error <TRequestResult>(e));
}
}
public override async Task <IResponse <TResult> > GetResult(IObjectLogger logger, IResponseComposer responseComposer)
{
Debug.Assert(logger != null);
try
{
var requestResult = this.ProcessResponse(logger, await this.GetResponse(logger, responseComposer));
Debug.Assert(requestResult != null);
return(await this.TransformFunc(requestResult, responseComposer, logger));
}
catch (Exception e)
{
logger.LogCritical(e);
return(responseComposer.Error <TResult>(e));
}
}
protected static async Task <IResponse <TResult> > Try(IResponse <TResult> response, Func <TResult, Task <IResponse> > request, IResponseComposer responseComposer, IObjectLogger logger)
{
var result = await request(response.Payload);
HandleResponse(logger, result);
return(result.Succeeded
? response
: responseComposer.From <TResult>(result));
}
public abstract Task <IResponse <TResult> > GetResult(IObjectLogger logger, IResponseComposer responseComposer);
private async Task <IResponse <TRequestResult> > GetResponse(IResponse <TFrom> parentResult, IObjectLogger logger, IResponseComposer responseComposer)
{
Debug.Assert(parentResult != null);
try
{
return(this.Request != null
? await this.Request(parentResult.Payload)
: throw new InvalidOperationException("Provider is null"));
}
catch (Exception e)
{
logger.LogCritical(e);
return(responseComposer.Error <TRequestResult>(e));
}
}
public override async Task <IResponse <TResult> > GetResult(IObjectLogger logger, IResponseComposer responseComposer)
{
Debug.Assert(this.Parent != null);
Debug.Assert(this.Request != null);
try
{
var parentResult = await this.Parent.GetResult(logger, responseComposer);
if (!parentResult.Succeeded)
{
return(responseComposer.From <TFrom, TResult>(parentResult));
}
var response = this.ProcessResponse(logger, await this.GetResponse(parentResult, logger, responseComposer));
return(await this.TransformFunc(parentResult, response, responseComposer, logger));
}
catch (Exception e)
{
logger.LogCritical(e);
return(responseComposer.Error <TResult>(e));
}
}
private IResponse <TCombineResult> Combine <TCombineResult>(Func <TFrom, TRequestResult, TCombineResult> combine,
IResponse <TFrom> source, IResponse <TRequestResult> response, IObjectLogger logger,
IResponseComposer composer)
{
return(this.ProcessResponse(logger, GetCombineResult(combine, source, response, composer)));
}
