/// <summary>
/// Binds a controller's parameter to a value.
/// </summary>
/// <param name="controller">The controller</param>
/// <param name="parameterInfo">The parameter</param>
/// <returns>The parsed value</returns>
/// <exception cref="RailsException">
/// If it could not find the <c>ParseElement</c> or <c>ParseArray</c> method.
/// </exception>
public object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
Type type = parameterInfo.ParameterType;
bool isArray = type.HasElementType;
if (isArray)
{
type = type.GetElementType();
}
string methodName = "Parse" + (isArray ? "Array" : "Element");
Type[] methodSig = isArray ? ParseArraySignature : ParseElementSignature;
MethodInfo mi = type.GetMethod(methodName, ParseBindingFlags, null, methodSig, null);
if (mi == null)
{
throw new RailsException(String.Format("Parsing {0} is not supported by the {1} class. Make sure the class implements a public static {2}(String) method.", (isArray ? "an array" : "an element"), type, methodName));
}
object vals = isArray
? (object)GetParameterValues(controller, parameterInfo)
: GetParameterValue(controller, parameterInfo);
return(mi.Invoke(null, new object[] { vals }));
}
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
if (String.IsNullOrEmpty(parameterName))
parameterName = parameterInfo.Name;
return String.IsNullOrEmpty(controller.Request.Params[parameterName]) ? 0 : 100;
}
int IParameterBinder.CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
return
(controller.Params.Keys
.OfType <string>()
.Where(s => !String.IsNullOrEmpty(s))
.Any(expr.IsMatch) ? 20 : 0);
}
int IParameterBinder.CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
return
controller.Params.Keys
.OfType<string>()
.Where(s => !String.IsNullOrEmpty(s))
.Any(expr.IsMatch) ? 20 : 0;
}
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
if (String.IsNullOrEmpty(parameterName))
{
parameterName = parameterInfo.Name;
}
return(String.IsNullOrEmpty(controller.Request.Params[parameterName]) ? 0 : 100);
}
public object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
if (String.IsNullOrEmpty(parameterName))
parameterName = parameterInfo.Name;
string value = controller.Request.Params[parameterName];
if (String.IsNullOrEmpty(value))
return null;
using (var s3des = new SimpleTripleDES(key))
return s3des.DecryptObjectFromBase64(AdjustBase64ForUrlUsage(false, value));
}
object IParameterBinder.Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
var genArgs = parameterInfo.ParameterType.GetGenericArguments();
var keyType = genArgs[0];
var valType = genArgs[1];
var keyModel = ActiveRecordModel.GetModel(keyType);
var valModel = ActiveRecordModel.GetModel(valType);
var keyPKType = keyModel == null ? NormalizeNullable(keyType) : keyModel.PrimaryKey.Property.PropertyType;
var valPKType = valModel == null ? NormalizeNullable(valType) : valModel.PrimaryKey.Property.PropertyType;
var dict = (IDictionary) Activator.CreateInstance(parameterInfo.ParameterType);
foreach (string requestKey in controller.Params.Keys)
{
if (String.IsNullOrEmpty(requestKey))
continue;
var m = expr.Match(requestKey);
if (!m.Success)
continue;
var keyContents = Convert.ChangeType(m.Groups[1].Value, keyPKType);
if (keyModel != null)
keyContents = ActiveRecordMediator.FindByPrimaryKey(keyType, keyContents);
var valContents = (object) controller.Params[requestKey];
if (String.Empty.Equals(valContents))
valContents = null;
if (valContents != null)
{
valContents = Convert.ChangeType(valContents, valPKType);
if (valModel != null)
valContents = ActiveRecordMediator.FindByPrimaryKey(valType, valContents);
}
// If the value is empty and this is a ValueType, get the default value for the ValueType
if (valContents == null && valType.IsValueType)
valContents = Activator.CreateInstance(valType);
if (AllowDuplicates)
dict[keyContents] = valContents;
else
dict.Add(keyContents, valContents);
}
return dict;
}
public object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
if (String.IsNullOrEmpty(parameterName))
{
parameterName = parameterInfo.Name;
}
string value = controller.Request.Params[parameterName];
if (String.IsNullOrEmpty(value))
{
return(null);
}
using (var s3des = new SimpleTripleDES(key))
return(s3des.DecryptObjectFromBase64(AdjustBase64ForUrlUsage(false, value)));
}
/// <summary>
/// Binds a controller's parameter to a value.
/// </summary>
/// <param name="controller">The controller</param>
/// <param name="parameterInfo">The parameter</param>
/// <returns>The parsed value</returns>
/// <exception cref="RailsException">
/// If it could not find the <c>ParseElement</c> or <c>ParseArray</c> method.
/// </exception>
public object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
Type type = parameterInfo.ParameterType;
bool isArray = type.HasElementType;
if (isArray)
type = type.GetElementType();
string methodName = "Parse" + (isArray ? "Array" : "Element");
Type[] methodSig = isArray ? ParseArraySignature : ParseElementSignature;
MethodInfo mi = type.GetMethod(methodName, ParseBindingFlags, null, methodSig, null);
if (mi == null)
throw new RailsException(String.Format("Parsing {0} is not supported by the {1} class. Make sure the class implements a public static {2}(String) method.", (isArray ? "an array" : "an element"), type, methodName));
object vals = isArray
? (object) GetParameterValues(controller, parameterInfo)
: GetParameterValue(controller, parameterInfo);
return mi.Invoke(null, new object[] { vals });
}
/// <summary>
/// Calculates the param points. Implementors should return value equals or greater than
/// zero indicating whether the parameter can be bound successfully. The greater the value (points)
/// the more successful the implementation indicates to the framework
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="parameterInfo">The parameter info.</param>
/// <returns></returns>
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
return controller.Params[entryKey] != null ? 1 : 0;
}
private string GetParameterValue(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
return(controller.Request.Params.Get(GetParameterName(parameterInfo)));
}
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
return(10);
}
public object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
Stream inputStream = controller.Context.UnderlyingContext.Request.InputStream;
return(CreateValueFromInputStream(parameterInfo.ParameterType, inputStream));
}
public static void Make(SmartDispatcherController controller)
{
new Sort(controller.Query).Apply(controller.PropertyBag);
}
public virtual int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
String paramName = RequestParameterName != null ? RequestParameterName : parameterInfo.Name;
return controller.Request.Params.Get(paramName) != null ? 10 : 0;
}
public override object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
ARDataBinder binder = (ARDataBinder) CreateBinder();
ConfigureValidator(controller, binder);
binder.AutoLoad = autoLoad;
CompositeNode node = controller.ObtainParamsNode(From);
object instance = binder.BindObject(parameterInfo.ParameterType, Prefix, Exclude, Allow, Expect, node);
BindInstanceErrors(controller, binder, instance);
PopulateValidatorErrorSummary(controller, binder, instance);
return instance;
}
/// <summary>
/// Binds the instance errors.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="binder">The binder.</param>
/// <param name="instance">The instance.</param>
protected void BindInstanceErrors(SmartDispatcherController controller, IDataBinder binder, object instance)
{
if (instance != null)
{
controller.BoundInstanceErrors[instance] = binder.ErrorList;
}
}
/// <summary>
/// Populates the validator error summary.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="binder">The binder.</param>
/// <param name="instance">The instance.</param>
protected void PopulateValidatorErrorSummary(SmartDispatcherController controller, IDataBinder binder, object instance)
{
if (validate)
{
controller.PopulateValidatorErrorSummary(instance, binder);
}
}
/// <summary>
/// Configures the validator.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="binder">The binder.</param>
protected void ConfigureValidator(SmartDispatcherController controller, IDataBinder binder)
{
if (validate)
{
binder.Validator = controller.Validator;
}
else
{
binder.Validator = null;
}
}
/// <summary>
/// Implementation of <see cref="IParameterBinder.Bind"/>
/// and it is used to read the data available and construct the
/// parameter type accordingly.
/// </summary>
/// <param name="controller">The controller instance</param>
/// <param name="parameterInfo">The parameter info</param>
/// <returns>The bound instance</returns>
public virtual object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
IDataBinder binder = CreateBinder();
ConfigureValidator(controller, binder);
CompositeNode node = controller.ObtainParamsNode(From);
object instance = binder.BindObject(parameterInfo.ParameterType, prefix, exclude, allow, node);
BindInstanceErrors(controller, binder, instance);
PopulateValidatorErrorSummary(controller, binder, instance);
return instance;
}
/// <summary>
/// Implementation of <see cref="IParameterBinder.CalculateParamPoints"/>
/// and it is used to give the method a weight when overloads are available.
/// </summary>
/// <param name="controller">The controller instance</param>
/// <param name="parameterInfo">The parameter info</param>
/// <returns>Positive value if the parameter can be bound</returns>
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
CompositeNode node = controller.ObtainParamsNode(From);
IDataBinder binder = CreateBinder();
return binder.CanBindObject(parameterInfo.ParameterType, prefix, node) ? 10 : 0;
}
/// <summary>
/// Binds the specified parameter for the action.
/// </summary>
/// <param name="controller">The controller.</param>
/// <param name="parameterInfo">The parameter info.</param>
/// <returns>A instance based on the JSON values present in the <see cref="EntryKey"/>.</returns>
public object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
string entryValue = controller.Params[entryKey];
return Bind(entryValue, parameterInfo.ParameterType);
}
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
string val = GetParameterValue(controller, parameterInfo);
return String.IsNullOrEmpty(val) ? 0 : 10;
}
public object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
Stream inputStream = controller.Context.UnderlyingContext.Request.InputStream;
return CreateValueFromInputStream(parameterInfo.ParameterType, inputStream);
}
private string GetParameterValue(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
return controller.Request.Params.Get(GetParameterName(parameterInfo));
}
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
return 10;
}
public static MonorailMailer Mailer(this SmartDispatcherController controller)
{
return(controller.Mailer <MonorailMailer>());
}
public int CalculateParamPoints(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
string val = GetParameterValue(controller, parameterInfo);
return(String.IsNullOrEmpty(val) ? 0 : 10);
}
object IParameterBinder.Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
var genArgs = parameterInfo.ParameterType.GetGenericArguments();
var keyType = genArgs[0];
var valType = genArgs[1];
var keyModel = ActiveRecordModel.GetModel(keyType);
var valModel = ActiveRecordModel.GetModel(valType);
var keyPKType = keyModel == null?NormalizeNullable(keyType) : keyModel.PrimaryKey.Property.PropertyType;
var valPKType = valModel == null?NormalizeNullable(valType) : valModel.PrimaryKey.Property.PropertyType;
var dict = (IDictionary)Activator.CreateInstance(parameterInfo.ParameterType);
foreach (string requestKey in controller.Params.Keys)
{
if (String.IsNullOrEmpty(requestKey))
{
continue;
}
var m = expr.Match(requestKey);
if (!m.Success)
{
continue;
}
var keyContents = Convert.ChangeType(m.Groups[1].Value, keyPKType);
if (keyModel != null)
{
keyContents = ActiveRecordMediator.FindByPrimaryKey(keyType, keyContents);
}
var valContents = (object)controller.Params[requestKey];
if (String.Empty.Equals(valContents))
{
valContents = null;
}
if (valContents != null)
{
valContents = Convert.ChangeType(valContents, valPKType);
if (valModel != null)
{
valContents = ActiveRecordMediator.FindByPrimaryKey(valType, valContents);
}
}
// If the value is empty and this is a ValueType, get the default value for the ValueType
if (valContents == null && valType.IsValueType)
{
valContents = Activator.CreateInstance(valType);
}
if (AllowDuplicates)
{
dict[keyContents] = valContents;
}
else
{
dict.Add(keyContents, valContents);
}
}
return(dict);
}
public virtual object Bind(SmartDispatcherController controller, ParameterInfo parameterInfo)
{
ARFetcher fetcher = new ARFetcher(controller.Binder.Converter);
return fetcher.FetchActiveRecord(parameterInfo, this, controller.Request);
}
