public UserRole AddUserRole([FromBody] AddUserRoleModel model)
{
Role role = roleRepository.Find(model.RoleId);
User user = userRepository.Find(model.UserId);
return(AddUserRole(role, user));
}
public async Task <ActionResult> AddUserToRole(AddUserRoleModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(e => e.Errors)));
}
var user = await _userManager.FindByEmailAsync(viewModel.Email).ConfigureAwait(true);
if (user == null)
{
return(BadRequest("Usuário não cadastrado"));
}
bool roleExists = await _roleManager.RoleExistsAsync(viewModel.Role).ConfigureAwait(true);
if (!roleExists)
{
return(BadRequest("Role não cadastrado"));
}
IdentityResult resultRole = await _userManager.AddToRoleAsync(user, viewModel.Role).ConfigureAwait(true);
if (!resultRole.Succeeded)
{
return(BadRequest(resultRole.Errors));
}
return(Ok());
}
public async Task <IActionResult> AddUserRole(AddUserRoleModel model)
{
var result = new TaskResult <string>();
var userResult = await _usersRepository.GetByIdAsync(model.UserId);
if (userResult.Data == null)
{
userResult.AddErrorMessage("El usuario no existe");
return(BadRequest(userResult));
}
var roleResult = await _rolesRepository.GetByNameAsync(model.RoleName);
if (roleResult.Data == null)
{
roleResult.AddErrorMessage("El role no existe");
return(BadRequest(roleResult));
}
var added = await _usersRepository.AddUserRoleAsync(roleResult.Data.Id, userResult.Data.Id);
if (!added)
{
result.AddErrorMessage($"Error al agregar el rol {model.RoleName} al usuario {userResult.Data.UserName}");
return(Ok(result));
}
result.AddMessage($"Se agregó exitosamente el rol {model.RoleName} al usuario {userResult.Data.UserName}");
return(Ok(result));
}
public async Task <IActionResult> AddRoleAsync(string id)
{
// public SelectList allRoles { get; set; }
var model = new AddUserRoleModel();
if (string.IsNullOrEmpty(id))
{
return(NotFound($"Không có user"));
}
model.user = await _userManager.FindByIdAsync(id);
if (model.user == null)
{
return(NotFound($"Không thấy user, id = {id}."));
}
model.RoleNames = (await _userManager.GetRolesAsync(model.user)).ToArray <string>();
List <string> roleNames = await _roleManager.Roles.Select(r => r.Name).ToListAsync();
ViewBag.allRoles = new SelectList(roleNames);
await GetClaims(model);
return(View(model));
}
public async Task <bool> DeleteUserRole(AddUserRoleModel <string> model, string userId)
{
var user = _user.Get(model.UserId);
var userRole = user.UserRoles.FirstOrDefault(m => m.RoleId == model.RoleId);
user.UserRoles.Remove(userRole);
await _user.Update(user);
return(true);
}
public async Task <bool> AddUserRole(AddUserRoleModel <int> model, int UserId)
{
var userRole = _userRole.GetFirst(m => m.UserId == model.UserId && m.RoleId == model.RoleId);
if (userRole != null)
{
}
userRole = (TUserRole)EntityUserRole.Create(model, UserId);
_userRole.Add(userRole);
return(true);
}
public async Task <NetResult <SuccessResult> > AddUserToRole([FromBody] AddUserRoleModel <TKey> model)
{
try
{
SuccessResult result = new SuccessResult();
result.Success = await _userRole.AddUserRole(model, this.UserId <TKey>());
return(result);
}
catch (Exception ext) { return(ext); }
}
public static EntityUserRole Create(AddUserRoleModel <int> model, int userId)
{
EntityUserRole entity = new EntityUserRole()
{
UserId = model.UserId,
AddUserId = userId,
RoleId = model.RoleId,
Status = AuthModel.Enum.UserStatus.Active
};
return(entity);
}
public async Task <object> DeleteUserRole([FromBody] AddUserRoleModel <TKey> model)
{
SuccessResult result = new SuccessResult();
try
{
result.Success = await _userRole.DeleteUserRole(model, this.UserId <TKey>());
}
catch (Exception ext)
{
result.Success = false;
}
return(result);
}
public async Task <bool> DeleteUserRole(AddUserRoleModel model, int userId)
{
var item = _dbSet.Where(m => m.UserId == model.UserId && m.RoleId == model.RoleId).ToList();
if (item.Count == 0)
{
return(true);
}
_dbSet.RemoveRange(item);
var obj = JsonConvert.SerializeObject(item);
var deleteData = (TDeleteData)Activator.CreateInstance(typeof(TDeleteData));
//TODO item
_deleteData.AddData("IdentityUserRole", userId, deleteData);
return(true);
}
private async Task GetClaims(AddUserRoleModel model)
{
var listRoles = from r in _context.Roles
join ur in _context.UserRoles on r.Id equals ur.RoleId
where ur.UserId == model.user.Id
select r;
var _claimsInRole = from c in _context.RoleClaims
join r in listRoles on c.RoleId equals r.Id
select c;
model.claimsInRole = await _claimsInRole.ToListAsync();
model.claimsInUserClaim = await(from c in _context.UserClaims
where c.UserId == model.user.Id select c).ToListAsync();
}
public async Task <IActionResult> AddRoleAsync(string id, [Bind("RoleNames")] AddUserRoleModel model)
{
if (string.IsNullOrEmpty(id))
{
return(NotFound($"Không có user"));
}
model.user = await _userManager.FindByIdAsync(id);
if (model.user == null)
{
return(NotFound($"Không thấy user, id = {id}."));
}
await GetClaims(model);
var OldRoleNames = (await _userManager.GetRolesAsync(model.user)).ToArray();
var deleteRoles = OldRoleNames.Where(r => !model.RoleNames.Contains(r));
var addRoles = model.RoleNames.Where(r => !OldRoleNames.Contains(r));
List <string> roleNames = await _roleManager.Roles.Select(r => r.Name).ToListAsync();
ViewBag.allRoles = new SelectList(roleNames);
var resultDelete = await _userManager.RemoveFromRolesAsync(model.user, deleteRoles);
if (!resultDelete.Succeeded)
{
ModelState.AddModelError(resultDelete);
return(View(model));
}
var resultAdd = await _userManager.AddToRolesAsync(model.user, addRoles);
if (!resultAdd.Succeeded)
{
ModelState.AddModelError(resultAdd);
return(View(model));
}
StatusMessage = $"Vừa cập nhật role cho user: {model.user.UserName}";
return(RedirectToAction("Index"));
}
public async Task <bool> AddUserRole(AddUserRoleModel model, int UserId)
{
var userRole = _dbSet.FirstOrDefault(m => m.UserId == model.UserId && m.RoleId == model.RoleId);
if (userRole != null)
{
}
userRole = (TUserRole)Activator.CreateInstance(typeof(TUserRole));
userRole.UserId = model.UserId;
userRole.RoleId = model.RoleId;
UserRoleChange userRoleChange = new UserRoleChange()
{
ChangeDate = DateTime.Now,
ChangeUserId = UserId,
Description = "User Role add"
};
userRole.AddUserRole(userRoleChange);
//_dbSet.Add(userRole);
Add(userRole);
return(true);
}
//todo
public async Task <bool> AddUserRole(AddUserRoleModel <string> model, string UserId)
{
var role = _role.Get(model.RoleId);// ?? throw new CoreException();
if (role == null)
{
throw new CoreException("Role not found", 20);
}
var userRole = (TUserRole)Activator.CreateInstance(typeof(TUserRole));
userRole.RoleId = role.Id;
userRole.MongoRole = role;
userRole.AddUserId = UserId;
var user = _user.Get(model.UserId);//?? throw new CoreException();
if (user == null)
{
throw new CoreException("User not found", 0);
}
user.UserRoles.Add(userRole);
await _user.Update(user);
return(true);
}
public async Task <bool> DeleteUserRole(AddUserRoleModel <int> model, int userId)
{
_userRole.DeleteMany(m => m.UserId == model.UserId && m.RoleId == model.RoleId);
return(true);
}
