web-dev-qa-db-fra.com

Configurez Microsoft.AspNet.Identity pour autoriser l'adresse électronique en tant que nom d'utilisateur

Je suis en train de créer une nouvelle application. J'ai commencé à utiliser EF6-RC1, Microsoft.AspNet.Identity.Core 1.0.0-RC1, Microsoft.AspNet.Identity.EntityFramework 1.0.0-RC1, Microsoft.AspNet.Identity .Owin 1.0.0-rc1, etc. et avec les versions RTM hier, je les ai mises à jour via NuGet ce soir vers RTM.

À part quelques modifications de code dans le travail que j'avais effectué jusqu'à présent, tout semblait bien se dérouler, jusqu'à ce que j'essaie de créer un compte d'utilisateur local pour l'application.

J'avais travaillé sur les adresses de messagerie étant le format du nom d'utilisateur, ce qui avec la version candidate a bien fonctionné, mais maintenant, lors de la création d'un utilisateur avec une adresse électronique pour un nom d'utilisateur, l'erreur de validation suivante est générée:

User name [email protected] is invalid, can only contain letters or digits.

J'ai passé presque une heure à chercher une solution ou une documentation sur les options de configuration, mais en vain.

Est-il possible de le configurer pour autoriser les adresses de messagerie pour les noms d'utilisateur?

asp.netasp.net-identity
115
LiamGu

Vous pouvez autoriser cela en connectant votre propre UserValidator sur UserManager ou simplement en le désactivant sur l'implémentation par défaut:

UserManager.UserValidator = new UserValidator<TUser>(UserManager) { AllowOnlyAlphanumericUserNames = false }
156
Hao Kung

La version C # de cela (dans App_Code\IdentityModels.cs) est

public UserManager()
        : base(new UserStore<ApplicationUser>(new ApplicationDbContext()))
    {
        UserValidator = new UserValidator<ApplicationUser>(this) { AllowOnlyAlphanumericUserNames = false };
    }
15
user2554240

Dans mon cas, fonctionnant sous VS 2013 C #, MVC 5.2.2 et utilisant ASP.NET Identity 2.0, la solution consistait à mettre à jour le constructeur ApplicationUserManager dans App_Start\IdentityConfig.cs comme suit:

public ApplicationUserManager(IUserStore<ApplicationUser> store)
        : base(store)
    {
        this.UserValidator = new UserValidator<ApplicationUser>(this) { AllowOnlyAlphanumericUserNames = false };
    }
8
N1njaB0b

Si vous utilisez des formulaires Web ASP.Net et tentez de le faire, ouvrez simplement votre fichier IdentityModels.vb/cs et, sous Public Class UserManager, faites-le de cette manière:

Public Class UserManager
Inherits UserManager(Of ApplicationUser)

Public Sub New()
    MyBase.New(New UserStore(Of ApplicationUser)(New ApplicationDbContext()))
    Users = store
    UserValidator = New UserValidator(Of ApplicationUser)(Me) With {.AllowOnlyAlphanumericUserNames = False}
End Sub

Public Property Users() As IUserStore(Of ApplicationUser)
    Get
        Return m_Users
    End Get
    Private Set(value As IUserStore(Of ApplicationUser))
        m_Users = value
    End Set
End Property
Private m_Users As IUserStore(Of ApplicationUser)

End Class
4
TyrolMedia

J'ai eu le même problème lorsque j'ai essayé de changer le code pour que le nom d'utilisateur soit le nom réel de la personne et non l'adresse électronique du système. Le même message d'erreur s'affiche: "Le nom d'utilisateur ABC DEF n'est pas valide, il ne peut contenir que des lettres ou des chiffres. . " J'ai résolu le problème en ajoutant le caractère d'espace (dans mon cas à la fin) à AllowedUserNameCharacters.

J'utilise Asp.Net Core 2.2 et VS2017

C'est mon code

Allez dans Startup.cs et modifiez ou ajoutez la ligne sous "// paramètres de l'utilisateur":

        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseMySql(Configuration.GetConnectionString("DefaultConnection")));

        services.AddIdentity<ApplicationUser, ApplicationRole>()
            .AddEntityFrameworkStores<ApplicationDbContext>()
            .AddDefaultTokenProviders();

        services.Configure<IdentityOptions>(options =>
        {
            // Password settings.
            options.Password.RequireDigit = true;
            options.Password.RequireLowercase = true;
            options.Password.RequireNonAlphanumeric = true;
            options.Password.RequireUppercase = true;
            options.Password.RequiredLength = 6;
            options.Password.RequiredUniqueChars = 1;

            // Lockout settings.
            options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5);
            options.Lockout.MaxFailedAccessAttempts = 5;
            options.Lockout.AllowedForNewUsers = true;


            // User settings.
            options.User.AllowedUserNameCharacters =
                "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+ ";
            options.User.RequireUniqueEmail = false;
        });

        services.ConfigureApplicationCookie(options =>
1
jcarrillo

Pour les utilisateurs d'AspNet.Identity.Core 2.1 et supérieur, ces validateurs de UserManager sont en lecture seule. Les adresses électroniques en tant que noms d'utilisateur sont autorisées par défaut, mais si vous devez personnaliser davantage les caractères de vos noms d'utilisateur, vous pouvez le faire dans Startup.cs comme ceci:

public void ConfigureServices(IServiceCollection services)
{
    services.AddIdentity<ApplicationUser, IdentityRole>(options => {
        options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@+/";
    });

    // ... etc
}

(J'avais besoin d'un '/' pour des raisons d'héritage.)

1
bsigma1

Dans mon cas, une classe de référentiel fonctionnant avec l'authentification ne me permettait pas d'utiliser un "-" dans les noms d'utilisateur.

//-------------------------------------------------------
public AuthRepository()
//-------------------------------------------------------
{
    _ctx = new AuthContext();
    _userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
    _userManager.UserValidator = new UserValidator<IdentityUser>(_userManager)
    {
        AllowOnlyAlphanumericUserNames = false
    };
}
0
Nick Kovalsky

Comme vous l'aurez probablement déjà constaté (et il fallait s'y attendre), ASP.NET Identity 2.0.0, publié en mars 2014, ajoute cette fonctionnalité au cadre.

Annonce: http://blogs.msdn.com/b/webdev/archive/2014/03/20/test-announcing-rtm-of-asp-net-identity-2-0-0.aspx

Exemple complet et didacticiel, y compris la confirmation du compte: http://www.asp.net/identity/overview/features-api/account-confirmation-and-password-recovery-secret-aspnet-identity

0
Vincent Sels

Depuis que coder ma propre application ApplicationUserManager: UserManager ne fonctionnait pas (peut-être que j'utilise Razor Pages, pas MVC), voici une autre solution: Dans Startup.cs de CofigureServices (), vous pouvez configurer les options d'identité, par exemple:

services.Configure<IdentityOptions>(options =>
{
  options.User.AllowedUserNameCharacters = 
  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@";
  options.User.RequireUniqueEmail = true;
});

Plus d'informations sur ce sujet dans Microsoft docs: https://docs.Microsoft.com/de-de/aspnet/core/security/authentication/identity-configuration?view=aspnetcore-2.2

0
Jimmy

Cela me tenait également à l'esprit, car la plupart du temps, les noms d'utilisateur sont des courriers électroniques, mais je peux comprendre le raisonnement d'un champ de courrier électronique séparé. Ce sont purement mes pensées/expérience car je ne pouvais pas non plus trouver le mot de Microsoft sur ce sujet.

Rappelez-vous, Asp Identity consiste uniquement à identifier une personne. Vous n'avez pas besoin d'avoir un courrier électronique pour l'identifier, mais ils nous permettent de le stocker car il fait partie d'une identité. Lorsque vous créez un nouveau projet Web dans Visual Studio, vous disposez d'une option pour les options d'authentification.

Si vous sélectionnez un type de projet non vide tel que MVC et définissez l'authentification sur "Comptes individuels", vous disposez des bases de la gestion des utilisateurs. L'une d'elles comprend une sous-classe semblable à celle-ci dans App_Start\IdentityConfig.cs:

 // Configure the application user manager used in this application. UserManager is defined in ASP.NET Identity and is used by the application.
public class ApplicationUserManager : UserManager<ApplicationUser>
{
    public ApplicationUserManager(IUserStore<ApplicationUser> store)
        : base(store)
    {
    }

    public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options, IOwinContext context) 
    {
        var manager = new ApplicationUserManager(new UserStore<ApplicationUser>(context.Get<ApplicationDbContext>()));
        // Configure validation logic for usernames
        manager.UserValidator = new UserValidator<ApplicationUser>(manager)
        {
            AllowOnlyAlphanumericUserNames = false,
            RequireUniqueEmail = true
        };
    }
    //N.B rest of code removed
}

Cela nous indique que Microsoft a l'intention de stocker des noms d'utilisateurs plus complexes (reportez-vous à AllowOnlyAlphaNumericUserNames = false). Nous avons donc des signaux mitigés.

Le fait que cela soit généré à partir d'un projet Web par défaut nous donne une bonne indication de Microsoft (et une méthode propre) pour nous permettre de saisir des courriers électroniques pour le champ du nom d'utilisateur. C'est propre car la méthode de création statique est utilisée dans App_Start\Startup.Auth.cs lors du démarrage de l'application avec le contexte Microsoft.OWIN.

Le seul inconvénient de cette approche est que vous finissez par stocker le courrier électronique deux fois ... Ce qui n’est pas bon!

0
Nabster

Si vous ne trouvez pas IdentityConfig.cs, remplacez le constructeur AccountController par ce code.

public AccountController(UserManager<ApplicationUser> userManager)
{
UserManager = userManager;
UserManager.UserValidator = new UserValidator<ApplicationUser>(UserManager) 
  {
      AllowOnlyAlphanumericUserNames = false  
  };
}
0
Suhail Mumtaz Awan

Si vous utilisez IOC de quelque sorte que ce soit (j'utilise StructureMap) dans votre contrôleur de compte, vous devrez appliquer le correctif mentionné ci-dessus par Hao Kung lorsque l'Usermanager est transmis: ( J'ai dû). Il existe peut-être un moyen de le faire dans la configuration IOC, mais je ne sais pas comment. 

public AccountController(ApplicationUserManager userManager)
    {
        _userManager = userManager;
        _userManager.UserValidator = new UserValidator<ApplicationUser>(_userManager)
        {
            AllowOnlyAlphanumericUserNames = false,
            RequireUniqueEmail = true
        };
0
davaus

J'ai rencontré le même problème. mais finalement, j'ai résolu le problème en ajoutant un élément ci-dessous à ma méthode, pas le constructeur.

public void MyMethod(){

     UserManager<ApplicationUser> manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));


                    // Configure validation logic for usernames  
                    manager.UserValidator = new UserValidator<ApplicationUser>(manager)
                    {
                        AllowOnlyAlphanumericUserNames = false,
                        RequireUniqueEmail = true

                    };         

}
0
sachith walpita