protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
var actionResult = (actionReturnValue as ActionResult)
?? _typedResultFactory.Build(controllerContext, actionReturnValue, actionDescriptor.ActionName);
return actionResult;
}
private static ThemedConditionalAttribute GetThemedAttribute(ActionDescriptor descriptor)
{
return
descriptor.GetCustomAttributes(typeof(ThemedConditionalAttribute), true).Concat(
descriptor.ControllerDescriptor.GetCustomAttributes(typeof(ThemedConditionalAttribute), true)).
OfType<ThemedConditionalAttribute>().FirstOrDefault();
}
/// <summary>
/// Gets all Filter instances adapted from IActionFilter instances in IWindsorContainer
/// </summary>
/// <param name="controllerContext">ControllerContext</param>
/// <param name="actionDescriptor">ActionDescriptor</param>
/// <returns>IEnumerable of Filter instances</returns>
public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
foreach (IActionFilter actionFilter in this._container.ResolveAll<IActionFilter>())
{
yield return new Filter(actionFilter, FilterScope.First, null);
}
}
/// <summary>
/// Gets all the filters that were registered with the <see cref="IFilterRegistry"/> instances.
/// </summary>
/// <param name="controllerContext"></param>
/// <param name="actionDescriptor"></param>
/// <returns></returns>
public IEnumerable<System.Web.Mvc.Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor) {
var globalList = GetGlobalFilters();
var controllerList = GetControllerFilters(controllerContext);
var actionList = GetActionFilters(actionDescriptor);
return globalList.Concat(controllerList).Concat(actionList);
}
public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return filterRegistry.Items.Where(item => item.IsMatching(controllerContext, actionDescriptor))
.SelectMany(item => item.BuildFilters())
.OrderBy(x => x.Order)
.ToArray();
}
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var filterInfo = base.GetFilters(controllerContext, actionDescriptor);
filterInfo.ExceptionFilters.Add(this._filter);
return filterInfo;
}
public static ParameterDescriptor[] GetParameters(ActionDescriptor actionDescriptor, MethodInfo methodInfo, ref ParameterDescriptor[] parametersCache)
{
ParameterDescriptor[] parameters = LazilyFetchParametersCollection(actionDescriptor, methodInfo, ref parametersCache);
// need to clone array so that user modifications aren't accidentally stored
return (ParameterDescriptor[])parameters.Clone();
}
public virtual void AddComposedFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor,
FilterInfo filters)
{
var foundFilters = FilterLocators.Select(f => f.FindFilters(controllerContext, actionDescriptor));
foundFilters.ForEach(f => AddFilters(filters, f));
}
private static ParameterDescriptor[] LazilyFetchParametersCollection(ActionDescriptor actionDescriptor, MethodInfo methodInfo, ref ParameterDescriptor[] parametersCache)
{
return DescriptorUtil.LazilyFetchOrCreateDescriptors<ParameterInfo, ParameterDescriptor>(
cacheLocation: ref parametersCache,
initializer: methodInfo.GetParameters,
converter: parameterInfo => new ReflectedParameterDescriptor(parameterInfo, actionDescriptor));
}
protected override IEnumerable<FilterAttribute> GetActionAttributes(
ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
//Ping controller lo excluyo
if (controllerContext.Controller.GetType() == typeof(PingController)) return new List<FilterAttribute>();
var attributes = new List<FilterAttribute>();
attributes.AddRange(base.GetControllerAttributes(controllerContext, actionDescriptor));
attributes.AddRange(base.GetActionAttributes(controllerContext, actionDescriptor));
attributes.AddRange(_globalFilters);
//By default add the AuthorizeItAttribute if is not present and not is anonymous
//var attributesTypes = attributes.Select(x => x.GetType());
//if(!attributesTypes.Contains(typeof(AnonymousAttribute))
// && !attributesTypes.Contains(typeof(AuthorizeItAttribute)))
// attributes.Add(new AuthorizeItAttribute());
foreach (var attribute in attributes)
{
_container.BuildUp(attribute.GetType(), attribute);
}
return attributes;
}
public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return from condition in _conditions
select condition(controllerContext, actionDescriptor) into filter
where filter != null
select new Filter(filter, FilterScope.Global, null);
}
public bool IsSameAction(ActionDescriptor descriptor)
{
var desc = descriptor as ReflectedActionDescriptor;
if (desc != null)
{
bool sameAction = ActionDescriptor.MethodInfo == desc.MethodInfo;
if (sameAction)
return true;
}
ParameterDescriptor[] parameters1 = descriptor.GetParameters();
bool same = descriptor.ControllerDescriptor.ControllerName.Equals(ActionDescriptor.ControllerDescriptor.ControllerName, StringComparison.OrdinalIgnoreCase) &&
descriptor.ActionName.Equals(ActionDescriptor.ActionName, StringComparison.OrdinalIgnoreCase) &&
(parameters1.Length == _actionParameterDescriptors.Length);
if (same)
{
for (int i = parameters1.Length - 1; i >= 0; i--)
{
if (parameters1[i].ParameterType == _actionParameterDescriptors[i].ParameterType)
{
continue;
}
same = false;
break;
}
}
return same;
}
private static bool ActionIsAuthorized(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
if (actionDescriptor == null) return false; // action does not exist so say yes - should we authorise this?!
var authContext = new AuthorizationContext(controllerContext, actionDescriptor);
// run each auth filter until one fails
// performance could be improved by some caching
var authorizeAttributes =
FilterProviders.Providers.GetFilters(controllerContext, actionDescriptor).Where(
x => x.Instance is AuthorizeActivityAttribute).Select(x => x.Instance);
foreach (AuthorizeActivityAttribute authFilter in authorizeAttributes)
{
authFilter.OnAuthorization(authContext);
if (authContext.Result != null) return false;
}
authorizeAttributes =
FilterProviders.Providers.GetFilters(controllerContext, actionDescriptor).Where(
x => x.Instance is AuthorizeAttribute).Select(x => x.Instance);
foreach (AuthorizeAttribute authFilter in authorizeAttributes)
{
authFilter.OnAuthorization(authContext);
if (authContext.Result != null) return false;
}
return true;
}
/// <summary>
/// Create new descriptor
/// </summary>
/// <param name="actionDescriptor">Instance of the action descriptor</param>
/// <param name="parameterName">Name of the parameter</param>
/// <param name="parameterType">Type, mostly object</param>
/// <param name="defaultValue">Default value, by default null</param>
public DynamicParameterDescriptor(ActionDescriptor actionDescriptor, string parameterName, Type parameterType, object defaultValue)
{
this.actionDescriptor = actionDescriptor;
this.parameterName = parameterName;
this.parameterType = parameterType;
this.defaultValue = defaultValue;
}
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
var filterList = base.GetFilters(controllerContext, actionDescriptor);
filterList.ResultFilters.Add(new ViewProviderFilter(actionDescriptor.ActionName));
return filterList;
}
private static IEnumerable<FilterAttribute> ExecutedAttributesOf(ActionDescriptor actionDescriptor)
{
var actionCustomAttributes = actionDescriptor.GetCustomAttributes(inherit: true).OfType<FilterAttribute>().OrderByDescending(attribute => attribute.Order);
var controllerCustomAttributes = actionDescriptor.ControllerDescriptor.GetCustomAttributes(inherit: true).OfType<FilterAttribute>().OrderByDescending(attribute => attribute.Order);
return actionCustomAttributes.Concat(controllerCustomAttributes);
}
/// <summary>
/// Gets the filters for the specified request and action.
/// </summary>
/// <param name="controllerContext">The controller context.</param>
/// <param name="actionDescriptor">The action descriptor.</param>
/// <returns>The filters.</returns>
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
FilterInfo filterInfo = base.GetFilters(controllerContext, actionDescriptor);
foreach (IActionFilter filter in filterInfo.ActionFilters.Where(f => f != null))
{
this.Kernel.Inject(filter);
}
foreach (IAuthorizationFilter filter in filterInfo.AuthorizationFilters.Where(f => f != null))
{
this.Kernel.Inject(filter);
}
foreach (IExceptionFilter filter in filterInfo.ExceptionFilters.Where(f => f != null))
{
this.Kernel.Inject(filter);
}
foreach (IResultFilter filter in filterInfo.ResultFilters.Where(f => f != null))
{
this.Kernel.Inject(filter);
}
return filterInfo;
}
/// <summary>
/// Retrieves information about the action filters.
/// </summary>
/// <param name="controllerContext">The controller context.</param>
/// <param name="actionDescriptor">The action descriptor.</param>
/// <returns>Information about the action filters.</returns>
protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
//let the base class do the actual work as usual
var filterInfo = base.GetFilters(controllerContext, actionDescriptor);
//configure each collection of filters using the IApplicationContext
foreach (IActionFilter filter in filterInfo.ActionFilters.Where(f => f != null))
{
_context.ConfigureObject(filter, filter.GetType().FullName);
}
foreach (IAuthorizationFilter filter in filterInfo.AuthorizationFilters.Where(f => f != null))
{
_context.ConfigureObject(filter, filter.GetType().FullName);
}
foreach (IExceptionFilter filter in filterInfo.ExceptionFilters.Where(f => f != null))
{
_context.ConfigureObject(filter, filter.GetType().FullName);
}
foreach (IResultFilter filter in filterInfo.ResultFilters.Where(f => f != null))
{
_context.ConfigureObject(filter, filter.GetType().FullName);
}
return filterInfo;
}
public IEnumerable<Filter> GetFilters(ControllerContext controllerContext,
ActionDescriptor actionDescriptor)
{
if ((actionDescriptor.ControllerDescriptor.ControllerType ==
typeof(ProductController) &&
(actionDescriptor.ActionName.Equals("Create",
StringComparison.InvariantCultureIgnoreCase) ||
actionDescriptor.ActionName.Equals("Edit",
StringComparison.InvariantCultureIgnoreCase)) &&
controllerContext.HttpContext.Request.HttpMethod == "POST") ||
(actionDescriptor.ControllerDescriptor.ControllerType ==
typeof(ProductVariantController) &&
(actionDescriptor.ActionName.Equals("Create",
StringComparison.InvariantCultureIgnoreCase) ||
actionDescriptor.ActionName.Equals("Edit",
StringComparison.InvariantCultureIgnoreCase)) &&
controllerContext.HttpContext.Request.HttpMethod == "POST"))
{
return new Filter[]
{
new Filter(_actionFilter, FilterScope.Action, null)
};
};
return new Filter[] { };
}
private string GetParamSignatureString(ActionDescriptor action)
{
var res = "(";
ReflectedActionDescriptor aD = action as ReflectedActionDescriptor;
foreach (var parameterDescriptor in aD.GetParameters())
{
res += parameterDescriptor.ParameterType.Name + " " + parameterDescriptor.ParameterName + ", ";
}
if (res == "(")
{
res += ")";
return res;
}
if (res.Substring(res.Length - 2) == ", ")
{
res = res.Substring(0, res.Length - 2);
res += ")";
}
return res;
}
public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
#if !DEBUG
yield return new Filter(new RedirectToHttpsAttribute(), FilterScope.Global, App.HttpsRedirectOrder);
#endif
yield return new Filter(new RequiresAllRoles("staff"), FilterScope.Global, App.ActiveAuthenticationOrder);
}
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
if(!(actionReturnValue is ActionResult))
{
var controller = controllerContext.Controller;
if(actionReturnValue is Result)
{
if(actionReturnValue == Result.Successfully)
{
actionReturnValue = controller.Success();
}
else
{
var result = actionReturnValue as IValueResult;
if(result.IsSucceed)
{
actionReturnValue = controller.Success(result.GetValue());
}
else actionReturnValue = controller.Faild(result.Message, result.Status);
}
}
else
{
actionReturnValue = controller.Success(actionReturnValue);
}
}
return base.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue);
}
protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
{
var uowParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IUnitOfWork));
if (uowParam != null)
{
var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute<ConnectionKeyAttribute>();
if (connectionKey == null)
throw new ArgumentNullException("connectionKey");
using (var connection = SqlConnections.NewByKey(connectionKey.Value))
using (var uow = new UnitOfWork(connection))
{
parameters[uowParam.ParameterName] = uow;
var result = base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
uow.Commit();
return result;
}
}
var cnnParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IDbConnection));
if (cnnParam != null)
{
var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute<ConnectionKeyAttribute>();
if (connectionKey == null)
throw new ArgumentNullException("connectionKey");
using (var cnn = SqlConnections.NewByKey(connectionKey.Value))
{
parameters[cnnParam.ParameterName] = cnn;
return base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
}
}
return base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
}
public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
//if (filterContext == null || filterContext.HttpContext == null)
// return new List<Filter>();
string controllerName = controllerContext.RouteData.Values["controller"].ToString();
Debug.WriteLine("Your Controller Name is " + controllerName);
if (String.IsNullOrEmpty(controllerName))
return new List<Filter>();
//you are only looking for the Admin area Product controller - get out if the area key doesn't exist
if (!controllerContext.RouteData.Values.ContainsKey("area"))
return new List<Filter>();
string areaName = controllerContext.RouteData.Values["area"].ToString();
Debug.WriteLine("Your Area Name is " + areaName);
if (String.IsNullOrEmpty(areaName))
return new List<Filter>();
//Note: you could also use controllerContext.RouteData.Values["action"].ToString();
if (controllerName == "Product" && areaName == "Admin" && actionDescriptor.ActionName.Equals("Create", StringComparison.InvariantCultureIgnoreCase))
{
Debug.WriteLine("You got into the IF statement for Create");
return new List<Filter>() { new Filter(this, FilterScope.Action, 0) };
}
return new List<Filter>();
}
CachePolicy IMvcCachePolicyProvider.CreateCachePolicy( ControllerContext context, ActionDescriptor action, IDictionary<string, object> parameters )
{
if ( context.IsChildAction )
return null;
return _provider.CreateCachePolicy( context.HttpContext );
}
/// <summary>
/// Gets the key from the action descriptor.
/// </summary>
/// <param name="actionDescriptor">The action descriptor.</param>
/// <returns>The key for the action.</returns>
private static string GetKey(ActionDescriptor actionDescriptor)
{
return string.Format(
"{0}.{1}",
actionDescriptor.ControllerDescriptor.ControllerName,
actionDescriptor.ActionName);
}
public ControllerAction Get(ActionDescriptor actionDescriptor)
{
string httpVerb = actionDescriptor.GetHttpVerb();
return DB.ControllerActions.SingleOrDefault(r => r.Controller == actionDescriptor.ControllerDescriptor.ControllerName
&& r.Action == actionDescriptor.ActionName
&& r.HttpVerb == httpVerb);
}
/// <summary>
/// 获取缓存策略
/// </summary>
/// <param name="context">MVC 请求上下文</param>
/// <param name="action">Action 信息</param>
/// <param name="parameters">Action 参数</param>
/// <returns>缓存策略</returns>
protected override CachePolicy CreateCachePolicy( ControllerContext context, ActionDescriptor action, IDictionary<string, object> parameters )
{
if ( CachePolicyProvider != null )
return CachePolicyProvider.CreateCachePolicy( context, action, parameters );
var httpMethod = context.HttpContext.Request.HttpMethod;
if ( !httpMethod.EqualsIgnoreCase( "get" ) && !httpMethod.EqualsIgnoreCase( "header" ) )//如果不是GET或Header请求，都不予缓存。
return null;
var provider = context.Controller as IMvcCachePolicyProvider;
if ( provider == null )
{
var _provider = context.Controller as ICachePolicyProvider;
if ( _provider != null )
provider = new MvcCachePolicyProviderWrapper( _provider );
}
var policy = provider.CreateCachePolicy( context, action, parameters );
if ( policy != null )
return policy;
return MvcEnvironment.CreateCachePolicy( context, action, parameters );
}
public void CreateRouteEntry_IfDirectRouteProviderReturnsRouteWithEmptyActionDescriptors_Throws()
{
// Arrange
string areaPrefix = null;
string controllerPrefix = null;
Route route = new Route(url: null, routeHandler: null);
route.DataTokens = new RouteValueDictionary();
route.DataTokens.Add(RouteDataTokenKeys.Actions, new ActionDescriptor[0]);
ActionDescriptor[] originalActions = route.GetTargetActionDescriptors();
Assert.NotNull(originalActions); // Guard
Assert.Equal(0, originalActions.Length); // Guard
RouteEntry entry = new RouteEntry(name: null, route: route);
IDirectRouteFactory factory = CreateStubRouteFactory(entry);
ControllerDescriptor controllerDescriptor = CreateStubControllerDescriptor("IgnoreController");
ActionDescriptor actionDescriptor = CreateStubActionDescriptor(controllerDescriptor, "IgnoreAction");
IReadOnlyCollection<ActionDescriptor> actions = new ActionDescriptor[] { actionDescriptor };
IInlineConstraintResolver constraintResolver =
new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;
// Act & Assert
string expectedMessage = "The route does not have any associated action descriptors. Routing requires " +
"that each direct route map to a non-empty set of actions.";
Assert.Throws<InvalidOperationException>(() => DefaultDirectRouteProvider.CreateRouteEntry(areaPrefix,
controllerPrefix, factory, actions, constraintResolver, targetIsAction: false), expectedMessage);
}
public void ShouldBeAbleToBuildWithFactoryUsingActionDescriptor(ActionDescriptor descriptor)
{
var testMessage = new TestMessage().AsActionMessage(descriptor);
Assert.Equal(descriptor.ActionName, testMessage.ActionName);
Assert.Equal(descriptor.ControllerDescriptor.ControllerName, testMessage.ControllerName);
}
protected virtual AuthorizationContext InvokeAuthorizationFilters(ControllerContext controllerContext, IList <IAuthorizationFilter> filters, ActionDescriptor actionDescriptor)
{
AuthorizationContext context = new AuthorizationContext(controllerContext, actionDescriptor);
foreach (IAuthorizationFilter filter in filters)
{
filter.OnAuthorization(context);
// short-circuit evaluation when an error occurs
if (context.Result != null)
{
break;
}
}
return(context);
}
protected virtual ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList <IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters)
{
ActionExecutingContext preContext = new ActionExecutingContext(controllerContext, actionDescriptor, parameters);
Func <ActionExecutedContext> continuation = () =>
new ActionExecutedContext(controllerContext, actionDescriptor, false /* canceled */, null /* exception */)
{
Result = InvokeActionMethod(controllerContext, actionDescriptor, parameters)
};
// need to reverse the filter list because the continuations are built up backward
Func <ActionExecutedContext> thunk = filters.Reverse().Aggregate(continuation,
(next, filter) => () => InvokeActionMethodFilter(filter, preContext, next));
return(thunk());
}
protected virtual ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
if (actionReturnValue == null)
{
return(new EmptyResult());
}
ActionResult actionResult = (actionReturnValue as ActionResult) ??
new ContentResult {
Content = Convert.ToString(actionReturnValue, CultureInfo.InvariantCulture)
};
return(actionResult);
}
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);
}
protected virtual AuthenticationContext InvokeAuthenticationFilters(ControllerContext controllerContext,
IList <IAuthenticationFilter> filters, ActionDescriptor actionDescriptor)
{
if (controllerContext == null)
{
throw new ArgumentNullException("controllerContext");
}
Contract.Assert(controllerContext.HttpContext != null);
IPrincipal originalPrincipal = controllerContext.HttpContext.User;
AuthenticationContext context = new AuthenticationContext(controllerContext, actionDescriptor,
originalPrincipal);
foreach (IAuthenticationFilter filter in filters)
{
filter.OnAuthentication(context);
// short-circuit evaluation when an error occurs
if (context.Result != null)
{
break;
}
}
IPrincipal newPrincipal = context.Principal;
if (newPrincipal != originalPrincipal)
{
Contract.Assert(context.HttpContext != null);
context.HttpContext.User = newPrincipal;
Thread.CurrentPrincipal = newPrincipal;
}
return(context);
}
protected virtual FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return(new FilterInfo(_getFiltersThunk(controllerContext, actionDescriptor)));
}
protected virtual ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary <string, object> parameters)
{
object returnValue = actionDescriptor.Execute(controllerContext, parameters);
ActionResult result = CreateActionResult(controllerContext, actionDescriptor, returnValue);
return(result);
}
protected virtual ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
{
ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName);
return(actionDescriptor);
}
protected virtual IDictionary <string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
Dictionary <string, object> parametersDict = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
ParameterDescriptor[] parameterDescriptors = actionDescriptor.GetParameters();
foreach (ParameterDescriptor parameterDescriptor in parameterDescriptors)
{
parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
}
return(parametersDict);
}
protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
{
if (!(actionReturnValue is ActionResult))
{
if (actionReturnValue is Result)
{
if (actionReturnValue is SuccessfullyResult)
{
actionReturnValue = new JsonNetResult(Successfully);
}
else
{
var result = actionReturnValue as Result;
var value = result.GetValue();
if (result.IsSucceed)
{
actionReturnValue = new JsonNetResult(value == null ? Successfully : new { Value = value });
}
else
{
actionReturnValue = new JsonNetResult(new { result.Message, result.Status });
}
}
}
else
{
actionReturnValue = new JsonNetResult(actionReturnValue);
}
}
return(base.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue));
}
IEnumerable <Filter> IFilterProvider.GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
{
return(this);
}