public async Task <bool> AssignRole(ClaimsPrincipal claim, string userId, List <string> selectedRoles)
{
if (!selectedRoles.Any())
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.EmptyData);
}
List <string> roleNames = _roleManager.Roles.Where(x => selectedRoles.Contains(x.Id) && x.Status).Select(x => x.Name).ToList();
if (!roleNames.Any())
{
throw new WebApiApplicationException(StatusCodes.Status404NotFound, ErrorMessages.RecordNotFound);
}
ApplicationUser user =
await Task.Run(() => _userManager.Users.FirstOrDefault(x => x.Id == userId));
ExtBusinessLogic.CheckRecord(user);
user.ModifiedBy = ExtBusinessLogic.UserValue(claim);
var result = await _userManager.AddToRolesAsync(user, roleNames);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.CommonErrorMessage,
result.Errors.ToList());
}
return(true);
}
public async Task <bool> GeneratePasswordResetTokenAsync(string userEmail)
{
ApplicationUser user =
_userManager.Users.FirstOrDefault(x => x.UserName == userEmail);
ExtBusinessLogic.CheckRecord(user);
if (user != null && !user.EmailConfirmed)
{
throw new WebApiApplicationException(StatusCodes.Status403Forbidden, ErrorMessages.EmailNotVerified);
}
string passwordResetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
var passwordReset = System.IO.Path.Combine(_env.WebRootPath, EmailFiles.ResetPassword);
string passwordResetContent = System.IO.File.ReadAllText(passwordReset);
string callbackUrl = _httpContextAccessor.HttpContext.Request.Headers[HttpRequestHeaders.RequestUrl]
.ToString().CreateRequestUrl(confirmationToken: HttpUtility.UrlEncode(passwordResetToken),
// ReSharper disable once PossibleNullReferenceException
userId: user.Id);
passwordResetContent = passwordResetContent.Replace(EmailContentKeywords.ActivateLink, callbackUrl);
await _emailSender.SendEmailAsync(user.Email, EmailSubject.ResetPassword, passwordResetContent);
return(true);
}
public async Task <bool> AddNewUserAsync(ClaimsPrincipal claim, AddNewUserViewModel data)
{
string userId = ExtBusinessLogic.UserValue(claim);
data.CreatedBy = userId;
ApplicationUser user = _mapper.Map <ApplicationUser>(data);
bool userAlreadyExit = _userManager.Users.Any(x => x.UserName == user.UserName);
if (userAlreadyExit)
{
throw new WebApiApplicationException(StatusCodes.Status409Conflict, ErrorMessages.ErrorCreatingLocalUser,
new object[]
{
new
{
Code = ErrorMessages.UserExistCode,
Description = ErrorMessages.UserExistDescription.Replace("[USERNAME]", user.UserName)
}
});
}
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status409Conflict, ErrorMessages.ErrorCreatingLocalUser, result.Errors.ToList());
}
await SendConfirmationEmail(user);
return(true);
}
public async Task <bool> VerifyPasswordResetTokenAsync(string token, string userId)
{
ApplicationUser user =
_userManager.Users.FirstOrDefault(x => x.Id == userId);
ExtBusinessLogic.CheckRecord(user);
return(await _userManager.VerifyUserTokenAsync(user, TokenOptions.DefaultProvider, "ResetPassword", token));
}
public async Task <bool> UserIsInRole(ClaimsPrincipal claim, string roleName)
{
ApplicationRole role = await Task.Run(() => _roleManager.Roles.FirstOrDefault(x => x.Name == roleName));
ExtBusinessLogic.CheckRecord(role);
ApplicationUser user =
await Task.Run(() => _userManager.Users.FirstOrDefault(x => x.Id == ExtBusinessLogic.UserValue(claim, nameof(ApplicationUser.Id))));
ExtBusinessLogic.CheckRecord(user);
return(await _userManager.IsInRoleAsync(user, role.Name));
}
public async Task <bool> UserIsInRole(string userId, string roleId)
{
ApplicationRole role = await Task.Run(() => _roleManager.Roles.FirstOrDefault(x => x.Id == roleId));
ExtBusinessLogic.CheckRecord(role);
ApplicationUser user =
await Task.Run(() => _userManager.Users.FirstOrDefault(x => x.Id == userId));
ExtBusinessLogic.CheckRecord(user);
return(await _userManager.IsInRoleAsync(user, role.Name));
}
public async Task <bool> UpdateRole(ClaimsPrincipal claim, ApplicationRoleViewModel data)
{
data.ModifiedBy = ExtBusinessLogic.UserValue(claim);
ApplicationRole roleData = _mapper.Map <ApplicationRole>(data);
var result = await _roleManager.UpdateAsync(roleData);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.CommonErrorMessage, result.Errors.ToList());
}
return(true);
}
public async Task <bool> ChangePasswordAsync(ClaimsPrincipal claim, ChangePasswordViewModel data)
{
ApplicationUser user =
_userManager.Users.FirstOrDefault(
x => x.Id == ExtBusinessLogic.UserValue(claim, nameof(ApplicationUser.Id)) && x.Status && !x.Trashed);
IdentityResult result = await _userManager.ChangePasswordAsync(user, data.OldPassword, data.NewPassword);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.ErrorSetPassword, result.Errors.ToList());
}
return(true);
}
public async Task <bool> ResetPasswordAsync(ResetPasswordWithTokenViewModel data)
{
ApplicationUser user = _userManager.Users.FirstOrDefault(x => x.Id == data.UserId);
ExtBusinessLogic.CheckRecord(user);
IdentityResult result = await _userManager.ResetPasswordAsync(user, data.Token, data.ConfirmPassword);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.ErrorSetPassword, result.Errors.ToList());
}
return(true);
}
public async Task <bool> RemoveRole(ClaimsPrincipal claim, ApplicationRoleViewModel data)
{
ApplicationRole roleData = _roleManager.Roles.FirstOrDefault(x => x.Id == data.Id);
ExtBusinessLogic.CheckRecord(roleData);
// ReSharper disable once PossibleNullReferenceException
roleData.ModifiedBy = ExtBusinessLogic.UserValue(claim);
var result = await _roleManager.DeleteAsync(roleData);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.CommonErrorMessage, result.Errors.ToList());
}
return(true);
}
public async Task <bool> RevokeToken(ClaimsPrincipal claim)
{
ApplicationUser user = _userManager.Users.FirstOrDefault(x =>
x.Id == ExtBusinessLogic.UserValue(claim, nameof(ApplicationUser.Id)));
if (user == null)
{
throw new WebApiApplicationException(StatusCodes.Status404NotFound, ErrorMessages.ErrorUserNotFound);
}
//CheckRecord(user);
user.TokenNumber = null;
await _userManager.UpdateAsync(user);
//_userStore.Context.SaveChanges();
await _tokenManager.DeactivateCurrentAsync();
return(true);
}
public async Task <bool> CreateRole(ClaimsPrincipal claim, ApplicationRoleViewModel data)
{
data.CreatedBy = ExtBusinessLogic.UserValue(claim);
data.ModifiedBy = ExtBusinessLogic.UserValue(claim);
ApplicationRole roleData = _mapper.Map <ApplicationRole>(data);
bool roleExist = await _roleManager.RoleExistsAsync(roleData.Name);
if (roleExist)
{
throw new WebApiApplicationException(StatusCodes.Status409Conflict, ErrorMessages.RoleAlreadyExist);
}
roleData.GenerateNewId();
var result = await _roleManager.CreateAsync(roleData);
if (!result.Succeeded)
{
throw new WebApiApplicationException(StatusCodes.Status400BadRequest, ErrorMessages.CommonErrorMessage, result.Errors.ToList());
}
return(true);
}
