public static DateTime ParseDate(ValueProviderResult value)
{
// Create an array of all supported standard date and time format specifiers.
string[] formats = {"d", "D", "f", "F", "g", "G", "m", "o", "r",
"s", "t", "T", "u", "U", "Y", "dd/MM/yyyy hh:mm:ss", "MM/dd/yyyy hh:mm:ss"};
//
CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("de-DE"),
CultureInfo.CreateSpecificCulture("en-US"),
CultureInfo.CreateSpecificCulture("he-IL"),
CultureInfo.CreateSpecificCulture("es-ES"),
CultureInfo.CreateSpecificCulture("fr-FR")};
var parsedSuccesfuly = false;
int cultureIndex = 0;
DateTime foundDateTime = DateTime.MinValue;
while (!parsedSuccesfuly && cultureIndex < cultures.Length)
{
parsedSuccesfuly = DateTime.TryParseExact(value.AttemptedValue, formats, cultures[cultureIndex], DateTimeStyles.None, out foundDateTime);
cultureIndex++;
}
if (parsedSuccesfuly)
{
return foundDateTime;
}
throw new FormatException("Could not parse the specified date, culture is not supported");
}
internal static object GetModelValue(ValueProviderResult result, Type memberType)
{
var memberMapping = ModelMappingManager.MappingFor(memberType);
var descriptor = new ModelDescriptor(memberMapping);
var value = result.ConvertTo(descriptor.KeyProperty.PropertyType);
return memberMapping.Configuration.Repository().Find(value);
}
public ValueProviderResult GetValue(string key)
{
ValueProviderResult result;
result = new ValueProviderResult(data,
"Id", CultureInfo.CurrentCulture);
return result;
}
protected virtual ValueProviderResult GetValue(string key)
{
ValueProviderResult res = null;
string val = this._context.HttpContext.Request.Form[key.Replace('.', '[')+']'] as string;
if (val != null)
res = new ValueProviderResult(val, val, CultureInfo.CurrentCulture);
return res;
}
/// <summary>
/// </summary>
/// <param name="result"></param>
/// <param name="sessionWrapper"></param>
/// <exception cref="ArgumentNullException"></exception>
public NHValueProviderResult(ValueProviderResult result, SessionWrapper sessionWrapper)
{
_result = result;
_sessionWrapper = sessionWrapper;
AttemptedValue = result.AttemptedValue;
Culture = result.Culture;
RawValue = result.RawValue;
}
private void SetModelState(ModelBindingContext bindingContext, ValueProviderResult valueProviderResult)
{
ModelState modelState;
if (!bindingContext.ModelState.TryGetValue(bindingContext.ModelName, out modelState))
{
bindingContext.ModelState.Add(bindingContext.ModelName, modelState = new ModelState());
}
modelState.Value = valueProviderResult;
}
public void ConvertToCanConvertArraysToSingleElements() {
// Arrange
ValueProviderResult vpr = new ValueProviderResult(new int[] { 1, 20, 42 }, "", CultureInfo.InvariantCulture);
// Act
string converted = (string)vpr.ConvertTo(typeof(string));
// Assert
Assert.AreEqual("1", converted);
}
public ValueProviderResult GetValue(string key)
{
ValueProviderResult result=null;
if (this.dictionary.ContainsKey(key))
{
result = new ValueProviderResult(this.dictionary[key],
this.dictionary[key], CultureInfo.CurrentCulture);
}
return result;
}
/// <summary>
/// Creates the list of ministries selected by the system users
/// </summary>
/// <param name="result"></param>
/// <returns></returns>
private static List<MinistryModel> BindMinistryModels(ValueProviderResult result)
{
var rawValue = result.RawValue as string[];
if (rawValue == null || rawValue.Length == 0)
{
return null;
}
List<MinistryModel> models = ManageMinistryModelHelper.GetMinistryModels(rawValue);
return models;
}
public void ConvertToCanConvertSingleElementsToSingleElements() {
// Arrange
ValueProviderResult vpr = new ValueProviderResult(42, "", CultureInfo.InvariantCulture);
// Act
string converted = (string)vpr.ConvertTo(typeof(string));
// Assert
Assert.IsNotNull(converted);
Assert.AreEqual("42", converted);
}
public void ConvertToChecksTypeConverterCanConvertFrom() {
// Arrange
object original = "someValue";
ValueProviderResult vpr = new ValueProviderResult(original, null, CultureInfo.GetCultureInfo("fr-FR"));
// Act
DefaultModelBinderTest.StringContainer returned = (DefaultModelBinderTest.StringContainer)vpr.ConvertTo(typeof(DefaultModelBinderTest.StringContainer));
// Assert
Assert.AreEqual(returned.Value, "someValue (fr-FR)");
}
private static string BindStartEndTime(ValueProviderResult result)
{
var rawValue = result.RawValue as string;
if (string.IsNullOrEmpty(rawValue))
{
return null;
}
// Is time valid?
Convert.ToDateTime(string.Format("1/1/2012 {0}", rawValue));
return rawValue.Trim();
}
public void GetValue_should_not_throw_exception_when_try_to_convert_value_from_ModelState()
{
result = new ValueProviderResult("11/22/2000", "11/22/2000", new CultureInfo("en-US"));
state = new ModelState();
state.Value = result;
viewContext.ViewData.ModelState.Remove("DatePicker1");
viewContext.ViewData.ModelState.Add("DatePicker1", state);
System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");
Assert.DoesNotThrow(() => datepicker.GetValue(o => (DateTime?)o));
}
public InputComponentExtensionsTests()
{
viewContext = TestHelper.CreateViewContext();
datepicker = DatePickerTestHelper.CreateDatePicker(null, viewContext);
datepicker.Name = "DatePicker1";
result = new ValueProviderResult("s", "s", System.Threading.Thread.CurrentThread.CurrentCulture);
state = new ModelState();
state.Value = result;
viewContext.ViewData.ModelState.Add("DatePicker1", state);
currentCulture = CultureInfo.CurrentCulture;
}
public static bool TryGetValue(this IValueProvider valueProvider, string key, out ValueProviderResult result)
{
try
{
result = valueProvider.GetValue(key);
return true;
}
catch
{
result = null;
return false;
}
}
internal static object GetNonModelValue(ValueProviderResult result, Type memberType)
{
var innerType = Nullable.GetUnderlyingType(memberType) ?? memberType;
if (innerType.IsEnum)
return Enum.Parse(innerType, result.AttemptedValue);
var value = innerType == typeof(Boolean)
? result.AttemptedValue.Split(',')[0]
: result.AttemptedValue;
return TypeDescriptor.GetConverter(innerType).ConvertFrom(null, CultureInfo.CurrentCulture, value);
}
public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo)
{
bool isValidName = false;
string keyValue = string.Format("{0}:{1}", Name, Argument);
var value = controllerContext.Controller.ValueProvider.GetValue(keyValue);
if (value != null) {
value = new ValueProviderResult(Argument, Argument, null);
controllerContext.Controller.ControllerContext.RouteData.Values[Name] = Argument;
isValidName = true;
}
return isValidName;
}
public void ConstructorSetsProperties() {
// Arrange
object rawValue = new object();
string attemptedValue = "some string";
CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
// Act
ValueProviderResult result = new ValueProviderResult(rawValue, attemptedValue, culture);
// Assert
Assert.AreSame(rawValue, result.RawValue);
Assert.AreSame(attemptedValue, result.AttemptedValue);
Assert.AreSame(culture, result.Culture);
}
public IDictionary<string, ValueProviderResult> ToValueProvider() {
CultureInfo currentCulture = CultureInfo.CurrentCulture;
Dictionary<string, ValueProviderResult> dict = new Dictionary<string, ValueProviderResult>(StringComparer.OrdinalIgnoreCase);
string[] keys = AllKeys;
foreach (string key in keys) {
string[] rawValue = GetValues(key);
string attemptedValue = this[key];
ValueProviderResult vpResult = new ValueProviderResult(rawValue, attemptedValue, currentCulture);
dict[key] = vpResult;
}
return dict;
}
public void ConvertToCanConvertArraysToArrays() {
// Arrange
ValueProviderResult vpr = new ValueProviderResult(new int[] { 1, 20, 42 }, "", CultureInfo.InvariantCulture);
// Act
string[] converted = (string[])vpr.ConvertTo(typeof(string[]));
// Assert
Assert.IsNotNull(converted);
Assert.AreEqual(3, converted.Length);
Assert.AreEqual("1", converted[0]);
Assert.AreEqual("20", converted[1]);
Assert.AreEqual("42", converted[2]);
}
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
ValueProviderResult valueResultHours = bindingContext.ValueProvider
.GetValue(bindingContext.ModelName + ".Hours");
ValueProviderResult valueResultMinutes = bindingContext.ValueProvider
.GetValue(bindingContext.ModelName + ".Minutes");
ValueProviderResult valueResultSeconds = bindingContext.ValueProvider
.GetValue(bindingContext.ModelName + ".Seconds");
if (valueResultHours != null || valueResultMinutes != null | valueResultSeconds != null)
{
int hours = 0;
int minutes = 0;
int seconds = 0;
TimeSpan? actualValue = null;
var valueResult = new ValueProviderResult(null, string.Empty, System.Globalization.CultureInfo.CurrentCulture);
var modelState = new ModelState { Value = valueResult };
try
{
if (valueResultHours != null)
{
hours = int.Parse(valueResultHours.AttemptedValue);
}
if (valueResultMinutes != null)
{
minutes = int.Parse(valueResultMinutes.AttemptedValue);
}
if (valueResultSeconds != null)
{
seconds = int.Parse(valueResultSeconds.AttemptedValue);
}
actualValue = new TimeSpan(hours, minutes, seconds);
}
catch (FormatException e)
{
modelState.Errors.Add(e);
}
bindingContext.ModelState.Add(bindingContext.ModelName, modelState);
return actualValue;
}
else
{
return base.BindModel(controllerContext, bindingContext);
}
}
private static bool? GetBooleanValue(ValueProviderResult valueProviderResult)
{
string attemptedValue = ((valueProviderResult != null) ? valueProviderResult.AttemptedValue : null)
?? string.Empty;
switch (attemptedValue)
{
case "0":
return false;
case "1":
return true;
default:
return null;
}
}
private void AddValues(NameValueCollection collection, CultureInfo culture) {
if (collection.Count > 0) {
_prefixes.Add("");
}
foreach (string key in collection) {
if (key != null) {
_prefixes.UnionWith(ValueProviderUtil.GetPrefixes(key));
string[] rawValue = collection.GetValues(key);
string attemptedValue = collection[key];
_values[key] = new ValueProviderResult(rawValue, attemptedValue, culture);
}
}
}
protected void HandleHttpRequestValidationException(System.Web.Mvc.ModelBindingContext bindingContext, HttpRequestValidationException ex)
{
var valueProviderCollection = bindingContext.ValueProvider as System.Web.Mvc.ValueProviderCollection;
if (valueProviderCollection != null)
{
System.Web.Mvc.ValueProviderResult valueProviderResult = valueProviderCollection.GetValue(bindingContext.ModelName, skipValidation: true);
bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
}
string errorMessage = string.Format(CultureInfo.CurrentCulture, "{0} contém caracteres inválidos: <, & ou >",
bindingContext.ModelMetadata.DisplayName);
bindingContext.ModelState.AddModelError(bindingContext.ModelName, errorMessage);
}
public IDictionary<string, ValueProviderResult> ToValueProvider()
{
var currentCulture = CultureInfo.CurrentCulture;
var dictionary = new Dictionary<string, ValueProviderResult>(StringComparer.OrdinalIgnoreCase);
foreach (var str in this.AllKeys)
{
var values = this.GetValues(str);
var attemptedValue = base[str];
var result = new ValueProviderResult(values, attemptedValue, currentCulture);
dictionary[str] = result;
}
return dictionary;
}
/// <summary>
/// Vyparsuje dateTime vo formate ISO 8601
/// </summary>
/// <param name="value">Hodnota ktoru chceme parsovat</param>
/// <returns>DateTime alebo null</returns>
private Decimal? parseDecimal(ValueProviderResult value)
{
NumberFormatInfo numberFormatInfo = new NumberFormatInfo();
numberFormatInfo.NumberDecimalDigits = 2;
numberFormatInfo.NumberDecimalSeparator = ".";
Decimal decimalValue = 0;
if (Decimal.TryParse(value.AttemptedValue.Replace(",", "."), NumberStyles.Any, numberFormatInfo, out decimalValue))
{
return decimalValue;
}
else
{
return null;
}
}
private TableRequest GetPropertyValues(TableRequest request, ValueProviderResult filtersValueResult)
{
var filters = (string)filtersValueResult.ConvertTo(typeof(string));
var appliedFilters = JObject.Parse(filters);
var tokens = appliedFilters.Children();
var Name = "";
var Surname = "";
var Role = Roles.All;
int? Id = null;
var index = 0;
foreach (var token in tokens)
{
if (index != 0)
{
for (var j = 0; j < token.First.Count(); j++)
{
var currentToken = token.First[j];
if (currentToken.Value<string>("field").Equals("Name"))
{
Name = currentToken["data"].ToString().Trim();
}
if (currentToken.Value<string>("field").Equals("Surname"))
{
Surname = currentToken["data"].ToString().Trim();
}
if (currentToken.Value<string>("field").Equals("Position"))
{
Role = (Roles)(Enum.Parse(typeof(Roles), currentToken["data"].ToString().Trim()));
}
if (currentToken.Value<string>("field").Equals("Id"))
{
Id = Convert.ToInt32(currentToken["data"].ToString().Trim());
}
}
}
index++;
}
request.Name = Name.Trim();
request.Surname = Surname.Trim();
request.Role = Role;
request.Id = Id;
return request;
}
private void AddValues(HttpSessionStateBase session)
{
if (session.Keys.Count > 0)
{
_prefixes.Add("");
}
foreach (string key in session.Keys)
{
if (key != null)
{
_prefixes.Add(key);
object rawValue = session[key];
string attemptedValue = session[key].ToString();
_values[key] = new ValueProviderResult(
rawValue,
attemptedValue,
CultureInfo.CurrentCulture);
}
}
}
/// <summary>
/// Binds the model by using the specified controller context and binding context.
/// </summary>
/// <param name="controllerContext">The context within which the controller operates. The context information includes the controller, HTTP content, request context, and route data.</param>
/// <param name="bindingContext">The context within which the model is bound. The context includes information such as the model object, model name, model type, property filter, and value provider.</param>
/// <returns>The bound object.</returns>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="bindingContext " />parameter is null.</exception>
public object BindModel( ControllerContext controllerContext, ModelBindingContext bindingContext )
{
if( bindingContext == null )
{
throw new ArgumentNullException( "bindingContext" );
}
string checkBoxListKey = string.Format( "{0}.{1}", bindingContext.ModelName, CheckBoxListItemExtensions.CheckBoxListHiddenName );
ValueProviderResult isCheckBoxListResult = bindingContext.ValueProvider.GetValue( checkBoxListKey );
if( isCheckBoxListResult != null )
{
if( bindingContext.ValueProvider.GetValue( bindingContext.ModelName ) == null )
{
var emptyValueResult = new ValueProviderResult( new string[] { }, string.Empty, isCheckBoxListResult.Culture );
bindingContext.ModelState.SetModelValue( bindingContext.ModelName, emptyValueResult );
return null;
}
}
return System.Web.Mvc.ModelBinders.Binders.DefaultBinder.BindModel( controllerContext, bindingContext );
}
public virtual object BindModel(
ControllerContext controllerContext,
ModelBindingContext bindingContext
)
{
RuntimeHelpers.EnsureSufficientExecutionStack();
if (bindingContext == null)
{
throw new ArgumentNullException("bindingContext");
}
bool performedFallback = false;
if (
!String.IsNullOrEmpty(bindingContext.ModelName) &&
!bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName)
)
{
// We couldn't find any entry that began with the prefix. If this is the top-level element, fall back
// to the empty prefix.
if (bindingContext.FallbackToEmptyPrefix)
{
bindingContext = new ModelBindingContext()
{
ModelMetadata = bindingContext.ModelMetadata,
ModelState = bindingContext.ModelState,
PropertyFilter = bindingContext.PropertyFilter,
ValueProvider = bindingContext.ValueProvider
};
performedFallback = true;
}
else
{
return(null);
}
}
// Simple model = int, string, etc.; determined by calling TypeConverter.CanConvertFrom(typeof(string))
// or by seeing if a value in the request exactly matches the name of the model we're binding.
// Complex type = everything else.
if (!performedFallback)
{
bool performRequestValidation = ShouldPerformRequestValidation(
controllerContext,
bindingContext
);
ValueProviderResult valueProviderResult =
bindingContext.UnvalidatedValueProvider.GetValue(
bindingContext.ModelName,
skipValidation: !performRequestValidation
);
if (valueProviderResult != null)
{
return(BindSimpleModel(controllerContext, bindingContext, valueProviderResult));
}
}
if (!bindingContext.ModelMetadata.IsComplexType)
{
return(null);
}
return(BindComplexModel(controllerContext, bindingContext));
}
public void SetModelValue(string key, ValueProviderResult value)
{
GetModelStateForKey(key).Value = value;
}
private static object ConvertProviderResult(ModelStateDictionary modelState, string modelStateKey, ValueProviderResult valueProviderResult, Type destinationType)
{
try
{
object convertedValue = valueProviderResult.ConvertTo(destinationType);
return(convertedValue);
}
catch (Exception ex)
{
modelState.AddModelError(modelStateKey, ex);
return(null);
}
}
internal object BindSimpleModel(ControllerContext controllerContext, ModelBindingContext bindingContext, ValueProviderResult valueProviderResult)
{
bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
// if the value provider returns an instance of the requested data type, we can just short-circuit
// the evaluation and return that instance
if (bindingContext.ModelType.IsInstanceOfType(valueProviderResult.RawValue))
{
return(valueProviderResult.RawValue);
}
// since a string is an IEnumerable<char>, we want it to skip the two checks immediately following
if (bindingContext.ModelType != typeof(string))
{
// conversion results in 3 cases, as below
if (bindingContext.ModelType.IsArray)
{
// case 1: user asked for an array
// ValueProviderResult.ConvertTo() understands array types, so pass in the array type directly
object modelArray = ConvertProviderResult(bindingContext.ModelState, bindingContext.ModelName, valueProviderResult, bindingContext.ModelType);
return(modelArray);
}
Type enumerableType = TypeHelpers.ExtractGenericInterface(bindingContext.ModelType, typeof(IEnumerable <>));
if (enumerableType != null)
{
// case 2: user asked for a collection rather than an array
// need to call ConvertTo() on the array type, then copy the array to the collection
object modelCollection = CreateModel(controllerContext, bindingContext, bindingContext.ModelType);
Type elementType = enumerableType.GetGenericArguments()[0];
Type arrayType = elementType.MakeArrayType();
object modelArray = ConvertProviderResult(bindingContext.ModelState, bindingContext.ModelName, valueProviderResult, arrayType);
Type collectionType = typeof(ICollection <>).MakeGenericType(elementType);
if (collectionType.IsInstanceOfType(modelCollection))
{
CollectionHelpers.ReplaceCollection(elementType, modelCollection, modelArray);
}
return(modelCollection);
}
}
// case 3: user asked for an individual element
object model = ConvertProviderResult(bindingContext.ModelState, bindingContext.ModelName, valueProviderResult, bindingContext.ModelType);
return(model);
}
public void ConvertToChecksTypeConverterCanConvertTo() {
// Arrange
object original = new DefaultModelBinderTest.StringContainer("someValue");
ValueProviderResult vpr = new ValueProviderResult(original, "", CultureInfo.GetCultureInfo("en-US"));
// Act
string returned = (string)vpr.ConvertTo(typeof(string));
// Assert
Assert.AreEqual(returned, "someValue (en-US)");
}
public void CulturePropertyDefaultsToInvariantCulture() {
// Arrange
ValueProviderResult result = new ValueProviderResult(null, null, null);
// Act & assert
Assert.AreSame(CultureInfo.InvariantCulture, result.Culture);
}