Tentativo di modificare i nomi di tabella in ASP.NET Identity 2.0

Question

Desidero modificare i nomi delle tabelle utilizzate da ASP.NET Identity 2.0. Ho visto varie domande simili ma nulla che risolva il mio problema. Ad esempio questo tipo di soluzione: http://www.goatly.net/customizing-table-names-for-identitydbcontextwithcustomuser-data-contexts sembra dipendere dal codice prima (?). Ad ogni modo l'implementazione di OnModelCreating non fa nulla per me. Ho praticamente ribattezzato AspNetUsers e tabelle simili con i miei nomi e voglio essere in grado di usarli. Ho un contesto EF esistente (myContext) che voglio usare, così ho modificato per derivare da IdentityDbContext (la modifica del modello T4), e poi in Startup.Auth ho:

 UserManagerFactory =() => 
     { 
      var context = new MyContext(); 

      Database.SetInitializer<MyContext>(new IdentityDbInitializer()); 

      var userStore = new UserStore<IdentityUser>(context){ 
       DisposeContext = true 
      }; 

      return new UserManager<IdentityUser>(userStore); 
     }; 

Ma il problema si verifica quando provo ad accedere ricevo "impossibile contattare il server". Immagino che sia perché il mio User Store non ha modo di sapere quali sono le tabelle degli utenti sul mio contesto. Speravo che questo fosse ciò che farebbe il codice OnModelCreating, ma non ne sono sicuro. Immagino che UserStore stia ancora cercando una tabella "AspNetUsers", anche se non so da dove vengano questi nomi. Sono anche a disagio nel modificare il template t4 per il mio contesto: è questo il modo in cui dovrei derivare da IdentityDbContext?

Qualsiasi aiuto molto apprezzato.

Answer 1

A pochi passi da seguire:

• Installare NuGet pacchetto: Microsoft.AspNet.Identity.EntityFramework
• Aggiungi un connection string al tuo web.config/app.config

Ora è necessario definire la vostra abitudine Database Context:

public class MyContext : IdentityDbContext 
{ 
    public MyContext() 
     : base(<connection string name>) 
    { 

    } 

    protected override void OnModelCreating(DbModelBuilder modelBuilder) 
    { 
     base.OnModelCreating(modelBuilder); 

     modelBuilder.Entity<IdentityUser>() 
      .ToTable("Users"); 

     modelBuilder.Entity<IdentityRole>() 
      .ToTable("Roles"); 

     modelBuilder.Entity<IdentityUserRole>() 
      .ToTable("UserRoles"); 

     modelBuilder.Entity<IdentityUserClaim>() 
      .ToTable("UserClaims"); 

     modelBuilder.Entity<IdentityUserLogin>() 
      .ToTable("UserLogins"); 
    } 
} 

Come potete vedere I Ho usato DbModelBuilder per mappare tutte le entità in una nuova tabella.

• Aprire NuGet Package Manager Console
• Esegui comando Enable-Migrations

Si creerà una cartella Migrations con il file di configurazione Configuration.cs.

Dovrebbe essere qualcosa di simile:

internal sealed class Configuration : DbMigrationsConfiguration<ConsoleApplication1.Models.MyContext> 
{ 
    public Configuration() 
    { 
     AutomaticMigrationsEnabled = false; 
    } 

    protected override void Seed(ConsoleApplication1.Models.MyContext context) 
    { 

    } 
} 

Nel costruttore modificare la proprietà AutomaticMigrationsEnabled a true.

• Aprire NuGet Package Manager Console
• Esegui comando Update-Database

Dovrebbe eseguire lo script per creare le nuove tabelle.

È possibile personalizzare le entità (e gli ID) creando una classe personalizzata per ogni interfaccia definita.

public class MyUser : IdentityUser<string, MyUserLogin, MyUserRole, MyUserClaim> 
{ 
} 

Dal momento che si sta utilizzando Owin è possibile definire le UserStore:

public class MyUserStore: UserStore<MyUser, MyRole, string, MyUserLogin, MyUserRole, MyUserClaim> 
{ 
    public MyUserStore(MyContext context) 
     : base(context) 
    { 
    } 
} 

e l'implementazione UserManager:

public class ApplicationUserManager : UserManager<ASPNETIdentity2.Models.MyUser, string> 
{ 
    public ApplicationUserManager(IUserStore<ASPNETIdentity2.Models.MyUser, string> store) 
     : base(store) 
    { 

    } 

    public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options, IOwinContext context) 
    { 
     var manager = new ApplicationUserManager(new MyUserStore(context.Get<MyContext>())); 

     manager.UserValidator = new UserValidator<MyUser, string>(manager) 
     { 
      AllowOnlyAlphanumericUserNames = false, 
      RequireUniqueEmail = true 
     }; 

     manager.PasswordValidator = new PasswordValidator() 
     { 
      RequiredLength = 5, 
      RequireNonLetterOrDigit = false,  // true 
      // RequireDigit = true, 
      RequireLowercase = false, 
      RequireUppercase = false, 
     }; 

     return (manager); 
    } 
} 

E il tuo Owin.Startup dovrebbe essere simile a questo:

public class Startup 
{ 
    public void Configuration(IAppBuilder app) 
    { 
     app.CreatePerOwinContext(MyContext.Create); 
     app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create); 
    } 
} 

Se si desidera dare un'occhiata a un'implementazione personalizzata è possibile controllare il mio GitHub repository con una soluzione di lavoro semplice su ASP.NET MVC.

UPDATE:

C'è un altro progetto in questa soluzione con una configurazione minima; in pratica devi solo definire il tuo contesto (IdentityDbContext) se vuoi solo rinominare le tue tabelle.

Il progetto può essere trovato here.

Answer 2

L'identità 2 con Entity Framework presuppone il codice. Questo progetto sembra fare ciò di cui ho bisogno: https://github.com/cbfrank/AspNet.Identity.EntityFramework