public Task <HttpResponseMessage> UpdateAsync([FromBody] CoreModels.User user)
{
return(TryExecuteAsync(async() =>
{
Guard.ArgumentIsNotNull(user, nameof(user));
IdentityResult result = await _authService.UpdateUserAsync(user);
return Request.CreateResponse(HttpStatusCode.OK, result);
}));
}
public Task <HttpResponseMessage> CreateAsync([FromBody] CoreModels.User user)
{
return(TryExecuteAsync(async() =>
{
Guard.ArgumentIsNotNull(user, nameof(user));
string userId = await _authService.CreateUserAsync(user);
return Request.CreateResponse(HttpStatusCode.OK, userId);
}));
}
private void ValdiateIfUserWithSameLoginExists(CoreModels.User user)
{
List <IdentityUser> userWithSameLoginList = _userManager.Users.Where(x => x.UserName == user.FullName).ToList();
if (userWithSameLoginList.Count > 1)
{
throw new ValidationException(UserWithSameEmailExistsMessage);
}
IdentityUser userWithSameLogin = userWithSameLoginList.FirstOrDefault();
if (userWithSameLogin != null && userWithSameLogin.Id != user.UserId)
{
throw new ValidationException(UserWithSameEmailExistsMessage);
}
}
public static void Validate(CoreModels.User user)
{
if (string.IsNullOrWhiteSpace(user.Login))
{
throw new ValidationException("Login is required");
}
if (user.Login.Length > FieldLength)
{
throw new ValidationException($"Login length can not be more than {FieldLength} symbols");
}
if (user.Login != null && !Regex.IsMatch(user.Login, EmailPattern))
{
throw new ValidationException("Login does not have an email format");
}
if (string.IsNullOrWhiteSpace(user.FullName))
{
throw new ValidationException("FullName is required");
}
if (user.FullName.Length > FieldLength)
{
throw new ValidationException($"FullName length can not be more than {FieldLength} symbols");
}
//if ((user.Roles & Roles.SuperAdmin) != Roles.SuperAdmin
// && (user.Roles & Roles.Admin) != Roles.Admin
// && (user.Roles & Roles.Employee) != Roles.Employee
// && (user.Roles & Roles.Manager) != Roles.Manager
// && (user.Roles & Roles.Recruiter) != Roles.Recruiter)
//{
// throw new ValidationException("Roles are not valid");
//}
if (!string.IsNullOrWhiteSpace(user.Password))
{
ValidatePassword(user.Password);
}
}
public async Task <string> CreateUserAsync(CoreModels.User user)
{
Guard.ArgumentIsNotNull(user, nameof(user));
UserValidator.Validate(user);
ValdiateIfUserWithSameLoginExists(user);
IdentityUser identityUser = new IdentityUser
{
Id = Guid.NewGuid().ToString(),
UserName = user.Login,
Email = user.FullName
};
foreach (Role role in user.Roles)
{
identityUser.Roles.Add(new IdentityUserRole
{
UserId = identityUser.Id,
RoleId = role.Id
});
identityUser.Claims.Add(new IdentityUserClaim
{
ClaimType = ClaimTypes.Role,
ClaimValue = role.Name,
UserId = identityUser.Id
});
}
identityUser.LockoutEnabled = true;
identityUser.PasswordHash = _userManager.PasswordHasher.HashPassword(user.Password);
IdentityResult result = await _userManager.CreateAsync(identityUser, user.Password);
return(result.Succeeded ? identityUser.Id : string.Empty);
}
public async Task <IdentityResult> UpdateUserAsync(CoreModels.User user)
{
Guard.ArgumentIsNotNull(user, nameof(user));
bool securityStampNeedToBeChanged = false;
UserValidator.Validate(user);
ValdiateIfUserWithSameLoginExists(user);
IdentityUser identityUser = await _userManager.Users.FirstOrDefaultAsync(x => x.Id == user.UserId);
if (identityUser == null)
{
return(new IdentityResult("IdentityUser is null"));
}
if (identityUser.UserName != user.Login)
{
identityUser.UserName = user.Login;
securityStampNeedToBeChanged = true;
}
identityUser.Email = user.FullName;
identityUser.Roles.Clear();
foreach (Role role in user.Roles)
{
identityUser.Roles.Add(new IdentityUserRole
{
UserId = user.UserId,
RoleId = role.Id
});
//identityUser.Claims.Add(new IdentityUserClaim
//{
// Id = maxClaimId++,
// ClaimType = ClaimTypes.Role,
// ClaimValue = role.Name,
// UserId = user.UserId
//});
}
if (!string.IsNullOrEmpty(user.Password))
{
identityUser.PasswordHash = _userManager.PasswordHasher.HashPassword(user.Password);
securityStampNeedToBeChanged = true;
}
IdentityResult result = await _userManager.UpdateAsync(identityUser);
if (result.Succeeded && securityStampNeedToBeChanged)
{
await _userManager.UpdateSecurityStampAsync(identityUser.Id);
}
if (result.Succeeded)
{
// TODO: refactor. Is needed because UserManager throws an exception "UserId" is required if Id is empty
await ClearClaimsManuallyAsync(identityUser.Id);
foreach (Role role in user.Roles)
{
await AddClaimsManuallyAsync(user.UserId, role.Name);
}
}
return(result);
}
