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(); } } }