public override void OnActionExecuted(ActionExecutedContext filterContext)
 {
     var categories = Repository.FindAll<Category>();
     var selectListItems = MappingEngine.Map<IEnumerable<Category>, IEnumerable<SelectListItem>>(categories);
     var controllerBase = filterContext.Controller;
     controllerBase.ViewData.Add(selectListItems);
 }

        public override void OnActionExecuted(
                ActionExecutedContext filterContext)
        {
            if (filterContext == null)
                throw new ArgumentNullException("filterContext");

            //
            // see if this request included a "callback" querystring
            // parameter
            //
            string callback = filterContext.HttpContext.
                      Request.QueryString["callback"];
            if (callback != null && callback.Length > 0)
            {
                //
                // ensure that the result is a "JsonResult"
                //
                JsonResult result = filterContext.Result as JsonResult;
                if (result == null)
                {
                    throw new InvalidOperationException(
                        @"JsonpFilterAttribute must be applied only
                        on controllers and actions that return a
                        JsonResult object.");
                }

                filterContext.Result = new JsonpResult
                {
                    ContentEncoding = result.ContentEncoding,
                    ContentType = result.ContentType,
                    Data = result.Data,
                    Callback = callback
                };
            }
        }

        void IActionFilter.OnActionExecuted(ActionExecutedContext aec)
        {
            var vr = aec.Result as ViewResult;
            var aof = aec.RouteData.Values["alternateOutputFormat"] as String;

            if (_requestSourceRestriction == RequestSourceRestriction.DenyRemoteRequests && !aec.RequestContext.HttpContext.Request.IsLocal)
            {
                aec.Result = new EmptyResult();
            }
            else
            {
                if (vr != null) switch (aof)
                {
                    case "json": aec.Result = new JsonResult
                    {
                        JsonRequestBehavior = _jsonRequestBehavior,
                        ContentType = "application/json",
                        ContentEncoding = Encoding.UTF8,
                        Data = vr.ViewData.Model
                    };
                    break;

                    case "txt": aec.Result = new ContentResult
                    {
                        Content = "Not yet implemented",
                        ContentType = "text/plain",
                        ContentEncoding = Encoding.UTF8,
                    };
                    break;
                }
            }
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            base.OnActionExecuted(filterContext);

            string _isMobileCheckParams = filterContext.HttpContext.Request.Params["isMobile"];
            string _userAgent = filterContext.HttpContext.Request.UserAgent;

            if (string.IsNullOrWhiteSpace(_isMobileCheckParams) || !_isMobileCheckParams.ToUpper().Equals("Y"))
            {
                if (!(IsAppleDevice(_userAgent) || IsAndroidDevice(_userAgent)))
                {
                    if (string.IsNullOrEmpty(RedirectUrl))
                    {
                        //throw new Exception("Mobile only!!");
                        var _errorMessage = new string[]
                    {
                        "mobile only",
                        filterContext.HttpContext.Request.Url.AbsoluteUri
                    };

                        string _model = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(_errorMessage);
                        filterContext.Result = new RedirectToRouteResult(
                            new System.Web.Routing.RouteValueDictionary { { "controller", "Error" }, { "model", _model } }
                        );
                    }
                    else
                    {
                        filterContext.HttpContext.Response.Redirect(RedirectUrl);
                    }

                }
            }
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            UserModel userModel;
            if (filterContext.Controller.ViewBag.UserModel == null)
            {
                userModel = new UserModel();
                filterContext.Controller.ViewBag.UserModel = userModel;
            }
            else
            {
                userModel = filterContext.Controller.ViewBag.UserModel as UserModel;
            }
            if (filterContext.HttpContext.User.Identity.IsAuthenticated)
            {
                YiHeUser yiheUser = filterContext.HttpContext.User.GetYiHeUser();
                if (userModel != null)
                {
                    userModel.IsUserAuthenticated = yiheUser.IsAuthenticated;
                    userModel.UserName = yiheUser.DisplayName;
                    userModel.RoleName = yiheUser.RoleName;
                }
            }

            base.OnActionExecuted(filterContext);
        }

 private void TranslateMessages(ActionExecutedContext filterContext)
 {
     if (filterContext.Controller.ViewData.ContainsKey("Messages"))
     {
         MessageViewData messageViewData = (MessageViewData) filterContext.Controller.ViewData["Messages"];
         foreach (KeyValuePair<string, IList<string>> messagesForType in messageViewData.Messages)
         {
             for (int i = 0; i < messagesForType.Value.Count; i++)
             {
                 string baseName = String.Format("{0}.globalresources"
                     , filterContext.Controller.GetType().Namespace.Replace(".Controllers", String.Empty).ToLowerInvariant());
                 string originalMessage = messagesForType.Value[i];
                 string translatedMessage = this._localizer.GetString(originalMessage, baseName);
                 if (translatedMessage != originalMessage)
                 {
                     messagesForType.Value[i] = translatedMessage;
                     // Change the key of the messageParams if there were params for the original key
                     if (messageViewData.MessageParams.ContainsKey(originalMessage))
                     {
                         messageViewData.MessageParams.Add(translatedMessage, messageViewData.MessageParams[originalMessage]);
                         messageViewData.MessageParams.Remove(originalMessage);
                     }
                 }
             }
         }
     }
 }

 public override void OnActionExecuted(ActionExecutedContext filterContext)
 {
     //_logger.InfoFormat(CultureInfo.InvariantCulture,
     //    "Executed action {0}.{1}",
     //    filterContext.ActionDescriptor.ControllerDescriptor.ControllerName,
     //    filterContext.ActionDescriptor.ActionName);
 }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            var sessionController = filterContext.Controller as SessionController;
            if (sessionController == null)
            {
                return;
            }

            using (var session = sessionController.Session)
            {
                if (session == null)
                {
                    return;
                }

                if (!session.Transaction.IsActive)
                {
                    return;
                }

                if (filterContext.Exception != null)
                {
                    session.Transaction.Rollback();
                }
                else
                {
                    session.Transaction.Commit();
                }
            }
        }

 protected override void OnActionExecuted(ActionExecutedContext filterContext)
 {
     Log.InfoFormat("Done executing {0}.{1}.",
         filterContext.ActionDescriptor.ControllerDescriptor.ControllerName,
         filterContext.ActionDescriptor.ActionName
     );
 }

 public override void OnActionExecuted(ActionExecutedContext filterContext)
 {
     var modelState = filterContext.Controller.ViewData.ModelState;
     if ((filterContext.Result is RedirectToRouteResult || filterContext.Result is RedirectResult) && !modelState.IsValid)
         filterContext.Controller.TempData.Add(flashkey, modelState);
     base.OnActionExecuted(filterContext);
 }

 /// <summary>
 /// Minification at the and of the request
 /// </summary>
 public void OnActionExecuted( ActionExecutedContext filterContext )
 {
     if ( IsSupportedContentType( filterContext ) )
     {
         filterContext.HttpContext.Response.Filter = new HtmlMinifyStream( filterContext.HttpContext.Response.Filter );
     }
 }

 /// <summary>
 /// Ensures that the controller is of the required type, if so lets execution continue on the base class
 /// </summary>
 /// <param name="filterContext"></param>
 public override void OnActionExecuted(ActionExecutedContext filterContext)
 {
     var backOfficeController = GetController(filterContext.Controller);
     if (!backOfficeController.Notifications.Any())
         return;
     base.OnActionExecuted(filterContext);
 }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            // After controller logic
            base.OnActionExecuted(filterContext);

            filterContext.HttpContext.Response.Write(this.Msg);
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            var request = filterContext.HttpContext.Request;
            string controllerName = filterContext.ActionDescriptor.ControllerDescriptor.ControllerName;
            string actionName = filterContext.ActionDescriptor.ActionName;

            //Generate an audit
            AuditModel audit = new AuditModel()
            {
                //Your Audit Identifier
                AuditID = Guid.NewGuid(),
                //Our Username (if available)
                UserName = (request.IsAuthenticated) ? filterContext.HttpContext.User.Identity.Name : "Anonymous",
                //The IP Address of the Request
                IPAddress = request.ServerVariables["HTTP_X_FORWARDED_FOR"] ?? request.UserHostAddress,
                //The URL that was accessed
                AreaAccessed = request.RawUrl,
                //Creates our Timestamp
                TimeAccessed = DateTime.UtcNow,
                //controller and action
                Action = string.Format("Controller: {0} | Action: {1}", controllerName, actionName),
                //result
                Result = GetResult(filterContext.Result)
            };

            this.activityLogsService.CreateAuditLog(audit.UserName, audit.IPAddress, audit.AreaAccessed, audit.TimeAccessed, audit.Action, audit.Result);
        }

 public JsReportStream(ActionExecutedContext context, EnableJsReportAttribute attr, Func<ActionExecutedContext, EnableJsReportAttribute, string, Task<Report>> renderReport)
 {
     _stream = context.HttpContext.Response.Filter;
     _context = context;
     _attr = attr;
     _renderReport = renderReport;
 }

 /// <summary>
 /// This provides simple feedback to the modelstate in the case of errors.
 /// </summary>
 /// <param name="filterContext"></param>
 protected override void OnActionExecuted(ActionExecutedContext filterContext)
 {
     if (filterContext.Result is RedirectToRouteResult)
     {
         try
         {
             // put the ModelState into TempData
             TempData.Add("_MODELSTATE", ModelState);
         }
         catch (Exception)
         {
             TempData.Clear();
             // swallow exception
         }
     }
     else if (filterContext.Result is ViewResult && TempData.ContainsKey("_MODELSTATE"))
     {
         // merge modelstate from TempData
         var modelState = TempData["_MODELSTATE"] as ModelStateDictionary;
         foreach (var item in modelState)
         {
             if (!ModelState.ContainsKey(item.Key))
                 ModelState.Add(item);
         }
     }
     base.OnActionExecuted(filterContext);
 }

        public void OnActionExecuted(ActionExecutedContext filterContext) {
            var settings = _sslService.GetSettings();

            if (!settings.Enabled) {
                _orchardServices.Notifier.Warning(T("You need to configure the SSL settings."));
            }
        }

        /// <summary>
        /// Called by the ASP.NET MVC framework after the action method executes.
        /// </summary>
        /// <param name="filterContext">The filter context.</param>
        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            if (filterContext == null || !filterContext.HttpContext.Request.IsAjaxRequest())
            {
                return;
            }

            // Preparing Json object for AJAX.success processing in forms.js javascript
            string destinationUrl = string.Empty;
            if (filterContext.Result is RedirectResult)
            {
                var result = filterContext.Result as RedirectResult;
                destinationUrl = UrlHelper.GenerateContentUrl(result.Url, filterContext.HttpContext);
            }

            if (filterContext.Result is RedirectToRouteResult)
            {
                var result = filterContext.Result as RedirectToRouteResult;
                var helper = new UrlHelper(filterContext.RequestContext);
                destinationUrl = helper.RouteUrl(result.RouteValues);
            }

            // Rendered context is getting reloaded by AJAX.success in forms.js javascript
            if (filterContext.Result is ViewResult)
            {
                return;
            }

            var jsonResult = new JsonResult { Data = new { resultType = "Redirect", redirectUrl = destinationUrl } };
            filterContext.Result = jsonResult;
        }

 public void OnActionExecuted(ActionExecutedContext filterContext)
 {
     if(filterContext.Exception == null)
         Database.Session.Transaction.Commit();
     else
         Database.Session.Transaction.Rollback();
 }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            if (!filterContext.Controller.ViewData.ModelState.IsValid)
                filterContext.Controller.ViewData[ValidationExtensions.FormNameKey] = Name;

            base.OnActionExecuted(filterContext);
        }