Suppose this view :
#Html.HiddenFor(model => model.Batiment.Client.Id)
#Html.LabelFor(model => model.Batiment.Code)</td>
#Html.EditorFor(model => model.Batiment.Code)</td>
<br>
#Html.LabelFor(model => model.Batiment.Nom)</td>
#Html.EditorFor(model => model.Batiment.Nom)</td>
When I submit my form on the controler the ModelState is invalid for the property "Nom" required into my class Client. Is true, the metadata in my class Client is set to required but I dont include this field into my view...! Why Mvc raise this error?
Can I hide a field (like Id) without specify all the required field into my view?
Errors enter model state during binding, therefore you could exclude your property from binding by including the following in your action method signature:
public ActionResult Register([Bind(Exclude="PropertyName")] UserViewModel user)
{
// Your logic here
}
This should exclude PropertyName from binding, therefore error won't enter your model state and your validation should succeed. Just to add, I think that this is more of a hack, rathern then solution. If you need only a part of your view model, than this view model should not be used and you should really consider creating a new view model without this property.
It might look very similar and it might seem like duplicate code, but it isn't. It promotes seperation of concerns and you should see the benefit of doing this in the near future when it comes to extending/modifying your application.
No, the validation is done on the model, not the view, why it is called 'model state'
You need to create another view for this scenario. This is exactly what ViewModels are for.
Then you can use a tool like AutoMapper to easily to copy the properties between this view model to your base model.
Related
I have a partial view that allows Html and the rendered name attribute of the <textarea> is throwing everything off, for instance this is my text area
#Html.TextAreaFor(model => model.cars.mycars)
causes the attribute to render as name="cars.mycars", is there anyway to change that to cars_mycars without using #Name ?
The reason why I want cars_mycars is because it is a field that has AllowHtml in it in the model
[AllowHtml]
public string mycars { get; set; }
In order for AllowHtml to work I would need a strongly typed model such as #Html.TextAreaFor(model => model.mycars) but I am using multiple models in 1 view therefore I have
#Html.TextAreaFor(model => model.cars.mycars, #new{id="cars_mycars",#Name="cars_mycars"})
This is all in a partialview and when I try to submit it nothing happens at all. That is the only field in the form so the issue much lie there and in addition if I put
ValidateInput(False)
on the action method then everything works fine which leads me back to the #name convention not working .
You can try like this
#Html.TextArea("cars_mycars")
I have an Index view in my application that shows a list of vendors. I also want to add a small form to add new items right on that page. The create form will post to the Create action. My model class contains a list of vendors, plus one property for a single vendor named NewVendor.
public IEnumerable<SoftwareVendor> Vendors { get; set; }
public SoftwareVendor NewVendor { get; set; }
The SoftwareVendor class has validation attributes. It's an Entity Framework class.
Making a form that posts to the Create action is easy:
#using (Html.BeginForm( "Create", "Vendor" )) {
#Html.ValidationSummary(true)
<fieldset>
<legend>New Software Vendor</legend>
<div class="editor-label">
#Html.LabelFor(model => model.NewVendor.Name)
</div>
<div class="editor-field">
#Html.EditorFor( model => model.NewVendor.Name )
#Html.ValidationMessageFor( model => model.NewVendor.Name )
</div>
<br />
<input type="submit" value="Create" />
</fieldset>
}
This posts just fine, and client-side validation also works. However, the default Create action takes an instance of SoftwareVendor and is looking for a key in the form collection called "Name". Instead, the above form posts "NewVendor.Name".
I can remedy this by specifying a template and field name in #Html.EditorFor.
#Html.EditorFor( model => model.NewVendor.Name, "string", "Name" )
Now the Create action is happy because the "Name" value is being received. However, the validation message is broken because it is still looking for a field named "NewVendor.Name", and there seems to be no way to override this.
<span class="field-validation-valid" data-valmsg-for="NewVendor.Name" data-valmsg-replace="true"></span>
Is there something simple I'm missing to make this work?
Here is a list of things I can do to solve this:
Have my Create action take an instance of my Index model instead of a SoftwareVendor. I still have a traditional Create view, though, and I don't want to do this.
Don't have my Create action take any parameters. Instead, manually look at the form keys and pull the name from either "Name" or "NewVendor.Name", whichever is there.
Have the Create action take both model classes and detect which one got populated properly. This is a lot like #2 but I'm checking properties for non-null values instead of checking the form collection.
Figure out how to make a model binder that will perform what #2 is doing. This seems overly complicated, and I'm going to have this problem in a number of pages, so I'm hoping for an easier way.
Use javascript to make the post instead of a form submit, so I can control the exact field names I'm posting. This works, but I'd prefer to leverage an HTML form, since that's what it's for.
Use the overload of EditorFor to specify the field name, and create the validation message manually.
Write my own extension method on HtmlHelper for a new ValidationMessageFor that can override the field name.
Of these options, #2 or #5 are the ones I think I'd choose from unless there's a better way.
Well, this worked:
#Html.EditorFor( model => model.NewVendor.Name, "string", "Name" )
#Html.ValidationMessage( "Name" )
Since my only real problem with my above code was a broken validation message, this seems to solve my problem. I'm still curious if there is a better solution overall.
I am using a DropDownListFor like this:
#Html.DropDownListFor(model => model.SelectedOrganisationValue, new SelectList(Model.OrganisationList, "Value", "Text"))
And I am also using:
[Required]
As Attribute in the View.
So when I PostBack the View to the Server and the Required Attribute will fail, the View is showed again, but then Model is null. So I will get a NullReferenceException in Model.OrganisationList.
That is the default behaviour. As you know ,MVC does not rely on ViewState, It can not keep the content inside the drop down across Postbacks (generic term). You need to repopulate it again in the ActionMethod.
I have a url like this:
http://localhost/products/AddFeature?code=SMW
in the controller action, I create a model and set the
model.Code = "123112".
The View has this
#Html.EditorFor(model => model.Code)
the final rendered html always shows "SMW" as the value.
Is this a bug where the query string value overrides the assigned value ?
Does anyone got same results or I need some coffee ?
Clear the model state before returning your view. Be sure that you haven't missed some model error before you do that. The helpers use the ModelState, then the models for their values.
ModelState.Clear();
Trying to understand when model objects are instantiated in MVC3:
I have a view for editing a "Person"; each person can have multiple addresses. I'm displaying the addresses in a grid on the Person View.
This works great when displaying a person; I have a partial view which iterates through Person.Addresses and builds the table/grid.
The problem arises when creating a new person: the person object is null and the Person.Addresses reference is illegal.
I'm certain I'm missing something fairly fundamental here: since MVC will be (auto-magically) creating the new person instance upon "Save"; it would seem counter-production to try and create my own object instance, and if I did, it is unclear how I would connect it to the rest of the entry values on the form.
One last complications: the list of Addresses is optional; it is perfectly legal not to have an address at all.
As relational data is so common, there has to be a simpler solution for handling this. All clarifications appreciated!
The answer to this question is that the objects are re-constituted from the POST data in the form. This is fairly basic, but MVC hides so much of what is happening that it is hard to see when you are trying to get your (MVC) bearings.
The sequence of items is:
Create form with all necessary fields; use hidden fields for non-displayed keys (ID).
User interacts with web page; then presses form submit button.
All field data is POSTed to the controller page.
MVC re-constitutes the data into class objects.
The controller page is invoked with the re-constituted class instance as a formal parameter.
Notes:
When creating the page: a form is generated with fields for each part of the object being represented. MVC uses hidden fields for ID's and other non-displayed data as well as for validation rules.
It is worth noting that forms are created (typically) either by listing all object properties on the _CreateOrEdit.cshtml page:
// Edit.cshtml
#model Person
#Html.Partial("_CreateOrEdit", Model)
and
// _CreateOrEdit.cshtml
#model Person
#Html.HiddenFor(model => model.PersonID)
#Html.LabelFor(model => model.first_name, "First Name")
#Html.EditorFor(model => model.first_name)
#Html.LabelFor(model => model.last_name, "Last Name")
#Html.EditorFor(model => model.last_name)
#Html.LabelFor(model => model.favorite_color, "Favorite Color")
#Html.EditorFor(model => model.favorite_color)
//etcetera
or by using a template for the class (templates must have the same name as the class they represent and they are located in the Views\Shared\EditorTemplates folder).
Using template pages is almost identical to the previous method:
// Edit.cshtml
#model Person
#Html.EditorForModel()
and
// Shared\EditorTemplates\Person.cshtml
#model Person
#Html.HiddenFor(model => model.PersonID)
#Html.LabelFor(model => model.first_name, "First Name")
#Html.EditorFor(model => model.first_name)
#Html.LabelFor(model => model.last_name, "Last Name")
#Html.EditorFor(model => model.last_name)
#Html.LabelFor(model => model.favorite_color, "Favorite Color")
#Html.EditorFor(model => model.favorite_color)
//etcetera
Using the template method makes it easy to add lists (of object) to the form. Person.cshtml becomes:
// Shared\EditorTemplates\Person.cshtml
#model Person
#Html.HiddenFor(model => model.PersonID)
#Html.LabelFor(model => model.first_name, "First Name")
#Html.EditorFor(model => model.first_name)
#Html.LabelFor(model => model.last_name, "Last Name")
#Html.EditorFor(model => model.last_name)
#Html.LabelFor(model => model.favorite_color, "Favorite Color")
#Html.EditorFor(model => model.favorite_color)
#EditorFor( model => model.Addresses )
//etcetera
and
// Shared\EditorTemplates\Address.cshtml
#model Address
#Html.HiddenFor(model => model.AddressID)
#Html.LabelFor(model => model.street, "Street")
#Html.EditorFor(model => model.street)
#Html.LabelFor(model => model.city, "City")
#Html.EditorFor(model => model.city)
//etcetera
MVC will handle creating as many form entries as necessary for each address in the list.
The POST works exactly in reverse; a new instance of the model object is created, calling the default parameter-less constructor, and then MVC fills in each of the fields. Lists are populating by reversing the serialization process of #Html.EditorFor( model.List ). It is important to note that you must make certain your class creates a valid container for the list in the constructor otherwise MVC's list re-constitution will fail:
public class Person
{
public List<Address> Addresses;
public Person()
{
// You always need to create this List object
Addresses = new List<Address>();
}
...
}
That cover's it. There is a lot going on behind the scenes, but it is all track-able.
Two important points if you are having trouble with this:
Make sure you have #Html.HiddenFor(...) for everything that needs to "survive" the trip back to the server.
Use Fiddler or HTTPLiveHeaders (Firefox plug-in) to examine the contents of the POST data. This will let you validate what data is being sent back to re-constitute the new class instance. I'm partial to Fiddler since you can use it with any browser (and it shows form data particularly well).
One last point: there is a good article on dynamically adding / removing elements from a list with MVC: http://jarrettmeyer.com/post/2995732471/nested-collection-models-in-asp-net-mvc-3 It's a good article to work through -- and yes, it does work with MVC3 and Razor.
The addresses I'm assuming are in a table, not actual input elements and likely just <td>info</td>?
If so, then they won't get instantiated as there is no data being posted back to the server.
You must have this data being created with elements that are posted back in order to have them mapped (by name) to their properties. The model binder will instantiate the objects and pass them to your controller upon postback if it can find appropriately named posted form (or querystring) elements.