none
Quiero desarrollar un proyecto ASP.NET Core 2.1 con diferentes bases de datos, PostgreSQL, MySQL y SQLite y alguna más, tengo problemas RRS feed

  • Pregunta

  • Muy buenas a ver tengo problemas con un proyecto en el que ahora esta empezando y ando probando ahora estoy en la fase de pruebas de PostgreSQL, aqui esta el github es:

    https://github.com/techcomputerworld/ASP.NET-Core-2.1-bootstrap-bs4

    Doy exactamente el fallo que me da usando PostgreSQL y me gustaria poder arreglarlo, con PostgreSQL si me da por saco usarla para desarrollo logicamente puedo pensar que para usarla en producción también me de problemas o fallos o lo que sea, por eso es por lo que necesito ayuda os he pegado en el README.md el fallo exacto que me da por si me podéis ayudar, saludos.

    miércoles, 20 de marzo de 2019 11:18

Respuestas

  • Define así tus clases para personalizar las tablas

    public class ApplicationRole : IdentityRole<int>
        {
            public virtual ICollection<ApplicationUserRole> UserRoles { get; set; }
            public virtual ICollection<ApplicationRoleClaim> RoleClaims { get; set; }
        }
    
    public class ApplicationRoleClaim : IdentityRoleClaim<int>
        {
            public virtual ApplicationRole Role { get; set; }
        }
    }
    
    public class ApplicationUser : IdentityUser<int>
        { 
    
            public virtual ICollection<ApplicationUserClaim> Claims { get; set; }
            public virtual ICollection<ApplicationUserLogin> Logins { get; set; }
            public virtual ICollection<ApplicationUserToken> Tokens { get; set; }
            public virtual ICollection<ApplicationUserRole> UserRoles { get; set; }
        }   
    
    public class ApplicationUserClaim : IdentityUserClaim<int>
        {
            public virtual ApplicationUser User { get; set; }
        }
    
    public class ApplicationUserLogin : IdentityUserLogin<int>
        {
            public virtual ApplicationUser User { get; set; }
        }
    
    public class ApplicationUserRole : IdentityUserRole<int>
        {
            public virtual ApplicationUser User { get; set; }
            public virtual ApplicationRole Role { get; set; }
        }
    
     public class ApplicationUserToken : IdentityUserToken<int>
        {
            public virtual ApplicationUser User { get; set; }
        }
    


    Luego modifica tu contexto así

    public class ApplicationDbContext : IdentityDbContext<ApplicationUser, ApplicationRole, int,
                                                            ApplicationUserClaim, ApplicationUserRole, ApplicationUserLogin,
                                                            ApplicationRoleClaim, ApplicationUserToken>
        {
    
            public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
            {
            }
    
            protected override void OnModelCreating(ModelBuilder builder)
            {
                base.OnModelCreating(builder);
    
                builder.Entity<ApplicationUser>(b =>
                {
                    // Each User can have many UserClaims
                    b.HasMany(e => e.Claims)
                        .WithOne(e => e.User)
                        .HasForeignKey(uc => uc.UserId)
                        .IsRequired();
    
                    // Each User can have many UserLogins
                    b.HasMany(e => e.Logins)
                        .WithOne(e => e.User)
                        .HasForeignKey(ul => ul.UserId)
                        .IsRequired();
    
                    // Each User can have many UserTokens
                    b.HasMany(e => e.Tokens)
                        .WithOne(e => e.User)
                        .HasForeignKey(ut => ut.UserId)
                        .IsRequired();
    
                    // Each User can have many entries in the UserRole join table
                    b.HasMany(e => e.UserRoles)
                        .WithOne(e => e.User)
                        .HasForeignKey(ur => ur.UserId)
                        .IsRequired();
                });
    
                builder.Entity<ApplicationRole>(b =>
                {
                    // Each Role can have many entries in the UserRole join table
                    b.HasMany(e => e.UserRoles)
                        .WithOne(e => e.Role)
                        .HasForeignKey(ur => ur.RoleId)
                        .IsRequired();
    
                    // Each Role can have many associated RoleClaims
                    b.HasMany(e => e.RoleClaims)
                        .WithOne(e => e.Role)
                        .HasForeignKey(rc => rc.RoleId)
                        .IsRequired();
                });
            }
        }

    Una vez hecho esto, en tu startup.cs

     services.AddDbContext<ApplicationDbContext>(options =>
                   options.UseMySQL(
                       Configuration.GetConnectionString("DefaultConnection")));
    
                services.AddDefaultIdentity<ApplicationUser>()
                    .AddDefaultUI(UIFramework.Bootstrap4)
                    .AddEntityFrameworkStores<ApplicationDbContext>();


    Y para lanzar las migrations puedes hacer lo siguiente situandote en la carpeta del proyecto donde tengas tu contexto (vía cmd.exe)

    dotnet ef  migrations add CreateDatabase
    dotnet ef database update
    

    El primer comando crea la migration y el segundo la ejecuta


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    • Marcado como respuesta onzulinapps viernes, 5 de abril de 2019 10:09
    miércoles, 3 de abril de 2019 12:23
    Moderador

Todas las respuestas

  • Bueno de hecho acabo de probar con MySQL y da problemas para crear la base de datos también por estas cosas es por lo que ASP.NET Core me hechapara atras no poder usar otra cosa que no sea SQL Server, ¿es posible usar MySQL y PostgreSQL sin problemas?
    miércoles, 20 de marzo de 2019 13:00
  • hola

    >>da problemas para crear la base de datos

    pero segun veo el mensaje dice

    The EF Core tools version '2.1.1-rtm-30846' is older than that of the runtime '2.1.8-servicing-32085'. Update the tools for the latest features and bug fixes.

    no actualizaste desde nuget las tools de EF?

    saludos


    Leandro Tuttini

    Blog
    MVP Profile
    Buenos Aires
    Argentina

    miércoles, 20 de marzo de 2019 13:24
  • Pues si te digo la verdad, no se como hacerlo lo de actualizar y de hecho me crea la DB en MySQL pero no me la crea entera como la deberia crear porque claro tambien probe en el mismo proyecto con SQL Server y funciona sin ningún problema. 

    La versión del EF Core Tools 2.1.1-rtm-30846 esa versión como la actualizo porque en el gestor de paquetes nuget no me aparece ese paquete de EF Core Tools para actualizarlo, saludos.

    miércoles, 20 de marzo de 2019 15:20
  • hola

    podrias actualizarlo usando la linea de comando de la consola nuget, como se menciona aqui

    How to upgrade EF Core Tools

    saludos


    Leandro Tuttini

    Blog
    MVP Profile
    Buenos Aires
    Argentina

    miércoles, 20 de marzo de 2019 20:51
  • Realmente el problema no creo que sea actualizarlo es que no consigo ningún conector de MySQL que funcione bien para desarrollar un proyecto  conectado con MySQL y logicamente poder lanzar la aplicación web en produccion conectado a una base de datos MySQL, si estoy probando en otro proyecto con ASP.NET Core 2.2  y la de pomelo al menos no funciona no veo ningún conector que funcione ¿has programado alguna aplicación ASP.NET Core 2.2 o 2.1 usando MySQL o PostgreSQL?
    lunes, 25 de marzo de 2019 11:33
  • hola

    >>no consigo ningún conector de MySQL que funcione bien para desarrollar un proyecto  conectado con MySQL

    pero que problems se presenta que no funciona ?


    saludos


    Leandro Tuttini

    Blog
    MVP Profile
    Buenos Aires
    Argentina

    lunes, 25 de marzo de 2019 13:28
  • Pues el problema te lo voiy a poner aquí es que lo unico que se me ocurre es que pruebes tu el programa realmente y veas vel error que dispara porque no veo otra forma de que veas el error a mi ahora me da otro error distinto al que me daba al principio

    https://github.com/techcomputerworld/domotica-mysql

    Ahí tienes el proyecto para probarlo con Visual Studio 2017 que imagino que lo tendras instalado es que no se me ocurre otra forma de que veas el error, el caso es que la base de datos no se me crea entera, por el error que da.

    lunes, 25 de marzo de 2019 14:36
  • Hola, qué error da? Viendo el proyecto en Github, veo que tiene las dependencias en el csproj corresspondiente. También puedes usar el fichero Dockerfile que  hay ya que indica que usa un contenedor docker.


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    lunes, 25 de marzo de 2019 15:29
    Moderador
  • Has probado este paquete? corePomelo.EntityFrameworkCore.MySql


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    lunes, 25 de marzo de 2019 16:47
    Moderador
  • A ver el primer error es este

    https://pastebin.com/4pnFqz6i

    lo tengo ahí el segundo error que ahora es el que tengo actualmente como esta el proyecto que he puesto aquí es este otro

    https://pastebin.com/n1jzAsp6

    Espero que con estos 2 errores mas o menos quede claro y bueno he probado el Pomelo.EntityFrameworkCore.MySql pero tampoco me ha funcionado con el que más he conseguido es con este que estoy usando en este proyecto.

    lunes, 25 de marzo de 2019 22:53
  • Hola primer error.

    Table 'aspnetroles' already exists

    Borra esas tablas antes de realizar la migración.

    Segundo error

    The entity type 'IdentityUserLogin<string>' requires a primary key to be defined.

    Muestranos la definición de la clase IdentityUserLogin que tienes. En tu contexto deberías tener algo así (muestranos también dicho contexto)

    modelBuilder.Entity<TUserRole>()
                .HasKey(r => new {r.UserId, r.RoleId})
                .ToTable("AspNetUserRoles");
    
    modelBuilder.Entity<TUserLogin>()
                .HasKey(l => new {l.LoginProvider, l.ProviderKey, l.UserId})
                .ToTable("AspNetUserLogins");


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    lunes, 25 de marzo de 2019 23:37
    Moderador
  • Muy buenas pues entiendo que lo que me has puesto ahí es para este método que lo tengo escrito de esta manera:

    protected override void OnModelCreating(ModelBuilder builder)
            {
                // Shorten key length for Identity
                builder.Entity<IdentityUser>(entity => entity.Property(m => m.Id).HasMaxLength(127));
                builder.Entity<IdentityRole>(entity => entity.Property(m => m.Id).HasMaxLength(127));
                builder.Entity<IdentityUserLogin<string>>(entity =>
                {
                    entity.Property(m => m.LoginProvider).HasMaxLength(127);
                    entity.Property(m => m.ProviderKey).HasMaxLength(127);
                });
                
                    .
                builder.Entity<IdentityUserRole<string>>(entity =>
                {
                    entity.Property(m => m.UserId).HasMaxLength(127);
                    entity.Property(m => m.RoleId).HasMaxLength(127);
                });
                builder.Entity<IdentityUserToken<string>>(entity =>
                {
                    entity.Property(m => m.UserId).HasMaxLength(127);
                    entity.Property(m => m.LoginProvider).HasMaxLength(127);
                    entity.Property(m => m.Name).HasMaxLength(127);
                });
            }

    Para que veas que no se escribe al menos como me has dicho, Sergio Parra, lo mismo escribiendolo de la forma nueva como tu me has dicho funciona es posible es lo que estoy intentando averiguar.

    Lo que no entiendo es que busques port donde busques en Google no hay forma de hallar una forma correcta que funcione a la primera con MySQL y ya no hablemos de PostgreSQL tampoco he encontrado la forma de hacerlo funcionar.

    martes, 26 de marzo de 2019 11:17
  • Si haber eso esta que lo acabo de ver ahora en este sitio, así sinceramente no entiendo que esta pasando la verdad para que no funcione MySQL cpomo base de datos si te das cuenta esas 2 llaves las esta creando como tal, en la migración.

    https://github.com/techcomputerworld/domotica-mysql/blob/master/Domotica-mysql/Data/Migrations/00000000000000_CreateIdentitySchema.Designer.cs

    y el código viene ahi dentro y es este trozo de código con el error

    The entity type 'IdentityUserLogin<string>' requires a primary key to be defined.

    si te das cuenta si la define ahí.

    modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
                    {
                        b.Property<string>("LoginProvider")
                            .HasMaxLength(128);
    
                        b.Property<string>("ProviderKey")
                            .HasMaxLength(128);
    
                        b.Property<string>("ProviderDisplayName");
    
                        b.Property<string>("UserId")
                            .IsRequired();
    
                        b.HasKey("LoginProvider", "ProviderKey");
    
                        b.HasIndex("UserId");
    
                        b.ToTable("AspNetUserLogins");
                    });

    Así que sinceramente no sé que esta pasando.

    martes, 26 de marzo de 2019 12:00
  • Bueno el caso es que veo que no me podéis ayudar a implementar MySQL de base de datos, pues viendo que no hay forma de trabajar ccon otro motor de bases de datos en ASP.NET Core la verdad es que no me interesa invertir tiempo en una tecnología que me condiciona a usar un motor de base de datos que encima es de pago  y privativo, he visto un monton de tutoriales y de todo.

    ¿Por qué he elegido para aprender ASP.NET Core? porque veo que es la tecnología que manejo y que se manejarme con ella de ahí mi interes por ASP.NET Core pero claro si no me deja usar MySQL o PostgreSQL que interes puedo tener pues ninguno y claro esta ya no hablemos de usar otras bases de datos NoSQL que tambien ando interesado en usarlas, no se si daran problemas pero imagino que también daran problemas.

    El problema que ahora me da despues de realizar cambios es este

    https://pastebin.com/JmRgXCEV

    pero bueno ¿os habéis mirado el github que precisamente lo puse para eso? es que puedo subir ahora como tengo el proyecto que tampoco lo he cambiado demasiado, lo he cambiado un poco solamente.

    miércoles, 27 de marzo de 2019 11:50
  • hola

    A ver la tecnologia puede estar mas o menos verde para algun provider en concreto, pero tambien hay que aprender a leer los errores, si analizas el ultimo link que has puesto alli menciona

    >>Specified key was too long; max key length is 3072 bytes

    ademas es un problema de migrations concretamente no de EF Core para resolver contra MySql

    No se si has estudiado algo de migrations, pero este ayuda en la creacion de la estructura de la db, no hace magia

    Si ejecutas migrations quizas despues debas tocar algo del codigo para adaptarlo, podrias ver las tablas generadas que key esta definiendo

    No recuerdo si MySql tiene alguna tool similar el Sql Profiler, pero si la hay podrias usrla para ver que queries ejecuta al momento de crear la estructura de la db y ver en que tabla genera el error para adaptar la migrations

    Recuerda que programar tambien lleva un poco de paciencia cuando estas usando librerias relativamente nuevas, sino ve a los seguro y pasa a .net full con EF6 que seguro sera mas estable por el tiempo que se viene utilizando, la decicion es de cada uno

    saludos


    Leandro Tuttini

    Blog
    MVP Profile
    Buenos Aires
    Argentina

    miércoles, 27 de marzo de 2019 13:37
  • Siguiendo con lo indicado por Leandro revisa esta respuesta de SO

    https://stackoverflow.com/questions/48678495/net-core-2-0-with-mysql-specified-key-was-too-long-max-key-length-is-3072-byt?rq=1


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    miércoles, 27 de marzo de 2019 13:51
    Moderador
  • A ver si esta claro, pero te puedo pasar unos cuantos enlaces dodne se ve que usando distintas librerias usan MySQL en ASP.NET Core, y sobre las migraciones claro he tocado también el tamaño de los campos que es lo que veo que falla

    Failed executing DbCommand (67ms) [Parameters=[], CommandType='Text', CommandTimeout='30']
    CREATE TABLE `AspNetUserRoles` (
        `UserId` varchar(767) NOT NULL,
        `RoleId` varchar(767) NOT NULL,
        PRIMARY KEY (`UserId`, `RoleId`),
        CONSTRAINT `FK_AspNetUserRoles_AspNetRoles_RoleId` FOREIGN KEY (`RoleId`) REFERENCES `AspNetRoles` (`Id`) ON DELETE CASCADE,
        CONSTRAINT `FK_AspNetUserRoles_AspNetUsers_UserId` FOREIGN KEY (`UserId`) REFERENCES `AspNetUsers` (`Id`) ON DELETE CASCADE
    );

    Bueno lo he puesto como código en C#, pero bueno así es como crea la tabla y claro en MySQL no la coge no me la cream las demas tablas me las crea.

    Aquí tienes el código que he modificado en el AplicationDbContext:

     protected override void OnModelCreating(ModelBuilder builder)
            {
                //base.OnModelCreating(builder);
                // Shorten key length for Identity
                builder.Entity<IdentityUser>(entity => entity.Property(m => m.Id).HasMaxLength(60));
                builder.Entity<IdentityRole>(entity => entity.Property(m => m.Id).HasMaxLength(60));
                
                builder.Entity<IdentityUserLogin<string>>(entity =>
                {
                    //definiendo estos 2 campos como claves primarias en la tabla a ver si asi funciona
                    entity.HasKey(m => new { m.LoginProvider, m.ProviderKey });
                    //entity.HasKey(m => m.ProviderKey);
                    entity.Property(m => m.LoginProvider).HasMaxLength(60);
                    entity.Property(m => m.ProviderKey).HasMaxLength(60);
                });
              
                builder.Entity<IdentityUserRole<string>>(entity =>
                {
                    entity.HasKey(m => new { m.UserId, m.RoleId });
                    entity.Property(m => m.UserId).HasMaxLength(60);
                    entity.Property(m => m.RoleId).HasMaxLength(60);
                });
                builder.Entity<IdentityUserToken<string>>(entity =>
                {
                    entity.HasKey(m => new { m.UserId, m.LoginProvider });
                    entity.Property(m => m.UserId).HasMaxLength(60);
                    entity.Property(m => m.LoginProvider).HasMaxLength(60);
                    entity.Property(m => m.Name).HasMaxLength(60);
                });
            }
            DbSet<Usuarios> Usuarios { get; set; }
    
        }

    si se supone que era muy grande el campo pues lo he puesto en 60 a ver si así funcionaba y no tira tampoco, se supone que he cambiado todos los campos esos que fallan en 60 y sin embargo en el error sigue dandome el mismo. 

    https://pastebin.com/JmRgXCEV

    Exactamente ese es el error, así que realmente ya no se que hacer y estas cosas me desaniman mucho pq echas tiempo y tiempo y no lo resuelvo.

    miércoles, 27 de marzo de 2019 13:56
  • hola

    No evaluaste generar un script en base a migrations para tener las instrucciones y ejecutarlas manualmente

    de esta forma podras saber que sql de que tabla esta fallando

    Generate SQL scripts

    al tener una mejor descripcion del problema en el script puedes ir puntualmente y adaptarlo en el codigo

    saludos


    Leandro Tuttini

    Blog
    MVP Profile
    Buenos Aires
    Argentina

    miércoles, 27 de marzo de 2019 14:02
  • Hola,

    Parece que el problema se encuentra por aquí, a la hora de crear ApsNetUserRoles

     CREATE TABLE `AspNetRoles` (
              `Id` varchar(767) NOT NULL,
              `Name` varchar(256) NULL,
              `NormalizedName` varchar(256) NULL,
              `ConcurrencyStamp` text NULL,
              PRIMARY KEY (`Id`)
          );
    CREATE TABLE `AspNetUsers` (
              `Id` varchar(767) NOT NULL,
              `UserName` varchar(256) NULL,
              `NormalizedUserName` varchar(256) NULL,
              `Email` varchar(256) NULL,
              `NormalizedEmail` varchar(256) NULL,
              `EmailConfirmed` bit NOT NULL,
              `PasswordHash` text NULL,
              `SecurityStamp` text NULL,
              `ConcurrencyStamp` text NULL,
              `PhoneNumber` text NULL,
              `PhoneNumberConfirmed` bit NOT NULL,
              `TwoFactorEnabled` bit NOT NULL,
              `LockoutEnd` timestamp NULL,
              `LockoutEnabled` bit NOT NULL,
              `AccessFailedCount` int NOT NULL,
              PRIMARY KEY (`Id`)
          );

    AQUI EL ERROR

    CREATE TABLE `AspNetUserRoles` (
              `UserId` varchar(767) NOT NULL,
              `RoleId` varchar(767) NOT NULL,
              PRIMARY KEY (`UserId`, `RoleId`),
              CONSTRAINT `FK_AspNetUserRoles_AspNetRoles_RoleId` FOREIGN KEY (`RoleId`) REFERENCES `AspNetRoles` (`Id`) ON DELETE CASCADE,
              CONSTRAINT `FK_AspNetUserRoles_AspNetUsers_UserId` FOREIGN KEY (`UserId`) REFERENCES `AspNetUsers` (`Id`) ON DELETE CASCADE
          );

    realmente es necesario que la clave sea un string?

    Prueba a modificar que sea entero. Tambien de AspNetRoles y de AspNetUsers

    Cambiar la clave principal de los usuarios en ASP.NET Identity

    Customize Asp.net Identity with Int Key


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos


    miércoles, 27 de marzo de 2019 15:06
    Moderador
  • Bueno según lo que pone en los 2 articulos que me has mandado me da a pensar que se hace heredandode esas clases que estan implementadas en:

    using Microsoft.AspNetCore.Identity; 

    y modificandolas a nuestras necesidades aunque no tengo muy claro como se hace el proceso la verdad, pero claro logicamente es buena idea cambiar los String esos por int pero sinceramente no se como se hace y aunque lo explique en esos articulos no me veo capaz de hacerlo la verdad ando viendo como se haria pero ni idea. Mi nivel de programación es tan alto como para entender com ose hacen esas modificaciones.

    Pues nose como hacerlo he creado varias clases que heredan de esas clases, pero no se como hacerlo la verdad no tengo tanto nivel de programación sinceramente.

    namespace Domotica_mysql.Data.CustomIdentity
    {
        //tabla AspNetUsers
        public class AspNetUsers : IdentityUser<int>
        {
            //Cambiando el Id a numero entero cuando estaba como cadena
            public int Id { get; set; }
        }
        public class CustomAspNetRoles : IdentityUserRole<int>
        {
            //cambiando el Id a numero cuando estaba como            cadena 
            public int Id { get; set; }
        }
    //tabla AspNetUserRoles
        public class CustomUserLogin : IdentityUserLogin<int>
        {
            public int UserId { get; set; }
            public int RoleId { get; set; }
        }
    }
    

    pero vamos no se como va la otra parte que explican en el documento que me has pasado

    • Editado onzulinapps jueves, 28 de marzo de 2019 15:16
    jueves, 28 de marzo de 2019 14:07
  • Bueno veo que no me decis nada ahi va una pregunta, me estoy mirando lo de cambiar las clases de Identity del modelo de Identidad y estoy mirando esta web de Microsoft pero no me queda clara una cuestión, cuando dice tipos genéricos de modelo

    Bueno pues como no se como se hace, y no se si vosotros lo habeis hecho o dejado de hacer y me hace falta, estoy intentando cambiar los datos de las tablas de Identity pero no consigo hacerlo, los cambios esos olos estoy haciendo en la rama Test

    https://github.com/techcomputerworld/domotica-mysql/tree/test/Domotica-mysql/Data

    y con la documentación que estoy leyendo de aquí:

    https://docs.microsoft.com/es-es/aspnet/core/security/authentication/customize-identity-model?view=aspnetcore-2.2

    Vamos no me queda claro ¿como se hacen los cambios en las tablas de Identity? como bien me sugeristes Sergio Parra, pero no consigo hacerlo, todo errores podrias probarlo por eso te he puesto el github para que le eches un ojo, un saludo y gracias.


    • Editado onzulinapps viernes, 29 de marzo de 2019 15:06
    viernes, 29 de marzo de 2019 14:52
  • En cuanto tenga un rato lo miro y te contesto por aqui

    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    viernes, 29 de marzo de 2019 14:57
    Moderador
  • Si ok ya lo vi que me respondistes antes yo creo que los tiros van por ahí pero tampoco sé como se hace, y todo el follon es por querer usar MySQL que con PostgreSQL sera algo parecido, por lo que veo. O bueno también estan las bases de datos NoSQL pero a esas no se me ocurre tal vez usar Identity hy lo mismo eso hace que sea todo más fácil.
    viernes, 29 de marzo de 2019 21:56
  • Hey espero que me puedas decir algo por favor sobre como hacer los cambios en asp.net Identity que por lo visto debe ser la mejor solución, al problema como me comentastes un poco más arriba, saludos
    martes, 2 de abril de 2019 9:18
  • Hola, Sergio Parra ando esperando a que me pudieras decir el problema, ¿lo has investigado? para poder cambiar dentro de las tablas de Identity los campos ID de las tablas AspNetUsers, AspNetRoles y la tabla AspNetUsersRoles creo que es esa la que hace de muchos a muchos entre las 2 tablas 1 a muchos, es que me hace falta para poder seguir programando con ASP.NET Core saludos.
    miércoles, 3 de abril de 2019 9:56
  • Hola, o sea que sólo necesitar usuarios y roles? 


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    miércoles, 3 de abril de 2019 12:07
    Moderador
  • Define así tus clases para personalizar las tablas

    public class ApplicationRole : IdentityRole<int>
        {
            public virtual ICollection<ApplicationUserRole> UserRoles { get; set; }
            public virtual ICollection<ApplicationRoleClaim> RoleClaims { get; set; }
        }
    
    public class ApplicationRoleClaim : IdentityRoleClaim<int>
        {
            public virtual ApplicationRole Role { get; set; }
        }
    }
    
    public class ApplicationUser : IdentityUser<int>
        { 
    
            public virtual ICollection<ApplicationUserClaim> Claims { get; set; }
            public virtual ICollection<ApplicationUserLogin> Logins { get; set; }
            public virtual ICollection<ApplicationUserToken> Tokens { get; set; }
            public virtual ICollection<ApplicationUserRole> UserRoles { get; set; }
        }   
    
    public class ApplicationUserClaim : IdentityUserClaim<int>
        {
            public virtual ApplicationUser User { get; set; }
        }
    
    public class ApplicationUserLogin : IdentityUserLogin<int>
        {
            public virtual ApplicationUser User { get; set; }
        }
    
    public class ApplicationUserRole : IdentityUserRole<int>
        {
            public virtual ApplicationUser User { get; set; }
            public virtual ApplicationRole Role { get; set; }
        }
    
     public class ApplicationUserToken : IdentityUserToken<int>
        {
            public virtual ApplicationUser User { get; set; }
        }
    


    Luego modifica tu contexto así

    public class ApplicationDbContext : IdentityDbContext<ApplicationUser, ApplicationRole, int,
                                                            ApplicationUserClaim, ApplicationUserRole, ApplicationUserLogin,
                                                            ApplicationRoleClaim, ApplicationUserToken>
        {
    
            public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
            {
            }
    
            protected override void OnModelCreating(ModelBuilder builder)
            {
                base.OnModelCreating(builder);
    
                builder.Entity<ApplicationUser>(b =>
                {
                    // Each User can have many UserClaims
                    b.HasMany(e => e.Claims)
                        .WithOne(e => e.User)
                        .HasForeignKey(uc => uc.UserId)
                        .IsRequired();
    
                    // Each User can have many UserLogins
                    b.HasMany(e => e.Logins)
                        .WithOne(e => e.User)
                        .HasForeignKey(ul => ul.UserId)
                        .IsRequired();
    
                    // Each User can have many UserTokens
                    b.HasMany(e => e.Tokens)
                        .WithOne(e => e.User)
                        .HasForeignKey(ut => ut.UserId)
                        .IsRequired();
    
                    // Each User can have many entries in the UserRole join table
                    b.HasMany(e => e.UserRoles)
                        .WithOne(e => e.User)
                        .HasForeignKey(ur => ur.UserId)
                        .IsRequired();
                });
    
                builder.Entity<ApplicationRole>(b =>
                {
                    // Each Role can have many entries in the UserRole join table
                    b.HasMany(e => e.UserRoles)
                        .WithOne(e => e.Role)
                        .HasForeignKey(ur => ur.RoleId)
                        .IsRequired();
    
                    // Each Role can have many associated RoleClaims
                    b.HasMany(e => e.RoleClaims)
                        .WithOne(e => e.Role)
                        .HasForeignKey(rc => rc.RoleId)
                        .IsRequired();
                });
            }
        }

    Una vez hecho esto, en tu startup.cs

     services.AddDbContext<ApplicationDbContext>(options =>
                   options.UseMySQL(
                       Configuration.GetConnectionString("DefaultConnection")));
    
                services.AddDefaultIdentity<ApplicationUser>()
                    .AddDefaultUI(UIFramework.Bootstrap4)
                    .AddEntityFrameworkStores<ApplicationDbContext>();


    Y para lanzar las migrations puedes hacer lo siguiente situandote en la carpeta del proyecto donde tengas tu contexto (vía cmd.exe)

    dotnet ef  migrations add CreateDatabase
    dotnet ef database update
    

    El primer comando crea la migration y el segundo la ejecuta


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    • Marcado como respuesta onzulinapps viernes, 5 de abril de 2019 10:09
    miércoles, 3 de abril de 2019 12:23
    Moderador
  • El resultado de la migración es el siguiente

    using System;
    using Microsoft.EntityFrameworkCore.Migrations;
    
    namespace MiNamespace
    {
        public partial class CreateDatabase : Migration
        {
            protected override void Up(MigrationBuilder migrationBuilder)
            {
                migrationBuilder.CreateTable(
                    name: "AspNetRoles",
                    columns: table => new
                    {
                        Id = table.Column<int>(nullable: false)
                            .Annotation("MySQL:AutoIncrement", true),
                        Name = table.Column<string>(maxLength: 256, nullable: true),
                        NormalizedName = table.Column<string>(maxLength: 256, nullable: true),
                        ConcurrencyStamp = table.Column<string>(nullable: true)
                    },
                    constraints: table =>
                    {
                        table.PrimaryKey("PK_AspNetRoles", x => x.Id);
                    });
    
                migrationBuilder.CreateTable(
                    name: "AspNetUsers",
                    columns: table => new
                    {
                        Id = table.Column<int>(nullable: false)
                            .Annotation("MySQL:AutoIncrement", true),
                        UserName = table.Column<string>(maxLength: 256, nullable: true),
                        NormalizedUserName = table.Column<string>(maxLength: 256, nullable: true),
                        Email = table.Column<string>(maxLength: 256, nullable: true),
                        NormalizedEmail = table.Column<string>(maxLength: 256, nullable: true),
                        EmailConfirmed = table.Column<short>(nullable: false),
                        PasswordHash = table.Column<string>(nullable: true),
                        SecurityStamp = table.Column<string>(nullable: true),
                        ConcurrencyStamp = table.Column<string>(nullable: true),
                        PhoneNumber = table.Column<string>(nullable: true),
                        PhoneNumberConfirmed = table.Column<short>(nullable: false),
                        TwoFactorEnabled = table.Column<short>(nullable: false),
                        LockoutEnd = table.Column<DateTimeOffset>(nullable: true),
                        LockoutEnabled = table.Column<short>(nullable: false),
                        AccessFailedCount = table.Column<int>(nullable: false)
                    },
                    constraints: table =>
                    {
                        table.PrimaryKey("PK_AspNetUsers", x => x.Id);
                    });
    
                migrationBuilder.CreateTable(
                    name: "AspNetRoleClaims",
                    columns: table => new
                    {
                        Id = table.Column<int>(nullable: false)
                            .Annotation("MySQL:AutoIncrement", true),
                        RoleId = table.Column<int>(nullable: false),
                        ClaimType = table.Column<string>(nullable: true),
                        ClaimValue = table.Column<string>(nullable: true)
                    },
                    constraints: table =>
                    {
                        table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
                        table.ForeignKey(
                            name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
                            column: x => x.RoleId,
                            principalTable: "AspNetRoles",
                            principalColumn: "Id",
                            onDelete: ReferentialAction.Cascade);
                    });
    
                migrationBuilder.CreateTable(
                    name: "AspNetUserClaims",
                    columns: table => new
                    {
                        Id = table.Column<int>(nullable: false)
                            .Annotation("MySQL:AutoIncrement", true),
                        UserId = table.Column<int>(nullable: false),
                        ClaimType = table.Column<string>(nullable: true),
                        ClaimValue = table.Column<string>(nullable: true)
                    },
                    constraints: table =>
                    {
                        table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
                        table.ForeignKey(
                            name: "FK_AspNetUserClaims_AspNetUsers_UserId",
                            column: x => x.UserId,
                            principalTable: "AspNetUsers",
                            principalColumn: "Id",
                            onDelete: ReferentialAction.Cascade);
                    });
    
                migrationBuilder.CreateTable(
                    name: "AspNetUserLogins",
                    columns: table => new
                    {
                        LoginProvider = table.Column<string>(maxLength: 128, nullable: false),
                        ProviderKey = table.Column<string>(maxLength: 128, nullable: false),
                        ProviderDisplayName = table.Column<string>(nullable: true),
                        UserId = table.Column<int>(nullable: false)
                    },
                    constraints: table =>
                    {
                        table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
                        table.ForeignKey(
                            name: "FK_AspNetUserLogins_AspNetUsers_UserId",
                            column: x => x.UserId,
                            principalTable: "AspNetUsers",
                            principalColumn: "Id",
                            onDelete: ReferentialAction.Cascade);
                    });
    
                migrationBuilder.CreateTable(
                    name: "AspNetUserRoles",
                    columns: table => new
                    {
                        UserId = table.Column<int>(nullable: false),
                        RoleId = table.Column<int>(nullable: false)
                    },
                    constraints: table =>
                    {
                        table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
                        table.ForeignKey(
                            name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
                            column: x => x.RoleId,
                            principalTable: "AspNetRoles",
                            principalColumn: "Id",
                            onDelete: ReferentialAction.Cascade);
                        table.ForeignKey(
                            name: "FK_AspNetUserRoles_AspNetUsers_UserId",
                            column: x => x.UserId,
                            principalTable: "AspNetUsers",
                            principalColumn: "Id",
                            onDelete: ReferentialAction.Cascade);
                    });
    
                migrationBuilder.CreateTable(
                    name: "AspNetUserTokens",
                    columns: table => new
                    {
                        UserId = table.Column<int>(nullable: false),
                        LoginProvider = table.Column<string>(maxLength: 128, nullable: false),
                        Name = table.Column<string>(maxLength: 128, nullable: false),
                        Value = table.Column<string>(nullable: true)
                    },
                    constraints: table =>
                    {
                        table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
                        table.ForeignKey(
                            name: "FK_AspNetUserTokens_AspNetUsers_UserId",
                            column: x => x.UserId,
                            principalTable: "AspNetUsers",
                            principalColumn: "Id",
                            onDelete: ReferentialAction.Cascade);
                    });
    
                migrationBuilder.CreateIndex(
                    name: "IX_AspNetRoleClaims_RoleId",
                    table: "AspNetRoleClaims",
                    column: "RoleId");
    
                migrationBuilder.CreateIndex(
                    name: "RoleNameIndex",
                    table: "AspNetRoles",
                    column: "NormalizedName",
                    unique: true);
    
                migrationBuilder.CreateIndex(
                    name: "IX_AspNetUserClaims_UserId",
                    table: "AspNetUserClaims",
                    column: "UserId");
    
                migrationBuilder.CreateIndex(
                    name: "IX_AspNetUserLogins_UserId",
                    table: "AspNetUserLogins",
                    column: "UserId");
    
                migrationBuilder.CreateIndex(
                    name: "IX_AspNetUserRoles_RoleId",
                    table: "AspNetUserRoles",
                    column: "RoleId");
    
                migrationBuilder.CreateIndex(
                    name: "EmailIndex",
                    table: "AspNetUsers",
                    column: "NormalizedEmail");
    
                migrationBuilder.CreateIndex(
                    name: "UserNameIndex",
                    table: "AspNetUsers",
                    column: "NormalizedUserName",
                    unique: true);
            }
    
            protected override void Down(MigrationBuilder migrationBuilder)
            {
                migrationBuilder.DropTable(
                    name: "AspNetRoleClaims");
    
                migrationBuilder.DropTable(
                    name: "AspNetUserClaims");
    
                migrationBuilder.DropTable(
                    name: "AspNetUserLogins");
    
                migrationBuilder.DropTable(
                    name: "AspNetUserRoles");
    
                migrationBuilder.DropTable(
                    name: "AspNetUserTokens");
    
                migrationBuilder.DropTable(
                    name: "AspNetRoles");
    
                migrationBuilder.DropTable(
                    name: "AspNetUsers");
            }
        }
    }
    

    y el snapshot

    // <auto-generated />
    using System;
    using Domotica_mysql.Data;
    using Microsoft.EntityFrameworkCore;
    using Microsoft.EntityFrameworkCore.Infrastructure;
    using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
    
    namespace Domotica_mysql.Migrations
    {
        [DbContext(typeof(ApplicationDbContext))]
        partial class ApplicationDbContextModelSnapshot : ModelSnapshot
        {
            protected override void BuildModel(ModelBuilder modelBuilder)
            {
    #pragma warning disable 612, 618
                modelBuilder
                    .HasAnnotation("ProductVersion", "2.2.0-rtm-35687");
    
                modelBuilder.Entity("MiNamespace.ApplicationRole", b =>
                    {
                        b.Property<int>("Id")
                            .ValueGeneratedOnAdd();
    
                        b.Property<string>("ConcurrencyStamp")
                            .IsConcurrencyToken();
    
                        b.Property<string>("Name")
                            .HasMaxLength(256);
    
                        b.Property<string>("NormalizedName")
                            .HasMaxLength(256);
    
                        b.HasKey("Id");
    
                        b.HasIndex("NormalizedName")
                            .IsUnique()
                            .HasName("RoleNameIndex");
    
                        b.ToTable("AspNetRoles");
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationRoleClaim", b =>
                    {
                        b.Property<int>("Id")
                            .ValueGeneratedOnAdd();
    
                        b.Property<string>("ClaimType");
    
                        b.Property<string>("ClaimValue");
    
                        b.Property<int>("RoleId");
    
                        b.HasKey("Id");
    
                        b.HasIndex("RoleId");
    
                        b.ToTable("AspNetRoleClaims");
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUser", b =>
                    {
                        b.Property<int>("Id")
                            .ValueGeneratedOnAdd();
    
                        b.Property<int>("AccessFailedCount");
    
                        b.Property<string>("ConcurrencyStamp")
                            .IsConcurrencyToken();
    
                        b.Property<string>("Email")
                            .HasMaxLength(256);
    
                        b.Property<bool>("EmailConfirmed");
    
                        b.Property<bool>("LockoutEnabled");
    
                        b.Property<DateTimeOffset?>("LockoutEnd");
    
                        b.Property<string>("NormalizedEmail")
                            .HasMaxLength(256);
    
                        b.Property<string>("NormalizedUserName")
                            .HasMaxLength(256);
    
                        b.Property<string>("PasswordHash");
    
                        b.Property<string>("PhoneNumber");
    
                        b.Property<bool>("PhoneNumberConfirmed");
    
                        b.Property<string>("SecurityStamp");
    
                        b.Property<bool>("TwoFactorEnabled");
    
                        b.Property<string>("UserName")
                            .HasMaxLength(256);
    
                        b.HasKey("Id");
    
                        b.HasIndex("NormalizedEmail")
                            .HasName("EmailIndex");
    
                        b.HasIndex("NormalizedUserName")
                            .IsUnique()
                            .HasName("UserNameIndex");
    
                        b.ToTable("AspNetUsers");
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserClaim", b =>
                    {
                        b.Property<int>("Id")
                            .ValueGeneratedOnAdd();
    
                        b.Property<string>("ClaimType");
    
                        b.Property<string>("ClaimValue");
    
                        b.Property<int>("UserId");
    
                        b.HasKey("Id");
    
                        b.HasIndex("UserId");
    
                        b.ToTable("AspNetUserClaims");
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserLogin", b =>
                    {
                        b.Property<string>("LoginProvider")
                            .HasMaxLength(128);
    
                        b.Property<string>("ProviderKey")
                            .HasMaxLength(128);
    
                        b.Property<string>("ProviderDisplayName");
    
                        b.Property<int>("UserId");
    
                        b.HasKey("LoginProvider", "ProviderKey");
    
                        b.HasIndex("UserId");
    
                        b.ToTable("AspNetUserLogins");
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserRole", b =>
                    {
                        b.Property<int>("UserId");
    
                        b.Property<int>("RoleId");
    
                        b.HasKey("UserId", "RoleId");
    
                        b.HasIndex("RoleId");
    
                        b.ToTable("AspNetUserRoles");
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserToken", b =>
                    {
                        b.Property<int>("UserId");
    
                        b.Property<string>("LoginProvider")
                            .HasMaxLength(128);
    
                        b.Property<string>("Name")
                            .HasMaxLength(128);
    
                        b.Property<string>("Value");
    
                        b.HasKey("UserId", "LoginProvider", "Name");
    
                        b.ToTable("AspNetUserTokens");
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationRoleClaim", b =>
                    {
                        b.HasOne("MiNamespace.ApplicationRole", "Role")
                            .WithMany("RoleClaims")
                            .HasForeignKey("RoleId")
                            .OnDelete(DeleteBehavior.Cascade);
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserClaim", b =>
                    {
                        b.HasOne("MiNamespace.ApplicationUser", "User")
                            .WithMany("Claims")
                            .HasForeignKey("UserId")
                            .OnDelete(DeleteBehavior.Cascade);
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserLogin", b =>
                    {
                        b.HasOne("MiNamespace.ApplicationUser", "User")
                            .WithMany("Logins")
                            .HasForeignKey("UserId")
                            .OnDelete(DeleteBehavior.Cascade);
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserRole", b =>
                    {
                        b.HasOne("MiNamespace.ApplicationRole", "Role")
                            .WithMany("UserRoles")
                            .HasForeignKey("RoleId")
                            .OnDelete(DeleteBehavior.Cascade);
    
                        b.HasOne("MiNamespace.ApplicationUser", "User")
                            .WithMany("UserRoles")
                            .HasForeignKey("UserId")
                            .OnDelete(DeleteBehavior.Cascade);
                    });
    
                modelBuilder.Entity("MiNamespace.ApplicationUserToken", b =>
                    {
                        b.HasOne("MiNamespace.ApplicationUser", "User")
                            .WithMany("Tokens")
                            .HasForeignKey("UserId")
                            .OnDelete(DeleteBehavior.Cascade);
                    });
    #pragma warning restore 612, 618
            }
        }
    }
    


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    miércoles, 3 de abril de 2019 12:30
    Moderador
  • Muy buenas pues nada yo no se si es que tengo la negra o algo pero a mi no me funciona me suelta un error el caso es que veo que lo de la tabla IdentityUser esta mal y creo que el error va por ahí,

    Eso ni con exactamente lo que me pusistes ni tampoco con lo que he probado yo, teniendo en cuenta que IdentityUser es la tabla AspNetUsers la delos usuarios por eso meti mi cambio no entiendo tus cambios pero es que daigual he probado con los 2 cambios con el tuyo primero y despues he intentado hacer mi cambio y tampoco funciona.

    De hecho el error de abajo me lo ha dado tal cual me pusistes tu en el código, que lo dejaré asi en la rama test.

    PM> Add-Migration [M1]
    An error occurred while accessing the IWebHost on class 'Program'. Continuing without the application service provider. Error: GenericArguments[0], 'Microsoft.AspNetCore.Identity.IdentityUser', on 'Microsoft.AspNetCore.Identity.EntityFrameworkCore.UserOnlyStore`6[TUser,TContext,TKey,TUserClaim,TUserLogin,TUserToken]' violates the constraint of type 'TUser'.
    Unable to create an object of type 'ApplicationDbContext'. For the different patterns supported at design time, see https://go.microsoft.com/fwlink/?linkid=851728

    Ese error me suelta creo que es por un fallo en IdentityUser voy a arreglarlo y ahora te cuento si lo he arreglado, pero me ha servido para coger la idea de como se soluciona el problema ahora te lo digo si soy capaz de solucionarlo.


    jueves, 4 de abril de 2019 10:36
  • Hola. Lo que te he diseñado es usar toda la estructura que usa Asp. Net Identity. 

    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    jueves, 4 de abril de 2019 12:48
    Moderador
  • Pues no consigo hacerlo como era de esperar lo que necesitaba que hicieras era probar la aplicación que para eso la subi al github y me moleste en ponerla en una rama test de testeo perof aun asi no hay manera de hacerla funcionar mi aplicacion con otra base de datos que no sea SQL Server por estas cosas es por lo que la gente no quiere tecnologias de Microsoft por no tener problemas con otras tecnologias que no sean de ellos.

    Por lo que veo solo me has copiado aquií lo que dice la documentación que por cierto por lo que veo solo sirve si quieres cambiar en SQL Server yo lo que realmente necesito es usar MySQL pero vamos que veo que hasta ahora es imposible usar otra cosa, seguramente deje de lado ASP.NET Core y aprenda otra tecnologia que no de tantos problemas para usar otras bases de datos.

    De todas maneras muchas gracias por ayudarme y saludos.

    jueves, 4 de abril de 2019 14:07
  • Hola, Me descargué tu solución de Github e implementé los cambios. He ejecutado la migración y se me generan las clases correspondientes. Como no tengo MySQL no he probado a lanzarla par verificar si genera el esquema de datos. Si te fijas en mi respuesta del resultado de la migración exite este entencia por ejemplo

      Id = table.Column<int>(nullable: false)
                            .Annotation("MySQL:AutoIncrement", true),

     


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    jueves, 4 de abril de 2019 16:33
    Moderador
  • lo acabo de probar y funciona perfectamente

     


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    jueves, 4 de abril de 2019 16:59
    Moderador
  • Bien es cierto que tuve que crear esta tabla

    USE domotica;
    CREATE TABLE IF NOT EXISTS __EFMigrationsHistory (
        MigrationId VARCHAR(150) NOT NULL,
        ProductVersion VARCHAR(32) NOT NULL,
     
        PRIMARY KEY (MigrationId)
    )  ENGINE=INNODB;


    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    jueves, 4 de abril de 2019 16:59
    Moderador
  • Si te copias las dos clases que he comentado en la carpeta Migration de tu proyecto, puedes lanzarla

    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    jueves, 4 de abril de 2019 17:00
    Moderador

  • Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    jueves, 4 de abril de 2019 17:03
    Moderador
  • Wow muchuisimas gracias, funciono hoy ya por fin lo unico que hice fue probar de nuevo pero tenia un error que no fue culpa tuya ni mucho menos, culpa mia y es en la clase Startup tenia puesto:

    Services.AddDefaultIdentity<IdentityUser>() y hay que cambiarlo por:

    Services.AddDefaultIdentity<ApplicationUser>().

    Bueno pues oye muchas gracias Sergio Parra me has alegrado el dia la verdad, saludos.

    viernes, 5 de abril de 2019 10:08
  • Un abrazo

    Si se solucionó tu consulta no olvides marcar la respuesta. Si te ayudó, vótala como útil. Saludos

    viernes, 5 de abril de 2019 11:07
    Moderador