public async Task RemoveUserRole(AddToRoleDto model)
{
await ProcessRequest(async() =>
{
ApplicationUser existingUser = await _unitOfWork.User.FindByNameAsync(model.UserName);
if (existingUser == null)
{
throw new AppException(_logger, $"User name: {model.UserName} not found");
}
List <ApplicationRole> currentRole = existingUser.UserRoles.Select(x => x.Role).ToList();
var existingRole = await _unitOfWork.Role.FindByNameAsync(model.RoleName);
if (existingRole == null)
{
throw new AppException(_logger, $"Role name: {model.RoleName} not found");
}
if (!currentRole.Select(x => x.Name).Contains(model.RoleName.ToLower()))
{
throw new AppException(_logger, $"the user is not in this role: {model.RoleName}");
}
var userRole = await _unitOfWork.UserRole.FirstOrDefaultAsync(x => x.RoleId == existingRole.Id && x.UserId == existingUser.Id);
if (userRole == null)
{
throw new AppException(_logger, $"User name: {model.UserName} not belong role: {model.RoleName}");
}
_unitOfWork.UserRole.Delete(userRole);
await _unitOfWork.SaveAsync();
});
}
public async Task <IActionResult> CreateAsync(AddToRoleDto model)
{
var getQuery = new AddUserToRole.Command(model);
var res = await _mediator.Send(getQuery);
return(Ok(res));
}
public async Task AddUserToRole(AddToRoleDto model)
{
await ProcessRequest(async() =>
{
ApplicationUser existingUser = await _unitOfWork.User.FindByNameAsync(model.UserName);
if (existingUser == null)
{
throw new AppException(_logger, $"User name: {model.UserName} not found");
}
List <ApplicationRole> currentRole = existingUser.UserRoles.Select(x => x.Role).ToList();
var existingRole = await _unitOfWork.Role.FindByNameAsync(model.RoleName);
if (existingRole == null)
{
throw new AppException(_logger, $"Role name: {model.RoleName} not found");
}
if (currentRole.Select(x => x.Name).Contains(model.RoleName.ToLower()))
{
throw new AppException(_logger, $"User already has an {model.RoleName} role");
}
ApplicationUserRole applicationUserRole = new ApplicationUserRole()
{
RoleId = existingRole.Id,
UserId = existingUser.Id
};
await _unitOfWork.UserRole.CreateAsync(applicationUserRole);
await _unitOfWork.SaveAsync();
});
}
public IActionResult AddUserToRole(AddToRoleDto model)
{
var user = UnitOfWork.UserManager.FindByEmailAsync(model.Email).GetAwaiter().GetResult();
UnitOfWork.UserManager.AddToRoleAsync(user, model.Role).GetAwaiter().GetResult();
return(Ok());
}
public async Task <IActionResult> RemoveUserRole(AddToRoleDto model)
{
try
{
await _roleService.RemoveUserRole(model);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <ApplicationUser> RegisterUSerByAdmin(RegisterAdminDto request)
{
return(await ProcessRequest(async() =>
{
if (request.Password != request.ConfirmPassword)
{
throw new AppException(_logger, "ConfirmPassword is not the same Password");
}
var userName = await _unitOfWork.User.FindByNameAsync(request.UserName);
if (userName != null)
{
throw new AppException(_logger, $"User Name: {request.UserName} is already taken");
}
var userEmail = await _unitOfWork.User.FindByEmailAsync(request.Email);
if (userEmail != null)
{
throw new AppException(_logger, $"User Email: {request.Email} is already taken");
}
if (!request.Dob.HasValue)
{
throw new AppException(_logger, "Date of birth is required");
}
var user = _mapper.Map <ApplicationUser>(request);
if (user == null)
{
throw new AppException(_logger, "Register Failed");
}
byte[] passwordHash, passwordSalt;
CreatePasswordHash(request.Password, out passwordHash, out passwordSalt);
user.PasswordHash = passwordHash;
user.PasswordSalt = passwordSalt;
user.NormalizedUserName = request.UserName.ToUpper();
user.NormalizedEmail = request.Email.ToUpper();
user.SecurityStamp = Guid.NewGuid().ToString("D");
await _unitOfWork.User.CreateAsync(user);
var claims = new List <Claim>()
{
new Claim(ClaimTypes.GivenName, request.FirstName),
new Claim(ClaimTypes.Surname, request.LastName),
new Claim(ClaimTypes.Email, request.Email)
};
foreach (var claim in claims)
{
var userClaim = new ApplicationUserClaim()
{
UserId = user.Id,
ClaimType = claim.Type,
ClaimValue = claim.Value
};
await _unitOfWork.UserClaim.CreateAsync(userClaim);
}
await _unitOfWork.SaveAsync();
var listRoleModel = new ArrayList();
if (request.ListRoleName == null)
{
var role = new AddToRoleDto()
{
RoleName = "USER",
UserName = request.UserName
};
await _roleService.AddUserToRole(role);
}
else
{
foreach (var role in request.ListRoleName)
{
var roleModel = new AddToRoleDto()
{
UserName = request.UserName,
RoleName = role
};
listRoleModel.Add(roleModel);
}
}
if (listRoleModel == null)
{
throw new AppException(_logger, "Add Role Failed");
}
foreach (AddToRoleDto roleModel in listRoleModel)
{
await _roleService.AddUserToRole(roleModel);
}
return user;
}));
}
public Command(AddToRoleDto model)
{
this.model = model;
}
public async Task <string> ExternalLoginCallback()
{
return(await ProcessRequest(async() =>
{
ExternalLoginInfo info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
throw new AppException(_logger, "Failed to get information");
}
ApplicationUser userEmailExists = await _unitOfWork.User.FindByEmailAsync(info.Principal.FindFirst(ClaimTypes.Email).Value);
if (userEmailExists == null)
{
ApplicationUser appUser = new ApplicationUser()
{
Email = info.Principal.FindFirst(ClaimTypes.Email).Value,
UserName = info.Principal.FindFirst(ClaimTypes.Email).Value,
FirstName = info.Principal.FindFirst(ClaimTypes.GivenName).Value,
LastName = info.Principal.FindFirst(ClaimTypes.Surname).Value,
EmailConfirmed = true,
};
await _unitOfWork.User.CreateAsync(appUser);
await _unitOfWork.SaveAsync();
List <Claim> claims = new List <Claim>()
{
new Claim(ClaimTypes.GivenName, appUser.FirstName),
new Claim(ClaimTypes.Surname, appUser.LastName),
new Claim(ClaimTypes.Email, appUser.Email),
};
AddToRoleDto role = new AddToRoleDto()
{
RoleName = "USER",
UserName = appUser.UserName
};
await _roleService.AddUserToRole(role);
foreach (var claim in claims)
{
var userClaim = new ApplicationUserClaim()
{
UserId = appUser.Id,
ClaimType = claim.Type,
ClaimValue = claim.Value
};
await _unitOfWork.UserClaim.CreateAsync(userClaim);
}
await _unitOfWork.SaveAsync();
return _tokenService.GenerateJWTToken(appUser, 1);
}
else
{
userEmailExists.Email = info.Principal.FindFirst(ClaimTypes.Email).Value;
userEmailExists.FirstName = info.Principal.FindFirst(ClaimTypes.GivenName).Value;
userEmailExists.LastName = info.Principal.FindFirst(ClaimTypes.Surname).Value;
userEmailExists.UserName = info.Principal.FindFirst(ClaimTypes.Email).Value;
userEmailExists.EmailConfirmed = true;
_unitOfWork.User.Update(userEmailExists);
await _unitOfWork.SaveAsync();
return _tokenService.GenerateJWTToken(userEmailExists, 1);
}
}));
}
