asp.net mvc 5 - mvc - Deshabilitar identificador de identidad de ASP.net

identity framework c#

Question

Usando la nueva Identidad ASP.net en MVC 5, ¿Cómo inhabilitamos a un usuario para iniciar sesión? No quiero borrarlos, tal vez solo deshabilite su cuenta por un período de tiempo.

¿Alguien tiene alguna idea sobre esto ya que no veo una columna de estado ni nada en la tabla ASPNetUsers?

Answer 1

await userManager.SetLockoutEnabledAsync(applicationUser.Id, true);
await userManager.SetLockoutEndDateAsync(DateTime.Today.AddYears(10));

Answer 2

UserManager.RemovePasswordAsync("userId") deshabilitará efectivamente a un usuario. Si el usuario no tiene contraseña, no podrá iniciar sesión. Tendrá que establecer una nueva contraseña para habilitar al usuario nuevamente.

Answer 3

Actualización : como lo señala CountZero, si está utilizando v2.1 +, debe probar y usar la funcionalidad de bloqueo que agregaron primero, antes de probar la solución a continuación. Consulte la publicación de su blog para obtener una muestra completa: http://blogs.msdn.com/b/webdev/archive/2014/08/05/announcing-rtm-of-asp-net-identity-2-1-0.aspx

La versión 2.0 tiene la interfaz IUserLockoutStore que puede usar para bloquear a los usuarios, pero la desventaja es que no hay ninguna funcionalidad OOB para aprovecharla realmente más allá de los métodos de transferencia expuestos por la clase UserManager. Por ejemplo, sería bueno si realmente incrementara el conteo de bloqueo como parte del proceso estándar de verificación de nombre de usuario / contraseña. Sin embargo, es bastante trivial implementarlo usted mismo.

Paso # 1 : crea una tienda de usuario personalizada que implemente IUserLockoutStore.

// I''m specifying the TKey generic param here since we use int''s for our DB keys
// you may need to customize this for your environment
public class MyUserStore : IUserLockoutStore<MyUser, int>
{
    // IUserStore implementation here

    public Task<DateTimeOffset> GetLockoutEndDateAsync(MyUser user)
    {
        //..
    }

    public Task SetLockoutEndDateAsync(MyUser user, DateTimeOffset lockoutEnd)
    {
        //..
    }

    public Task<int> IncrementAccessFailedCountAsync(MyUser user)
    {
        //..
    }

    public Task ResetAccessFailedCountAsync(MyUser user)
    {
        //..
    }

    public Task<int> GetAccessFailedCountAsync(MyUser user)
    {
        //..
    }

    public Task<bool> GetLockoutEnabledAsync(MyUser user)
    {
        //..
    }

    public Task SetLockoutEnabledAsync(MyUser user, bool enabled)
    {
        //..
    }
}

Paso # 2 : En lugar de UserManager, use la siguiente clase en sus acciones de inicio de sesión / cierre de sesión, pasando una instancia de su tienda de usuario personalizada.

public class LockingUserManager<TUser, TKey> : UserManager<TUser, TKey>
    where TUser : class, IUser<TKey> 
    where TKey : IEquatable<TKey> 
{
    private readonly IUserLockoutStore<TUser, TKey> _userLockoutStore;

    public LockingUserManager(IUserLockoutStore<TUser, TKey> store)
        : base(store)
    {
        if (store == null) throw new ArgumentNullException("store");

        _userLockoutStore = store;
    }

    public override async Task<TUser> FindAsync(string userName, string password)
    {
        var user = await FindByNameAsync(userName);

        if (user == null) return null;

        var isUserLockedOut = await GetLockoutEnabled(user);

        if (isUserLockedOut) return user;

        var isPasswordValid = await CheckPasswordAsync(user, password);

        if (isPasswordValid)
        {
            await _userLockoutStore.ResetAccessFailedCountAsync(user);
        }
        else
        {
            await IncrementAccessFailedCount(user);

            user = null;
        }

        return user;
    }

    private async Task<bool> GetLockoutEnabled(TUser user)
    {
        var isLockoutEnabled = await _userLockoutStore.GetLockoutEnabledAsync(user);

        if (isLockoutEnabled == false) return false;

        var shouldRemoveLockout = DateTime.Now >= await _userLockoutStore.GetLockoutEndDateAsync(user);

        if (shouldRemoveLockout)
        {
            await _userLockoutStore.ResetAccessFailedCountAsync(user);

            await _userLockoutStore.SetLockoutEnabledAsync(user, false);

            return false;
        }

        return true;
    }

    private async Task IncrementAccessFailedCount(TUser user)
    {
        var accessFailedCount = await _userLockoutStore.IncrementAccessFailedCountAsync(user);

        var shouldLockoutUser = accessFailedCount > MaxFailedAccessAttemptsBeforeLockout;

        if (shouldLockoutUser)
        {
            await _userLockoutStore.SetLockoutEnabledAsync(user, true);

            var lockoutEndDate = new DateTimeOffset(DateTime.Now + DefaultAccountLockoutTimeSpan);

            await _userLockoutStore.SetLockoutEndDateAsync(user, lockoutEndDate);
        }
    }
}

Ejemplo :

    [AllowAnonymous]
    [HttpPost]
    public async Task<ActionResult> Login(string userName, string password)
    {
        var userManager = new LockingUserManager<MyUser, int>(new MyUserStore())
        {
            DefaultAccountLockoutTimeSpan = /* get from appSettings */,
            MaxFailedAccessAttemptsBeforeLockout = /* get from appSettings */
        };

        var user = await userManager.FindAsync(userName, password);

        if (user == null)
        {
            // bad username or password; take appropriate action
        }

        if (await _userManager.GetLockoutEnabledAsync(user.Id))
        {
            // user is locked out; take appropriate action
        }

        // username and password are good
        // mark user as authenticated and redirect to post-login landing page
    }

Si desea bloquear manualmente a alguien, puede establecer el indicador que esté marcando en MyUserStore.GetLockoutEnabledAsync() .

Answer 4

Puede tener una nueva clase, que debe derivarse de la clase IdentityUser. Puede agregar una propiedad booleana en la nueva clase y puede usar esta nueva propiedad de cuido por cheque para el proceso de inicio de sesión. Yo también lo hice bastante bien. Me gustaría echar un vistazo a: blog