/// <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)
{
// don't touch temp data if there's no work to perform
if (!_notifier.List().Any())
return;
var tempData = filterContext.Controller.TempData;
// initialize writer with current data
var sb = new StringBuilder();
if (tempData.ContainsKey(TempDataMessages)) {
sb.Append(tempData[TempDataMessages]);
}
// accumulate messages, one line per message
foreach (var entry in _notifier.List()) {
sb.Append(Convert.ToString(entry.Type))
.Append(':')
.AppendLine(entry.Message.ToString())
.AppendLine("-");
}
// assign values into temp data
// string data type used instead of complex array to be session-friendly
tempData[TempDataMessages] = sb.ToString();
}
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
Debug.WriteLine("Route: " + filterContext.HttpContext.Request.Url);
Debug.WriteLine("Controller: " + filterContext.RouteData.Values["controller"] + "Controller");
Debug.WriteLine("Action Method: " + filterContext.ActionDescriptor.ActionName);
Debug.WriteLine("Entered!");
}
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);
}
protected override void OnActionExecuted(ActionExecutedContext filterContext)
{
if (filterContext.IsChildAction)
return;
ViewBag.BlogConfig = BlogConfig.MapTo<BlogConfigViewModel>();
}
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
};
}
}
public void OnActionExecuted(ActionExecutedContext filterContext)
{
if (filterContext.Exception != null)
return;
using (var session = Bootstrapper.Container.GetInstance<IDocumentSession>())
session.SaveChanges();
}
protected override void OnActionExecuted(ActionExecutedContext filterContext)
{
ViewBag.WelcomeMessage = _settings.WelcomeMessage;
ViewBag.Title = _settings.SiteTitle;
base.OnActionExecuted(filterContext);
}
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);
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
//_logger.InfoFormat(CultureInfo.InvariantCulture,
// "Executed action {0}.{1}",
// filterContext.ActionDescriptor.ControllerDescriptor.ControllerName,
// filterContext.ActionDescriptor.ActionName);
}
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;
}
}
}
/// <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 (ApplicationStartContextSecurityMVCExtensions.ActionFilterBuilder.IsNotNull())
{
ApplicationStartContextSecurityMVCExtensions.ActionFilterBuilder(this.PageViewItem).OnActionExecuted(filterContext);
}
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
var request = filterContext.HttpContext.Request;
var viewResult = filterContext.Result as ViewResult;
if (viewResult == null)
return;
if (request.IsAjaxRequest())
{
// Replace result with PartialViewResult
filterContext.Result = new PartialViewResult
{
TempData = viewResult.TempData,
ViewData = viewResult.ViewData,
ViewName = viewResult.ViewName,
};
}
else if (request.IsJsonRequest())
{
// Replace result with JsonResult
filterContext.Result = new JsonResult
{
Data = viewResult.Model,
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
}
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
BaseController controller = filterContext.Controller as BaseController;
if (filterContext.Result.GetType() == typeof(ViewResult))
{
if (controller != null)
{
if (controller.Toastr != null && controller.Toastr.ToastMessages.Any())
{
controller.ViewData["Toastr"] = controller.Toastr;
}
}
}
else if (filterContext.Result.GetType() == typeof(RedirectToRouteResult))
{
if (controller != null)
{
if (controller.Toastr != null && controller.Toastr.ToastMessages.Any())
{
controller.TempData["Toastr"] = controller.Toastr;
}
}
}
base.OnActionExecuted(filterContext);
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
IDataFormatter formatter = filterContext.Controller.ViewBag.DataFormatter as IDataFormatter;
if (formatter != null)
{
object model = filterContext.Controller.ViewData.Model;
if (formatter.ProcessModel)
{
BaseController controller = filterContext.Controller as BaseController;
if (controller!=null)
{
if (model is PageModel)
{
model = controller.ProcessPageModel((PageModel)model);
}
else
{
model = controller.ProcessEntityModel(model as EntityModel) ?? model;
}
}
}
ActionResult result = formatter.FormatData(filterContext, model);
if (result != null)
{
filterContext.Result = result;
}
}
base.OnActionExecuted(filterContext);
}
public override void OnActionExecuted(ActionExecutedContext filterContext)
{
if (!filterContext.Controller.ViewData.ModelState.IsValid)
filterContext.Controller.ViewData[ValidationExtensions.FormNameKey] = Name;
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."));
}
}
public void OnActionExecuted(ActionExecutedContext filterContext)
{
if(filterContext.Exception == null)
Database.Session.Transaction.Commit();
else
Database.Session.Transaction.Rollback();
}
/// <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 );
}
}
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();
}
}
}
/// <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 void OnActionExecuted(ActionExecutedContext filterContext)
{
if (filterContext.Exception != null || !filterContext.HttpContext.Request.IsAjaxRequest())
{
return; // this filter only cares about AJAX requests that successfully produced an ActionResult.
}
var controller = filterContext.Controller as StringRenderingController;
if (controller == null)
{
throw new InvalidOperationException(Resources.Error.AjaxTransformAttributeDecoration);
}
var viewResult = filterContext.Result as ViewResult;
if (viewResult != null) // view result AJAX transformation
{
string title = controller.ViewBag.Title ?? defaultTitle;
string container = controller.ViewBag.AjaxViewContainer;
SeparationOfConcernsResult view = controller.PartialViewSeparationOfConcerns(viewResult.ViewName, null, viewResult.Model);
string html = view.Html;
string script = view.JavaScript;
AjaxViewJsonResult ajaxView = new AjaxViewJsonResult(title, html, script, container);
filterContext.Result = ajaxView;
}
var redirectResult = filterContext.Result as RedirectResult;
if (redirectResult != null)
{
filterContext.Result = new JsonRedirectResult(redirectResult);
}
}
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 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 context)
{
if (!context.ExceptionHandled && context.Exception != null)
{
Exception e = context.Exception;
var socketException = e.InnerException as SocketException;
if (socketException != null)
{
switch (socketException.SocketErrorCode)
{
case SocketError.AddressNotAvailable:
case SocketError.NetworkDown:
case SocketError.NetworkUnreachable:
case SocketError.ConnectionAborted:
case SocketError.ConnectionReset:
case SocketError.TimedOut:
case SocketError.ConnectionRefused:
case SocketError.HostDown:
case SocketError.HostUnreachable:
case SocketError.HostNotFound:
context.Result = new ViewResult()
{
ViewData = new ViewDataDictionary(),
TempData = new TempDataDictionary(),
ViewName = "NoDb",
ViewEngineCollection = ViewEngines.Engines
};
context.ExceptionHandled = true;
break;
}
}
}
base.OnActionExecuted(context);
}
protected override void OnActionExecuted(ActionExecutedContext filterContext)
{
Log.InfoFormat("Done executing {0}.{1}.",
filterContext.ActionDescriptor.ControllerDescriptor.ControllerName,
filterContext.ActionDescriptor.ActionName
);
}
public JsReportStream(ActionExecutedContext context, EnableJsReportAttribute attr, Func<ActionExecutedContext, EnableJsReportAttribute, string, Task<Report>> renderReport)
{
_stream = context.HttpContext.Response.Filter;
_context = context;
_attr = attr;
_renderReport = renderReport;
}
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)
{
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(System.Web.Mvc.ActionExecutedContext filterContext)
{
var messages = Notifier.Messages;
if (messages.Any())
{
filterContext.Controller.TempData[Constants.TempDataKey] = messages;
}
}
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
base.OnActionExecuted(filterContext);
filterContext.HttpContext.Response.Expires = -1;
filterContext.HttpContext.Response.Cache.SetExpires(DateTime.UtcNow.AddDays(-1));
filterContext.HttpContext.Response.Cache.SetValidUntilExpires(false);
filterContext.HttpContext.Response.Cache.SetRevalidation(HttpCacheRevalidation.AllCaches);
filterContext.HttpContext.Response.Cache.SetCacheability(HttpCacheability.NoCache);
filterContext.HttpContext.Response.Cache.SetNoServerCaching();
//filterContext.HttpContext.Response.Cache.SetAllowResponseInBrowserHistory(false);
//filterContext.HttpContext.Response.CacheControl = "no-cache";
filterContext.HttpContext.Response.Cache.SetNoStore();
}
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
var modelState = filterContext.Controller.ViewData.ModelState;
if (!modelState.IsValid && filterContext.HttpContext.Request.IsAjaxRequest())
{
filterContext.Result = new JsonResult()
{
Data = modelState.ToDictionary(x => x.Key, x => x.Value.Errors.Select(error => error.ErrorMessage)),
JsonRequestBehavior = JsonRequestBehavior.AllowGet
};
filterContext.HttpContext.Response.StatusCode = (int)HttpStatusCode.BadRequest;
filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
}
}
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
ViewResult result = filterContext.Result as ViewResult;
if (result != null)
{
if (result.Model is WidgetBase)
{
WidgetBase widget = result.Model as WidgetBase;
if (!widget.PageID.IsNullOrEmpty())
{
filterContext.Controller.ViewData[ViewDataKeys.Zones] = new ZoneService().GetZonesByPageId(widget.PageID).ToDictionary(m => m.ID, m => m.ZoneName);
}
else if (!widget.LayoutID.IsNullOrEmpty())
{
filterContext.Controller.ViewData[ViewDataKeys.Zones] = new ZoneService().GetZonesByLayoutId(widget.LayoutID).ToDictionary(m => m.ID, m => m.ZoneName);
}
}
}
}
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
ViewResult result = filterContext.Result as ViewResult;
if (result != null)
{
if (result.Model is WidgetBase)
{
WidgetBase widget = result.Model as WidgetBase;
var zoneService = ServiceLocator.Current.GetInstance <IZoneService>();
if (!widget.PageID.IsNullOrEmpty())
{
filterContext.Controller.ViewData[ViewDataKeys.Zones] = new SelectList(zoneService.GetZonesByPageId(widget.PageID), "ID", "ZoneName");
}
else if (!widget.LayoutID.IsNullOrEmpty())
{
filterContext.Controller.ViewData[ViewDataKeys.Zones] = new SelectList(zoneService.GetZonesByLayoutId(widget.LayoutID), "ID", "ZoneName");
}
}
}
}
public virtual void OnActionExecuted(ActionExecutedContext filterContext)
{
}
public virtual bool InvokeAction(ControllerContext controllerContext, string actionName)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
Contract.Assert(controllerContext.RouteData != null);
if (
String.IsNullOrEmpty(actionName) &&
!controllerContext.RouteData.HasDirectRouteMatch()
)
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
}
ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext);
ActionDescriptor actionDescriptor = FindAction(
controllerContext,
controllerDescriptor,
actionName
);
if (actionDescriptor != null)
{
FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);
try
{
AuthenticationContext authenticationContext = InvokeAuthenticationFilters(
controllerContext,
filterInfo.AuthenticationFilters,
actionDescriptor
);
if (authenticationContext.Result != null)
{
// An authentication filter signaled that we should short-circuit the request. Let all
// authentication filters contribute to an action result (to combine authentication
// challenges). Then, run this action result.
AuthenticationChallengeContext challengeContext =
InvokeAuthenticationFiltersChallenge(
controllerContext,
filterInfo.AuthenticationFilters,
actionDescriptor,
authenticationContext.Result
);
InvokeActionResult(
controllerContext,
challengeContext.Result ?? authenticationContext.Result
);
}
else
{
AuthorizationContext authorizationContext = InvokeAuthorizationFilters(
controllerContext,
filterInfo.AuthorizationFilters,
actionDescriptor
);
if (authorizationContext.Result != null)
{
// An authorization filter signaled that we should short-circuit the request. Let all
// authentication filters contribute to an action result (to combine authentication
// challenges). Then, run this action result.
AuthenticationChallengeContext challengeContext =
InvokeAuthenticationFiltersChallenge(
controllerContext,
filterInfo.AuthenticationFilters,
actionDescriptor,
authorizationContext.Result
);
InvokeActionResult(
controllerContext,
challengeContext.Result ?? authorizationContext.Result
);
}
else
{
if (controllerContext.Controller.ValidateRequest)
{
ValidateRequest(controllerContext);
}
IDictionary <string, object> parameters = GetParameterValues(
controllerContext,
actionDescriptor
);
ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(
controllerContext,
filterInfo.ActionFilters,
actionDescriptor,
parameters
);
// The action succeeded. Let all authentication filters contribute to an action result (to
// combine authentication challenges; some authentication filters need to do negotiation
// even on a successful result). Then, run this action result.
AuthenticationChallengeContext challengeContext =
InvokeAuthenticationFiltersChallenge(
controllerContext,
filterInfo.AuthenticationFilters,
actionDescriptor,
postActionContext.Result
);
InvokeActionResultWithFilters(
controllerContext,
filterInfo.ResultFilters,
challengeContext.Result ?? postActionContext.Result
);
}
}
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
throw;
}
catch (Exception ex)
{
// something blew up, so execute the exception filters
ExceptionContext exceptionContext = InvokeExceptionFilters(
controllerContext,
filterInfo.ExceptionFilters,
ex
);
if (!exceptionContext.ExceptionHandled)
{
throw;
}
InvokeActionResult(controllerContext, exceptionContext.Result);
}
return(true);
}
// notify controller that no method matched
return(false);
}
internal static ActionExecutedContext InvokeActionMethodFilter(
IActionFilter filter,
ActionExecutingContext preContext,
Func <ActionExecutedContext> continuation
)
{
filter.OnActionExecuting(preContext);
if (preContext.Result != null)
{
return(new ActionExecutedContext(
preContext,
preContext.ActionDescriptor,
true /* canceled */
,
null /* exception */
)
{
Result = preContext.Result
});
}
bool wasError = false;
ActionExecutedContext postContext = null;
try
{
postContext = continuation();
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
postContext = new ActionExecutedContext(
preContext,
preContext.ActionDescriptor,
false /* canceled */
,
null /* exception */
);
filter.OnActionExecuted(postContext);
throw;
}
catch (Exception ex)
{
wasError = true;
postContext = new ActionExecutedContext(
preContext,
preContext.ActionDescriptor,
false /* canceled */
,
ex
);
filter.OnActionExecuted(postContext);
if (!postContext.ExceptionHandled)
{
throw;
}
}
if (!wasError)
{
filter.OnActionExecuted(postContext);
}
return(postContext);
}
/// <summary>
/// 执行action后执行这个方法
/// </summary>
/// <param name="filterContext"></param>
void System.Web.Mvc.IActionFilter.OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
}
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
}
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
filterContext.Controller.ViewData[ViewDataKeys.Layouts] = new SelectList(ServiceLocator.Current.GetInstance <ILayoutService>().Get(), "ID", "LayoutName");
}
void IActionFilter.OnActionExecuted(ActionExecutedContext filterContext);
public override void OnActionExecuted(System.Web.Mvc.ActionExecutedContext filterContext)
{
SillyLogger.ExitMethod(filterContext.RouteData.Values["action"].ToString());
}
protected virtual void OnActionExecuted(ActionExecutedContext filterContext);
