public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
var handlerInstance = context.HandlerInstance;
if (handlerInstance == null)
{
throw new InvalidOperationException(Resources.FormatPropertyOfTypeCannotBeNull(
nameof(context.HandlerInstance),
nameof(PageHandlerExecutedContext)));
}
if (handlerInstance is IAsyncPageFilter asyncPageFilter)
{
return(asyncPageFilter.OnPageHandlerExecutionAsync(context, next));
}
else if (handlerInstance is IPageFilter pageFilter)
{
return(ExecuteSyncFilter(context, next, pageFilter));
}
else
{
return(next());
}
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
if (context.HandlerMethod == null)
{
await next();
return;
}
var pageHandlerExecutedContext = await next();
if (pageHandlerExecutedContext.Exception == null)
{
return;
}
var wrapResultAttribute = ReflectionHelper.GetSingleAttributeOfMemberOrDeclaringTypeOrDefault(
context.HandlerMethod.MethodInfo,
_configuration.DefaultWrapResultAttribute
);
if (wrapResultAttribute.LogError)
{
LogHelper.LogException(Logger, pageHandlerExecutedContext.Exception);
}
HandleAndWrapException(pageHandlerExecutedContext, wrapResultAttribute);
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
var dbContext = context.HttpContext.RequestServices.GetService <UniversityDbContext>();
try
{
await dbContext.BeginTransactionAsync();
var actionExecuted = await next();
if (actionExecuted.Exception != null && !actionExecuted.ExceptionHandled)
{
dbContext.RollbackTransaction();
}
else
{
await dbContext.CommitTransactionAsync();
}
}
catch (System.Exception)
{
dbContext.RollbackTransaction();
throw;
}
}
/// <summary>
/// Ons the page handler execution async.
/// </summary>
/// <returns>The page handler execution async.</returns>
/// <param name="context">Context.</param>
/// <param name="next">Next.</param>
public async Task OnPageHandlerExecutionAsync(
PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
_logger.LogDebug("Global OnPageHandlerExecutionAsync called.");
await next.Invoke().ConfigureAwait(false);
}
public async Task OnPageHandlerExecutionAsync(
PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
// Do post work.
await next.Invoke();
}
public async Task OnPageHandlerExecutionAsync
(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
var page = context.HandlerInstance as PageModel;
if (page == null)
{
return;
}
var cookie = page.HttpContext.Request.Cookies.TryGetValue("x-token", out string token);
if (!cookie)
{
context.Result = new RedirectToPageResult("Login");
return;
}
var user = await authService.IdentifyUser(token);
page.HttpContext.Items["userId"] = user.ToString();
page.ViewData["userId"] = user.ToString();
page.ViewData["Host"] = context.HttpContext.Request.Host.Host;
await next();
}
public async Task VerifyAsyncReturnsBoolean(bool success)
{
var reCaptchaServiceMock = new Mock <IReCaptchaService>();
reCaptchaServiceMock.Setup(x => x.VerifyAsync(It.IsAny <string>())).Returns(Task.FromResult(success));
var filter = new ValidateRecaptchaFilter(reCaptchaServiceMock.Object, "", "");
var expected = new StringValues("123");
var httpContextMock = new Mock <HttpContext>();
var pageContext = CreatePageContext(new ActionContext(httpContextMock.Object, new RouteData(), new ActionDescriptor()));
var model = new Mock <PageModel>();
var pageHandlerExecutedContext = new PageHandlerExecutedContext(
pageContext,
Array.Empty <IFilterMetadata>(),
new HandlerMethodDescriptor(),
model.Object);
var actionExecutingContext = CreatePageHandlerExecutingContext(httpContextMock, pageContext, expected, model);
PageHandlerExecutionDelegate next = () => Task.FromResult(pageHandlerExecutedContext);
await filter.OnPageHandlerExecutionAsync(actionExecutingContext, next);
reCaptchaServiceMock.Verify(x => x.VerifyAsync(It.IsAny <string>()), Times.Once);
}
public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
ip = context.HttpContext.Connection.RemoteIpAddress;
//page.ViewData["filterMessage"];
return(next.Invoke());
//throw new NotImplementedException();
}
public override async Task OnPageHandlerExecutionAsync(
PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
// Before page handler
await next();
// Adter page handler
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
await next.Invoke();
var feature = new RouteDataProviderFeature(context.RouteData.Values);
context.HttpContext.Features.Set(feature);
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
var cacheAttribute = context.HandlerMethod.MethodInfo.GetCustomAttribute <ClientResponseCacheAttribute>();
trySetHeaders(cacheAttribute, context.HttpContext);
await next.Invoke();
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
await next.Invoke();
var attributes = context.HandlerMethod.MethodInfo.GetCustomAttributes(false);
var feature = new PageHandlerAttributesProviderFeature(attributes);
context.HttpContext.Features.Set(feature);
}
public Task OnPageHandlerExecutionAsync(
PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
if (ShouldShortCircuit(context.HttpContext, nameof(OnPageHandlerExecutionAsync)))
{
context.Result = new PageResult();
return(Task.CompletedTask);
}
return(next());
}
public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
var trackingIdCookieName = configuration_.GetTrackingIdCookieName();
if (!context.HttpContext.Request.Cookies.ContainsKey(trackingIdCookieName))
{
context.HttpContext.Response.Cookies.Append(trackingIdCookieName, CryptoHelper.CreateKey(10)); // limit for client
}
return(next());
}
private static async Task ExecuteSyncFilter(
PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next,
IPageFilter pageFilter)
{
pageFilter.OnPageHandlerExecuting(context);
if (context.Result == null)
{
pageFilter.OnPageHandlerExecuted(await next());
}
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
if (context.ModelState.IsValid)
{
await next.Invoke();
}
else
{
returnError(context.HttpContext);
}
}
public async override Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
var key = _config.GetValue(typeof(string), "UserAgentID");
context.HttpContext.Request.Headers.TryGetValue("user-agent", out StringValues value);
ProcessUserAgent.Write(context.ActionDescriptor.DisplayName,
"/IndexModel-OnPageHandlerSelectionAsync",
value, key.ToString());
await next.Invoke();
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
var result = context.Result;
if (result is PageResult)
{
var page = ((PageResult)result);
page.ViewData["IP"] = "siema";
}
await next.Invoke();
}
public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
if (environment.EnvironmentName == EnvironmentConstants.Production)
{
var isApiResponse = context.Result is ApiResponse apiResponse;
if (isApiResponse)
{
apiResponse = (ApiResponse)context.Result;
apiResponse.ClearException();
}
}
return(Task.CompletedTask);
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
var log = new XLogPageData();
log.ProcessStart = DateTime.UtcNow;
log.Area = context.ActionDescriptor.AreaName;
log.IpAddress = context.HttpContext.Connection.RemoteIpAddress.ToString();
log.Port = context.HttpContext.Connection.RemotePort.ToString();
log.HttpMethod = context.HttpContext.Request.Method;
log.Page = context.HandlerInstance.GetType().Name;
log.HandlerMethod = context.HandlerMethod.Name;
await next();
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
try
{
// Do post work.
await next.Invoke();
}
catch (AppError ex)
{
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task OnPageHandlerExecutionAsync(
PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
// Check user agent
string userAgent = context.HttpContext.Request.Headers["User-Agent"];
foreach (string client in _rejectedClients)
{
if (userAgent.Contains(client))
{
context.Result = new NotFoundResult();
await Task.CompletedTask;
break;
}
}
await next.Invoke();
}
public async Task OnPageHandlerExecutionAsync_DoesNotInvokeHandlerExecuted_IfResultIsSet()
{
// Arrange
var pageContext = new PageContext(new ActionContext(
new DefaultHttpContext(),
new RouteData(),
new PageActionDescriptor(),
new ModelStateDictionary()));
var model = new Mock <object>();
var modelAsFilter = model.As <IPageFilter>();
modelAsFilter
.Setup(f => f.OnPageHandlerExecuting(It.IsAny <PageHandlerExecutingContext>()))
.Callback((PageHandlerExecutingContext context) => context.Result = new PageResult())
.Verifiable();
modelAsFilter
.Setup(f => f.OnPageHandlerExecuted(It.IsAny <PageHandlerExecutedContext>()))
.Throws(new Exception("Shouldn't be called"));
var pageHandlerExecutingContext = new PageHandlerExecutingContext(
pageContext,
Array.Empty <IFilterMetadata>(),
new HandlerMethodDescriptor(),
new Dictionary <string, object>(),
model.Object);
var pageHandlerExecutedContext = new PageHandlerExecutedContext(
pageContext,
Array.Empty <IFilterMetadata>(),
new HandlerMethodDescriptor(),
model.Object);
PageHandlerExecutionDelegate next = () => Task.FromResult(pageHandlerExecutedContext);
var pageHandlerPageFilter = new PageHandlerPageFilter();
// Act
await pageHandlerPageFilter.OnPageHandlerExecutionAsync(pageHandlerExecutingContext, next);
// Assert
modelAsFilter.Verify();
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
var page = context.HandlerInstance as PageModel;
if (page == null)
{
return;
}
var pageType = context.ActionDescriptor.DeclaredModelTypeInfo;
var attrs = pageType.GetCustomAttributes(typeof(BreadcrumbAttribute));
if (attrs.Any() && attrs.First() is BreadcrumbAttribute breadcrumbAttribute)
{
page.ViewData["ShowBreadcrumbs"] = !breadcrumbAttribute.Default;
}
await next();
}
public async Task OnPageHandlerExecutionAsync_ExecutesSyncFilters()
{
// Arrange
var pageContext = new PageContext(new ActionContext(
new DefaultHttpContext(),
new RouteData(),
new PageActionDescriptor(),
new ModelStateDictionary()));
var model = new Mock <object>();
var modelAsFilter = model.As <IPageFilter>();
modelAsFilter
.Setup(f => f.OnPageHandlerExecuting(It.IsAny <PageHandlerExecutingContext>()))
.Verifiable();
modelAsFilter
.Setup(f => f.OnPageHandlerExecuted(It.IsAny <PageHandlerExecutedContext>()))
.Verifiable();
var pageHandlerExecutingContext = new PageHandlerExecutingContext(
pageContext,
Array.Empty <IFilterMetadata>(),
new HandlerMethodDescriptor(),
new Dictionary <string, object>(),
model.Object);
var pageHandlerExecutedContext = new PageHandlerExecutedContext(
pageContext,
Array.Empty <IFilterMetadata>(),
new HandlerMethodDescriptor(),
model.Object);
PageHandlerExecutionDelegate next = () => Task.FromResult(pageHandlerExecutedContext);
var pageHandlerPageFilter = new PageHandlerPageFilter();
// Act
await pageHandlerPageFilter.OnPageHandlerExecutionAsync(pageHandlerExecutingContext, next);
// Assert
modelAsFilter.Verify();
}
public async Task OnPageHandlerExecutionAsync_InvokesNextDelegateIfHandlerDoesNotImplementFilter()
{
// Arrange
var pageContext = new PageContext(new ActionContext(
new DefaultHttpContext(),
new RouteData(),
new PageActionDescriptor(),
new ModelStateDictionary()));
var model = new object();
var pageHandlerExecutingContext = new PageHandlerExecutingContext(
pageContext,
Array.Empty <IFilterMetadata>(),
new HandlerMethodDescriptor(),
new Dictionary <string, object>(),
model);
var pageHandlerExecutedContext = new PageHandlerExecutedContext(
pageContext,
Array.Empty <IFilterMetadata>(),
new HandlerMethodDescriptor(),
model);
var invoked = false;
PageHandlerExecutionDelegate next = () =>
{
invoked = true;
return(Task.FromResult(pageHandlerExecutedContext));
};
var pageHandlerPageFilter = new PageHandlerPageFilter();
// Act
await pageHandlerPageFilter.OnPageHandlerExecutionAsync(pageHandlerExecutingContext, next);
// Assert
Assert.True(invoked);
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
var result = await HandleAsync(context);
if (result.result)
{
await next();
}
else
{
context.Result = _options.onIntercepted(context.HttpContext, result.valve, IntercepteWhere.PageFilter);
}
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
if (!context.ModelState.IsValid)
{
// Do Something
if (!string.IsNullOrWhiteSpace(Handler))
{
if (!string.Equals(context.HandlerMethod.Name, Handler, StringComparison.InvariantCultureIgnoreCase))
{
await next.Invoke();
}
}
if (!string.IsNullOrWhiteSpace(HttpMethod))
{
if (!string.Equals(context.HandlerMethod.HttpMethod, HttpMethod, StringComparison.InvariantCultureIgnoreCase))
{
await next.Invoke();
}
}
SetPageResult(context);
}
else
{
await next.Invoke();
}
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
if (context.HandlerMethod == null || !context.ActionDescriptor.IsPageAction())
{
await next();
return;
}
var methodInfo = context.HandlerMethod.MethodInfo;
using (AbpCrossCuttingConcerns.Applying(context.HandlerInstance, AbpCrossCuttingConcerns.FeatureChecking))
{
var methodInvocationFeatureCheckerService = context.GetRequiredService <IMethodInvocationFeatureCheckerService>();
await methodInvocationFeatureCheckerService.CheckAsync(new MethodInvocationFeatureCheckerContext(methodInfo));
await next();
}
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
if (context.HandlerMethod == null)
{
await next();
return;
}
var unitOfWorkAttr = context.HandlerMethod.MethodInfo.GetUnitOfWorkAttributeOrNull();
if (unitOfWorkAttr == null)
{
// Default UnitOfWorkAttribute
unitOfWorkAttr = _serviceProvider.GetService <UnitOfWorkAttribute>();
}
if (unitOfWorkAttr.IsDisabled)
{
await next();
return;
}
var unitOfWorkOptions = unitOfWorkAttr.CreateOptions();
using (var uow = _unitOfWorkManager.Begin(unitOfWorkOptions))
{
var result = await next();
if (result.Exception == null || result.ExceptionHandled)
{
await uow.CompleteAsync();
}
}
}
