public async Task AddUserToRole(ISiteUser user, ISiteRole role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (role.SiteId != user.SiteId)
{
throw new ArgumentException("user and role must have the same siteid");
}
await _commands.AddUserToRole(role.SiteId, role.Id, user.Id, CancellationToken);
user.RolesChanged = true;
await _commands.Update(user, CancellationToken);
foreach (var handler in _userAddedToRoleHandlers)
{
try
{
await handler.Handle(user, role);
}
catch (Exception ex)
{
_log.LogError($"{ex.Message}-{ex.StackTrace}");
}
}
}
public async Task <IdentityResult> RemoveUserFromRole(Guid siteId, Guid userId, string roleName)
{
var errors = new List <IdentityError>();
var role = await _queries.FetchRole(siteId, roleName);
if (role == null)
{
var er = new IdentityError
{
Description = "role not found"
};
errors.Add(er);
return(IdentityResult.Failed(errors.ToArray()));
}
var user = await _queries.Fetch(siteId, userId);
if (user == null)
{
var er = new IdentityError
{
Description = "user not found"
};
errors.Add(er);
return(IdentityResult.Failed(errors.ToArray()));
}
await _commands.RemoveUserFromRole(role.SiteId, role.Id, user.Id);
user.RolesChanged = true;
await _commands.Update(user);
return(IdentityResult.Success);
}
public async Task <IdentityResult> RemoveUserFromRole(Guid siteId, Guid userId, string roleName)
{
var errors = new List <IdentityError>();
var role = await _queries.FetchRole(siteId, roleName);
if (role == null)
{
var er = new IdentityError
{
Description = "role not found"
};
errors.Add(er);
return(IdentityResult.Failed(errors.ToArray()));
}
var user = await _queries.Fetch(siteId, userId);
if (user == null)
{
var er = new IdentityError
{
Description = "user not found"
};
errors.Add(er);
return(IdentityResult.Failed(errors.ToArray()));
}
await _commands.RemoveUserFromRole(role.SiteId, role.Id, user.Id);
user.RolesChanged = true;
await _commands.Update(user);
foreach (var handler in _userRemovedFromRoleHandlers)
{
try
{
await handler.Handle(user, role);
}
catch (Exception ex)
{
_log.LogError($"{ex.Message}-{ex.StackTrace}");
}
}
return(IdentityResult.Success);
}
public async Task AddUserToRole(ISiteUser user, ISiteRole role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
if (role.SiteId != user.SiteId)
{
throw new ArgumentException("user and role must have the same siteid");
}
await commands.AddUserToRole(role.Id, user.Id, CancellationToken);
user.RolesChanged = true;
await commands.Update(user, CancellationToken);
}
public async Task <IdentityResult> UpdateAsync(TUser user, CancellationToken cancellationToken)
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
log.LogDebug("UpdateAsync");
if (user == null)
{
throw new ArgumentNullException("user");
}
await commands.Update(user, cancellationToken);
return(IdentityResult.Success);
}
//public override async Task<string> GenerateEmailConfirmationTokenAsync(TUser user)
//{
// Guid registerConfirmGuid = Guid.NewGuid();
// bool result = await userRepo.SetRegistrationConfirmationGuid(user.UserGuid, registerConfirmGuid, CancellationToken.None);
// return registerConfirmGuid.ToString();
//}
//public override async Task<IdentityResult> ConfirmEmailAsync(TUser user, string token)
//{
// if(token.Length != 36)
// {
// // TODO: log info or warning
// return IdentityResult.Failed();
// }
// Guid confirmGuid = new Guid(token);
// ISiteUser siteUser = await userRepo.FetchByConfirmationGuid(Site.SiteId, confirmGuid, CancellationToken);
// if((siteUser != null)&&(siteUser.UserGuid == user.UserGuid))
// {
// bool result = await userRepo.ConfirmRegistration(confirmGuid, CancellationToken.None);
// if(result) { return IdentityResult.Success; }
// }
// return IdentityResult.Failed();
//}
/// <summary>
/// Increments the access failed count for the user as an asynchronous operation.
/// If the failed access account is greater than or equal to the configured maximum number of attempts,
/// the user will be locked out for the configured lockout time span.
/// </summary>
/// <param name="user">The user whose failed access count to increment.</param>
/// <returns>The <see cref="Task"/> that represents the asynchronous operation, containing the <see cref="IdentityResult"/> of the operation.</returns>
public override async Task <IdentityResult> AccessFailedAsync(TUser user)
{
//ThrowIfDisposed();
var store = GetUserLockoutStore();
if (user == null)
{
throw new ArgumentNullException("user");
}
// If this puts the user over the threshold for lockout, lock them out and reset the access failed count
var count = await store.IncrementAccessFailedCountAsync(user, CancellationToken);
//if (count < defaultIdentityOptions.Lockout.MaxFailedAccessAttempts)
if (count < Site.MaxInvalidPasswordAttempts)
{
//return await UpdateUserAsync(user);
await commands.Update(user, CancellationToken.None);
return(IdentityResult.Success);
}
Logger.LogWarning(12, "User {userId} is locked out.", await GetUserIdAsync(user));
// TODO: should DefaultLockoutTimeSpan be promoted to a site setting?
await store.SetLockoutEndDateAsync(
user,
DateTimeOffset.UtcNow.Add(identityOptions.Lockout.DefaultLockoutTimeSpan),
CancellationToken);
await store.ResetAccessFailedCountAsync(user, CancellationToken);
//return await UpdateUserAsync(user);
await commands.Update(user, CancellationToken.None);
return(IdentityResult.Success);
}
public UserModel Update(
string id,
string token = null,
string lastUpdatedOnUtc = null,
string lastLoginOnUtc = null)
{
var result = _userCommands.Update(id, token, lastUpdatedOnUtc, lastLoginOnUtc);
if (result == null)
{
return(null);
}
return(new UserModel()
{
Id = result.Id,
CreatedOnUtc = result.CreatedOnUtc,
LastLoginOnUtc = result.LastLoginOnUtc,
LastUpdatedOnUtc = result.LastUpdatedOnUtc,
Token = result.Token
});
}
