public void OnResourceExecuting(ResourceExecutingContext context) { context.Result = new ContentResult() { Content = "Resource unavailable - header should not be set" }; }
public void OnResourceExecuting(ResourceExecutingContext context) { // Do not modify existing json formatters as they would effect all controllers. // Instead remove and add new formatters which only effects the controllers this // attribute is decorated on. context.InputFormatters.RemoveType<JsonInputFormatter>(); var loggerFactory = context.HttpContext.RequestServices.GetRequiredService<ILoggerFactory>(); var logger = loggerFactory.CreateLogger<JsonInputFormatter>(); context.InputFormatters.Add(new JsonInputFormatter(logger ,_serializerSettings)); }
public void OnResourceExecuting(ResourceExecutingContext context) { var result = new ObjectResult("someValue"); foreach (var formatter in _formatters) { result.Formatters.Add(formatter); } context.Result = result; }
public void OnResourceExecuting(ResourceExecutingContext context) { // InputFormatters collection contains JsonInputFormatter and JsonPatchInputFormatter. Picking // JsonInputFormatter by matching the type exactly rather than using OfType. var jsonFormatter = context.InputFormatters.OfType<JsonInputFormatter>() .Where(t => t.GetType() == typeof(JsonInputFormatter)).FirstOrDefault(); context.InputFormatters.Clear(); context.InputFormatters.Add(jsonFormatter); }
public void OnResourceExecuting(ResourceExecutingContext context) { _cacheKey = context.HttpContext.Request.Path.ToString(); if (_cache.ContainsKey(_cacheKey)) { var cachedValue = _cache[_cacheKey] as string; if (cachedValue != null) { context.Result = new ContentResult() { Content= cachedValue }; } } }
/// <inheritdoc /> public void OnResourceExecuting(ResourceExecutingContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var statusCodeFeature = context.HttpContext.Features.Get<IStatusCodePagesFeature>(); if (statusCodeFeature != null) { // Turn off the StatusCodePages feature. statusCodeFeature.Enabled = false; } }
public void OnResourceExecuting(ResourceExecutingContext context) { // InputFormatters collection contains JsonInputFormatter and JsonPatchInputFormatter. Picking // JsonInputFormatter by matching the typename var jsonFormatter = context.InputFormatters.OfType<JsonInputFormatter>() .Where(t => t.GetType() == typeof(JsonInputFormatter)).FirstOrDefault(); context.InputFormatters.Clear(); context.InputFormatters.Add(jsonFormatter); // Update the output formatter collection to only return JSON. var jsonOutputFormatter = context.OutputFormatters.OfType<JsonOutputFormatter>().Single(); context.OutputFormatters.Clear(); context.OutputFormatters.Add(jsonOutputFormatter); }
public void OnResourceExecuting(ResourceExecutingContext context) { var descriptions = new List<ApiExplorerData>(); foreach (var group in _descriptionProvider.ApiDescriptionGroups.Items) { foreach (var description in group.Items) { if (context.ActionDescriptor == description.ActionDescriptor) { descriptions.Add(CreateSerializableData(description)); } } } context.Result = new JsonResult(descriptions); }
/// <inheritdoc /> public void OnResourceExecuting(ResourceExecutingContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } // Only execute if the current filter is the one which is closest to the action. // Ignore all other filters. This is to ensure we have a overriding behavior. if (IsApplicable(context.ActionDescriptor)) { MediaTypeHeaderValue requestContentType = null; MediaTypeHeaderValue.TryParse(context.HttpContext.Request.ContentType, out requestContentType); // Confirm the request's content type is more specific than a media type this action supports e.g. OK // if client sent "text/plain" data and this action supports "text/*". if (requestContentType != null && !ContentTypes.Any(contentType => requestContentType.IsSubsetOf(contentType))) { context.Result = new UnsupportedMediaTypeResult(); } } }
/// <summary> /// Called asynchronously before the rest of the pipeline. /// </summary> /// <param name="context">The <see cref="T:Microsoft.AspNetCore.Mvc.Filters.ResourceExecutingContext" />.</param> /// <param name="next">The <see cref="T:Microsoft.AspNetCore.Mvc.Filters.ResourceExecutionDelegate" />. Invoked to execute the next resource filter or the remainder /// of the pipeline.</param> public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { var cacheKey = context.HttpContext.Request.Path.ToString(); if (_cache != null && _cache.ContainsKey(cacheKey)) { var cacheValue = _cache[cacheKey]; if (cacheValue != null) { context.Result = cacheValue; } } else { var executedContext = await next(); var result = executedContext.Result as ObjectResult; if (result != null) { _cache.Add(cacheKey, result); } } }
public void OnResourceExecuting(ResourceExecutingContext context) { if (context.ActionDescriptor is ControllerActionDescriptor controllerActionDescriptor && controllerActionDescriptor.MethodInfo.IsDefined(typeof(PassThruAttribute))) { return; } var descriptions = new List <ApiExplorerData>(); foreach (var group in _descriptionProvider.ApiDescriptionGroups.Items) { foreach (var description in group.Items) { if (context.ActionDescriptor == description.ActionDescriptor) { descriptions.Add(CreateSerializableData(description)); } } } context.Result = new JsonResult(descriptions); }
public void InvalidRouteDataProvided() { var filters = Substitute.For <IList <IFilterMetadata> >(); var actionContext = new ActionContext( new DefaultHttpContext(), m_routeData, new ActionDescriptor(), new ModelStateDictionary()); ResourceExecutingContext exingContext = new ResourceExecutingContext( actionContext, filters, Substitute.For <IList <IValueProviderFactory> >()); var lockObj = new ReaderWriterLockFilterAsyncAttribute( m_mgr, m_logger, m_config, m_remoteStatus, m_gitContext); var execDel = Substitute.For <ResourceExecutionDelegate>(); lockObj.OnResourceExecutionAsync(exingContext, execDel).Wait(); }
public void OnResourceExecuting(ResourceExecutingContext context) { string culture = context.HttpContext.Request.Query["lang"]; // 取得 Cookie 內的 Culture string _cultureInCookie = ""; if (string.IsNullOrEmpty(culture)) { if (!context.HttpContext.Request.Cookies.TryGetValue("b2d.culture", out _cultureInCookie)) { _cultureInCookie = "zh-TW"; } culture = _cultureInCookie; } var hasCultureFromUrl = Regex.IsMatch(culture, @"^[A-Za-z]{2}-[A-Za-z]{2}$"); _localizer.Culture = hasCultureFromUrl ? culture : CultureInfo.CurrentCulture.Name; // 更新 Cookie 內的 Culture context.HttpContext.Response.Cookies.Append("b2d.culture", culture); }
public async void OnResourceExecuting(ResourceExecutingContext context) { try { // FILTRO AS REQUISICOES // /api/sistema/checkrotina if (context.HttpContext.Request.Path != "/api/sistema/checkrotina") { _contexto.SEO_Visitas .Add(new SEO_Visita() { URL = context.HttpContext.Request.Path, DTHR = DateTime.Now, IdUsu = context.HttpContext.User.Identity.IsAuthenticated ? context.HttpContext.User.Identity.Name : "visitante" }); await _contexto.SaveChangesAsync(); } } catch (Exception) { } //Console.WriteLine("Passando pelo Resource Filter ANTES do metodo"); }
/// <inheritdoc /> public void OnResourceExecuting(ResourceExecutingContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var request = context.HttpContext.Request; if (!HttpMethods.IsPost(request.Method)) { // Log about the issue and short-circuit remainder of the pipeline. context.RouteData.TryGetWebHookReceiverName(out var receiverName); context.Result = CreateBadMethodResult(request.Method, receiverName); } else if (request.Body == null || !request.ContentLength.HasValue || request.ContentLength.Value == 0L) { context.RouteData.TryGetWebHookReceiverName(out var receiverName); context.Result = CreateBadBodyResult(receiverName); } }
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { var principal = new AppPrincipal(_RoleProvider, context.HttpContext.User.Identity); bool isInOneOfThisRole = false; foreach (var item in _requiredRoles.RequiredRoles) { if (principal.IsInRole(item)) { isInOneOfThisRole = true; } } if (isInOneOfThisRole == false) { context.Result = new UnauthorizedResult(); await context.Result.ExecuteResultAsync(context); } else { await next(); } }
public async Task OnResourceExecutionAsync( ResourceExecutingContext context, ResourceExecutionDelegate next) { Console.WriteLine("Executing async!"); using (StreamReader reader = new StreamReader(context.HttpContext.Request.Body, Encoding.UTF8)) { var stt = await reader.ReadToEndAsync(); var dataSource = new User() { Name = "hello", DName = "world" }; var json = JsonConvert.SerializeObject(dataSource); //replace request stream to downstream handlers var requestContent = new StringContent(json, Encoding.UTF8, "application/problem+json"); context.HttpContext.Request.Body = await requestContent.ReadAsStreamAsync();//modified stream } ResourceExecutedContext executedContext = await next(); Console.WriteLine("Executed async!"); }
public void OnResourceExecuting(ResourceExecutingContext context) { var request = context.HttpContext.Request; var response = context.HttpContext.Response; var language = ""; if (!request.Cookies.ContainsKey("language")) { response.Cookies.Append("language", "ar-SA", new CookieOptions { Expires = DateTime.Today.AddYears(1) }); language = "ar-SA"; } else { language = request.Cookies["language"]; } var culture = new CultureInfo(language); // set your culture here CultureInfo.CurrentCulture = culture; CultureInfo.CurrentUICulture = culture; }
/// <inheritdoc /> public void OnResourceExecuting(ResourceExecutingContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var routeData = context.RouteData; var pingRequestMetadata = _pingRequestMetadata; if (pingRequestMetadata == null) { if (!routeData.TryGetWebHookReceiverName(out var requestReceiverName)) { return; } pingRequestMetadata = _metadataProvider.GetPingRequestMetadata(requestReceiverName); if (pingRequestMetadata == null) { return; } } // If this is a ping request, short-circuit further processing. if (pingRequestMetadata != null && routeData.TryGetWebHookEventName(out var eventName) && string.Equals(eventName, pingRequestMetadata.PingEventName, StringComparison.OrdinalIgnoreCase)) { _logger.LogInformation( 0, "Received a Ping Event for the '{ReceiverName}' WebHook receiver -- ignoring.", pingRequestMetadata.ReceiverName); context.Result = new OkResult(); } }
/// <inheritdoc /> public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { if (context == null) { throw new System.ArgumentNullException(nameof(context)); } if (next == null) { throw new System.ArgumentNullException(nameof(next)); } var routeData = context.RouteData; if (routeData.TryGetReceiverName(out var receiverName) && HttpMethods.IsGet(context.HttpContext.Request.Method)) { var getRequestMetadata = _getRequestMetadata .FirstOrDefault(metadata => metadata.IsApplicable(receiverName)); if (getRequestMetadata != null) { var getMetadata = getRequestMetadata.WebHookGetRequest; if (getMetadata == null) { // Simple case. Earlier filters likely did all necessary verification. context.Result = new OkResult(); return; } var request = context.HttpContext.Request; context.Result = await GetChallengeResponse(getMetadata, receiverName, request, routeData); return; } } await next(); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="next"></param> /// <returns></returns> public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { var settings = new HttpCacheSettings() { Expiry = ConfiguredExpiry }; if (_options.EnableConfiguration) { settings = GetConfigSettings(context, settings); } if (!settings.Enabled) { await next(); return; } var pipa = new CachingPipeline(_validator, CacheDirectiveProvider, _options) { ApplyNoCacheNoStoreForNonCacheableResponse = ApplyNoCacheNoStoreForNonCacheableResponse, ConfiguredExpiry = settings.Expiry }; var carryon = await pipa.Before(context.HttpContext); if (!carryon) // short-circuit { return; } var execCtx = await next(); // _______________________________________________________________________________ var or = execCtx.Result as ObjectResult; await pipa.After(context.HttpContext, or == null || or.Value == null?null : or.Value); }
public virtual void OnResourceExecuting(ResourceExecutingContext context) { if (!IsRamlController(context)) { return; } if (!IsRawAction(context)) { return; } var ramlVersion = GetRamlVersion(context); ApiExplorerService apiExplorerService; if (ramlVersion == RamlVersion.Version1) { apiExplorerService = new ApiExplorerServiceVersion1(_descriptionProvider); } else { apiExplorerService = new ApiExplorerServiceVersion08(_descriptionProvider); } var ramlDocument = GetRamlContents(apiExplorerService); var raml = new RamlSerializer().Serialize(ramlDocument); var result = new ContentResult { ContentType = "text/raml", Content = raml, StatusCode = 200 }; context.Result = result; }
public void OnResourceExecuting(ResourceExecutingContext context) { var controllerActionDescriptor = context.ActionDescriptor as ControllerActionDescriptor; var dbWrite = (DatabaseChooseAttribute)controllerActionDescriptor.MethodInfo.GetCustomAttributes(typeof(DatabaseChooseAttribute), false).FirstOrDefault(); if (dbWrite != null) { if (dbWrite.IsWrite) { _dataBaseConnectionFactory.SetDatabaseChooseType(DatabaseChooseType.Write); } } else { if (context.HttpContext.Request.Method == HttpMethod.Get.Method) { _dataBaseConnectionFactory.SetDatabaseChooseType(DatabaseChooseType.Read); } else if (context.HttpContext.Request.Method == HttpMethod.Post.Method) { _dataBaseConnectionFactory.SetDatabaseChooseType(DatabaseChooseType.Write); } else if (context.HttpContext.Request.Method == HttpMethod.Put.Method) { _dataBaseConnectionFactory.SetDatabaseChooseType(DatabaseChooseType.Write); } else if (context.HttpContext.Request.Method == HttpMethod.Delete.Method) { _dataBaseConnectionFactory.SetDatabaseChooseType(DatabaseChooseType.Write); } else { _dataBaseConnectionFactory.SetDatabaseChooseType(DatabaseChooseType.Read); } } }
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { IEnumerable <Attribute> attributes = context.ActionDescriptor switch { CompiledPageActionDescriptor p => p.ModelTypeInfo.GetCustomAttributes(), ControllerActionDescriptor c => c.ControllerTypeInfo.GetCustomAttributes(), _ => throw new NotImplementedException( $"Unknown controller type: {context.ActionDescriptor.GetType().Name}" ) }; ISet <SanityCheckKind> failures = this._checker.Run(SanityCheckKind.MainPasswordIsSet); if (failures.Count > 0 && attributes.All(a => a.GetType() != typeof(Ignore))) { this._nb.Add($"Sanity checks failed: {String.Join(", ", failures)}."); context.Result = new RedirectResult(Urls.InitUrl); } else { await next(); } } }
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { string menuUrl = _requiredPermissions.UrlAndButtonType.Url; //判断用户权限 if (string.IsNullOrEmpty(menuUrl)) { //区域判断 var area = context.RouteData.Values["area"]; var controller = context.RouteData.Values["controller"]; var action = context.RouteData.Values["action"]; if (area == null) { menuUrl = "_" + controller + "_" + action; } else { menuUrl = "_" + area + "_" + controller + "_" + action;; } } menuUrl = menuUrl.Trim(); //var authorities = context.HttpContext.User.Claims.Where(p => p.Type.Equals( "authorities")).Select(o => o.Value).ToList(); if (context.HttpContext.User.HasPermission(menuUrl)) { await next(); } else { context.Result = new ContentResult() { Content = PermissionStatusCodes.Status2Unauthorized.ToString() }; await context.Result.ExecuteResultAsync(context); } }
/// <summary> /// Validate authorization /// </summary> /// <param name="context"></param> /// <param name="next"></param> /// <returns></returns> public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { // check the context - ignore certain paths string url = context.HttpContext.Request.Path; Debug.WriteLine("Authorizing request (user: {0} | path: {1})", context.HttpContext.User.Identity.Name, url); if (url.Contains("/authentication/dev") || url.Contains("/error") || url.Contains("/hangfire") || url.Contains("/swagger") || url.Contains(".map") || url.Contains(".png") || url.Contains(".css") || url.Contains(".ico") || url.Contains(".eot") || url.Contains(".woff") || url.Contains(".ttf") || url.Contains(".js")) { await next(); } AuthorizationResult result = await _authService.AuthorizeAsync(context.HttpContext.User, context.ActionDescriptor.DisplayName, _requiredPermissions); if (!result.Succeeded) { context.Result = new BadRequestObjectResult(new HetsResponse("HETS-43", ErrorViewModel.GetDescription("HETS-43", _configuration))); } else { await next(); } }
public void OnResourceExecuting(ResourceExecutingContext context) { if (GlobalFilterHelper.IsSkit(context)) { return; } string token = context.HttpContext.Request.Headers["Authorization"]; if (token.IsNullOrWhiteSpace()) { // 无Token,未登录 OkObjectResult res = new OkObjectResult(ResultCode.NotLogin.GetResult()); context.Result = res; } else { if (!TokenHelper.CheckToken(token)) { // Token无效,登陆超时 OkObjectResult res = new OkObjectResult(ResultCode.LoginTimeout.GetResult()); context.Result = res; } } }
} /* End of Function - GitAuthorizationCheckFilterAttribute */ /************************ Methods ****************************************/ /*----------------------- OnResourceExecutionAsync ----------------------*/ /// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="next"></param> public async Task OnResourceExecutionAsync( ResourceExecutingContext context, ResourceExecutionDelegate next) { string auth = null; // Will look in the headers for an "Authentication" record var headers = context.HttpContext.Request.Headers; // If so, then we will get the value to use (assuming the first is // good enough, since there should just be one) if (headers.ContainsKey("Authorization")) { auth = headers["Authorization"].First(); } // And we will need our repository object for checking var repo = m_factory.Build( context.RouteData.Values["destinationServer"].ToString(), context.RouteData.Values["repositoryOwner"].ToString(), context.RouteData.Values["repository"].ToString(), auth); // Check to see if we have authority to access the repository var result = await CheckAuthorizationAsync(repo); // If we got a result back, it is the forwarded response from // the check, so go ahead and use it and shortcut to the end of the // pipeline if (null != result) { context.Result = result; } // otherwise, we are good, let the pipeline continue else { await next(); } } /* End of Function - OnResourceExecutionAsync */
public override IDisposable?GetResource(ResourceExecutingContext context) { var user = UserEntity.Current; if (user == null) { return(null); } var isolation = user.TryMixin <IsolationMixin>()?.Isolation; if (isolation == null) { var isolationKey = context.HttpContext.Request.Headers[Signum_Isolation_Key].FirstOrDefault(); if (isolationKey != null) { isolation = Lite.Parse <IsolationEntity>(isolationKey); } } context.HttpContext.Items[Signum_Isolation_Key] = isolation; return(IsolationEntity.Override(isolation)); }
public void OnResourceExecuting(ResourceExecutingContext context) { if (!SecurityContext.IsAuthenticated) { return; } if (context.ActionDescriptor is ControllerActionDescriptor controllerActionDescriptor) { var pid = FindProduct(controllerActionDescriptor); if (pid != Guid.Empty) { if (CallContext.GetData("asc.web.product_id") == null) { CallContext.SetData("asc.web.product_id", pid); } if (!WebItemSecurity.IsAvailableForMe(CoreContext.TenantManager.GetCurrentTenant(context.HttpContext), pid)) { context.Result = new StatusCodeResult((int)HttpStatusCode.Forbidden); log.WarnFormat("Product {0} denied for user {1}", controllerActionDescriptor.ControllerName, SecurityContext.CurrentAccount); } } } }
public void OnResourceExecuting(ResourceExecutingContext context) { var httpContext = context.HttpContext; if (!Utils.IsAuthenticated(httpContext)) { context.Result = new RedirectResult("/OAuth/Unauthorized"); return; } var token = Utils.GetJWT(httpContext); var routeData = context.RouteData; var currentController = routeData.Values["controller"].ToString().ToLower(); var currentAction = routeData.Values["action"].ToString().ToLower(); var currentMethod = httpContext.Request.Method.ToLower(); var can = Utils.Can(token, currentController, currentAction, currentMethod); if (!can) { context.Result = new RedirectResult("/OAuth/Unauthorized"); } }
/// <summary> /// action执行之前 /// </summary> /// <param name="context"></param> public void OnResourceExecuting(ResourceExecutingContext context) { var isDefined = false; if (context.ActionDescriptor is ControllerActionDescriptor controllerActionDescriptor) { isDefined = controllerActionDescriptor.MethodInfo.GetCustomAttributes(inherit: true) .Any(a => a.GetType().Equals(typeof(NoVerificationLoginAttribute))); } if (isDefined) { return; } SysUser sysUsersLogin = context.HttpContext.Session.GetSession <SysUser>("UserLogin"); if (sysUsersLogin == null) { context.HttpContext.Response.Redirect("/Home/BackLogin"); } else if (sysUsersLogin.UserStatus == 0) { context.HttpContext.Response.Redirect("/Home/BackLogin"); } }
public void FormatFilter_ExplicitContentType_SetOnObjectResult_TakesPrecedence() { // Arrange var mediaType = new StringSegment("application/foo"); var mockObjects = new MockObjects("json", FormatSource.QueryData); var httpContext = new Mock <HttpContext>(); httpContext.Setup(c => c.Response).Returns(new Mock <HttpResponse>().Object); httpContext.Setup(c => c.Request.Query["format"]).Returns("json"); var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor()); var objectResult = new ObjectResult("Hello!"); objectResult.ContentTypes.Add(new MediaTypeHeaderValue("application/foo")); var resultExecutingContext = new ResultExecutingContext( actionContext, new IFilterMetadata[] { }, objectResult, controller: new object()); var resourceExecutingContext = new ResourceExecutingContext( actionContext, new IFilterMetadata[] { }, new List <IValueProviderFactory>()); var filter = new FormatFilter(mockObjects.OptionsManager); // Act filter.OnResourceExecuting(resourceExecutingContext); filter.OnResultExecuting(resultExecutingContext); // Assert var result = Assert.IsType <ObjectResult>(resultExecutingContext.Result); Assert.Single(result.ContentTypes); MediaTypeAssert.Equal(mediaType, result.ContentTypes[0]); }
private void LogAudit(ResourceExecutingContext context) { if (!ShouldAuditRequest(context)) { return; } var str = GetRequestBody(context.HttpContext.Request); if (string.IsNullOrEmpty(str)) { return; } var actionDisplayName = context.ActionDescriptor.DisplayName; str = ClearPasswords(str); if (!string.IsNullOrEmpty(str)) { _logger.Log(LogLevel.Information, new LogsAuditEntity { RequestBody = str, Ip = context.HttpContext.Connection.RemoteIpAddress.ToString(), AuthInfo = GetUser(context.HttpContext.Request.Headers["Authorization"]), // responseHeaders.ContainsKey("Auth") // ? JsonConvert.DeserializeObject<AuthEntity>(responseHeaders["Auth"]) // : null, Info = actionDisplayName, RequestUri = context.HttpContext.Request.GetEncodedUrl(), TraceIdentifier = context.HttpContext.TraceIdentifier }); } }
public void OnResourceExecuting(ResourceExecutingContext context) { if (!context.HttpContext.Request.Path.Value.Contains("Login")) { var token = string.Empty; var cookieExists = context.HttpContext .Request .Cookies .Any(x => x.Key == Constants.tokenKey); if (cookieExists) { token = context.HttpContext.Request.Cookies .FirstOrDefault(x => x.Key == Constants.tokenKey).Value; if (string.IsNullOrWhiteSpace(token) || !_authService.IsTokenValid(token)) { context.Result = new RedirectResult("/Login/Index"); } } else { context.Result = new RedirectResult("/Login/Index"); } } }
public async Task OnResourceExecutionAsync(ResourceExecutingContext context, ResourceExecutionDelegate next) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (next == null) { throw new ArgumentNullException(nameof(next)); } var routeData = context.RouteData; var request = context.HttpContext.Request; if (routeData.TryGetWebHookReceiverName(out var receiverName) && IsApplicable(receiverName) && HttpMethods.IsPost(request.Method)) { var errorResult = EnsureSecureConnection(ReceiverName, context.HttpContext.Request); if (errorResult != null) { context.Result = errorResult; return; } }
/// <inheritdoc /> public void OnResourceExecuting(ResourceExecutingContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } // Only execute if the current filter is the one which is closest to the action. // Ignore all other filters. This is to ensure we have a overriding behavior. if (IsApplicable(context.ActionDescriptor)) { var requestContentType = context.HttpContext.Request.ContentType; // Confirm the request's content type is more specific than a media type this action supports e.g. OK // if client sent "text/plain" data and this action supports "text/*". // // Requests without a content type do not return a 415. It is a common pattern to place [Consumes] on // a controller and have GET actions if (requestContentType != null && !IsSubsetOfAnyContentType(requestContentType)) { context.Result = new UnsupportedMediaTypeResult(); } } }
/// <inheritdoc /> public void OnResourceExecuting(ResourceExecutingContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var notificationId = (string)context.RouteData.Values[StripeConstants.NotificationIdKeyName]; if (IsTestEvent(notificationId)) { // Log about and optionally short-circuit this test event. var passThroughString = _configuration[StripeConstants.PassThroughTestEventsConfigurationKey]; if (bool.TryParse(passThroughString, out var passThrough) && passThrough) { _logger.LogDebug(0, "Received a Stripe Test Event."); } else { _logger.LogInformation(1, "Ignoring a Stripe Test Event."); context.Result = new OkResult(); } } }
public void EnableOutputCaching(ResourceExecutingContext context) { var action = (string)context.RouteData.Values["Action"]; var controller = (string)context.RouteData.Values["Controller"]; context.HttpContext.EnableOutputCaching( NoCache, SharedTimeSpan, ClientTimeSpan, ServerTimeSpan, ExcludeQueryStringFromCacheKey, MustRevalidate, AnonymousOnly, CacheKeyGenerator, Private, CustomTimeSpanMethodClassType, CustomTimeSpanMethodName, CachePerUser, ExpirationMode, ApiName, LogEnabled, action, controller); }
public void OnResourceExecuting(ResourceExecutingContext context) { // ShortCircuit. context.Result = new ObjectResult("someValue"); }
/// <inheritdoc /> public void OnResourceExecuting(ResourceExecutingContext context) { }
public void OnResourceExecuting(ResourceExecutingContext context) { if (context.ActionDescriptor.Properties.ContainsKey("culture")) { var culture = context.ActionDescriptor.Properties["culture"] as CultureInfo; if (culture != null) { #if DNX451 Thread.CurrentThread.CurrentCulture = culture; Thread.CurrentThread.CurrentUICulture = culture; #else CultureInfo.CurrentCulture = culture; CultureInfo.CurrentUICulture = culture; #endif } } }
public void OnResourceExecuting_ForAContentTypeMatch_IsNoOp(string contentType) { // Arrange var httpContext = new DefaultHttpContext(); httpContext.Request.ContentType = contentType; var consumesFilter = new ConsumesAttribute("application/json", "application/xml"); var actionWithConstraint = new ActionDescriptor() { ActionConstraints = new List<IActionConstraintMetadata>() { consumesFilter }, FilterDescriptors = new List<FilterDescriptor>() { new FilterDescriptor(consumesFilter, FilterScope.Action) } }; var actionContext = new ActionContext(httpContext, new RouteData(), actionWithConstraint); var resourceExecutingContext = new ResourceExecutingContext(actionContext, new[] { consumesFilter }); // Act consumesFilter.OnResourceExecuting(resourceExecutingContext); // Assert Assert.Null(resourceExecutingContext.Result); }