public override void OnActionExecuting(ActionExecutingContext context)
 {
     if (!context.RouteData.DataTokens.ContainsKey("actionName"))
     {
         context.RouteData.DataTokens.Add("actionName", context.ActionDescriptor.Name);
     }
 }

        public override void OnActionExecuting(ActionExecutingContext actionContext)
        {
            var clientKeyString = actionContext.HttpContext.Request.Headers["ClientKey"];

            if (string.IsNullOrWhiteSpace(clientKeyString))
            {
                var objectResult = new ObjectResult(ErrorDto.Create("ClientKey is not provided", DocumentationLinks.ClientKey));
                objectResult.StatusCode = StatusCodes.Status403Forbidden;
                actionContext.Result = objectResult;
                return;
            }

            Guid clientKey = Guid.Empty;
            if(!Guid.TryParse(clientKeyString, out clientKey))
            {
                var objectResult = new ObjectResult(ErrorDto.Create("ClientKey have bad format", DocumentationLinks.ClientKey));
                objectResult.StatusCode = StatusCodes.Status403Forbidden;
                actionContext.Result = objectResult;
                return;
            }

            if(!_externalClientService.IsClientKeyValid(clientKey))
            {
                var objectResult = new ObjectResult(ErrorDto.Create("ClientKey is not authorized", DocumentationLinks.ClientKey));
                objectResult.StatusCode = StatusCodes.Status403Forbidden;
                actionContext.Result = objectResult;
            }
        }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            if (context.RouteData.Values[routeField] == null)
                claimValue = null;
            else
                claimValue = context.RouteData.Values[routeField].ToString();

            var user = context.HttpContext.User;
            foreach (var r in roles)
            {
                if (user.IsInRole(r))
                {
                    base.OnActionExecuting(context);
                    return;
                }
            }
            if (!string.IsNullOrEmpty(claimValue))
            {
                foreach(var c in claimTypes)
                {
                    if (user.HasClaim(c, claimValue))
                    {
                        base.OnActionExecuting(context);
                        return;
                    }
                }
            }
            HandleUnauthorizedRequest(context);
        }

 public override void OnActionExecuting(ActionExecutingContext context)
 {
     if (context.HttpContext.User.Identity.IsAuthenticated)
         HandleUnauthorizedRequest(context);
     else
         base.OnActionExecuting(context);
 }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            var gitHubAccessToken = context.HttpContext.Session.GetString("GitHubAccessToken");
            var gitHubName = context.HttpContext.Session.GetString("GitHubName");

            // If session state didn't have our data, either there's no one logged in, or they just logged in
            // but the claims haven't yet been read.
            if (string.IsNullOrEmpty(gitHubAccessToken))
            {
                if (!context.HttpContext.User.Identity.IsAuthenticated)
                {
                    // Not authenticated at all? Go to GitHub to authorize the app
                    context.Result = new ChallengeResult(
                        authenticationScheme: "GitHub",
                        properties: new AuthenticationProperties { RedirectUri = "/" });
                    return;
                }

                // Authenticated but haven't read the claims? Process the claims
                gitHubAccessToken = context.HttpContext.User.FindFirst("access_token")?.Value;
                gitHubName = context.HttpContext.User.Identity.Name;
                context.HttpContext.Session.SetString("GitHubAccessToken", gitHubAccessToken);
                context.HttpContext.Session.SetString("GitHubName", gitHubName);
            }

            context.ActionArguments.Add("gitHubAccessToken", gitHubAccessToken);
            context.ActionArguments.Add("gitHubName", gitHubName);
        }

        //parts that contains this. 
        /*
        1. This action filter attribute
        ---------------------------------------------------
        2. CourseAdd - View = 
            @inject Microsoft.AspNet.Antiforgery.IAntiforgery Xsrf
            @functions
            {
                public string GetAntiXsrfToken()
                    {
                        var tokens = Xsrf.GetTokens(Context);
                        return tokens.CookieToken + ":" + tokens.FormToken;
                    }
                }

            <form....>
             <input type="hidden" name="__RequestVerificationToken" value="@GetAntiXsrfToken()" />

           ---------------------------------------------------
            3. Angular controller
              var token = $('[name=__RequestVerificationToken]').val();

                var config = {
                    headers: {
                        'RequestVerificationToken': token
                    }
                };

                //$scope.model 

                $http.post('AddACourse', $scope.model, config)
                   .then(function (response) {
                       debugger;
                       var s = response;

                       $scope.model.Location = 'teststest';

                       // this callback will be called asynchronously
                       // when the response is available
                   }, function (response) {
                       var s = response;
                       // called asynchronously if an error occurs
                       // or server returns response with an error status.
                   });

            4. Mvc Controller
              [ValidateCustomAntiForgeryToken()]
    */

        public override void OnActionExecuting(ActionExecutingContext actionContext)
        {
            IAntiforgery antiforgery = actionContext.HttpContext.ApplicationServices.GetService(typeof(IAntiforgery)) as IAntiforgery;

            var cookieToken = string.Empty;
            var formToken = string.Empty;
            StringValues tokenHeaders;
            string[] tokens = null;

            //go grab this token
            if (actionContext.HttpContext.Request.Headers.TryGetValue("RequestVerificationToken", out tokenHeaders))
            {
                tokens = tokenHeaders.First().Split(':');

                if (tokens != null && tokens.Length == 2)
                {
                    cookieToken = tokens[0];
                    formToken = tokens[1];
                }
                else
                {
                    throw new Exception("Can't Find Request Verification Token");
                }
            }
            else
            {
                throw new Exception("Can't Find Request Verification Token");
            }


            antiforgery.ValidateTokens(actionContext.HttpContext, new AntiforgeryTokenSet(formToken, cookieToken));

            base.OnActionExecuting(actionContext);
        }

        public bool HandleAuthorization(ActionExecutingContext context)
        {
            Console.WriteLine("[RecAaaService] Handling Authorization");
            var controllerName = context.RouteData.Values["Controller"]?.ToString();
            var errorType = string.Empty;

            if (controllerName == null)
                errorType = "Invalid Route";
            else if (!FunctionList.Keys.Contains(controllerName))
                errorType = "Invalid Controller";
            else
            {
                //var roleService = AutoSessionServiceFactory.GetRoleService(ServiceDbConnStr);
                //var permissions = roleService.GetPermissionsByCurrentUserID();
                //if (!permissions.Contains(FunctionList[controllerName]))
                //    errorType = "No-Access-Right";
                var sessonUserIdStr = context.HttpContext.Session.GetString("UI.CURRENT_USERID");
                var sessonUserId = int.Parse(sessonUserIdStr);
                var permissions = GetUserPermission(sessonUserId);
                //or even just if(permissions.IndexOf(FunctionList[controllerName]) < 0)
                if (Array.IndexOf(permissions.Split(','), FunctionList[controllerName]) < 0)
                    errorType = "No-Access-Right";
            }

            if (errorType.Equals(string.Empty)) return true; //No error

            if (!IsAjaxRequest(context.HttpContext.Request))
                context.Result = new RedirectResult(RedirectToWomUrl);
            else
                context.Result = new JsonResult(new { Data = new { isSuccess = false, errorType } });

            return false;
        }

 public override void OnActionExecuting(ActionExecutingContext context)
 {
     if (!context.ModelState.IsValid)
     {
         context.Result = new BadRequestObjectResult(context.ModelState);
     }
 }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            var uowParam = context.ActionDescriptor.Parameters.FirstOrDefault(x => x.ParameterType == typeof(IUnitOfWork));
            if (uowParam != null)
            {
                var connectionKey = this.GetType().GetCustomAttribute<ConnectionKeyAttribute>();
                if (connectionKey == null)
                    throw new ArgumentNullException("connectionKey");

                this.connection = SqlConnections.NewByKey(connectionKey.Value);
                this.unitOfWork = new UnitOfWork(connection);
                context.ActionArguments[uowParam.Name] = this.unitOfWork;
                base.OnActionExecuting(context);
                return;
            }

            var cnnParam = context.ActionDescriptor.Parameters.FirstOrDefault(x => x.ParameterType == typeof(IDbConnection));
            if (cnnParam != null)
            {
                var connectionKey = this.GetType().GetCustomAttribute<ConnectionKeyAttribute>();
                if (connectionKey == null)
                    throw new ArgumentNullException("connectionKey");

                this.connection = SqlConnections.NewByKey(connectionKey.Value);
                context.ActionArguments[cnnParam.Name] = connection;
                base.OnActionExecuting(context);
            }

            base.OnActionExecuting(context);
        }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            if (!context.HttpContext.User.Identity.IsAuthenticated)
            {
                context.Result = new HttpStatusCodeResult((int)System.Net.HttpStatusCode.Forbidden);
            }
            else
            {
                var scopeAttribute = (ScopeAttribute)context.Controller.GetType().GetTypeInfo().GetCustomAttribute(typeof(ScopeAttribute));

                var result = from claim in context.HttpContext.User.Claims
                    where claim.Type == "scope"
                    select claim;
                if (!result.Any())
                {
                    context.Result = new HttpStatusCodeResult((int) System.Net.HttpStatusCode.Forbidden);
                    return;
                }
                var scopeClaim = result.First();
                if (!scopeAttribute.Values.Contains(scopeClaim.Value))
                {
                    context.Result = new HttpStatusCodeResult((int)System.Net.HttpStatusCode.Forbidden);
                    return;
                }
            }

            base.OnActionExecuting(context);
        }

 public override async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
 {
     if (context.HttpContext.Request.Method == "GET")
     {
         await HandleQueryRequest(context, next);
     }
 }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            if (!context.ModelState.IsValid)
            {
                var bodyParameter = context.ActionDescriptor
                                          .Parameters
                                          .FirstOrDefault(parameter => IsBodyBindingSource(
                                              parameter.BindingInfo?.BindingSource));
                if (bodyParameter != null)
                {
                    // Body model binder normally reports errors for parameters using the empty name.
                    var parameterBindingErrors = context.ModelState[bodyParameter.Name]?.Errors ??
                        context.ModelState[string.Empty]?.Errors;
                    if (parameterBindingErrors != null && parameterBindingErrors.Count != 0)
                    {
                        var errorInfo = new ErrorInfo
                        {
                            ActionName = context.ActionDescriptor.Name,
                            ParameterName = bodyParameter.Name,
                            Errors = parameterBindingErrors.Select(x => x.ErrorMessage).ToList(),
                            Source = "filter"
                        };

                        context.Result = new ObjectResult(errorInfo);
                    }
                }
            }

            base.OnActionExecuting(context);
        }

 public override void OnActionExecuting(ActionExecutingContext context)
 {
     if (context.HttpContext.Session.GetString("Admin") != "true")
         context.Result = new RedirectResult("/Admin/Login");
     else
         base.OnActionExecuting(context);
 }

        public void OnActionExecuting(ActionExecutingContext filterContext)
        {
            var messages = Convert.ToString(_httpContextAccessor.HttpContext.Request.Cookies[CookiePrefix]);
            if (String.IsNullOrEmpty(messages))
            {
                return;
            }

            IList<NotifyEntry> messageEntries;

            messageEntries = DeserializeNotifyEntries(messages);
            if(messageEntries == null)
            {
                // An error occured during deserialization
                _shouldDeleteCookie = true;
                return;
            }

            if (!messageEntries.Any())
            {
                return;
            }

            // Make the notifications available for the rest of the current request.
            _existingEntries = messageEntries;
        }

 public override void OnActionExecuting(ActionExecutingContext context)
 {
     userAgent = Request?.UserAgent();
     IsMobile = Request != null ? Request.IsMobileBrowser() : false;
     ViewData["IsMobile"] = IsMobile;
     base.OnActionExecuting(context);
 }

        public override void OnActionExecuting(ActionExecutingContext context)
        {
            object age = null;

            var controller = context.Controller as FiltersController;

            if (controller != null)
            {
                controller.CustomUser.Log += "Age Enhanced!" + Environment.NewLine;
            }

            if (context.ActionArguments.TryGetValue("age", out age))
            {
                if (age is int)
                {
                    var intAge = (int)age;

                    if (intAge < 21)
                    {
                        intAge += 5;
                    }
                    else if (intAge > 30)
                    {
                        intAge = 29;
                    }

                    context.ActionArguments["age"] = intAge;
                }
            }
        }

    public override void OnActionExecuting(ActionExecutingContext filterContext)
    {
        var httpsPort = Convert.ToInt32(ConfigurationManager.AppSettings["httpsPort"]);
            var httpPort = Convert.ToInt32(ConfigurationManager.AppSettings["httpPort"]);
            var request = filterContext.HttpContext.Request;
            var response = filterContext.HttpContext.Response;

            if (httpsPort > 0 && RequireSecure)
            {
                string url = null;
                if (httpsPort > 0)
                {
                    url = "https://" + request.Url.Host + request.RawUrl;

                    if (httpsPort != 443)
                    {
                        var builder = new UriBuilder(url) { Port = httpsPort };
                        url = builder.Uri.ToString();
                    }
                }
                if (httpsPort != request.Url.Port)
                {
                    filterContext.Result = new RedirectResult(url);
                }
            }
            // se for uma conexao segura e não está requerendo um SSL, retira o ssl e volta para http.
            else if (filterContext.HttpContext.Request.IsSecureConnection && !RequireSecure)
            {
                filterContext.Result = new RedirectResult(filterContext.HttpContext.Request.Url.ToString().Replace("https:", "http:").Replace(httpsPort.ToString(), httpPort.ToString()));
                filterContext.Result.ExecuteResult(filterContext);
            }
            base.OnActionExecuting(filterContext);
    }

 public override void OnActionExecuting(ActionExecutingContext context)
 {
     if (!string.IsNullOrEmpty(context.HttpContext.Request.Query["culture"]))
     {
         CultureInfo.DefaultThreadCurrentCulture = CultureInfo.DefaultThreadCurrentUICulture = new CultureInfo(context.HttpContext.Request.Query["culture"]);
     }
     base.OnActionExecuting(context);
 }

 public override void OnActionExecuting(ActionExecutingContext context)
 {
     if (context.ActionDescriptor.DisplayName == "FiltersWebSite.ActionFilterController.GetHelloWorld")
     {
         (context.ActionArguments["fromGlobalActionFilter"] as List<ContentResult>).
             Add(Helpers.GetContentResult(context.Result, "Action Filter - OnActionExecuting"));
     }
 }

 public override void OnActionExecuting(ActionExecutingContext context)
 {
     if (context.ModelState.IsValid == false)
     {
         context.Result = new BadRequestObjectResult(context.ModelState.Values
             .SelectMany(p=>p.Errors).First(p=>p.ErrorMessage!="" || p.Exception!=null).ErrorMessage);
     }
 }