public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (bindingContext.ModelType == typeof(AddSheduleViewModel)) { HttpRequestBase request = controllerContext.HttpContext.Request; var model = base.BindModel(controllerContext, bindingContext) as AddSheduleViewModel; bindingContext.ModelState.Clear(); var shedule = request.Form["Shedule"]; Regex reg = new Regex(@"\d{1,2}:\d{1,2}"); MatchCollection matches = reg.Matches(shedule); if (matches.Count != 0) { try { model.Shedule = matches.Cast<Match>().Select(x => TimeSpan.Parse(x.Value)).ToList(); } catch(Exception ex) { NLog.LogManager.GetCurrentClassLogger().Error(ex); bindingContext.ModelState.AddModelError("", "Неверно заполнено расписание"); } } return model; } else { return base.BindModel(controllerContext, bindingContext); } }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var obj = new DataTablesParam(); var request = controllerContext.HttpContext.Request.Params; obj.iDisplayStart = Convert.ToInt32(request["iDisplayStart"]); obj.iDisplayLength = Convert.ToInt32(request["iDisplayLength"]); obj.iColumns = Convert.ToInt32(request["iColumns"]); obj.sSearch = request["sSearch"]; obj.bEscapeRegex = Convert.ToBoolean(request["bEscapeRegex"]); obj.iSortingCols = Convert.ToInt32(request["iSortingCols"]); obj.sEcho = int.Parse(request["sEcho"]); for (int i = 0; i < obj.iColumns; i++) { obj.bSortable.Add(Convert.ToBoolean(request["bSortable_" + i])); obj.bSearchable.Add(Convert.ToBoolean(request["bSearchable_" + i])); obj.sSearchColumns.Add(request["sSearch_" + i]); obj.bEscapeRegexColumns.Add(Convert.ToBoolean(request["bEscapeRegex_" + i])); obj.iSortCol.Add(Convert.ToInt32(request["iSortCol_" + i])); obj.sSortDir.Add(request["sSortDir_" + i]); } return obj; }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (controllerContext == null) throw new ArgumentNullException("controllerContext", "controllerContext is null."); if (bindingContext == null) throw new ArgumentNullException("bindingContext", "bindingContext is null."); var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); if (value == null) return null; bindingContext.ModelState.SetModelValue(bindingContext.ModelName, value); try { var date = value.ConvertTo(typeof(DateTime), CurrentRequestData.CultureInfo); return date; } catch (Exception ex) { bindingContext.ModelState.AddModelError(bindingContext.ModelName, ex); return null; } }
public override object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var displayFormat = bindingContext.ModelMetadata.DisplayFormatString; var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); if (value.AttemptedValue == "TBD") { return(null); } if (!string.IsNullOrEmpty(displayFormat) && value != null) { DateTime date; displayFormat = displayFormat.Replace("{0:", string.Empty).Replace("}", string.Empty); // use the format specified in the DisplayFormat attribute to parse the date if (DateTime.TryParseExact(value.AttemptedValue, displayFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out date)) { // we always work with UTC times, only in UI we display in local time return(DateTime.SpecifyKind(date, DateTimeKind.Utc)); } else { bindingContext.ModelState.AddModelError( bindingContext.ModelName, string.Format("{0} is an invalid date format", value.AttemptedValue) ); } } return(base.BindModel(controllerContext, bindingContext)); }
public override object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var displayFormat = bindingContext.ModelMetadata.DisplayFormatString; var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); /* * if (!string.IsNullOrEmpty(displayFormat) && value != null) * { * DateTime date; * displayFormat = displayFormat.Replace("{0:", string.Empty).Replace("}", string.Empty); * // use the format specified in the DisplayFormat attribute to parse the date * if (DateTime.TryParseExact(value.AttemptedValue, displayFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out date)) * { * return date; * } * else * { * bindingContext.ModelState.AddModelError( * bindingContext.ModelName, * string.Format("{0} no es un formato de fecha válido", value.AttemptedValue) * ); * } * } */ return(base.BindModel(controllerContext, bindingContext)); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var stringified = controllerContext.HttpContext.Request[bindingContext.ModelName]; if (string.IsNullOrEmpty(stringified)) return null; return Serializer.Deserialize(stringified, bindingContext.ModelType); }
/// <summary> /// Gets the decimal value from data received /// </summary> /// <param name="controllerContext">Controller context</param> /// <param name="bindingContext">Binding context</param> /// <returns>Parsed value</returns> public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { ValueProviderResult result = bindingContext.ValueProvider .GetValue(bindingContext.ModelName); var modelState = new System.Web.Mvc.ModelState { Value = result }; object actualValue = null; var culture = CultureInfo.CurrentCulture; if (result.AttemptedValue != string.Empty) { try { // Try with your current culture actualValue = Convert.ToDecimal(result.AttemptedValue, culture); } catch (FormatException) { try { // Try with invariant culture if current culture failed actualValue = Convert.ToDecimal(result.AttemptedValue, CultureInfo.InvariantCulture); } catch (FormatException ex) { modelState.Errors.Add(ex); } } } bindingContext.ModelState.Add(bindingContext.ModelName, modelState); return(actualValue); }
private static void CheckPropertyFilter(ModelBindingContext bindingContext) { if (bindingContext.ModelType.GetProperties().Select(p => p.Name).Any(name => !bindingContext.PropertyFilter(name))) { throw new InvalidOperationException(MvcResources.ExtensibleModelBinderAdapter_PropertyFilterMustNotBeSet); } }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { CheckPropertyFilter(bindingContext); ExtensibleModelBindingContext newBindingContext = CreateNewBindingContext(bindingContext, bindingContext.ModelName); IExtensibleModelBinder binder = Providers.GetBinder(controllerContext, newBindingContext); if (binder == null && !String.IsNullOrEmpty(bindingContext.ModelName) && bindingContext.FallbackToEmptyPrefix && bindingContext.ModelMetadata.IsComplexType) { // fallback to empty prefix? newBindingContext = CreateNewBindingContext(bindingContext, String.Empty /* modelName */); binder = Providers.GetBinder(controllerContext, newBindingContext); } if (binder != null) { bool boundSuccessfully = binder.BindModel(controllerContext, newBindingContext); if (boundSuccessfully) { // run validation and return the model newBindingContext.ValidationNode.Validate(controllerContext, null /* parentNode */); return newBindingContext.Model; } } return null; // something went wrong }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { IPhotoService<User, PhotoAlbum, Photo, Friend> myPhotoService = new PhotoService<User, PhotoAlbum, Photo, Friend>(new FriendService<User, Friend>(new EntityHAVFriendRepository()), new EntityHAVPhotoAlbumRepository(), new EntityHAVPhotoRepository()); User myUserInfo = HAVUserInformationFactory.GetUserInformation().Details; int myUserId = Int32.Parse(BinderHelper.GetA(bindingContext, "UserId")); int myAlbumId = Int32.Parse(BinderHelper.GetA(bindingContext, "AlbumId")); string myProfilePictureURL = BinderHelper.GetA(bindingContext, "ProfilePictureURL"); string selectedProfilePictureIds = BinderHelper.GetA(bindingContext, "SelectedProfilePictureId").Trim(); IEnumerable<Photo> myPhotos = myPhotoService.GetPhotos(SocialUserModel.Create(myUserInfo), myAlbumId, myUserId); string[] splitIds = selectedProfilePictureIds.Split(','); List<int> selectedProfilePictures = new List<int>(); foreach (string id in splitIds) { if (id != string.Empty) { selectedProfilePictures.Add(Int32.Parse(id)); } } return new PhotosModel() { UserId = myUserId, ProfilePictureURL = myProfilePictureURL, Photos = myPhotos, SelectedPhotos = selectedProfilePictures }; }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { object result = null; var args = new BindModelEvent(controllerContext, bindingContext); StrixPlatform.RaiseEvent(args); if (args.IsBound) { result = args.Result; } else { result = base.BindModel(controllerContext, bindingContext); if (bindingContext.ModelMetadata.Container == null && result != null && result.GetType().Equals(typeof(string))) { if (controllerContext.Controller.ValidateRequest) { int index; if (IsDangerousString((string)result, out index)) { throw new HttpRequestValidationException("Dangerous Input Detected"); } } result = GetSafeValue((string)result); } } return result; }
GetModelProperties(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var toReturn = base.GetModelProperties(controllerContext, bindingContext); List <PropertyDescriptor> additional = new List <PropertyDescriptor>(); //now look for any aliasable properties in here foreach (var p in this.GetTypeDescriptor(controllerContext, bindingContext) .GetProperties().Cast <PropertyDescriptor>()) { foreach (var attr in p.Attributes.OfType <BindAliasAttribute>()) { additional.Add(new AliasedPropertyDescriptor(attr.Alias, p)); if (bindingContext.PropertyMetadata.ContainsKey(p.Name)) { bindingContext.PropertyMetadata.Add(attr.Alias, bindingContext.PropertyMetadata[p.Name]); } } } return(new PropertyDescriptorCollection (toReturn.Cast <PropertyDescriptor>().Concat(additional).ToArray())); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (bindingContext.Model != null) throw new InvalidOperationException("Cannot update instances"); if(controllerContext.RouteData.Values.ContainsKey("r")) { return new ReturnUrl { Url = controllerContext.RouteData.Values["r"].ToString() }; } else if(controllerContext.HttpContext.Request.QueryString["r"] != null) { return new ReturnUrl { Url = controllerContext.HttpContext.Request.QueryString["r"] }; } else if (controllerContext.HttpContext.Request.UrlReferrer != null) { return new ReturnUrl { Url = controllerContext.HttpContext.Request.UrlReferrer.PathAndQuery }; } return new ReturnUrl(); }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var request = controllerContext.HttpContext.Request; var values = request.Headers.GetValues("BoxGentle"); return(JsonConvert.DeserializeObject <Employee>(values.First())); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { //get the car from the session Cart cart = null; if (controllerContext.HttpContext.Session != null) { cart = (Cart)controllerContext.HttpContext.Session[sessionKey]; } //create the Cart if there wasn't one in the session data if(cart == null) { cart = new Cart(); if (controllerContext.HttpContext.Session != null) { controllerContext.HttpContext.Session[sessionKey] = cart; } } return cart; }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (bindingContext == null) { throw new ArgumentNullException("bindingContext"); } DetectionGroup obj = null; string groupId = ModelBinderHelper.FromPostedData<String>(bindingContext, "Key"); if (string.IsNullOrEmpty(groupId)) { groupId = Guid.NewGuid().ToString("N"); obj = (DetectionGroup)(bindingContext.Model ?? new DetectionGroup(groupId, RepositoryFactory.GetRepository<IDetectionCompanyRepository, DetectionCompany>().FindBy(ModelBinderHelper.FromPostedData<String>(bindingContext, "DetectionCompany")), DetectionGroupCategory.Misc)); obj.IsLocked = false; } else { obj = RepositoryFactory.GetRepository<IDetectionGroupRepository, DetectionGroup>().FindBy(groupId); } obj.Name = ModelBinderHelper.FromPostedData<String>(bindingContext, "Name"); obj.Telephone = ModelBinderHelper.FromPostedData<String>(bindingContext, "Telephone"); return obj; }
void ValidateModel(object model, ModelBindingContext bindingContext, List<int> validatedObjects = null) { validatedObjects = validatedObjects ?? new List<int>(); var typeDescriptor = GetTypeDescriptor(model, model.GetType()); // validate the model foreach (ValidationAttribute attribute in typeDescriptor.GetAttributes().OfType<ValidationAttribute>()) { if (!attribute.IsValid (bindingContext.Model)) { bindingContext.ModelState.AddModelError(bindingContext.ModelName, attribute.FormatErrorMessage(bindingContext.ModelName)); } validatedObjects.Add (model.GetHashCode()); } // validate properties, recurse if necessary foreach (PropertyDescriptor property in typeDescriptor.GetProperties()) { var propInstance = property.GetValue (model); foreach (ValidationAttribute attribute in property.Attributes.OfType<ValidationAttribute>()) { if (!attribute.IsValid(propInstance)) { bindingContext.ModelState.AddModelError(property.Name, attribute.FormatErrorMessage(property.Name)); if (propInstance != null) { validatedObjects.Add(propInstance.GetHashCode()); } } else if (propInstance != null) { ValidateModel(propInstance, bindingContext, validatedObjects); } } } }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var pageRequest = new DataTablesRequest { Echo = BindDataTablesRequestParam <Int32>(bindingContext, "sEcho"), DisplayStart = BindDataTablesRequestParam <Int32>(bindingContext, "iDisplayStart"), DisplayLength = BindDataTablesRequestParam <Int32>(bindingContext, "iDisplayLength"), ColumnNames = BindDataTablesRequestParam <string>(bindingContext, "sColumns"), Columns = BindDataTablesRequestParam <Int32>(bindingContext, "iColumns"), Search = BindDataTablesRequestParam <string>(bindingContext, "sSearch"), Regex = BindDataTablesRequestParam <bool>(bindingContext, "bRegex"), SortingCols = BindDataTablesRequestParam <Int32>(bindingContext, "iSortingCols"), DataProp = BindDataTablesRequestParam <string>(controllerContext.HttpContext.Request, "mDataProp_"), RegexColumns = BindDataTablesRequestParam <bool>(controllerContext.HttpContext.Request, "bRegex_"), Searchable = BindDataTablesRequestParam <bool>(controllerContext.HttpContext.Request, "bSearchable_"), Sortable = BindDataTablesRequestParam <bool>(controllerContext.HttpContext.Request, "bSortable_"), SortCol = BindDataTablesRequestParam <Int32>(controllerContext.HttpContext.Request, "iSortCol_"), SearchColumns = BindDataTablesRequestParam <string>(controllerContext.HttpContext.Request, "sSearch_"), SortDir = BindDataTablesRequestParam <string>(controllerContext.HttpContext.Request, "sSortDir_"), CategoryId = BindDataTablesRequestParamstring(bindingContext, "CategoryId"), VendorId = BindDataTablesRequestParamstring(bindingContext, "VendorId") }; return(pageRequest); }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { ProjectNewViewModel model = (ProjectNewViewModel)bindingContext.Model ?? (ProjectNewViewModel)DependencyResolver.Current.GetService(typeof(ProjectNewViewModel)); bool hasPrefix = bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName); string searchPrefix = (hasPrefix) ? bindingContext.ModelName + ".":""; //since viewmodel contains custom types like project make sure project is not null and to pass key arround for value providers //use Project.Name even if your makrup dont have Project prefix model.Project = new Project(); //populate the fields of the model model.Project.ProjectId = 0; model.Project.Name = GetValue(bindingContext, searchPrefix, "Project.Name"); model.Project.Url = GetValue(bindingContext, searchPrefix, "Project.Url"); model.Project.CreatedOn = DateTime.Now; model.Project.UpdatedOn = DateTime.Now; model.Project.isDisabled = GetCheckedValue(bindingContext, searchPrefix, "Project.isDisabled"); model.Project.isFeatured = GetCheckedValue(bindingContext, searchPrefix, "Project.isFeatured"); model.Project.GroupId = int.Parse(GetValue(bindingContext, searchPrefix, "Project.GroupId")); model.Project.Tags = new List<Tag>(); foreach (var tagid in GetValue(bindingContext, searchPrefix, "Tags").Split(',')) { var tag = new Tag { TagId = int.Parse(tagid)}; model.Project.Tags.Add(tag); } var total = model.Project.Tags.Count; return model; }
/// <summary> /// Binds the model to a value by using the specified controller context and binding context. /// </summary> /// <param name="controllerContext">The controller context.</param> /// <param name="bindingContext">The binding context.</param> /// <returns> /// The bound value. /// </returns> public virtual object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { FacebookClient client = _config.ClientProvider.CreateClient(); dynamic signedRequest = FacebookRequestHelpers.GetSignedRequest( controllerContext.HttpContext, rawSignedRequest => { return client.ParseSignedRequest(rawSignedRequest); }); if (signedRequest != null) { string accessToken = signedRequest.oauth_token; string userId = signedRequest.user_id; client.AccessToken = accessToken; return new FacebookContext { Client = client, SignedRequest = signedRequest, AccessToken = accessToken, UserId = userId, Configuration = _config }; } else { bindingContext.ModelState.AddModelError(bindingContext.ModelName, Resources.MissingSignedRequest); } return null; }
public virtual object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (bindingContext == null) { throw new ArgumentNullException("bindingContext"); } ValueProviderResult valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); // case 1: there was no <input ... /> element containing this data if (valueResult == null) { return null; } string value = valueResult.AttemptedValue; // case 2: there was an <input ... /> element but it was left blank if (String.IsNullOrEmpty(value)) { return null; } // Future proofing. If the byte array is actually an instance of System.Data.Linq.Binary // then we need to remove these quotes put in place by the ToString() method. string realValue = value.Replace("\"", String.Empty); return Convert.FromBase64String(realValue); }
public override object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var request = controllerContext.HttpContext.Request; var requestWrapper = new MvcPagingParameters(new NameValueCollection(request.Params)); return(requestWrapper); }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); if (string.IsNullOrEmpty(valueResult.AttemptedValue)) { return(0m); } var modelState = new System.Web.Mvc.ModelState { Value = valueResult }; object actualValue = null; try { actualValue = Convert.ToDecimal( valueResult.AttemptedValue.Replace(",", "."), CultureInfo.InvariantCulture ); } catch (FormatException e) { modelState.Errors.Add(e); } bindingContext.ModelState.Add(bindingContext.ModelName, modelState); return(actualValue); }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var contentType = controllerContext.HttpContext.Request.ContentType; if (!contentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase)) { return(null); } string jsonString; using (var stream = controllerContext.HttpContext.Request.InputStream) { stream.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(stream)) jsonString = reader.ReadToEnd(); } if (string.IsNullOrEmpty(jsonString)) { return(null); } DynamicComplexObject ExtraData = new DynamicComplexObject(); ExtraData.Details = new JavaScriptSerializer().Deserialize <dynamic>(jsonString); return(ExtraData); }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { // Bind normally var model = base.BindModel(controllerContext, bindingContext); if (model == null) return null; // get a validator for the viewmodel var validator = GetValidator(model); if (validator == null) return model; // validate! var validationReport = validator.Validate(model); // valid? if (!validationReport.IsValid) { var violationPropertyNameResolver = new MvcViolationPropertyNameResolver(); foreach (var violation in validationReport.Violations) { // add errors to modelstate bindingContext.ModelState.AddModelError(violationPropertyNameResolver.ResolvePropertyName(violation), violation.ErrorMessage); } } return model; }
/// <summary> /// Binds the model to a value by using the specified controller context and binding context. /// </summary> /// <param name="controllerContext"></param> /// <param name="bindingContext"></param> /// <returns></returns> public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (!controllerContext.HttpContext.Request.IsAuthenticated) return null; var identity = _authenticationService.GetIdentityFromTicket(controllerContext.HttpContext); return identity; }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { string modelName = bindingContext.ModelName; NameValueCollection col = controllerContext.HttpContext.Request.Form; return (List<Guid>)Ext.Net.JSON.Deserialize(col[modelName], typeof(List<Guid>)); }
public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var displayFormat = bindingContext.ModelMetadata.DisplayFormatString; var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); if (!string.IsNullOrEmpty(displayFormat) && value != null) { DateTime date; displayFormat = displayFormat.Replace("{0:", string.Empty).Replace("}", string.Empty); // use the format specified in the DisplayFormat attribute to parse the date if (DateTime.TryParseExact(value.AttemptedValue, displayFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out date)) { return date; } else { bindingContext.ModelState.AddModelError( bindingContext.ModelName, string.Format("{0} is an invalid date format", value.AttemptedValue) ); } } return base.BindModel(controllerContext, bindingContext); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); var date = value.ConvertTo(typeof(DateTime), CultureInfo.CurrentCulture); return date; }
public override object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { object result = null; var name = bindingContext.ModelName; var value = bindingContext.ValueProvider.GetValue(name); if (dateFormat == null) { EvolutionEntities db = new EvolutionEntities(); var mms = new MembershipManagementService.MembershipManagementService(db); var user = mms.User; dateFormat = user.DateFormat; } if (value != null && !string.IsNullOrEmpty(value.AttemptedValue)) { DateTimeOffset date; if (DateTimeOffset.TryParseExact(value.AttemptedValue, dateFormat + " HH:mm:ss", CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out date)) { result = date; } else if (DateTimeOffset.TryParseExact(value.AttemptedValue, dateFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out date)) { result = date; } else { result = base.BindModel(controllerContext, bindingContext); } } return(result); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { ValueProviderResult valueResult = bindingContext.ValueProvider .GetValue(bindingContext.ModelName); ModelState modelState = new ModelState {Value = valueResult}; object actualValue = null; try { if (!string.IsNullOrEmpty(valueResult.AttemptedValue)) { actualValue = Convert.ToDecimal(valueResult.AttemptedValue, CultureInfo.CurrentCulture); } } catch (FormatException e) { modelState.Errors.Add(e); } bindingContext.ModelState.Add(bindingContext.ModelName, modelState); return actualValue; }
protected override bool OnPropertyValidating(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, object value) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } if (bindingContext == null) { throw new ArgumentNullException("bindingContext"); } if (propertyDescriptor == null) { throw new ArgumentNullException("propertyDescriptor"); } if (value is string && controllerContext.HttpContext.Request.ContentType.StartsWith(WebConstants.APPLICATIONJSON, StringComparison.OrdinalIgnoreCase)) { if (controllerContext.Controller.ValidateRequest && bindingContext.PropertyMetadata[propertyDescriptor.Name].RequestValidationEnabled) { int index; if (IsDangerousString(value.ToString(), out index)) { throw new HttpRequestValidationException("Dangerous Input Detected"); } } } return base.OnPropertyValidating(controllerContext, bindingContext, propertyDescriptor, value); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } if (bindingContext == null) { throw new ArgumentNullException("bindingContext"); } try { var message = WSFederationMessage.CreateFromUri(controllerContext.HttpContext.Request.Url); if (!bindingContext.ModelType.IsInstanceOfType(message)) { throw new WSFederationMessageException(); } return message; } catch (WSFederationMessageException ex) { bindingContext.ModelState.AddModelError("", ex); return null; } }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { if (controllerContext == null) { throw new ArgumentNullException("controllerContext"); } return new FormCollection(controllerContext.HttpContext.Request.Form); }
protected override object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType) { string dataRuleTypeStr; string dataruleTypeName = !string.IsNullOrWhiteSpace(bindingContext.ModelName) ? (bindingContext.ModelName + ".DataRuleType") : "DataRuleType"; dataRuleTypeStr = controllerContext.HttpContext.Request[dataruleTypeName]; if (string.IsNullOrEmpty(dataRuleTypeStr)) { return null; } var dataRuleInt = Int32.Parse(dataRuleTypeStr); DataRuleType dataRuleTypeEnum = (DataRuleType)dataRuleInt; object model = null; switch (dataRuleTypeEnum) { case DataRuleType.Folder: model = new FolderDataRule(); break; case DataRuleType.Schema: model = new SchemaDataRule(); break; case DataRuleType.Category: model = new CategoryDataRule(); break; } bindingContext.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()); return model; }
/// <summary> /// Binds the specified property by using the specified controller context and binding context and the specified property descriptor. /// </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> /// <param name="propertyDescriptor">Describes a property to be bound. The descriptor provides information such as the component type, property type, and property value. It also provides methods to get or set the property value.</param> protected override void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor) { if (propertyDescriptor.PropertyType == typeof(AggregateReference<>) || propertyDescriptor.PropertyType == typeof(AggregateReference<>)) { var ag = new AggregateReference(); var form = controllerContext.HttpContext.Request.Form; var name = form.AllKeys.SingleOrDefault(x => x.Equals(propertyDescriptor.Name, StringComparison.InvariantCultureIgnoreCase)); if (!string.IsNullOrEmpty(name)) { var value = form.Get(name); if(value.IsValidGuid()) { ag.Guid = value; } } SetProperty(controllerContext, bindingContext, propertyDescriptor, ag.ToTypedReference()); } else { base.BindProperty(controllerContext, bindingContext, propertyDescriptor); } }
private ToDoController CreateToDoController(object ViewModel = null, bool isAuthorized = true) { MockingHelper.InitMocking(); ToDoController toDoController; if (isAuthorized) { toDoController = new ToDoController(MockingHelper.DBContext, MockingHelper.ApplicationManager); } else { var userStore = new Mock <IUserStore <ApplicationUser> >(); var applicationUserManager = new Mock <UserManager <ApplicationUser> >(userStore.Object); toDoController = new ToDoController(MockingHelper.DBContext, applicationUserManager.Object); } toDoController.ControllerContext = MockingHelper.ControllerContext; if (ViewModel != null) { var modelBinder = new System.Web.Mvc.ModelBindingContext() { ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => ViewModel, ViewModel.GetType()), ValueProvider = new NameValueCollectionValueProvider(new NameValueCollection(), CultureInfo.InvariantCulture) }; var binder = new DefaultModelBinder().BindModel(toDoController.ControllerContext, modelBinder); toDoController.ModelState.Clear(); toDoController.ModelState.Merge(modelBinder.ModelState); } return(toDoController); }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var result = new AdvancedSearchContainerField(); result.Id = int.Parse(bindingContext.ValueProvider.GetValue(bindingContext.ModelName + ".Id").AttemptedValue); ValueProviderResult value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName + ".IsMultiple"); if (value != null) { result.IsMultiple = bool.Parse(((IEnumerable <string>)value.RawValue).FirstOrDefault()); } value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName + ".IsAutoComplete"); if (value != null) { result.IsAutoComplete = bool.Parse(((IEnumerable <string>)value.RawValue).FirstOrDefault()); } value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName + ".IsDropdown"); if (value != null) { result.IsDropdown = bool.Parse(((IEnumerable <string>)value.RawValue).FirstOrDefault()); } value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName + ".SelectedDisplayOption"); if (value != null) { result.SelectedDisplayOption = (eDisplayOption)Enum.Parse(typeof(eDisplayOption), ((IEnumerable <string>)value.RawValue).FirstOrDefault()); } return(result); }
public object BindModel(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { Dictionary <string, string> dic = null; if (bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName)) { dic = new Dictionary <string, string>(); string prefix = bindingContext.ModelName + "."; var form = controllerContext.RequestContext.HttpContext.Request.Unvalidated().Form; foreach (var item in form.AllKeys) { if (item.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)) { var fieldName = item.Substring(prefix.Length); var value = form[item]; if (value == "true,false") { value = "true"; } dic[fieldName] = value; } } } return(dic); }
protected override object CreateModel(ModelBindingContext bindingContext, Type modelType) { if (IsBasicType(modelType)) { return base.GetValue(controllerContext, modelName, modelType, modelState); } if (IsSimpleType(modelType)) { ModelBinderResult } var instance = Activator.CreateInstance(modelType); foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(instance)) { if (IsBasicType(descriptor.PropertyType)) { var obj = GetBinder(descriptor.PropertyType).GetValue(controllerContext, descriptor.Name, descriptor.PropertyType, modelState); descriptor.SetValue(instance, obj); } else { descriptor.SetValue(instance, Activator.CreateInstance(descriptor.PropertyType)); BindComplexType(controllerContext, descriptor.PropertyType, descriptor.GetValue(instance), modelState); } } return instance; }
/// <summary> /// Binds the model to a value by using the specified controller context and binding context. /// </summary> /// <param name="controllerContext">The controller context.</param> /// <param name="bindingContext">The binding context.</param> /// <returns>The bound value.</returns> public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var parameters = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); var sp = parameters != null ? parameters.RawValue as SearchParameters : null; if (sp == null) { var qs = GetParams(controllerContext); var qsDict = NvToDict(qs); var facets = qsDict.Where(k => FacetRegex.IsMatch(k.Key)).Select(k => k.WithKey(FacetRegex.Replace(k.Key, ""))).ToDictionary(x=>x.Key, y=>y.Value.Split(',')); sp = new SearchParameters { FreeSearch = qs["q"].EmptyToNull(), PageIndex = qs["p"].TryParse(1), PageSize = qs["pageSize"].TryParse(0), Sort = qs["sort"].EmptyToNull(), SortOrder = qs["sortorder"].EmptyToNull(), Facets = facets }; if (!string.IsNullOrEmpty(sp.FreeSearch)) { sp.FreeSearch = sp.FreeSearch.EscapeSearchTerm(); } } return sp; }
protected override void SetProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor, object value) { base.SetProperty(controllerContext, bindingContext, propertyDescriptor, value); switch (propertyDescriptor.Name) { case "ClientName" : if (string.IsNullOrEmpty((string)value)) { bindingContext.ModelState.AddModelError("ClientName", ""); } break; case "Date": if((bindingContext.ModelState.IsValidField("Date")) && (DateTime.Now>(DateTime)value)) { bindingContext.ModelState.AddModelError("Date", ""); } break; case "TermsAccepted": if (!(bool)value) { bindingContext.ModelState.AddModelError("TermsAccepted", ""); } break; } }
public static object PerformBindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var idName = string.IsNullOrEmpty(bindingContext.ModelName) ? "id" : bindingContext.ModelName; var valueProviderResult = bindingContext.GetValue(idName); if (valueProviderResult == null) { return null; } var rawId = valueProviderResult.ConvertTo(typeof(string)) as string; var parseResult = HiveId.TryParse(rawId); if (parseResult.Success) { //add the bound value to model state if it's not already there, generally only simple props will be there if (!bindingContext.ModelState.ContainsKey(idName)) { bindingContext.ModelState.Add(idName, new ModelState()); bindingContext.ModelState.SetModelValue(idName, new ValueProviderResult(parseResult.Result, parseResult.Result.ToString(), null)); } } return parseResult.Result; }
protected override object CreateModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, Type modelType) { Employee e = new Employee(); e.FirstName = controllerContext.RequestContext.HttpContext.Request.Form["FName"]; e.LastName = controllerContext.RequestContext.HttpContext.Request.Form["LName"]; e.Salary = int.Parse(controllerContext.RequestContext.HttpContext.Request.Form["Salary"]); return(e); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var model = (AddressSummary)bindingContext.Model ?? new AddressSummary(); model.City = GetValue(bindingContext, "City"); model.Country = GetValue(bindingContext, "Country"); return(model); }
private static string BindDataTablesRequestParamstring(System.Web.Mvc.ModelBindingContext context, string propertyName) { string value = string.Empty; if (context.ValueProvider.GetValue(propertyName) != null) { value = context.ValueProvider.GetValue(propertyName).AttemptedValue; } return(value); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var model = new LoginModel { Login = controllerContext.HttpContext.Request.Form["Login"], Password = controllerContext.HttpContext.Request.Form["Password"] }; return(model); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var file = controllerContext.HttpContext.Request.Files["file"]; var firstName = controllerContext.HttpContext.Request["firstName"]; return(new Model { File = file, FirstName = firstName }); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { Grade grade = controllerContext.HttpContext.Session[GradeSessionKey] as Grade; //<= cookie, niet session if (grade == null) { grade = new Grade(); controllerContext.HttpContext.Session[GradeSessionKey] = grade; } return(grade); }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingcontext) { Cart cart = (Cart)controllerContext.HttpContext.Session[sessionKey]; if (cart == null) { cart = new Cart(); controllerContext.HttpContext.Session[sessionKey] = cart; } return(cart); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { var appUser = UserManager.FindById(controllerContext.HttpContext.User.Identity.GetUserId()); var webUser = new WebUser() { Id = appUser.Id, UserName = appUser.UserName }; return(webUser); }
public Object BindModel(ControllerContext mbctx, System.Web.Mvc.ModelBindingContext bctx) { CarroCompra carroCompra = (CarroCompra)mbctx.HttpContext.Session[ID_SESSION_CARRO]; if (carroCompra == null) { carroCompra = new CarroCompra(); mbctx.HttpContext.Session[ID_SESSION_CARRO] = carroCompra; } return(carroCompra); }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { try { var result = bindingContext.ValueProvider.GetValue(bindingContext.ModelName); return(result == null ? ObjectId.Empty : ObjectId.Parse((string)result.ConvertTo(typeof(string)))); } catch { return(ObjectId.Empty); } }
protected override void SetProperty(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor, object value) { if (propertyDescriptor.PropertyType == typeof(string)) { var stringValue = (string)value; if (!string.IsNullOrEmpty(stringValue)) { stringValue = stringValue.Trim(); } value = stringValue; } base.SetProperty(controllerContext, bindingContext, propertyDescriptor, value); }
string GetValue(ModelBindingContext context, string name) { name = (context.ModelName == string.Empty ? string.Empty : context.ModelName + ".") + name; var result = context.ValueProvider.GetValue(name); if (result == null || result.AttemptedValue == string.Empty) { return("<Not Specified>"); } return(result.AttemptedValue); }
/// <summary> /// Recupera o valor da propriedade. /// </summary> /// <param name="controllerContext"></param> /// <param name="bindingContext"></param> /// <param name="descriptor"></param> /// <param name="loader"></param> /// <param name="propertyName"></param> /// <returns></returns> protected object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, System.ComponentModel.ICustomTypeDescriptor descriptor, string propertyName) { var propertyMetadata = bindingContext.PropertyMetadata[propertyName]; var property = descriptor.GetProperties()[propertyName]; var propertyBinder = this.Binders.GetBinder(property.PropertyType); var propertyBindingContext = new System.Web.Mvc.ModelBindingContext(bindingContext) { ModelMetadata = propertyMetadata, ModelName = CreatePropertyModelName(bindingContext.ModelName, propertyMetadata.PropertyName) }; return(propertyBinder.BindModel(controllerContext, propertyBindingContext)); }
/// <summary> /// Binds the value to the model. /// </summary> /// <param name="controllerContext">The current controller context.</param> /// <param name="bindingContext">The binding context.</param> /// <returns>The new model.</returns> public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { var culture = GetUserCulture(controllerContext); string value = bindingContext.ValueProvider .GetValue(bindingContext.ModelName) .ConvertTo(typeof(string)) as string; double result = 0; double.TryParse(value, NumberStyles.Any, culture, out result); return(result); }
private static List <T> BindDataTableRequestJsonParam <T>(System.Web.Mvc.ModelBindingContext context, string keyPrefix) { List <T> value = new List <T>(); if (context.ValueProvider.GetValue(keyPrefix) != null) { string JsonValue = context.ValueProvider.GetValue(keyPrefix).AttemptedValue; if (JsonValue != string.Empty && JsonValue != null) { value = (ClsWebCommon.JsonDeserialize <List <T> >(JsonValue)) as List <T>; } } return(value); }
public object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext binderContext) { //get the cart from the session Cart cart = (Cart)controllerContext.HttpContext.Session[sessionKey]; if (cart == null) { cart = new Cart(); controllerContext.HttpContext.Session[sessionKey] = cart; } //return the cart return(cart); }
/// <summary> /// To bind the Model to the controller. Checks if the data is indeed json type and deserialiizes it. A global entry has been made in application_start() /// </summary> /// <param name="controllerContext"></param> /// <param name="bindingContext"></param> /// <returns></returns> public override object BindModel(ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext) { if (!IsJSONRequest(controllerContext)) { return(base.BindModel(controllerContext, bindingContext)); } // Get the JSON data that's been posted var request = controllerContext.HttpContext.Request; var jsonStringData = new StreamReader(request.InputStream).ReadToEnd(); //Use the built-in serializer return(new JavaScriptSerializer().Deserialize(jsonStringData, bindingContext.ModelMetadata.ModelType)); }