public virtual async Task <TUser> FindByEmailAsync(string email)
{
ThrowIfDisposed();
IUserEmailStore <TUser> emailStore = GetEmailStore();
if (email == null)
{
throw new ArgumentNullException(nameof(email));
}
TUser user = await emailStore.FindByEmailAsync(email, CancellationToken);
if (user == null && Options.Stores.ProtectPersonalData)
{
ILookupProtectorKeyRing keyRing = _services.GetService <ILookupProtectorKeyRing>();
ILookupProtector protector = _services.GetService <ILookupProtector>();
if (keyRing != null && protector != null)
{
foreach (var key in keyRing.GetAllKeyIds())
{
string oldKey = protector.Protect(key, email);
user = await emailStore.FindByEmailAsync(oldKey, CancellationToken);
if (user != null)
{
return(user);
}
}
}
}
return(user);
}
public override async Task <IDisplayResult> UpdateAsync(User user, UpdateEditorContext context)
{
var model = new EditUserViewModel();
if (!await context.Updater.TryUpdateModelAsync(model, Prefix))
{
return(await EditAsync(user, context));
}
model.UserName = model.UserName?.Trim();
model.Email = model.Email?.Trim();
user.EmailConfirmed = model.EmailConfirmed;
if (string.IsNullOrWhiteSpace(model.UserName))
{
context.Updater.ModelState.AddModelError("UserName", T["A user name is required."]);
}
if (string.IsNullOrWhiteSpace(model.Email))
{
context.Updater.ModelState.AddModelError("Email", T["An email is required."]);
}
await _userStore.SetUserNameAsync(user, model.UserName, default(CancellationToken));
await _userEmailStore.SetEmailAsync(user, model.Email, default(CancellationToken));
var userWithSameName = await _userStore.FindByNameAsync(_userManager.NormalizeKey(model.UserName), default(CancellationToken));
if (userWithSameName != null)
{
var userWithSameNameId = await _userStore.GetUserIdAsync(userWithSameName, default(CancellationToken));
if (userWithSameNameId != model.Id)
{
context.Updater.ModelState.AddModelError(string.Empty, T["The user name is already used."]);
}
}
var userWithSameEmail = await _userEmailStore.FindByEmailAsync(_userManager.NormalizeKey(model.Email), default(CancellationToken));
if (userWithSameEmail != null)
{
var userWithSameEmailId = await _userStore.GetUserIdAsync(userWithSameEmail, default(CancellationToken));
if (userWithSameEmailId != model.Id)
{
context.Updater.ModelState.AddModelError(string.Empty, T["The email is already used."]);
}
}
if (context.Updater.ModelState.IsValid)
{
var roleNames = model.Roles.Where(x => x.IsSelected).Select(x => x.Role).ToList();
if (context.IsNew)
{
// Add new roles
foreach (var role in roleNames)
{
await _userRoleStore.AddToRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken));
}
}
else
{
// Remove roles in two steps to prevent an iteration on a modified collection
var rolesToRemove = new List <string>();
foreach (var role in await _userRoleStore.GetRolesAsync(user, default(CancellationToken)))
{
if (!roleNames.Contains(role))
{
rolesToRemove.Add(role);
}
}
foreach (var role in rolesToRemove)
{
await _userRoleStore.RemoveFromRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken));
}
// Add new roles
foreach (var role in roleNames)
{
if (!await _userRoleStore.IsInRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken)))
{
await _userRoleStore.AddToRoleAsync(user, _userManager.NormalizeKey(role), default(CancellationToken));
}
}
}
}
return(await EditAsync(user, context));
}