c# - tutorial - mvc 5 identity authentication

Identidad 2.0 con tablas personalizadas

Question

Soy nuevo en la identidad de ASP.NET y todavía estoy tratando de entender cómo funciona todo. Desafortunadamente, he encontrado que muchos de los tutoriales que he probado son para Identity 1.0, mientras que estoy intentando trabajar con Identity 2.0.

El mayor problema al que me enfrento es algo que pensé que sería simple, pero resultó no serlo. Lo que estoy tratando de hacer es usar una base de datos existente con una tabla de usuarios existente. Actualmente, todo lo que puedo hacer es obtener Identity para crear sus propias tablas para almacenar datos de usuario. No quiero usar Entity Framework, pero he tenido grandes dificultades para separar Entity Framework de Identity 2.0.

Mientras estoy usando el servidor SQL, pensé que intentaría implementar el proveedor personalizado para MySQL en este enlace: http://www.asp.net/identity/overview/extensibility/implementing-a-custom-mysql-aspnet-identity-storage-provider y https://github.com/raquelsa/AspNet.Identity.MySQL . Esto parece funcionar solo bajo Identidad 1. Parece que hay uno más nuevo, sin embargo, utiliza Entity Framework. También he intentado https://github.com/ILMServices/RavenDB.AspNet.Identity .

Con todo lo que he probado, me quedo atascado con la siguiente línea:

var manager = new IdentityUserManager(new UserStore<IdentityUser>(context.Get<ApplicationDbContext>()));

El problema al que me enfrento es que necesito eliminar la clase ApplicaitonDbContext de acuerdo con las instrucciones para RavenDB, sin embargo no sé qué poner en esta línea.

Los errores que recibo son:

El tipo no genérico ''AspNet.Identity.MySQL.UserStore'' no puede usarse con argumentos de tipo

y

No se pudo encontrar el tipo o el nombre de espacio de nombres ''ApplicationDbContext'' (¿falta una directiva using o una referencia de ensamblado?)

El segundo error es de esperar, sin embargo, no estoy seguro de qué usar en esta línea de código. ¿Alguien ha tenido alguna experiencia con la implementación de un proveedor personalizado sin usar Entity Framework?

Gracias.

Actualización 1:

He intentado el siguiente tutorial [ http://aspnetguru.com/customize-authentication-to-your-own-set-of-tables-in-asp-net-mvc-5/ ] pero parece estar incompleto, con errores de compilación o tiempo de ejecución cuando se sigue exactamente el tutorial. Algunos problemas que todavía tengo son ...

Al reemplazar todas las instancias de "ApplicationUser" con "User", tiene un problema con la siguiente línea en IdentityConfig.cs

var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context.Get<MyDbContext>()));

El cambio de ApplicationUser a User produce el siguiente error

El tipo ''WebApplicationTest2.Models.User'' no se puede usar como parámetro de tipo ''TUser'' en el tipo o método genérico ''Microsoft.AspNet.Identity.EntityFramework.UserStore''. No hay conversión de referencia implícita de ''WebApplicationTest2.Models.User'' a ''Microsoft.AspNet.Identity.EntityFramework.IdentityUser''.

También tengo dificultades para aprender a usar el administrador de usuarios y muchos de los métodos de ASync. Las siguientes líneas no funcionan:

AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, await user.GenerateUserIdentityAsync(UserManager));

En AccountController.cs con los siguientes errores:

La mejor coincidencia de método sobrecargada para ''Microsoft.Owin.Security.IAuthenticationManager.SignIn (Microsoft.Owin.Security.AuthenticationProperties, params System.Security.Claims.ClaimsIdentity [])'' tiene algunos argumentos no válidos.

''WebApplicationTest2.Models.User'' no contiene una definición para ''GenerateUserIsentIdentityAsync'' y no se puede encontrar el método de extensión ''GenerateUserIdentityAsync'' aceptando un primer argumento de tipo ''WebApplicationTest2.Models.User'' ?)

Answer 1

Creo que esto se ha actualizado recientemente a esto en ApplicationUser :

public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager, string authenticationType)
{
    // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
    var userIdentity = await manager.CreateIdentityAsync(this, authenticationType);
    // Add custom user claims here
    return userIdentity;
}

Se llama así desde AccountController -> GetExternalLogin

ClaimsIdentity oAuthIdentity = await user.GenerateUserIdentityAsync(UserManager,
    OAuthDefaults.AuthenticationType);
ClaimsIdentity cookieIdentity = await user.GenerateUserIdentityAsync(UserManager,
    CookieAuthenticationDefaults.AuthenticationType);

Answer 2

En sus ejemplos, parece querer reemplazar el DbContext con otra cosa, pero creo que en realidad, necesita enfocar sus esfuerzos en un nivel superior.

El marco tiene una clase UserManager que tiene la responsabilidad de administrar, pero no almacenar, a los usuarios y su información relacionada. Cuando desea almacenar los usuarios (o su información relacionada), el valor predeterminado es usar el UserStore<IdentityUser> que sabe cómo almacenar instancias de IdentityUser en una base de datos utilizando un DbContext .

En el marco 2.0, los diversos bits del almacenamiento de identidad se dividieron en varias interfaces. La implementación predeterminada proporcionada, UserStore<IdentityUser> implementa varias de estas interfaces y almacena los datos para todos ellos en la base de datos utilizando un DBContext .

Si observa la definición del almacén de usuarios basado en el marco de la entidad proporcionado por defecto, puede ver que implementa muchas de estas pequeñas interfaces:

public class UserStore<TUser, TRole, TKey, TUserLogin, TUserRole, TUserClaim> : IUserLoginStore<TUser, TKey>, 
IUserClaimStore<TUser, TKey>, IUserRoleStore<TUser, TKey>, IUserPasswordStore<TUser, TKey>, 
IUserSecurityStampStore<TUser, TKey>, IQueryableUserStore<TUser, TKey>, IUserEmailStore<TUser, TKey>, 
IUserPhoneNumberStore<TUser, TKey>, IUserTwoFactorStore<TUser, TKey>, IUserLockoutStore<TUser, TKey>, 
IUserStore<TUser, TKey>, IDisposable 
where TUser : IdentityUser<TKey, TUserLogin, TUserRole, TUserClaim>
where TRole : IdentityRole<TKey, TUserRole>
where TKey : Object, IEquatable<TKey>
where TUserLogin : new(), IdentityUserLogin<TKey>
where TUserRole : new(), IdentityUserRole<TKey>
where TUserClaim : new(), IdentityUserClaim<TKey>

Como no desea utilizar Entity Framework en absoluto, debe proporcionar sus propias implementaciones de algunas de estas interfaces clave que almacenarán esos datos en los lugares donde desea que se almacenen los datos. La interfaz principal es IUserStore<Tuser,TKey> . esto define el contrato para almacenar usuarios que tienen una clave de un tipo particular. Si solo desea almacenar usuarios y ninguna otra información, puede implementar esta interfaz y luego pasar su implementación al UserManager y debería estar listo.

Es poco probable que esto sea suficiente, aunque es probable que desee contraseñas, roles, inicios de sesión, etc. para sus usuarios. Si es así, debe hacer que su clase que implementa IUserStore<Tuser,TKey> también implemente IUserPasswordStore<TUser, TKey> , IRoleStore<TRole, TKey> y IUserClaimStore<TUser, TKey> .

Puede encontrar una lista de todas las interfaces en MSDN aquí

Dependiendo de los bits que desee utilizar, necesita implementar esas interfaces.

Es probable que también necesite definir sus propias versiones de las clases de Identity* que existen para el marco de Entity ya listo para usar. Por lo tanto, necesitará su propia clase IdentityUser , que representa a los usuarios que desea almacenar, y IdentityUserClaim para las reclamaciones de los usuarios. No lo he hecho yo mismo, así que no estoy muy seguro, pero tengo la sensación de que tendrás que hacerlo.

Scott Allen tiene un buen artículo sobre los diversos bits del modelo que podría ser útil.

En cuanto a sus problemas con esta línea:

AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, await user.GenerateUserIdentityAsync(UserManager));

Existe un método llamado GenerateUserIdentityAsync que se define en Applicationuser que extiende IdentityUser . Se define en el proyecto de plantilla que creo y se ve algo así:

public class ApplicationUser : IdentityUser 
{    
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
    return userIdentity;
    }
}

Como ya no está utilizando IdentityUser marco de la entidad, debe definir un método similar o su propia clase de User o implementar la misma funcionalidad de otra manera (como simplemente llamar a await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie) )

Answer 3

Soy bastante nuevo en Identity. ¿Su entidad de usuario implementa la interfaz IUser? p.ej

public partial class User : IUser<Guid> //Whatever your key is
{
    public Task<ClaimsIdentity> GenerateUserIdentityAsync(ApplicationUserManager manager)
    {
        return Task.FromResult(GenerateUserIdentity(manager));
    }

    public ClaimsIdentity GenerateUserIdentity(ApplicationUserManager manager)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = manager.CreateIdentity<User, Guid>(this, DefaultAuthenticationTypes.ApplicationCookie);
        // Add custom user claims here
        return userIdentity;
    }
}

Luego para iniciar sesión puedes llamar al anterior:

public async Task SignInAsync(User user, bool isPersistent)
    {
        var userIdentity = await user.GenerateUserIdentityAsync(UserManager);
        AuthenticationManager.SignIn(
            new AuthenticationProperties
            {
                IsPersistent = isPersistent
            },
            userIdentity
        );
    }