public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
// validate feature is enabled
var config = await _cache.Configuration();
if (!config.Session_Logging_Is_Enabled)
{
await next();
return;
}
var session = await _sessionManager.GetSession();
int sessionLogId;
using (var uow = _uowFactory.GetUnitOfWork())
{
var methoInfo = context.HandlerMethod.MethodInfo.Name;
var method = context.HttpContext.Request.Method;
var dbRequest = new Repositories.DatabaseRepos.SessionRepo.Models.CreateSessionLogRequest()
{
Session_Id = session.SessionEntity.Id,
Page = (string)context.RouteData.Values["Page"],
Handler_Name = context.HandlerMethod.Name,
Method = method,
Controller = (string)context.RouteData.Values["Controller"],
Action = (string)context.RouteData.Values["Action"],
IsAJAX = !(methoInfo == "OnGet" || methoInfo == "OnPost"),
Url = context.HttpContext.Request.GetDisplayUrl(),
Created_By = ApplicationConstants.SystemUserId
};
if (method == "POST" || !string.IsNullOrEmpty(context.HandlerMethod.Name))
{
var postData = new Dictionary <string, object>();
var hasHandlerArguments = context.HandlerArguments.Any();
if (hasHandlerArguments)
{
postData.Add("Handler_Arguments", context.HandlerArguments);
}
var formData = context.HandlerInstance.GetType().GetProperty("FormData");
var hasFormData = formData != null;
if (hasFormData)
{
// todo: FormData always gets added on ajax posts :/ figure out how to filter it out
postData.Add("Form_Data", ((dynamic)context.HandlerInstance).FormData);
}
if (hasHandlerArguments || hasFormData)
{
var jsonString = JsonConvert.SerializeObject(postData, Formatting.Indented).Trim();
dbRequest.Action_Data_JSON = JsonHelper.ObfuscateFieldValues(jsonString, ApplicationConstants.ObfuscatedActionArgumentFields);
}
}
sessionLogId = await uow.SessionRepo.CreateSessionLog(dbRequest);
uow.Commit();
// required for session event logging
await _sessionProvider.Set(SessionConstants.SessionLogId, sessionLogId);
}
// do something before the action executes
var resultContext = await next();
// do something after the action executes; resultContext.Result will be set
if (resultContext.Exception != null && !resultContext.ExceptionHandled)
{
await _sessionManager.WriteSessionLogEvent(new Models.ManagerModels.Session.CreateSessionLogEventRequest()
{
EventKey = SessionEventKeys.Error,
Info = new Dictionary <string, string>()
{
{ "Message", resultContext.Exception.Message }
}
});
}
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext pageContext)
{
int a = 0;
}
private static void AfterOnPageHandlerExecutingImpl(DiagnosticListener diagnosticListener, PageHandlerExecutingContext handlerExecutingContext, IPageFilter filter)
{
if (diagnosticListener.IsEnabled(Diagnostics.AfterPageFilterOnPageHandlerExecutingEventData.EventName))
{
diagnosticListener.Write(
Diagnostics.AfterPageFilterOnPageHandlerExecutingEventData.EventName,
new AfterPageFilterOnPageHandlerExecutingEventData(
handlerExecutingContext.ActionDescriptor,
handlerExecutingContext,
filter
));
}
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
//throw new NotImplementedException();
}
public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next) => next();
public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
return(next());
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
requestTime = DateTime.Now;
}
public override void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
base.OnPageHandlerExecuting(context);
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
//_logger.LogDebug("Global sync PageHandlerExecutingContext called.");
}
public override void OnPageHandlerExecuting(
PageHandlerExecutingContext context)
{
context.HttpContext.Response.Headers.Add("test", new string[] { "123" });
}
public override Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
return(base.OnPageHandlerExecutionAsync(context, next));
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
_timer = new Stopwatch();
_timer.Start();
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
await OnActionExecutionAsync(context);
await next();
}
public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
return(_aspNetCoreUnitOfWorkHandler.OnExceptionPageHandlerExecutionAsync(context, next));
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
var log = "executing";
}
private bool ShouldSaveAudit(PageHandlerExecutingContext actionContext)
{
return(_configuration.IsAuditingEnabled &&
_auditingHelper.ShouldSaveAudit(actionContext.HandlerMethod.MethodInfo, true));
}
public Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
throw new NotImplementedException();
}
public override void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
Keywords = "Value set in filter";
}
private Task Next(ref State next, ref Scope scope, ref object state, ref bool isCompleted)
{
switch (next)
{
case State.PageBegin:
{
_instance = CreateInstance();
goto case State.PageSelectHandlerBegin;
}
case State.PageSelectHandlerBegin:
{
_cursor.Reset();
_handler = SelectHandler();
goto case State.PageSelectHandlerNext;
}
case State.PageSelectHandlerNext:
var currentSelector = _cursor.GetNextFilter <IPageFilter, IAsyncPageFilter>();
if (currentSelector.FilterAsync != null)
{
if (_handlerSelectedContext == null)
{
_handlerSelectedContext = new PageHandlerSelectedContext(_pageContext, _filters, _instance)
{
HandlerMethod = _handler,
};
}
state = currentSelector.FilterAsync;
goto case State.PageSelectHandlerAsyncBegin;
}
else if (currentSelector.Filter != null)
{
if (_handlerSelectedContext == null)
{
_handlerSelectedContext = new PageHandlerSelectedContext(_pageContext, _filters, _instance)
{
HandlerMethod = _handler,
};
}
state = currentSelector.Filter;
goto case State.PageSelectHandlerSync;
}
else
{
goto case State.PageSelectHandlerEnd;
}
case State.PageSelectHandlerAsyncBegin:
{
Debug.Assert(state != null);
Debug.Assert(_handlerSelectedContext != null);
var filter = (IAsyncPageFilter)state;
var handlerSelectedContext = _handlerSelectedContext;
_diagnosticSource.BeforeOnPageHandlerSelection(handlerSelectedContext, filter);
_logger.BeforeExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IAsyncPageFilter.OnPageHandlerSelectionAsync),
filter);
var task = filter.OnPageHandlerSelectionAsync(handlerSelectedContext);
if (task.Status != TaskStatus.RanToCompletion)
{
next = State.PageSelectHandlerAsyncEnd;
return(task);
}
goto case State.PageSelectHandlerAsyncEnd;
}
case State.PageSelectHandlerAsyncEnd:
{
Debug.Assert(state != null);
Debug.Assert(_handlerSelectedContext != null);
var filter = (IAsyncPageFilter)state;
_diagnosticSource.AfterOnPageHandlerSelection(_handlerSelectedContext, filter);
_logger.AfterExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IAsyncPageFilter.OnPageHandlerSelectionAsync),
filter);
goto case State.PageSelectHandlerNext;
}
case State.PageSelectHandlerSync:
{
Debug.Assert(state != null);
Debug.Assert(_handlerSelectedContext != null);
var filter = (IPageFilter)state;
var handlerSelectedContext = _handlerSelectedContext;
_diagnosticSource.BeforeOnPageHandlerSelected(handlerSelectedContext, filter);
_logger.BeforeExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IPageFilter.OnPageHandlerSelected),
filter);
filter.OnPageHandlerSelected(handlerSelectedContext);
_diagnosticSource.AfterOnPageHandlerSelected(handlerSelectedContext, filter);
goto case State.PageSelectHandlerNext;
}
case State.PageSelectHandlerEnd:
{
if (_handlerSelectedContext != null)
{
_handler = _handlerSelectedContext.HandlerMethod;
}
_arguments = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
_cursor.Reset();
var task = BindArgumentsAsync();
if (task.Status != TaskStatus.RanToCompletion)
{
next = State.PageNext;
return(task);
}
goto case State.PageNext;
}
case State.PageNext:
{
var current = _cursor.GetNextFilter <IPageFilter, IAsyncPageFilter>();
if (current.FilterAsync != null)
{
if (_handlerExecutingContext == null)
{
_handlerExecutingContext = new PageHandlerExecutingContext(_pageContext, _filters, _handler, _arguments, _instance);
}
state = current.FilterAsync;
goto case State.PageAsyncBegin;
}
else if (current.Filter != null)
{
if (_handlerExecutingContext == null)
{
_handlerExecutingContext = new PageHandlerExecutingContext(_pageContext, _filters, _handler, _arguments, _instance);
}
state = current.Filter;
goto case State.PageSyncBegin;
}
else
{
goto case State.PageInside;
}
}
case State.PageAsyncBegin:
{
Debug.Assert(state != null);
Debug.Assert(_handlerExecutingContext != null);
var filter = (IAsyncPageFilter)state;
var handlerExecutingContext = _handlerExecutingContext;
_diagnosticSource.BeforeOnPageHandlerExecution(handlerExecutingContext, filter);
_logger.BeforeExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IAsyncPageFilter.OnPageHandlerExecutionAsync),
filter);
var task = filter.OnPageHandlerExecutionAsync(handlerExecutingContext, InvokeNextPageFilterAwaitedAsync);
if (task.Status != TaskStatus.RanToCompletion)
{
next = State.PageAsyncEnd;
return(task);
}
goto case State.PageAsyncEnd;
}
case State.PageAsyncEnd:
{
Debug.Assert(state != null);
Debug.Assert(_handlerExecutingContext != null);
var filter = (IAsyncPageFilter)state;
if (_handlerExecutedContext == null)
{
// If we get here then the filter didn't call 'next' indicating a short circuit.
_logger.PageFilterShortCircuited(filter);
_handlerExecutedContext = new PageHandlerExecutedContext(
_pageContext,
_filters,
_handler,
_instance)
{
Canceled = true,
Result = _handlerExecutingContext.Result,
};
}
_diagnosticSource.AfterOnPageHandlerExecution(_handlerExecutedContext, filter);
_logger.AfterExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IAsyncPageFilter.OnPageHandlerExecutionAsync),
filter);
goto case State.PageEnd;
}
case State.PageSyncBegin:
{
Debug.Assert(state != null);
Debug.Assert(_handlerExecutingContext != null);
var filter = (IPageFilter)state;
var handlerExecutingContext = _handlerExecutingContext;
_diagnosticSource.BeforeOnPageHandlerExecuting(handlerExecutingContext, filter);
_logger.BeforeExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IPageFilter.OnPageHandlerExecuting),
filter);
filter.OnPageHandlerExecuting(handlerExecutingContext);
_diagnosticSource.AfterOnPageHandlerExecuting(handlerExecutingContext, filter);
_logger.AfterExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IPageFilter.OnPageHandlerExecuting),
filter);
if (handlerExecutingContext.Result != null)
{
// Short-circuited by setting a result.
_logger.PageFilterShortCircuited(filter);
_handlerExecutedContext = new PageHandlerExecutedContext(
_pageContext,
_filters,
_handler,
_instance)
{
Canceled = true,
Result = _handlerExecutingContext.Result,
};
goto case State.PageEnd;
}
var task = InvokeNextPageFilterAsync();
if (task.Status != TaskStatus.RanToCompletion)
{
next = State.PageSyncEnd;
return(task);
}
goto case State.PageSyncEnd;
}
case State.PageSyncEnd:
{
Debug.Assert(state != null);
Debug.Assert(_handlerExecutingContext != null);
Debug.Assert(_handlerExecutedContext != null);
var filter = (IPageFilter)state;
var handlerExecutedContext = _handlerExecutedContext;
_diagnosticSource.BeforeOnPageHandlerExecuted(handlerExecutedContext, filter);
_logger.BeforeExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IPageFilter.OnPageHandlerExecuted),
filter);
filter.OnPageHandlerExecuted(handlerExecutedContext);
_diagnosticSource.AfterOnPageHandlerExecuted(handlerExecutedContext, filter);
_logger.AfterExecutingMethodOnFilter(
PageLoggerExtensions.PageFilter,
nameof(IPageFilter.OnPageHandlerExecuted),
filter);
goto case State.PageEnd;
}
case State.PageInside:
{
var task = InvokeHandlerMethodAsync();
if (task.Status != TaskStatus.RanToCompletion)
{
next = State.PageEnd;
return(task);
}
goto case State.PageEnd;
}
case State.PageEnd:
{
if (scope == Scope.Page)
{
if (_handlerExecutedContext == null)
{
_handlerExecutedContext = new PageHandlerExecutedContext(_pageContext, _filters, _handler, _instance)
{
Result = _result,
};
}
isCompleted = true;
return(Task.CompletedTask);
}
var handlerExecutedContext = _handlerExecutedContext;
Rethrow(handlerExecutedContext);
if (handlerExecutedContext != null)
{
_result = handlerExecutedContext.Result;
}
isCompleted = true;
return(Task.CompletedTask);
}
default:
throw new InvalidOperationException();
}
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
await next.Invoke();
}
public override async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
ExternalLogins = (await SignInManager.GetExternalAuthenticationSchemesAsync()).ToList();
await next();
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
// Called before the handler method executes after model binding is complete.
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext ctx)
{
// Your logic here.
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context,
PageHandlerExecutionDelegate next)
{
_logger.LogDebug("全局过滤器方法：OnPageHandlerExecutionAsync ，被调用 【WY02】");
await next.Invoke();
}
public async Task OnPageHandlerExecutionAsync(PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
context.HttpContext.Response.Headers.Add(header, value);
await next().ConfigureAwait(false);
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
}
private static void BeforeOnPageHandlerExecutionImpl(DiagnosticListener diagnosticListener, PageHandlerExecutingContext handlerExecutionContext, IAsyncPageFilter filter)
{
if (diagnosticListener.IsEnabled(Diagnostics.BeforePageFilterOnPageHandlerExecutionEventData.EventName))
{
diagnosticListener.Write(
Diagnostics.BeforePageFilterOnPageHandlerExecutionEventData.EventName,
new BeforePageFilterOnPageHandlerExecutionEventData(
handlerExecutionContext.ActionDescriptor,
handlerExecutionContext,
filter
));
}
}
public override void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
context.HandlerArguments["message"] = "Hello from OnPageHandlerExecuting";
}
public void OnPageHandlerExecuting(PageHandlerExecutingContext context)
{
_logger.LogDebug("Global Filter OnPageHandlerExecuting called.");
}
/// <summary>
/// 验证权限得方法
/// </summary>
/// <param name="serviceProvider"></param>
/// <param name="context"></param>
/// <param name="next"></param>
/// <returns></returns>
public virtual async Task ValidatePermissionAsync(IServiceProvider serviceProvider, PageHandlerExecutingContext context, PageHandlerExecutionDelegate next)
{
bool canAccessResource = false;
bool isAjax = false;
isAjax = IsAjax(context);
CustomerResourceAttribute attributeCodes = context.HandlerMethod.MethodInfo
.GetCustomAttributes(typeof(CustomerResourceAttribute), false)
.OfType <CustomerResourceAttribute>()
.FirstOrDefault();
bool isIgnore = context.Filters.OfType <IgnoreAuthAttribute>().Any();
IEnumerable <string> resourceCodes = attributeCodes?.ResourceCodes.ToList() ?? new List <string>()
{
"*"
}; //当前方法的资源Code
//Console.WriteLine("isAjax:{0}， isIgnore：{1}", isAjax, isIgnore);
System.Diagnostics.Debug.WriteLine("isAjax:{0}, isIgnore: {1}", isAjax, isIgnore);
if (isIgnore || (resourceCodes.Any(_ => "*".Equals(_) && isAjax)))
{
await next();
}
else
{
string url = string.Join(string.Empty, context.RouteData.Values.Values.Reverse());
if (!url.StartsWith("/"))
{
url = string.Concat("/", url); // /Admin/AdminUserInfo/Index
}
System.Diagnostics.Debug.WriteLine("url:{0}", url);
canAccessResource = await serviceProvider.GetService <SysPermissionService>().HasPermissionAsync(resourceCodes, url, isAjax);// await Task.FromResult(true);//TODO...
if (canAccessResource)
{
await next();
}
else
{
string path = context.HttpContext.Request.Path.Value;
IActionResult actionResult = null;
if (isAjax)
{
actionResult = new OkObjectResult(new AjaxReturnModel <string>(path)
{
Msg = "您没有权限访问", Success = false
})
{
StatusCode = (int)System.Net.HttpStatusCode.Forbidden
};
}
context.Result = actionResult ?? new RedirectResult("/Admin/Forbidden?url=" + System.Web.HttpUtility.UrlEncode(path));
}
}
}
