/// <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); }