MVC 5 identity how to add to custom user child tables? - entity-framework

Question

I am using a Visual Studio MVC 5 identity user template and am trying to expand the user information by creating a child table with information about Company.
There is a lot to read about how to create this parent/child tables with great examples so that's not the problem. My question is how do I add/remove/change the child tables in a smart and easy way by using the foreign key relationship?
I'm sorry I don't have any code to show right now, but I have used a MVC 5 template and added a virtual ICollection<Company> companies to the applicationUser model and it works great. I just can't figure out how to add the custom data to the child table....
Edit-------------
ApplicationUser model:(Here i use a userData table instead of the Company table i mention in the text)
// You can add profile data for the user by adding more properties to your ApplicationUser class, please visit http://go.microsoft.com/fwlink/?LinkID=317594 to learn more.
public class ApplicationUser : IdentityUser
{
//Create new custom tables
//User information
public virtual ICollection<Table_UserData> UserDatas { get; set; }
public virtual Table_UserData UserData { get; set; }
public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
{
// Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
// Add custom user claims here
//userIdentity.AddClaim(new Claim("myCustomClaim", "value of claim"));
return userIdentity;
}
}
My table:(Here i use a userData table instead of the Company table i mention in the text)
public class Table_UserData
{
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
}
Controller(Here i use a userData table instead of the Company table i mention in the text):
public async Task<PartialViewResult> Register(RegisterUserViewModel model)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser { UserName = model.UserName, Email = model.Email};
var result = await UserManager.CreateAsync(user, model.Password);
var userName = await UserManager.FindByNameAsync(model.UserName);
ApplicationUser userModel = UserManager.FindById(userName.Id);
userModel.UserDatas.Add(new Table_UserData { FirstName = model.FirstName, LastName = model.LastName });
await UserManager.UpdateAsync(userModel);
if (result.Succeeded)
{
ModelState.Clear();
return PartialView(model);
}
AddErrors(result);
}
//Something failed, redisplay form
return PartialView(model);
}

Answer 1

Use a ViewModel.
The following is untested, and just off the top of my head, but something similar should work.
ViewModel:
public class ViewModel
{
public Parent Parent { get; set; }
public Child Child { get; set; }
}
Controller:
public ActionResult Create()
{
return View();
}
[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult Create(
[Bind(Prefix = "Parent", Include = "ID,Field1,Field2")]Parent parent,
[Bind(Prefix = "Child", Include = "ID,ParentID,Field1,Field2")]Child child,
)
{
if(ModelState.IsValid)
{
db.Parents.Add(parent);
db.Childen.Add(child);
db.SaveChanges();
}
}
View:
#using ViewModel
#using (Html.BeginForm())
{
#Html.AntiForgeryToken()
<div>
#* Parent Properties *#
#Html.LabelFor(model => model.Parent.Field1)
#Html.EditorFor(model => model.Parent.Field1)
#Html.LabelFor(model => model.Parent.Field2)
#Html.EditorFor(model => model.Parent.Field2)
#* Child Properties *#
#Html.HiddenFor(model => model.Child.ParentID)
#Html.LabelFor(model => model.Child.Field1)
#Html.EditorFor(model => model.Child.Field1)
#Html.LabelFor(model => model.Child.Field2)
#Html.EditorFor(model => model.Child.Field2)
</div>
<div>
<input type="submit" value="Create" />
</div>
}

Answer 2

Ok, this answer comes late but it might help others who are learning MVC+EF to solve this issue. My code is tested and it is only a documented effort to demonstrate the solution given by Luke works fine.
For this example I am using MS Sql Server 2012, Visual Studio 2013 Professional edition, MVC 5.
To start, these are my example tables:
CREATE TABLE person(
personId int IDENTITY(1,1) NOT NULL,
personName varchar(15) NOT NULL,
personLastName varchar(15) NOT NULL,
personPhone varchar(10) NULL,
CONSTRAINT PK_person
PRIMARY KEY CLUSTERED (personId ASC)
);
CREATE TABLE pet(
petId int IDENTITY(1,1) NOT NULL,
personId int NOT NULL,
petName varchar(20) NOT NULL,
petType varchar(20) NOT NULL,
CONSTRAINT PK_pet PRIMARY KEY CLUSTERED ([petId] ASC, [personId] ASC),
CONSTRAINT FK_pet_person
FOREIGN KEY(personId)
REFERENCES person (personId)
);
It is a one-to-many relationship using automatically generated key columns (identity). The pet table has a foreign key referencing the person table primary key.
In order to add data to the child table (pet table in this example) I will use a ViewModel class, which will act as model in the View.
Here are the models:
namespace WebApp.Models
{
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
// The [Table()] attribute is used to map this class to a database table.
// The table name must be written exactly as it is in the database.
[Table("person")]
public partial class person
{
// This attribute was added manually. The scaffolded class did not include it.
// It MUST be indicated that the key column is identity.
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
[Key]
public int personId { get; set; }
[Required(ErrorMessage = "First name is required.")]
[StringLength(15)]
[Display(Name="First name")]
public string personName { get; set; }
[Required(ErrorMessage = "Last name is required.")]
[StringLength(15)]
[Display(Name="Last name")]
public string personLastName { get; set; }
[StringLength(10)]
[Display(Name="Phone number")]
public string personPhone { get; set; }
public virtual ICollection<pet> pets { get; set; }
}
}
namespace WebApp.Models
{
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
[Table("pet")]
public partial class pet
{
[Key, Column(Order = 0)]
// Same thing here: DatabaseGeneratedOption was originally "none"
// It was manually changed to "Identity"
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public int petId { get; set; }
// This is the foreign key column
[Key, Column(Order = 1)]
[DatabaseGenerated(DatabaseGeneratedOption.None)]
public int personId { get; set; }
[Required(ErrorMessage = "Pet name is required.")]
[StringLength(20)]
[Display(Name="Pet name")]
public string petName { get; set; }
[Required(ErrorMessage = "Pet type is required.")]
[StringLength(20)]
[Display(Name="Pet type")]
public string petType { get; set; }
public virtual person person { get; set; }
}
}
This is the ViewModel:
using WebApp.Models;
namespace WebApp.ViewModels
{
public class personPetVM
{
public person persons { get; set; }
public pet pets { get; set; }
}
}
It is simply a class containing two properties, where each property type is a class we defined in the models.
For these classes to communicate with the database we have this context:
namespace WebApp.Models
{
using System.Data.Entity;
public partial class petContext : DbContext
{
// DBConn is defined in the Web.Config file
public petContext()
: base("name=DBConn") {
}
public virtual DbSet<person> people { get; set; }
public virtual DbSet<pet> pets { get; set; }
}
}
This is the controller:
using System.Web.Mvc;
using WebApp.Models;
using WebApp.ViewModels;
namespace WebApp.Controllers
{
public class personController : Controller
{
// Create an instance of the context class to get connected to the Database
petContext db = new petContext();
public ActionResult Index() {
// Create an instance of the ViewModel class
// and pass it to the View as its model.
personPetVM person = new personPetVM();
return View(person);
}
[HttpPost]
[ValidateAntiForgeryToken]
// Because the ViewModel contains the definition of two different classes
// it is imperative to differentiate the properties belonging to each class
// by using the [Bind(Prefix="")] attribute in the action method parameters.
// As you can see, the parameters are instances of the model classes and are
// automatically populated with the values posted on the form.
public ActionResult saveData([Bind(Prefix = "persons")] person Person,
[Bind(Prefix = "pets")] pet Pet) {
try {
// ModelState is a dictionary that contains the state of the model
// and its validation rules.
if (ModelState.IsValid) {
db.people.Add(Person);
db.pets.Add(Pet);
db.SaveChanges();
}
return RedirectToAction("Index");
}
catch {
return View();
}
}
}
}
Because our ViewModel class does not have a key column defined, it is not possible for Visual Studio to generate the View automatically for you, so you will have to write it manually:
#model WebApp.ViewModels.personPetVM
#{
ViewBag.Title = "Index";
}
<h2>Pets registry</h2>
#using (Html.BeginForm("saveData", "person", FormMethod.Post)) {
#Html.AntiForgeryToken()
<div class="form-horizontal">
<h4>Person</h4>
<hr />
#Html.ValidationSummary(true, "", new { #class = "text-danger" })
<div class="form-group">
#Html.LabelFor(model => model.persons.personName, htmlAttributes: new { #class = "control-label col-md-2" })
<div class="col-md-10">
#Html.EditorFor(model => model.persons.personName, new { htmlAttributes = new { #class = "form-control" } })
#Html.ValidationMessageFor(model => model.persons.personName, "", new { #class = "text-danger" })
</div>
</div>
<div class="form-group">
#Html.LabelFor(model => model.persons.personLastName, htmlAttributes: new { #class = "control-label col-md-2" })
<div class="col-md-10">
#Html.EditorFor(model => model.persons.personLastName, new { htmlAttributes = new { #class = "form-control" } })
#Html.ValidationMessageFor(model => model.persons.personLastName, "", new { #class = "text-danger" })
</div>
</div>
<div class="form-group">
#Html.LabelFor(model => model.persons.personPhone, htmlAttributes: new { #class = "control-label col-md-2" })
<div class="col-md-10">
#Html.EditorFor(model => model.persons.personPhone, new { htmlAttributes = new { #class = "form-control" } })
#Html.ValidationMessageFor(model => model.persons.personPhone, "", new { #class = "text-danger" })
</div>
</div>
<h4>Pet</h4>
<hr />
<div class="form-group">
#Html.LabelFor(model => model.pets.petName, htmlAttributes: new { #class = "control-label col-md-2" })
<div class="col-md-10">
#Html.EditorFor(model => model.pets.petName, new { htmlAttributes = new { #class = "form-control" } })
#Html.ValidationMessageFor(model => model.pets.petName, "", new { #class = "text-danger" })
</div>
</div>
<div class="form-group">
#Html.LabelFor(model => model.pets.petType, htmlAttributes: new { #class = "control-label col-md-2" })
<div class="col-md-10">
#Html.EditorFor(model => model.pets.petType, new { htmlAttributes = new { #class = "form-control" } })
#Html.ValidationMessageFor(model => model.pets.petType, "", new { #class = "text-danger" })
</div>
</div>
<div class="form-group">
<div class="col-md-offset-2 col-md-10">
<input type="submit" value="Create" class="btn btn-default" />
</div>
</div>
</div>
}
Please be aware that a prefix is added to all the form generated inputs (id and name). In this particular example, all the inputs have their id composed by the name of the Model name + underscore + input name. For example: "persons_personName".
The input name is generated as Model name + dot + input name. For example: "persons.personName"
The prefix is the way Razor Views assigns values to the database tables participating in the form.
Take this into account if you want to refer to any input id/name using javascript/jQuery, especially if you add a database table field to the form (select, input, etc) by yourself. Make sure to add the respective prefix, as indicated, if you plan to post its value to the controller. If not, the form will not update the database because some input value did not pass the validation rules specified in the model.
So that's it!
I hope this example may help someone wondering how to:
Map model classes to database tables.
Define key columns in the model classes.
Create ViewModels.
Bind values to an action method.
Insert data into single tables.
Insert data into 1-to-many relationships.
Use some common Entity Framework [attributes]
Validate forms in a View.