Microsoft ASP.NET 身份 - 多个用户同名

Question

我正在尝试一些我认为非常奇特的东西，我遇到了一些问题，我希望可以在 Whosebug 上的用户的帮助下解决这些问题。

故事

我正在编写需要身份验证和注册的应用程序。我选择使用 Microsoft.AspNet.Identity。我过去没有经常使用它，所以不要根据这个决定来评判我。

上面提到的框架包含一个用户 table，它包含所有注册用户。

我创建了一张示例图片来展示应用程序的工作方式。

该应用程序由 3 个不同的组件组成：

后端 (WebAPI)。
客户（直接使用 WebAPI）。
最终用户（使用移动应用程序 - iOS）。

因此，我确实有一个客户可以在其上注册的后端。每个成员有一个唯一用户，所以这里没有问题。这里的客户是公司，最终用户是公司的客户。

您可能已经看到问题了，User 1 很可能是 Customer 1 的客户，但也是 Customer 2.

的客户

现在，客户可以邀请会员使用移动应用程序。当客户这样做时，最终用户确实会收到一封电子邮件，其中包含 link 以激活自己。

现在，只要您的用户是唯一的，这一切都可以正常工作，但我确实有一个用户是 Customer 1 和 Customer 2 的客户。两位客户可以邀请同一用户，该用户需要注册 2 次，每人 1 次 Customer.

问题

在Microsoft.AspNet.Identity框架中，用户应该是唯一的，根据我的情况，我无法管理。

问题

是否可以向 IdentityUser 添加额外的参数以确保用户是唯一的？

我已经做了什么

创建一个继承自 IdentityUser 的自定义 class，其中包含一个应用程序 ID：

public class AppServerUser : IdentityUser
{
    #region Properties

    /// <summary>
    ///     Gets or sets the id of the member that this user belongs to.
    /// </summary>
    public int MemberId { get; set; }

    #endregion
}

相应地更改了我的 IDbContext：

public class AppServerContext : IdentityDbContext<AppServerUser>, IDbContext { }

使用框架的修改调用。

IUserStore<IdentityUser> -> IUserStore<AppServerUser>
UserManager<IdentityUser>(_userStore) -> UserManager<AppServerUser>(_userStore);

_userStore 偏离了类型 IUserStore<AppServerUser>

但是，当我使用已被占用的用户名注册用户时，我仍然收到一条错误消息，提示用户名已被占用：

var result = await userManager.CreateAsync(new AppServerUser {UserName = "testing"}, "testing");

我相信这是一个解决方案

我确实认为我需要更改 UserManager 但我不确定。我希望这里有人对框架有足够的了解来帮助我，因为它确实阻碍了我们的应用程序开发。

如果不可能，我也想知道，也许你可以给我指出另一个允许我这样做的框架。

注意：我不想自己写一个完整的用户管理，因为那将是重新发明轮子。

Answer 1

首先，我理解您的想法，因此我将开始解释 "why" 您是否无法创建具有相同名称的多个用户。

同名用户名： 您现在遇到的问题与 IdentityDbContext 有关。如您所见 (https://aspnetidentity.codeplex.com/SourceControl/latest#src/Microsoft.AspNet.Identity.EntityFramework/IdentityDbContext.cs)，identityDbContext 设置了关于唯一用户和角色的规则，首先是模型创建：

protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        if (modelBuilder == null)
        {
            throw new ArgumentNullException("modelBuilder");
        }

        // Needed to ensure subclasses share the same table
        var user = modelBuilder.Entity<TUser>()
            .ToTable("AspNetUsers");
        user.HasMany(u => u.Roles).WithRequired().HasForeignKey(ur => ur.UserId);
        user.HasMany(u => u.Claims).WithRequired().HasForeignKey(uc => uc.UserId);
        user.HasMany(u => u.Logins).WithRequired().HasForeignKey(ul => ul.UserId);
        user.Property(u => u.UserName)
            .IsRequired()
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("UserNameIndex") { IsUnique = true }));

        // CONSIDER: u.Email is Required if set on options?
        user.Property(u => u.Email).HasMaxLength(256);

        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");

        modelBuilder.Entity<TUserClaim>()
            .ToTable("AspNetUserClaims");

        var role = modelBuilder.Entity<TRole>()
            .ToTable("AspNetRoles");
        role.Property(r => r.Name)
            .IsRequired()
            .HasMaxLength(256)
            .HasColumnAnnotation("Index", new IndexAnnotation(new IndexAttribute("RoleNameIndex") { IsUnique = true }));
        role.HasMany(r => r.Users).WithRequired().HasForeignKey(ur => ur.RoleId);
    }

其次是验证实体：

protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry,
        IDictionary<object, object> items)
    {
        if (entityEntry != null && entityEntry.State == EntityState.Added)
        {
            var errors = new List<DbValidationError>();
            var user = entityEntry.Entity as TUser;
            //check for uniqueness of user name and email
            if (user != null)
            {
                if (Users.Any(u => String.Equals(u.UserName, user.UserName)))
                {
                    errors.Add(new DbValidationError("User",
                        String.Format(CultureInfo.CurrentCulture, IdentityResources.DuplicateUserName, user.UserName)));
                }
                if (RequireUniqueEmail && Users.Any(u => String.Equals(u.Email, user.Email)))
                {
                    errors.Add(new DbValidationError("User",
                        String.Format(CultureInfo.CurrentCulture, IdentityResources.DuplicateEmail, user.Email)));
                }
            }
            else
            {
                var role = entityEntry.Entity as TRole;
                //check for uniqueness of role name
                if (role != null && Roles.Any(r => String.Equals(r.Name, role.Name)))
                {
                    errors.Add(new DbValidationError("Role",
                        String.Format(CultureInfo.CurrentCulture, IdentityResources.RoleAlreadyExists, role.Name)));
                }
            }
            if (errors.Any())
            {
                return new DbEntityValidationResult(entityEntry, errors);
            }
        }
        return base.ValidateEntity(entityEntry, items);
    }
}

提示： 您可以轻松克服此问题的方法是，在您当前拥有的 ApplicationDbContext 上，覆盖这两种方法以克服此验证

警告如果没有该验证，您现在可以使用具有相同名称的多个用户，但您必须实施规则来阻止您在同一客户中使用相同的用户名创建用户。您可以做的是，将其添加到验证中。

希望帮助是有价值的:)干杯！

Answer 2

可能有人会觉得这有帮助。在我们的项目中，我们使用 ASP.NET 身份 2，有一天我们遇到了两个用户具有相同名称的情况。我们在我们的应用程序中使用电子邮件作为登录名，而且它们确实必须是唯一的。但无论如何我们都不希望用户名是唯一的。我们所做的只是定制了几个 classes 身份框架，如下所示：

通过在 UserName 字段上创建非唯一索引并以巧妙的方式覆盖 ValidateEntity 来更改我们的 AppIdentityDbContext。然后使用迁移更新数据库。代码如下：

public class AppIdentityDbContext : IdentityDbContext<AppUser>
{

public AppIdentityDbContext()
    : base("IdentityContext", throwIfV1Schema: false)
{
}

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    base.OnModelCreating(modelBuilder); // This needs to go before the other rules!

     *****[skipped some other code]*****

    // In order to support multiple user names 
    // I replaced unique index of UserNameIndex to non-unique
    modelBuilder
    .Entity<AppUser>()
    .Property(c => c.UserName)
    .HasColumnAnnotation(
        "Index", 
        new IndexAnnotation(
        new IndexAttribute("UserNameIndex")
        {
            IsUnique = false
        }));

    modelBuilder
        .Entity<AppUser>()
        .Property(c => c.Email)
        .IsRequired()
        .HasColumnAnnotation(
            "Index",
            new IndexAnnotation(new[]
            {
                new IndexAttribute("EmailIndex") {IsUnique = true}
            }));
}

/// <summary>
///     Override 'ValidateEntity' to support multiple users with the same name
/// </summary>
/// <param name="entityEntry"></param>
/// <param name="items"></param>
/// <returns></returns>
protected override DbEntityValidationResult ValidateEntity(DbEntityEntry entityEntry,
    IDictionary<object, object> items)
{
    // call validate and check results 
    var result = base.ValidateEntity(entityEntry, items);

    if (result.ValidationErrors.Any(err => err.PropertyName.Equals("User")))
    {
        // Yes I know! Next code looks not good, because I rely on internal messages of Identity 2, but I should track here only error message instead of rewriting the whole IdentityDbContext

        var duplicateUserNameError = 
            result.ValidationErrors
            .FirstOrDefault(
            err =>  
                Regex.IsMatch(
                    err.ErrorMessage,
                    @"Name\s+(.+)is\s+already\s+taken",
                    RegexOptions.IgnoreCase));

        if (null != duplicateUserNameError)
        {
            result.ValidationErrors.Remove(duplicateUserNameError);
        }
    }

    return result;
}
}

创建 IIdentityValidator<AppUser> 界面的自定义 class 并将其设置为我们的 UserManager<AppUser>.UserValidator 属性:

public class AppUserValidator : IIdentityValidator<AppUser>
{
/// <summary>
///     Constructor
/// </summary>
/// <param name="manager"></param>
public AppUserValidator(UserManager<AppUser> manager)
{
    Manager = manager;
}

private UserManager<AppUser, string> Manager { get; set; }

/// <summary>
///     Validates a user before saving
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public virtual async Task<IdentityResult> ValidateAsync(AppUser item)
{
    if (item == null)
    {
        throw new ArgumentNullException("item");
    }

    var errors = new List<string>();

    ValidateUserName(item, errors);
    await ValidateEmailAsync(item, errors);

    if (errors.Count > 0)
    {
        return IdentityResult.Failed(errors.ToArray());
    }
    return IdentityResult.Success;
}

private void ValidateUserName(AppUser user, List<string> errors)
{
    if (string.IsNullOrWhiteSpace(user.UserName))
    {
        errors.Add("Name cannot be null or empty.");
    }
    else if (!Regex.IsMatch(user.UserName, @"^[A-Za-z0-9@_\.]+$"))
    {
        // If any characters are not letters or digits, its an illegal user name
        errors.Add(string.Format("User name {0} is invalid, can only contain letters or digits.", user.UserName));
    }
}

// make sure email is not empty, valid, and unique
private async Task ValidateEmailAsync(AppUser user, List<string> errors)
{
    var email = user.Email;

    if (string.IsNullOrWhiteSpace(email))
    {
        errors.Add(string.Format("{0} cannot be null or empty.", "Email"));
        return;
    }
    try
    {
        var m = new MailAddress(email);
    }
    catch (FormatException)
    {
        errors.Add(string.Format("Email '{0}' is invalid", email));
        return;
    }
    var owner = await Manager.FindByEmailAsync(email);
    if (owner != null && !owner.Id.Equals(user.Id))
    {
        errors.Add(string.Format(CultureInfo.CurrentCulture, "Email '{0}' is already taken.", email));
    }
}
}

public class AppUserManager : UserManager<AppUser>
{
public AppUserManager(
    IUserStore<AppUser> store,
    IDataProtectionProvider dataProtectionProvider,
    IIdentityMessageService emailService)
    : base(store)
{

    // Configure validation logic for usernames
    UserValidator = new AppUserValidator(this);

最后一步是更改 AppSignInManager。因为现在我们的用户名不是唯一的，所以我们使用电子邮件登录：

public class AppSignInManager : SignInManager<AppUser, string>
{
 ....
public virtual async Task<SignInStatus> PasswordSignInViaEmailAsync(string userEmail, string password, bool isPersistent, bool shouldLockout)
{
    var userManager = ((AppUserManager) UserManager);
    if (userManager == null)
    {
        return SignInStatus.Failure;
    }

    var user = await UserManager.FindByEmailAsync(userEmail);
    if (user == null)
    {
        return SignInStatus.Failure;
    }

    if (await UserManager.IsLockedOutAsync(user.Id))
    {
        return SignInStatus.LockedOut;
    }

    if (await UserManager.CheckPasswordAsync(user, password))
    {
        await UserManager.ResetAccessFailedCountAsync(user.Id);
        await SignInAsync(user, isPersistent, false);
        return SignInStatus.Success;
    }

    if (shouldLockout)
    {
        // If lockout is requested, increment access failed count which might lock out the user
        await UserManager.AccessFailedAsync(user.Id);
        if (await UserManager.IsLockedOutAsync(user.Id))
        {
            return SignInStatus.LockedOut;
        }
    }
    return SignInStatus.Failure;
}

现在代码如下：

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Index(User model, string returnUrl)
{
    if (!ModelState.IsValid)
    {
        return View(model);
    }
    var result = 
        await signInManager.PasswordSignInViaEmailAsync(
            model.Email,
            model.Password, 
            model.StaySignedIn,
            true);

    var errorMessage = string.Empty;
    switch (result)
    {
        case SignInStatus.Success:
            if (IsLocalValidUrl(returnUrl))
            {
                return Redirect(returnUrl);
            }

            return RedirectToAction("Index", "Home");
        case SignInStatus.Failure:
            errorMessage = Messages.LoginController_Index_AuthorizationError;
            break;
        case SignInStatus.LockedOut:
            errorMessage = Messages.LoginController_Index_LockoutError;
            break;
        case SignInStatus.RequiresVerification:
            throw new NotImplementedException();
    }

    ModelState.AddModelError(string.Empty, errorMessage);
    return View(model);
}

P.S。我不太喜欢重写 ValidateEntity 方法的方式。但我决定这样做是因为我必须实现与 IdentityDbContext 几乎相同的 DbContext class，因此在我的项目中更新身份框架包时我必须跟踪它的变化。

Microsoft ASP.NET 身份 - 多个用户同名

Microsoft ASP.NET Identity - Multiple Users with the same name

c#

asp.net

authentication

forms-authentication

asp.net-identity

故事

问题

问题

我已经做了什么

我相信这是一个解决方案