public async Task RouteAsync(RouteContext context)
{
// Build a request model from the request
IInputFormatter inputFormatter = new JsonInputFormatter();
IEnumerable <IValueParser> valueParsers = new List <IValueParser> {
new RouteValueParser(context.RouteData)
};
RequestModelActivator modelActivator = new RequestModelActivator(
context.HttpContext,
inputFormatter,
valueParsers
);
TRequest requestModel = await modelActivator.CreateRequestModelAsync <TRequest>();
// Run the request through our command pipeline
IHandlerResult pipelineResult = _pipeline.Dispatch(context.HttpContext, requestModel);
// If the request was handled by our pipeline then write the response out
if (pipelineResult.IsHandled)
{
// Serialize the response model
IOutputFormatter outputFormatter = new JsonOutputFormatter();
ResponseWriter responseWriter = new ResponseWriter(context.HttpContext, outputFormatter);
await responseWriter.SerializeResponseAsync(pipelineResult);
// Let OWIN know our middleware handled the request
context.IsHandled = true;
}
}
private IActionResult Remap(IHandlerResult result)
{
switch (result)
{
case IDataHandlerResult <object> dhr:
return(this.Ok(dhr.Data));
case IDataHandlerResult <int> dhr:
return(this.Ok(dhr.Data));
case IDataHandlerResult <bool> dhr:
return(this.Ok(dhr.Data));
case IPagedDataHandlerResult <object> pdhr:
return(new OkPagedResult <IReadOnlyCollection <object> >(pdhr.Items, pdhr.Count));
case ICreatedHandlerResult <int> chr:
return(this.StatusCode(StatusCodes.Status201Created, chr.Data));
case ICreatedHandlerResult <object> chr:
return(this.StatusCode(StatusCodes.Status201Created, chr.Data));
case InternalServerErrorHandlerResult isehr:
return(ErrorResult(isehr.ErrorMessage, () => this.StatusCode(500), sr => this.StatusCode(412, sr)));
default:
throw new KeyNotFoundException($"Unknown handler result '{result.GetType()}' encountered.");
}
}
private async Task SendResult <T>(long chatId, IHandlerResult <T> result)
{
switch (result)
{
case ValidationFailedHandlerResult <T> validationFailedHandlerResult:
await _telegram.SendTextMessageAsync(chatId, validationFailedHandlerResult.Message);
break;
}
}
public async Task <IHandlerResult> Handle(TRequest query, CancellationToken cancellationToken)
{
IHandlerResult canHandle = await this.CanHandleAsync(query, cancellationToken);
if (canHandle == null)
{
return(await this.HandleAsync(query, cancellationToken));
}
return(canHandle);
}
public void Dispatch_should_only_handle_appropriate_request_methods(string requestMethod, Type expectedResultType)
{
// Given a POST FooRequest CommandPipeline
CommandPipeline <FooRequest> pipeline = new CommandPipeline <FooRequest>(HttpVerb.Post, new TestFooHandler());
// And an HttpContext for a GET operation
HttpContext httpContext = new DefaultHttpContext();
httpContext.Request.Method = requestMethod;
// When I try to dispatch a FooRequest
FooRequest request = new FooRequest();
IHandlerResult handlerResult = pipeline.Dispatch(httpContext, request);
// Then the pipeline should not handle the request
handlerResult.Should().BeOfType(expectedResultType);
}
public IHandlerResult Execute(IReadOnlyDictionary <string, string> tokens, IReadOnlyList <IHandlerResult> results, JObject json)
{
Stopwatch watch = Stopwatch.StartNew();
try
{
string targetName = json["name"].ToString();
IHandlerResult result = results.FirstOrDefault(x => x.Name == targetName);
if (result is ExecuteHandlerResult xr)
{
xr.Kill();
}
return(new GenericHandlerResult(watch.Elapsed, true, null));
}
finally
{
watch.Stop();
}
}
public virtual async Task <IHandlerResult> Execute(IPacket <TData> packet, IPlayer player = null)
{
IHandlerResult handlerResult = null;
object result = null;
var reflector = handlers[packet.Command].Reflector;
var parameters = reflector.ParameterReflectors;
if (parameters.Length > 0)
{
var args = Array.ConvertAll(parameters, r => GetParameter(packet, r, player));
result = reflector.Invoke(this, args);
}
else
{
result = reflector.Invoke(this);
}
switch (result)
{
case Task <StatusDescriptor> codeTask:
handlerResult = new THandlerResult {
Status = await codeTask
};
break;
case Task <IHandlerResult> resultTask:
handlerResult = await resultTask;
break;
case Task emptyTask:
await emptyTask;
handlerResult = new THandlerResult();
break;
default: throw new FormatException($"Command:{packet.Command} invoke invaild return type : {result.GetType()}");
}
return(handlerResult);
}
/// <summary>
/// Creates an appropriate HttpResponse from our command handler result
/// </summary>
/// <param name="handlerResult">The command handler result that we need to create ah HttpResponse from</param>
public async Task SerializeResponseAsync(IHandlerResult handlerResult)
{
// Set the status code on the response
var httpResponseResult = handlerResult as IHttpResponseResult;
var status = httpResponseResult?.Status ?? HttpStatusCode.OK;
_httpContext.Response.StatusCode = (int)status;
// If the response type is is null or Unit, then don't do anything since we have nothing to serialize
if ((handlerResult.Response ?? Unit.Result) == Unit.Result)
{
return;
}
// Create a context so that our formatter knows where to serialize the response
var formatterContext = new OutputFormatterWriteContext(
_httpContext,
_responseWriterFactory,
handlerResult.ResponseType,
handlerResult.Response);
// Use our writer to write a reponse body
await _outputFormatter.WriteAsync(formatterContext);
}
internal IHandlerResult Dispatch(HttpContext context, TRequest requestModel)
{
// Check to see if this pipeline handles the request verb
bool pipelineHandlesVerb = string.Equals(
context.Request.Method, $"{_verb}",
StringComparison.OrdinalIgnoreCase
);
// Run the command through our command pipeline until it gets handled
if (pipelineHandlesVerb)
{
foreach (var handler in _commandHandlers)
{
IHandlerResult handlerResult = handler.Dispatch(requestModel);
if (handlerResult.IsHandled)
{
return(handlerResult);
}
}
}
// Otherwise our pipeline can't handle the request
return(new NotHandled());
}
/// <summary>
/// Converts <see cref="IHandlerResult"/> to <see cref="IActionResult"/>.
/// </summary>
/// <param name="result">Service response.</param>
/// <returns>Returns data wrapped into <see cref="IActionResult"/>.</returns>
protected IActionResult Send(IHandlerResult result)
{
return(this.Remap(result));
}
public IHandlerResult OnHandlerExecuted(IHandlerResult handlerResult, Type messageType, object message)
{
return handlerResult;
}
public IHandlerResult OnHandlerExecuted(IHandlerResult handlerResult, Type messageType, object message)
{
return(handlerResult);
}
public IHandlerResult OnHandlerExecuted(IHandlerResult handlerResult, Type messageType, object message)
{
this.log.Value.InfoFormat("Processed {0} message. Result {1}", messageType, handlerResult);
return(handlerResult);
}
public IHandlerResult OnHandlerExecuted(IHandlerResult handlerResult, Type messageType, object message)
{
this.log.Value.InfoFormat("Processed {0} message. Result {1}", messageType, handlerResult);
return handlerResult;
}
public static IHandlerResult Join(this IHandlerResult a, IHandlerResult b)
{
return(new JoiningHandlerResult(a, b));
}
/// <summary>
/// Invokes all chained filters in the order they were applied on the specified message
/// </summary>
/// <param name="messageType"></param>
/// <param name="messageEnvelope"></param>
/// <returns></returns>
private IHandlerResult PerformFilters(Type messageType, object messageEnvelope, IHandlerResult handlerResult, Func<IInboundMessageFilter, IHandlerResult> filterFunc)
{
Func<Type, IHandlerResult, IHandlerResult> performFilters = (mType, result) =>
{
foreach (var filter in this.messageFilters[mType].ToList())
{
try
{
result = filterFunc(filter);
if (!(result is SuccessResult))
{
return result;
}
}
catch (Exception ex)
{
this.configuration.Logger.ErrorFormat("Unhandled exception in filter: {0}", ex.ToString());
return new RetryResult(ex.ToString());
}
}
return result;
};
// Global Filters
if (this.messageFilters.ContainsKey(typeof(Object)))
{
handlerResult = performFilters(typeof(Object), handlerResult);
}
// Scoped Filters
if (this.messageFilters.ContainsKey(messageType))
{
handlerResult = performFilters(messageType, handlerResult);
}
return handlerResult;
}
/// <summary>
/// Invokes all chained filters in the order they were applied on the specified message
/// </summary>
/// <param name="messageType"></param>
/// <param name="messageEnvelope"></param>
/// <returns></returns>
private IHandlerResult PerformFilters(Type messageType, object messageEnvelope, IHandlerResult handlerResult, Func <IInboundMessageFilter, IHandlerResult> filterFunc)
{
Func <Type, IHandlerResult, IHandlerResult> performFilters = (mType, result) =>
{
foreach (var filter in this.messageFilters[mType].ToList())
{
try
{
result = filterFunc(filter);
if (!(result is SuccessResult))
{
return(result);
}
}
catch (Exception ex)
{
this.configuration.Logger.ErrorFormat("Unhandled exception in filter: {0}", ex.ToString());
return(new RetryResult(ex.ToString()));
}
}
return(result);
};
// Global Filters
if (this.messageFilters.ContainsKey(typeof(Object)))
{
handlerResult = performFilters(typeof(Object), handlerResult);
}
// Scoped Filters
if (this.messageFilters.ContainsKey(messageType))
{
handlerResult = performFilters(messageType, handlerResult);
}
return(handlerResult);
}
protected async Task <IActionResult> FromResult <T>(IHandlerResult <T> result) =>
result switch
{
