Saludos a todos nuestros lectores, en esta ocasión veremos cómo añadir nuestras columnas a la base de datos que creamos con SimpleMembership, si aún no tienen su aplicación con SimpleMembership, pueden ver el artículo MVC 4 – SimpleMembershipProvider.

Nosotros veremos dos formas de realizarlo, la primera es antes de inicializar nuestra base de datos con InitializeSimpleMembershipAttribute.cs mediante CodeFirst, y la segunda es cuando ya tenemos nuestra base de datos inicializada y no queremos perder los datos ya creados. Para la primera opción deberemos realizar el siguiente procedimiento:

Añadir los proveedores al Web.Config, a pesar de que esto ya está definido, por lo que cuando corramos el comando “update-database” desde la Consola del administrador de paquetes nosotros podemos usar el Api “Roles” nativo. En la sección “System.Web” agregamos:
[sourcecode language=”xml” gutter=”No” highlight=”1,7″ file=”/Web.Config”]

[/sourcecode]

Después agregamos nuestros campos personalizados a nuestro UserProfile Entity (/Models/AccountModel.cs)
[sourcecode language=”csharp” highlight=”8,9″ firstline=”21″ file=”/Models/AccountModel.cs”]
[Table(“UserProfile”)]
public class UserProfile
{
[Key]
[DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
public int UserId { get; set; }
public string UserName { get; set; }
public string Nombre { get; set; }
public string Apellido { get; set; }30.
}
[/sourcecode]

Después activamos EF5 CodeFirst Migrations (ver figura 1):

Figura 1. Consola del Administrador de paquetes.

Ahora colocamos los usuarios y roles que nosotros queremos proveer, para esto invocaremos el método WebSecurity.InitializeDatabaseConnection. Este método es el que le dice a SimpleMembership cual tabla utilicé cuando trabaje con usuarios y cuales columnas son para el UserID y UserName. También veremos cómo llenar nuestras columnas personalizadas:
[sourcecode language=”csharp” file=”/Migrations/Configuration.cs”]
namespace Mvc4_SimpleMembership.Migrations
{
using System;
using System.Data.Entity;
using System.Data.Entity.Migrations;
using System.Linq;
using System.Web.Security;
using Mvc4_SimpleMembership.Migrations;
using WebMatrix.WebData;

internal sealed class Configuration : DbMigrationsConfiguration<Mvc4_SimpleMembership.Models.UsersContext>
{
public Configuration()
{
AutomaticMigrationsEnabled = true; //Activamos la migración automática
}

protected override void Seed(Mvc4_SimpleMembership.Models.UsersContext context)
{
//Realizamos la conexión
WebSecurity.InitializeDatabaseConnection(
“DefaultConnection” //Cadena de conexión a utilizar
, “UserProfile” //Nombre de la tabla que contiene la información de los perfiles de usuario
, “userId” //Nombre de la columna que contiene el ID del usuario
, “UserName” //Nombre de la columna que contiene el nombre del usuario
, autoCreateTables: true);

//Creamos el rol
if (!Roles.RoleExists(“Administrador”))
Roles.CreateRole(“Administrador”);

//Creamos el usuario
if (!WebSecurity.UserExists(“JaimeMaldonado”))
WebSecurity.CreateUserAndAccount(
“JaimeMaldonado” //Nombre de usuario
, “Contraseña” //Contraseña
, new { Nombre = “Jaime”, Apellido = “Maldonado” });

//Añadimos al usuario al rol de administrador
if (!Roles.GetRolesForUser(“JaimeMaldonado”).Contains(“Administrador”))
Roles.AddUsersToRoles(new[] { “JaimeMaldonado” }, new[] { “Administrador” });
}
}
}
[/sourcecode]

Ahora ejecutamos “update-database -verbose” desde la Consola del Administrador de paquetes, usamos –verbose para tener una mejor visibilidad de lo que está siendo ejecutado en SQL. Observemos que el campo Nombre y Apellido se están creando. En nuestra primer ejecución nos muestra el mensaje siguiente:


Figura 2. Mensaje informativo sobre la ejecución del comando update-database -verbose.

Esto es porque ya habíamos inicializado nuestra base de datos (ver MVC 4 – SimpleMembership) y creado las tablas respectivas, así que eliminamos las tablas de nuestra base de datos para que quede vacía. Por ultimo ejecutamos nuevamente nuestro comando update:

Figura 3. Ejecución exitosa del comando update-database –verbose.

Verificamos que los usuarios y roles fueron creados y que el usuario fue añadido al rol correspondiente:
MVC C# t.gerardoverduzco.com

Figura 4. Consulta de usuarios, roles y usuarios en roles con SQL Server Management Studio 2012.

Finalmente ejecutamos nuestra aplicación e iniciamos sesión para realizar la última validación y ver que el usuario se creó con nuestro método Seed.

MVC C# t.gerardoverduzco.com
Figura 5. Inicio de sesión exitoso.

Ya como último paso, agregamos los campos creados a nuestra vista de registro, al modelo y al AccountController para pedir la información durante el registro:

RegisterModel (AccountModel.cs):
[sourcecode language=”csharp” highlight=”20,24″ firstline=”75″ file=”/Models/AccountModels.cs”]
public class RegisterModel
{
[Required]
[Display(Name = “Nombre de usuario”)]
public string UserName { get; set; }

[Required]
[StringLength(100, ErrorMessage = “El número de caracteres de {0} debe ser al menos {2}.”, MinimumLength = 6)]
[DataType(DataType.Password)]
[Display(Name = “Contraseña”)]
public string Password { get; set; }

[DataType(DataType.Password)]
[Display(Name = “Confirmar contraseña”)]
[Compare(“Password”, ErrorMessage = “La contraseña y la contraseña de confirmación no coinciden.”)]
public string ConfirmPassword { get; set; }

[Required]
[Display(Name = “Nombre(s)”)]
public string Nombre { get; set; }

[Required]
[Display(Name = “Apellidos”)]
public string Apellido { get; set; }
}
[/sourcecode]
Vista de registro (Register.cshtml):
[sourcecode language=”csharp” file=”/Views/Register.cshtml”]
@model Mvc4_SimpleMembership.Models.RegisterModel
@{
ViewBag.Title = “Registrarse”;
}

@ViewBag.Title.

Cree una cuenta nueva.

@using (Html.BeginForm()) {
@Html.AntiForgeryToken()
@Html.ValidationSummary()

Formulario de registro
  1. @Html.LabelFor(m => m.UserName)
    @Html.TextBoxFor(m => m.UserName)
  2. @Html.LabelFor(m => m.Password)
    @Html.PasswordFor(m => m.Password)
  3. @Html.LabelFor(m => m.ConfirmPassword)
    @Html.PasswordFor(m => m.ConfirmPassword)
  4. @Html.LabelFor(m => m.Nombre)
    @Html.TextBoxFor(m => m.Nombre)
  5. @Html.LabelFor(m => m.Apellido)
    @Html.TextBoxFor(m => m.Apellido)

}

@section Scripts {
@Scripts.Render(“~/bundles/jqueryval”)
}
[/sourcecode]
Acción Register (AccountController.cs)
[sourcecode language=”csharp” firstline=”72″ file=”/Controllers/AccountController.cs”]
[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Intento de registrar al usuario
try
{
WebSecurity.CreateUserAndAccount(
model.UserName
, model.Password
, new { Nombre = model.Nombre, Apellido = model.Apellido });
WebSecurity.Login(model.UserName, model.Password);
return RedirectToAction(“Index”, “Home”);
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError(“”, ErrorCodeToString(e.StatusCode));
}
}

// Si llegamos a este punto, es que se ha producido un error y volvemos a mostrar el formulario
return View(model);
}
[/sourcecode]

Ahora ¡vamos a registrarnos!


Figura 6. Inicio de sesión exitoso con usuario Demo.

MVC C# t.gerardoverduzco.com
Figura 7. Consulta de usuarios, roles y usuarios en roles.

La segunda forma, es agregar los campos que deseamos a la base de datos, y añadir las referencias en el modelo, controlador y vistas deseadas como lo hicimos en el paso 8. Espero les sirva la información, no olviden dejar sus dudas y comentarios ;). Hasta la próxima.

2 Comments

Deja un comentario! :)