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