/// <summary>
/// Initializes a new instance of the <see cref="DetailActionParamsMapper"/> class.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="itemType">Type of the item that is expected.</param>
/// <param name="providerNameResolver">A function that returns provider name for the content. If null then default provider is used.</param>
/// <param name="actionName">Name of the action.</param>
/// <exception cref="System.ArgumentException">When the given controller does not contain a method corresponding to the action name.</exception>
public DetailActionParamsMapper(ControllerBase controller, Type itemType, Func<string> providerNameResolver, string actionName)
: base(controller)
{
if (itemType == null)
throw new ArgumentNullException("itemType");
this.actionName = actionName;
this.providerNameResolver = providerNameResolver;
this.ActionMethod = new ReflectedControllerDescriptor(controller.GetType()).FindAction(controller.ControllerContext, actionName);
if (this.ActionMethod == null)
throw new ArgumentException("The controller {0} does not have action '{1}'.".Arrange(controller.GetType().Name, actionName));
this.ItemType = itemType;
}
private static ActionDescriptor GetActionDescriptor(ControllerBase controller, RouteData routeData)
{
var controllerDescriptor = new ReflectedControllerDescriptor(controller.GetType());
var actionName = routeData.GetRequiredString("action");
var actionDescriptor = controllerDescriptor.FindAction(controller.ControllerContext, actionName);
return actionDescriptor;
}
/// <summary>
/// Get the label with the specified key from the resource files.
/// </summary>
/// <param name="controller">Controller that requests the resource.</param>
/// <param name="key">The key.</param>
/// <param name="fallbackToKey">If true then if a resource is not found with the specified key the key is returned.</param>
private static string Resource(ControllerBase controller, RouteData routeData, string key, bool fallbackToKey)
{
var resClass = LocalizationHelpers.FindResourceStringClassType(controller.GetType());
var widgetName = routeData != null ? routeData.Values["widgetName"] as string : null;
if (!string.IsNullOrEmpty(widgetName))
{
var widget = FrontendManager.ControllerFactory.ResolveControllerType(widgetName);
if (widget != null)
{
var widgetResClass = LocalizationHelpers.FindResourceStringClassType(widget);
string res;
if (widgetResClass != null && Res.TryGet(widgetResClass.Name, key, out res))
{
return res;
}
}
}
string result;
if (Res.TryGet(resClass.Name, key, out result))
{
return result;
}
if (fallbackToKey)
{
return key;
}
return "#ResourceNotFound: {0}, {1}#".Arrange(resClass.Name, key);
}
/// <summary>
/// Initializes a new instance of the <see cref="TaxonomyUrlParamsMapper" /> class.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="taxonUrlEvaluator">The taxon URL evaluator.</param>
/// <param name="actionName">Name of the action.</param>
public TaxonomyUrlParamsMapper(ControllerBase controller, TaxonUrlMapper taxonUrlEvaluator, string actionName = TaxonomyUrlParamsMapper.DefaultActionName)
: base(controller)
{
this.actionName = actionName;
this.taxonUrlEvaluator = taxonUrlEvaluator;
this.actionMethod = controller.GetType().GetMethod(this.actionName, BindingFlags.Instance | BindingFlags.Public);
}
public static ControllerContext CreateControllerContext (ControllerBase controller, Dictionary<string, string> formValues,
HttpCookieCollection requestCookies, IDictionary<string, string> routeData)
{
HttpContextBase httpContext = CreateHttpContext ();
if (formValues != null) {
foreach (string key in formValues.Keys)
httpContext.Request.Form.Add (key, formValues[key]);
}
if (requestCookies != null) {
foreach (string key in requestCookies.Keys)
httpContext.Request.Cookies.Add (requestCookies[key]);
}
RouteData route = new RouteData ();
route.Values.Add ("controller", controller.GetType ().Name);
if (routeData != null) {
foreach (var valuePair in routeData)
route.Values.Add (valuePair.Key, valuePair.Value);
}
return new ControllerContext (new RequestContext (httpContext, route), controller);
}
public object GetFormletResult(ControllerBase controller, string actionName, HttpRequestBase request)
{
var type = formletType ?? controller.GetType();
var methodName = formletMethodName ?? (actionName + "Formlet");
var method = type.GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
if (method == null)
throw new Exception(string.Format("Formlet method '{0}' not found in '{1}'", methodName, type));
var formlet = method.Invoke(controller, null);
return formlet.GetType().GetMethod("Run").Invoke(formlet, new[] { GetCollectionBySource(request) });
}
protected virtual Type FindModelType(ControllerBase controller, string actionName)
{
ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controller.GetType());
var actionDescriptor = controllerDescriptor.FindAction(controller.ControllerContext, actionName);
var qry = from p in actionDescriptor.GetParameters()
let paramType = p.ParameterType
where typeof(Csla.Core.IBusinessObject).IsAssignableFrom(paramType)
select paramType;
return qry.SingleOrDefault();
}
/// <summary>
/// Initializes a new instance of the <see cref="CustomActionParamsMapper"/> class.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="routeTemplateResolver">This function should return the route template that the mapper will use.</param>
/// <param name="actionName">Name of the action.</param>
/// <exception cref="System.ArgumentNullException">routeTemplateResolver</exception>
public CustomActionParamsMapper(ControllerBase controller, Func<string> routeTemplateResolver, string actionName = CustomActionParamsMapper.DefaultActionName)
: base(controller)
{
if (routeTemplateResolver == null)
throw new ArgumentNullException("routeTemplateResolver");
this.actionName = actionName;
this.actionMethod = controller.GetType().GetMethod(this.actionName, BindingFlags.Instance | BindingFlags.Public);
this.routeTemplateResolver = routeTemplateResolver;
}
protected virtual bool IsIlaroAdminController(ControllerBase controller)
{
var currentType = controller.GetType();
return currentType == typeof (EntitiesController) ||
currentType == typeof (EntityController) ||
currentType == typeof (AccountController) ||
currentType == typeof (GroupController) ||
currentType == typeof (ResourceController) ||
currentType == typeof (SharedController);
}
static MethodInfo GetActionMethod(HttpContextBase context, RouteData routeData, ControllerBase controller)
{
var actionName = routeData.Values["action"] as string;
if (actionName == null)
return null;
var controllerContext = new ControllerContext(context, routeData, controller);
var controllerDescriptor = new ReflectedControllerDescriptor(controller.GetType());
var actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName) as ReflectedActionDescriptor;
return actionDescriptor?.MethodInfo;
}
/// <summary>
/// Avoids risking things like AmbiguousMatchException, by accessing the controller and action descriptors.
/// </summary>
internal IEnumerable<AuthorizeAttribute> GetAuthorizeAttributes(ControllerBase controller, string actionName)
{
ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controller.GetType());
ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controller.ControllerContext, actionName);
if (actionDescriptor == null)
{
// if we can't find a matching action descriptor, we just issue a warning log and trim the action from the site map.
log.Warn(Exceptions.MiniAclModule_ActionDescriptorNotFound.FormatWith(controllerDescriptor.ControllerName, actionName));
return new AuthorizeAttribute[] { new UnauthorizedAttribute() };
}
IEnumerable<AuthorizeAttribute> controllerAttributes = controllerDescriptor.GetAttributes<AuthorizeAttribute>();
IEnumerable<AuthorizeAttribute> actionAttributes = actionDescriptor.GetAttributes<AuthorizeAttribute>();
return controllerAttributes.Concat(actionAttributes);
}
private IEnumerable<string> GetProviderNames(ControllerBase controller, Type contentType)
{
var providerNameProperty = controller.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).FirstOrDefault(p => p.Name == "ProviderName" && p.PropertyType == typeof(string));
if (providerNameProperty != null)
{
return new string[1] { providerNameProperty.GetValue(controller, null) as string };
}
else
{
var mappedManager = ManagerBase.GetMappedManager(contentType);
if (mappedManager != null)
{
return mappedManager.Providers.Select(p => p.Name);
}
else
{
return new string[0];
}
}
}
private void DisplayModelStateErrors(ControllerBase currentController)
{
// Show the ModelState errors in the standard Cuyahoga errorbox.
if (!currentController.ViewData.ModelState.IsValid)
{
string generalMessage = this._localizer.GetString("ModelValidationErrorMessage");
TagBuilder errorList = new TagBuilder("ul");
StringBuilder errorSummary = new StringBuilder();
foreach (KeyValuePair<string, ModelState> modelStateKvp in currentController.ViewData.ModelState)
{
foreach (ModelError modelError in modelStateKvp.Value.Errors)
{
TagBuilder listItem = new TagBuilder("li");
string baseName = String.Format("{0}.globalresources"
, currentController.GetType().Namespace.Replace(".Controllers", String.Empty).ToLowerInvariant());
listItem.SetInnerText(this._localizer.GetString(modelError.ErrorMessage, baseName));
errorSummary.AppendLine(listItem.ToString(TagRenderMode.Normal));
}
}
errorList.InnerHtml = errorSummary.ToString();
this._messageViewData.AddErrorMessage(generalMessage + errorList.ToString(TagRenderMode.Normal));
}
this._messageViewData.FlashMessageAdded -= new EventHandler(MessageViewData_FlashMessageAdded);
}
public static bool IsDefined(ControllerBase controller)
{
Type controllerType = controller.GetType();
WebApiEnabledAttribute[] rea = controllerType.GetCustomAttributes(typeof(WebApiEnabledAttribute), true) as WebApiEnabledAttribute[];
return rea != null && rea.Length > 0;
}
private TipoPermiso GetPermisoAction(string actionName, ControllerBase controller, string verb)
{
var methodInfo = controller.GetType().GetMethods().FirstOrDefault(p =>
p.Name == actionName &&
p.CustomAttributes.Any(
q =>
verb == HttpVerbs.Get.ToString().ToUpperInvariant()
? q.AttributeType == typeof (HttpGetAction)
: q.AttributeType == typeof (HttpPostAction)));
if (methodInfo == null)
throw new Exception("No se ha asignado los atributos correspondientes en el controlador....");
var attributePermiso = methodInfo.GetCustomAttributes(typeof (IPermiso), true).FirstOrDefault() as IPermiso;
return attributePermiso.GetPermiso();
}
/// <summary>
/// Determines if specified action is accessible to current user.
/// </summary>
/// <param name="htmlHelper">HtmlHelper object.</param>
/// <param name="actionName">Action name to test.</param>
/// <param name="controllerBase">Controller to test.</param>
/// <returns>True/false if action is accessible to current user.</returns>
private static bool ActionIsAccessibleToUser(this HtmlHelper htmlHelper, string actionName, ControllerBase controllerBase)
{
// Get controller context.
var controllerContext = new ControllerContext(htmlHelper.ViewContext.RequestContext, controllerBase);
// Get controller descriptor.
var controllerDescriptor = new ReflectedControllerDescriptor(controllerBase.GetType());
// Get action descriptor.
var actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName);
// Check on authorization.
return ActionIsAuthorized(actionDescriptor, controllerContext);
}
public static bool IsAllowedAnonymousAccess(ControllerBase controller)
{
bool isAllowedAnonymous = controller.GetType().IsDefined(typeof(Cruder.Web.Auth.Attributes.AllowAnonymousAccess), true);
return isAllowedAnonymous;
}
private static string GetReadingName(ControllerBase controller, string actionName)
{
return controller.GetType().Name + "/" + actionName;
}
/// <summary>
/// Gets the module.
/// </summary>
/// <param name="controller">The controller.</param>
/// <returns></returns>
public IViewModule GetModule(ControllerBase controller)
{
var lazyMod = _modules.FirstOrDefault(m => m.Value.Controllers.Contains(controller.GetType()));
if (lazyMod != null)
return lazyMod.Value;
return null;
}
private IUrlParamsMapper GetInferredTaxonFilterMapper(ControllerBase controller, string actionName)
{
var actionDescriptor = new ReflectedControllerDescriptor(controller.GetType()).FindAction(controller.ControllerContext, actionName);
if (actionDescriptor == null || actionDescriptor.GetParameters().Length == 0)
return null;
IUrlParamsMapper result = null;
if (actionDescriptor.GetParameters()[0].ParameterType == typeof(ITaxon))
{
var taxonParamName = actionDescriptor.GetParameters()[0].ParameterName;
if (actionDescriptor.GetParameters()[1].ParameterType == typeof(int?))
{
var pageParamName = actionDescriptor.GetParameters()[1].ParameterName;
result = new CustomActionParamsMapper(controller, () => "/{" + taxonParamName + ":category,tag}/{" + pageParamName + "}", actionName);
}
result = result.SetLast(new CustomActionParamsMapper(controller, () => "/{" + taxonParamName + ":category,tag}", actionName));
}
return result;
}
private IEnumerable<string> GetProviderNames(ControllerBase controller, Type contentType)
{
var providerNameProperty = controller.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).FirstOrDefault(p => p.Name == "ProviderName" && p.PropertyType == typeof(string));
if (providerNameProperty != null)
{
return new string[1] { providerNameProperty.GetValue(controller, null) as string };
}
else
{
IManager manager;
try
{
ManagerBase.TryGetMappedManager(contentType, string.Empty, out manager);
}
catch (Exception ex)
{
Log.Write(string.Format(System.Globalization.CultureInfo.InvariantCulture, "Exception occurred in the routing functionality, details: {0}", ex));
manager = null;
}
if (manager != null)
{
return manager.Providers.Select(p => p.Name);
}
else
{
return new string[0];
}
}
}
private IUrlParamsMapper GetInferredDetailActionParamsMapper(ControllerBase controller)
{
var controllerType = controller.GetType();
IUrlParamsMapper result = null;
var detailsAction = new ReflectedControllerDescriptor(controllerType).FindAction(controller.ControllerContext, DetailActionParamsMapper.DefaultActionName);
if (detailsAction != null)
{
var contentParam = detailsAction.GetParameters().FirstOrDefault();
if (contentParam != null && contentParam.ParameterType.ImplementsInterface(typeof(IDataItem)))
{
Type contentType;
if (typeof(DynamicContent) == contentParam.ParameterType)
{
var dynamicContentType = controller.GetDynamicContentType();
contentType = dynamicContentType != null ? TypeResolutionService.ResolveType(dynamicContentType.GetFullTypeName(), throwOnError: false) : null;
}
else
{
contentType = contentParam.ParameterType;
}
if (contentType != null)
{
var providerNames = this.GetProviderNames(controller, contentType);
foreach (var provider in providerNames)
{
var providerName = provider;
result = result.SetLast(new DetailActionParamsMapper(controller, contentType, () => providerName));
}
}
}
}
return result;
}
private IUrlParamsMapper GetInferredPagingMapper(ControllerBase controller, string actionName)
{
var actionDescriptor = new ReflectedControllerDescriptor(controller.GetType()).FindAction(controller.ControllerContext, actionName);
if (actionDescriptor == null || actionDescriptor.GetParameters().Length == 0 || actionDescriptor.GetParameters()[0].ParameterType != typeof(int?))
return null;
return new CustomActionParamsMapper(controller, () => "/{" + actionDescriptor.GetParameters()[0].ParameterName + ":int}", actionName);
}
private IUrlParamsMapper GetInferredClassificationFilterMapper(ControllerBase controller, string actionName)
{
var actionDescriptor = new ReflectedControllerDescriptor(controller.GetType()).FindAction(controller.ControllerContext, actionName);
if (actionDescriptor == null || actionDescriptor.GetParameters().Length == 0)
return null;
return new TaxonomyUrlParamsMapper(controller, new TaxonUrlMapper(new TaxonUrlEvaluatorAdapter()));
}
private static string GetViewDirectoryName(ControllerBase controller)
{
return controller.GetType().Name.Replace("Controller", string.Empty);
}
public static string GetName(this ControllerBase controller)
{
return(controller.GetType().Name.Replace("Controller", ""));
}
internal static object ExecuteRequestedMethod(
XmlRpcRequest request,
XmlRpcMethodDescriptor methodDescriptor,
ControllerBase controller)
{
var parameters = new List<object>();
var method = methodDescriptor.MethodInfo;
var requiredParameters = method.GetParameters();
for (var i = 0; i < requiredParameters.Length; i++)
{
var parameter = requiredParameters[i];
var type = parameter.ParameterType;
if (type.IsPrimitive())
{
try
{
var obj = Convert.ChangeType(request.Parameters[i], type);
parameters.Add(obj);
}
catch (ArgumentOutOfRangeException)
{
// Add the default value for the requested type.
parameters.Add(Activator.CreateInstance(type));
}
catch (Exception)
{
parameters.Add(request.Parameters[i]);
}
}
else if (type.IsArray)
{
var elementType = type.GetElementType();
var arrayParameters =
(object[])request.Parameters[i];
var listType = typeof(List<>);
var genericListType = listType.MakeGenericType(elementType);
var list = Activator.CreateInstance(genericListType);
foreach (Dictionary<string, object> values
in arrayParameters)
{
var element = Activator.CreateInstance(elementType);
foreach (var property
in element.GetType().GetProperties())
{
var nameKey = property.GetSerializationName();
object value;
if (values.TryGetValue(nameKey, out value))
{
property.SetValue(element, value);
}
}
list.GetType()
.GetMethod("Add")
.Invoke(
list,
new[] { element });
}
parameters.Add(
list.GetType()
.GetMethod("ToArray")
.Invoke(list, null));
}
else
{
var complexInstanceParameters =
(Dictionary<string, object>)request.Parameters[i];
var complexInstance =
Activator.CreateInstance(type);
foreach (var property in
complexInstance.GetType().GetProperties())
{
var nameKey = property.GetSerializationName();
object value;
if (complexInstanceParameters.TryGetValue(
nameKey,
out value))
{
property.SetValue(complexInstance, value);
}
}
parameters.Add(complexInstance);
}
}
var instanceType = method.DeclaringType;
if (method.DeclaringType != null &&
method.DeclaringType.IsInterface)
{
instanceType = _s_getImplementation(method.DeclaringType);
}
var instance =
controller.GetType() == instanceType
? controller
: Activator.CreateInstance(instanceType);
try
{
Trace.TraceInformation(
"XmlRpcMvc: Invoking method {0} with '{1}'",
method.Name,
string.Join(", ", parameters));
return method.Invoke(instance, parameters.ToArray());
}
catch (XmlRpcFaultException exception)
{
return exception;
}
}
private static string GetDefaultTitle(ControllerBase controller)
{
var title = controller.GetType().Name.Replace("Controller", "");
return Regex.Replace(title, "([a-z](?=[A-Z])|[A-Z](?=[A-Z][a-z]))", "$1 ");
}
