public async Task <IActionResult> DeleteUserFromRole(UsersRoleViewModel model)
{
//find the role
var role = await _roleManager.FindByNameAsync(model.RoleName);
if (role == null)
{
return(NotFound(new { message = "Role Not Found" }));
}
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(NotFound(new { message = "user not found" }));
}
var result = await _userManager.RemoveFromRoleAsync(user, role.Name);
if (result.Succeeded)
{
return(Ok(new { message = "Removed successfully" }));
}
return(BadRequest(new { message = "Failed to Remove User" }));
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.roleId = roleId;
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {roleId} cannot be found";
return(View("NotFound"));
}
var model = new List <UsersRoleViewModel>();
foreach (var user in userManager.Users)
{
var userRoleViewModel = new UsersRoleViewModel
{
UserId = user.Id,
Email = user.Email
};
if (await userManager.IsInRoleAsync(user, role.Name))
{
userRoleViewModel.IsSelected = true;
}
else
{
userRoleViewModel.IsSelected = false;
}
model.Add(userRoleViewModel);
}
return(View(model));
}
public async Task <IActionResult> AddUserToRole(UsersRoleViewModel model)
{
//first find the role
var role = await _roleManager.FindByNameAsync(model.RoleName);
if (role == null)
{
return(NotFound(new { message = "Role Not Found" }));
}
//find the user by Id
var user = await _userManager.FindByIdAsync(model.UserId);
if (user == null)
{
return(NotFound(new { message = "User not Found" }));
}
//add the user to the role
var result = await _userManager.AddToRoleAsync(user, role.Name);
if (result.Succeeded)
{
return(Ok(new { message = "User added to role" }));
}
return(BadRequest(new { message = "Failed to add user" }));
}
public override bool IsUserInRole(string UserName, string roleName)
{
bool outputResult = false;
// Находим пользователя
using (DBContext _db = new DBContext())
{
try
{
// Получаем пользователя
UserViewModel user = _db.User.ViewSingle(UserName);
if (user != null)
{
// получаем роль
UsersRoleViewModel userRole = _db.UserRole.ViewSingle(user.UserRoleId);
//сравниваем
if (userRole != null && userRole.UserRoleName == roleName)
{
outputResult = true;
}
}
}
catch
{
outputResult = false;
}
}
return(outputResult);
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.RoleId = roleId;
var role = await this._roleManager.FindByIdAsync(roleId);
if (role == null)
{
return(View("NotFound", NotFoundId(roleId)));
}
var viewModel = new UsersRoleViewModel();
foreach (var user in this._userManager.Users)
{
var userRoleViewModel = new UserRoleItemViewModel()
{
UserId = user.Id,
UserName = user.UserName
};
if (await this._userManager.IsInRoleAsync(user, role.Name))
{
userRoleViewModel.IsSelected = true;
}
else
{
userRoleViewModel.IsSelected = false;
}
viewModel.Items.Add(userRoleViewModel);
}
return(View(viewModel));
}
public IActionResult UpdateUsersRole(UsersRoleViewModel model)
{
var id = model.userDetail.Id;
if (id == null)
{
return(View("_NotFound"));
}
//cek user with id
var getUser = _MainSystem.AspNetUsers.SingleOrDefault(a => a.Id == id);
if (getUser != null)
{
//lakukan update
getUser.RolesId = Convert.ToString(model.rolesDetail.Id);
getUser.Departement = model.userDetail.Departement;
_MainSystem.AspNetUsers.Update(getUser);
_MainSystem.SaveChanges();
return(Json(new { status = true, message = "Your Data Has Been Saved!" }));
}
else
{
return(Json(new { status = false, message = "User with ID = " + id + " cannot be found...!" }));
}
}
public async Task <IActionResult> EditUsersInRole(string id)
{
ViewBag.roleId = id;
var role = await roleManager.FindByIdAsync(id);
//create an instance of List of UserRoleViewModel - because we use UserRoleViewModel to pass data to view
List <UsersRoleViewModel> model = new List <UsersRoleViewModel>();
foreach (var user in userManager.Users)
{
//create an instance of UserRoleViewModel to assign each user's value to that model
var userRole = new UsersRoleViewModel()
{
UserId = user.Id,
UserName = user.UserName
};
//check whether user is already in that role
if (await userManager.IsInRoleAsync(user, role.Name))
{
userRole.IsSelected = true;
}
else
{
userRole.IsSelected = false;
}
model.Add(userRole);
}
return(View(model));
}
public bool Change(UsersRoleViewModel entity)
{
using (var repository = _sourceFactory.CreateRepository <Entity.UsersRole, int>())
{
return(repository.Change(new UsersRole(entity.UserRoleId, entity.UserRoleName)));
}
}
public override string[] GetRolesForUser(string UserName)
{
string[] role = new string[] { };
using (DBContext _db = new DBContext())
{
try
{
// Получаем пользователя
UserViewModel user = _db.User.ViewSingle(UserName);
if (user != null)
{
// получаем роль
UsersRoleViewModel userRole = _db.UserRole.ViewSingle(user.UserRoleId);
if (userRole != null)
{
role = new string[] { userRole.UserRoleName };
}
}
}
catch
{
role = new string[] { };
}
}
return(role);
}
public async Task <IActionResult> Index()
{
if (!_cache.TryGetValue("role", out list))
{
list = await _roleManager.Roles.ToListAsync();
_cache.Set("role", list, cacheOptions);
}
else
{
list = _cache.Get("role") as List <Role>;
}
var viewModel = new UsersRoleViewModel {
Roles = list, Users = await _userManager.Users.ToListAsync()
};
var roles = new Dictionary <string, string>();
foreach (var user in viewModel.Users)
{
roles.Add(user.Id, (await _userManager.GetRolesAsync(user)).FirstOrDefault());
}
viewModel.RoleNames = roles;
_logger.LogInformation("Listando todos níveis de acesso");
return(View(viewModel));
}
public bool AddUpdateRole(UsersRoleViewModel Role)
{
Roles userrole = new Roles {
RoleName = Role.RoleName
};
return(this._IUsersRoleRepository.AddUpdateRole(userrole));
}
public async Task <IActionResult> EditUsersInRole(string roleId, UsersRoleViewModel viewModel)
{
var role = await this._roleManager.FindByIdAsync(roleId);
if (role == null)
{
return(View("NotFound", NotFoundId(roleId)));
}
try
{
for (int i = 0; i < viewModel.Items.Count; i++)
{
var user = await this._userManager.FindByIdAsync(viewModel.Items[i].UserId);
IdentityResult result = null;
if (viewModel.Items[i].IsSelected && !(await this._userManager.IsInRoleAsync(user, role.Name)))
{
result = await this._userManager.AddToRoleAsync(user, role.Name);
}
else if (!viewModel.Items[i].IsSelected && await this._userManager.IsInRoleAsync(user, role.Name))
{
result = await this._userManager.RemoveFromRoleAsync(user, role.Name);
}
else
{
continue;
}
if (result.Succeeded)
{
if (i < (viewModel.Items.Count - 1))
{
continue;
}
else
{
return(RedirectToAction("EditRole", new { roleId = roleId }));
}
}
}
return(RedirectToAction("EditRole", new { roleId = roleId }));
}
catch (DbUpdateException ex)
{
this._logger.LogError(ex.Message);
return(View("Error", new ErrorViewModel()
{
ErrorTitle = "Edit Users In Role Role", ErrorMessage = ex.Message
}));
}
}
public ActionResult ManageRoles(UsersRoleViewModel valu2e)
{
var roleNames = (from userRole in _context.Roles
select userRole.Name).ToList();
var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(_context));
if (valu2e.Role != null)
{
UserManager.RemoveFromRole(valu2e.UserId, valu2e.Role);
}
var index = roleNames.FindIndex(x => x == valu2e.Role);
var result1 = UserManager.AddToRole(valu2e.UserId, roleNames[(index + 1) % roleNames.Count]);
return(ManageRoles());
}
public ActionResult Edit(UsersRoleViewModel role)
{
if (ModelState.IsValid)
{
if (usersRoles.Any(c => c.UserRoleId == role.UserRoleId))
{
_db.UserRole.Change(role);
TempData["message"] = string.Format("Role \"{0}\"uploaded", role.UserRoleName);
}
else
{
_db.UserRole.Add(role);
TempData["message"] = string.Format("Role\"{0}\"added", role.UserRoleName);
}
return(RedirectToAction("Index"));
}
else
{
return(View(role));
}
}
public async Task <IEnumerable <UsersRoleViewModel> > GetUsersWithRole()
{
var users = await this.context.Users.ToListAsync();
List <UsersRoleViewModel> userModels = new List <UsersRoleViewModel>();
foreach (var user in users)
{
var roles = await this.userManager.GetRolesAsync(user);
UsersRoleViewModel userViewModel = new UsersRoleViewModel
{
Role = roles.SingleOrDefault(),
Username = user.UserName,
Email = user.Email,
};
userModels.Add(userViewModel);
}
return(userModels);
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
ViewBag.roleId = roleId;
var role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Роли с ID = {roleId} не найдены";
return(View("NotFound"));
}
var model = new List <UsersRoleViewModel>();
foreach (var user in await userManager.Users.ToListAsync())
{
var userRoleViewModel = new UsersRoleViewModel
{
UserId = user.Id,
UserName = user.UserName
};
if (await userManager.IsInRoleAsync(user, role.Name))
{
userRoleViewModel.IsSelected = true;
}
else
{
userRoleViewModel.IsSelected = false;
}
model.Add(userRoleViewModel);
}
return(View(model));
}
public ViewResult Edit(int?UserRoleId)
{
UsersRoleViewModel roles = usersRoles.FirstOrDefault(c => c.UserRoleId == UserRoleId);
return(View(roles));
}
