private async Task ExecuteHandlerMethod(MethodInfo handlerMethodInfo, IMessageController controller, OwinContext context)
{
var properties = PropertieBuilder.Build(handlerMethodInfo, context, out bool error);
if (error == true)
{
return;
}
var obj = handlerMethodInfo.Invoke(controller, properties.Values.ToArray());
IActionResult actionResult = null;
if (obj is Task <IActionResult> actionTask)
{
actionResult = await actionTask;
}
else if (obj is IActionResult)
{
actionResult = obj as IActionResult;
}
var actionContext = new ActionContext(context, new ActionDescriptor()
{
}, properties, controller);
await actionResult.ExecuteResultAsync(actionContext);
}
public async Task Invoke(HttpContext context, WebScriptHostManager manager)
{
// flow required context through the request pipeline
// downstream middleware and filters rely on this
context.Items[ScriptConstants.AzureFunctionsHostManagerKey] = manager;
SetRequestId(context.Request);
if (_next != null)
{
await _next(context);
}
IFunctionExecutionFeature functionExecution = context.Features.Get <IFunctionExecutionFeature>();
if (functionExecution != null && !context.Response.HasStarted)
{
int nestedProxiesCount = GetNestedProxiesCount(context, functionExecution);
IActionResult result = await GetResultAsync(context, functionExecution);
if (nestedProxiesCount > 0)
{
// if Proxy, the rest of the pipleline will be processed by Proxies in
// case there are response overrides and what not.
SetProxyResult(context, nestedProxiesCount, result);
return;
}
var actionContext = new ActionContext
{
HttpContext = context
};
await result.ExecuteResultAsync(actionContext);
}
}
private async Task WriteResultAsync(HttpContext context, IActionResult result)
{
var routeData = context.GetRouteData() ?? new RouteData();
var actionContext = new ActionContext(context, routeData, new ActionDescriptor());
await result.ExecuteResultAsync(actionContext);
}
/// <summary>
/// Configures the function host, adding a catch-all route that then hands off to Menes to process the request.
/// </summary>
/// <param name="app">The <see cref="IApplicationBuilder"/> to configure.</param>
public void Configure(IApplicationBuilder app)
{
var openApiRouteHandler = new RouteHandler(
async context =>
{
try
{
IOpenApiHost <HttpRequest, IActionResult> handler = context.RequestServices.GetRequiredService <IOpenApiHost <HttpRequest, IActionResult> >();
IActionResult result = await handler.HandleRequestAsync(context.Request.Path, context.Request.Method, context.Request, context).ConfigureAwait(false);
var actionContext = new ActionContext(context, context.GetRouteData(), new ActionDescriptor());
await result.ExecuteResultAsync(actionContext).ConfigureAwait(false);
}
catch (Exception ex)
{
Assert.Fail(ex.ToString());
}
});
var routeBuilder = new RouteBuilder(app, openApiRouteHandler);
routeBuilder.MapRoute("CatchAll", "{*path}");
IRouter router = routeBuilder.Build();
app.UseRouter(router);
}
public async Task Invoke(HttpContext context)
{
if (_next != null)
{
await _next(context);
}
var functionExecution = context.Features.Get <IFunctionExecutionFeature>();
if (functionExecution != null && !context.Response.HasStarted)
{
int nestedProxiesCount = GetNestedProxiesCount(context, functionExecution);
IActionResult result = await GetResultAsync(context, functionExecution);
if (nestedProxiesCount > 0)
{
// if Proxy, the rest of the pipleline will be processed by Proxies in
// case there are response overrides and what not.
SetProxyResult(context, nestedProxiesCount, result);
return;
}
ActionContext actionContext = new ActionContext(context, new RouteData(), new ActionDescriptor());
await result.ExecuteResultAsync(actionContext);
}
}
public async Task Invoke(HttpContext context)
{
nowTime = DateTime.Now;
//check
var result = await CheckAsync(context);
if (result.result)
{
//在Request的header中存放状态标记
context.Request.Headers[Common.HeaderStatusKey] = "1";
await _next.Invoke(context);
//因为考虑到性能问题，全局valve暂时去掉RateValve的添加
//var status = context.GetHeaderValue(Common.HeaderStatusKey);
//if ("1".Equals(status))
//{
// //保存
// await SaveAsync(context);
//}
}
else
{
context.Request.Headers[Common.HeaderStatusKey] = "0";
IActionResult actionResult = _options.onIntercepted(context, result.valve, IntercepteWhere.Middleware);
ActionContext c = new ActionContext(httpContext: context, routeData: new RouteData(), actionDescriptor: new ActionDescriptor());
await actionResult.ExecuteResultAsync(c);
}
}
/// <inheritdoc/>
public virtual Task ExecuteResultAsync(ActionContext context)
{
HttpRequest request = context.HttpContext.Request;
IActionResult result = GetInnerActionResult(request);
return(result.ExecuteResultAsync(context));
}
public async Task Invoke(HttpContext context)
{
// TODO: DI Need to make sure downstream services are getting what they need
// that includes proxies.
//if (scriptHost != null)
//{
// // flow required context through the request pipeline
// // downstream middleware and filters rely on this
// context.Items[ScriptConstants.AzureFunctionsHostKey] = scriptHost;
//}
if (_next != null)
{
await _next(context);
}
IFunctionExecutionFeature functionExecution = context.Features.Get <IFunctionExecutionFeature>();
if (functionExecution != null && !context.Response.HasStarted())
{
int nestedProxiesCount = GetNestedProxiesCount(context, functionExecution);
IActionResult result = await GetResultAsync(context, functionExecution);
if (nestedProxiesCount > 0)
{
// if Proxy, the rest of the pipleline will be processed by Proxies in
// case there are response overrides and what not.
SetProxyResult(context, nestedProxiesCount, result);
return;
}
ActionContext actionContext = new ActionContext(context, new RouteData(), new ActionDescriptor());
await result.ExecuteResultAsync(actionContext);
}
}
public async Task ExecuteResultAsync(ActionContext context)
{
var wrappedStream = context.HttpContext.Response.Body;
using (var stream = new MemoryStream())
{
context.HttpContext.Response.Body = stream;
string html = null;
try
{
await _wrappedActionResult.ExecuteResultAsync(context);
stream.Seek(0, SeekOrigin.Begin);
html = Encoding.UTF8.GetString(stream.ToArray()).Trim();
}
finally
{
context.HttpContext.Response.Body = wrappedStream;
}
// Check for not XML
if (IsHtmlContent(context, html))
{
html = await AddCofoundryDependenciesAsync(html, context);
}
using (var outputStream = new StreamWriter(wrappedStream, Encoding.UTF8))
{
await outputStream.WriteAsync(html);
}
}
}
/// <summary>
/// Execute this IActionResult
/// </summary>
/// <param name="context"><see cref="ActionContext"/></param>
/// <returns><see cref="Task"/></returns>
public async Task ExecuteResultAsync(ActionContext context)
{
if (_result == null)
{
_result = CreateError();
}
await _result.ExecuteResultAsync(context);
}
public async Task ExecuteResultAsync(ActionContext context)
{
var alertProvider = context.HttpContext.RequestServices.GetRequiredService <IJavaScriptAlertProvider>();
alertProvider.AddAlert(_alert);
await _result.ExecuteResultAsync(context);
}
/// <inheritdoc/>
public async virtual Task ExecuteResultAsync(ActionContext context)
{
HttpResponse response = context.HttpContext.Response;
HttpRequest request = context.HttpContext.Request;
IActionResult result = GetInnerActionResult(request);
await result.ExecuteResultAsync(context);
ResultHelpers.AddServiceVersion(response, () => ODataUtils.ODataVersionToString(ResultHelpers.GetODataResponseVersion(request)));
}
public Task ExecuteResultAsync(ActionContext context)
{
var factory = context.HttpContext.RequestServices.GetService <ITempDataDictionaryFactory>();
var tempData = factory.GetTempData(context.HttpContext);
tempData["ClasseAlert"] = _classeAlert;
tempData["Message"] = _message;
return(_actionResult.ExecuteResultAsync(context));
}
public async Task ExecuteResultAsync(ActionContext context)
{
await _internalResult.ExecuteResultAsync(context);
var alerts = new List <ApplicationAlert>();
alerts.Add(new ApplicationAlert(_type, _message));
context.HttpContext.SetAlerts(alerts);
}
public async Task ExecuteResultAsync(ActionContext context)
{
var factory = context.HttpContext.RequestServices.GetRequiredService <ITempDataDictionaryFactory>();
var tempData = factory.GetTempData(context.HttpContext);
tempData["alert-title"] = _title;
tempData["alert-type"] = _type;
tempData["alert-message"] = _body;
await _result.ExecuteResultAsync(context);
}
public override Task ExecuteResultAsync(ActionContext context)
{
var tempDataFactory = context.HttpContext.RequestServices.GetRequiredService <ITempDataDictionaryFactory>();
var tempData = tempDataFactory.GetTempData(context.HttpContext);
tempData["alert-title"] = _title;
tempData["alert-type"] = _type;
tempData["alert-body"] = _body;
return(_result.ExecuteResultAsync(context));
}
public static HttpStatusCode ExecuteResult(IActionResult result)
{
var actionContext = MockRepository.GenerateStub <ActionContext>();
actionContext.HttpContext = new DefaultHttpContext();
result.ExecuteResultAsync(actionContext);
var statusCode = actionContext.HttpContext.Response.StatusCode;
return((HttpStatusCode)statusCode);
}
public async Task ExecuteResultAsync(ActionContext context)
{
var factory = context.HttpContext.RequestServices.GetService <ITempDataDictionaryFactory>();
var tempData = factory.GetTempData(context.HttpContext);
tempData["_alert.type"] = Type;
tempData["_alert.title"] = Title;
tempData["_alert.body"] = Body;
await actionResult.ExecuteResultAsync(context);
}
public Task ExecuteResultAsync(ActionContext context)
{
var headers = context.HttpContext.Response?.Headers;
if (headers != null && !headers.ContainsKey(Allow))
{
headers.Add(Allow, new StringValues(allowedMethods));
}
return(inner.ExecuteResultAsync(context));
}
private async Task InvokeResultAsync(IActionResult result)
{
_diagnosticSource.BeforeActionResult(Context, result);
try
{
await result.ExecuteResultAsync(Context);
}
finally
{
_diagnosticSource.AfterActionResult(Context, result);
}
}
public override async Task ExecuteResultAsync(ActionContext context)
{
ViewDataDictionary viewData = _actionResult
.GetType()
.GetProperty("ViewData")
.GetValue(_actionResult) as ViewDataDictionary;
if (viewData != null)
{
viewData["Title"] = _modalTitle;
}
await _actionResult.ExecuteResultAsync(context);
}
public async Task ExecuteResultAsync(ActionContext context)
{
try
{
context.HttpContext.Response.Headers["Cache-Control"] = new StringValues($"public, max-age={(int)Duration.TotalSeconds}");
}
catch (Exception ex)
{
var test = ex.ToString();
throw;
}
await _innerActionResult.ExecuteResultAsync(context);
}
/// <inheritdoc/>
public async virtual Task ExecuteResultAsync(ActionContext context)
{
HttpRequest request = context.HttpContext.Request;
HttpResponse response = context.HttpContext.Response;
IActionResult result = GetInnerActionResult(request);
response.Headers["Location"] = GenerateLocationHeader(request).ToString();
// Since AddEntityId relies on the response, make sure to execute the result
// before calling AddEntityId() to ensure the response code is set correctly.
await result.ExecuteResultAsync(context);
ResultHelpers.AddEntityId(response, () => GenerateEntityId(request));
}
/// <inheritdoc/>
public async override Task ExecuteResultAsync(ActionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
HttpResponse response = context.HttpContext.Response;
HttpRequest request = context.HttpContext.Request;
IActionResult result = GetInnerActionResult(request);
await result.ExecuteResultAsync(context).ConfigureAwait(false);
ResultHelpers.AddServiceVersion(response, () => ODataUtils.ODataVersionToString(request.GetODataVersion()));
}
public static async Task WritesToBody(string expected, IActionResult actionResult)
{
var stream = new MemoryStream();
var context = new ActionContextStub();
context.HttpContext.Response.Body = stream;
await actionResult.ExecuteResultAsync(context);
var actual = Encoding.UTF8.GetString(stream.ToArray());
Console.WriteLine(actual);
Assert.AreEqual(expected, actual);
}
/// <inheritdoc/>
public async virtual Task ExecuteResultAsync(ActionContext context)
{
HttpRequest request = context.HttpContext.Request;
HttpResponse response = context.HttpContext.Response;
IActionResult result = GetInnerActionResult(request);
Uri location = GenerateLocationHeader(request);
response.Headers["Location"] = location.AbsoluteUri;
// Since AddEntityId relies on the response, make sure to execute the result
// before calling AddEntityId() to ensure the response code is set correctly.
await result.ExecuteResultAsync(context);
ResultHelpers.AddEntityId(response, () => GenerateEntityId(request));
ResultHelpers.AddServiceVersion(response, () => ODataUtils.ODataVersionToString(ResultHelpers.GetODataResponseVersion(request)));
}
protected async Task InvokeResultAsync(IActionResult result)
{
var actionContext = _actionContext;
_diagnosticSource.BeforeActionResult(actionContext, result);
try
{
await result.ExecuteResultAsync(actionContext);
}
finally
{
_diagnosticSource.AfterActionResult(actionContext, result);
}
}
public async Task ExecuteResultAsync(ActionContext context)
{
var wrappedStream = context.HttpContext.Response.Body;
using (var stream = new MemoryStream())
using (var streamReader = new StreamReader(stream, Encoding.UTF8))
{
context.HttpContext.Response.Body = stream;
string html = null;
try
{
await _wrappedActionResult.ExecuteResultAsync(context);
stream.Seek(0, SeekOrigin.Begin);
{
html = (await streamReader.ReadToEndAsync()).Trim();
}
}
finally
{
context.HttpContext.Response.Body = wrappedStream;
}
// Check for not XML
if (IsHtmlContent(context, html))
{
var headScript = _visualEditorScriptGenerator.CreateHeadScript();
var bodyScript = await _visualEditorScriptGenerator.CreateBodyScriptAsync(context);
html = _htmlDocumentScriptInjector.InjectScripts(html, headScript, bodyScript);
}
var outputStream = new StreamWriter(wrappedStream, Encoding.UTF8, 1024, true);
try
{
await outputStream.WriteAsync(html);
await outputStream.FlushAsync();
}
finally
{
// The "using" pattern would cause a sync flush which throws an error in NET Core 3.1
await outputStream.DisposeAsync();
}
}
}
public async Task ExecuteResultAsync(ActionContext context)
{
var factory = context.HttpContext.RequestServices.GetService <ITempDataDictionaryFactory>();
var tempData = factory.GetTempData(context.HttpContext);
var notifications = tempData.GetNotifications();
notifications.Add(new Notification
{
Type = _notificationType,
Message = _notificationMessage
});
tempData.SetNotifications(notifications);
await _innerResult.ExecuteResultAsync(context);
}
public static Task ExecuteResultAsync(this HttpContext context, IActionResult result)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var routeData = context.GetRouteData() ?? EmptyRouteData;
var actionContext = new ActionContext(context, routeData, EmptyActionDescriptor);
return(result.ExecuteResultAsync(actionContext));
}
