public async Task <ActionResult> ManageRole(string roleID)
{
AppRole appRole = await RoleManager.FindByIdAsync(roleID);
if (appRole == null)
{
ViewBag.Error = $"Error occurred while looking for role with ID = {roleID}";
return(View("Error"));
}
UserInRoleViewModel userList = new UserInRoleViewModel();
userList.RoleID = appRole.Id;
userList.RoleName = appRole.Name;
foreach (AppUser user in UserManager.Users)
{
userList.Users.Add(user.UserName);
if (await UserManager.IsInRoleAsync(user.Id, appRole.Name))
{
userList.IsInRole.Add(true);
}
else
{
userList.IsInRole.Add(false);
}
}
return(View(userList));
}
public ActionResult Item(Guid?id)
{
if (!id.HasValue)
{
throw new HttpException(HttpStatusCode.NotFound.ToInt(), Definition.Message.Item.NotFound);
}
var _user = _userRepo.GetById(id.Value);
if (_user == null)
{
throw new HttpException(HttpStatusCode.NotFound.ToInt(), Definition.Message.Item.NotFound);
}
var _userRoles = (from rr in _roleRepo.GetAll()
join uir in _userInRoleRepo.GetAll(x => x.UserId == id) on rr.ID equals uir.RoleId into luir
from uir in luir.DefaultIfEmpty()
select new SelectListItem
{
Text = rr.Name,
Value = rr.ID.ToString(),
Selected = uir.ID != null
}).ToList();
var result = new UserInRoleViewModel(id.Value, string.Format("{0} {1}", _user.FirstName, _user.LastName), _userRoles);
return(View(result));
}
public async Task <IActionResult> Edit([Bind("Username, UserRoles")] UserInRoleViewModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var user = await _context.Users.FirstOrDefaultAsync(u => u.UserName == model.Username);
if (user == null)
{
return(NotFound());
}
var roles = await _userManager.GetRolesAsync(user);
// remove old roles
await _userManager.RemoveFromRolesAsync(user, roles);
// add new roles
await _userManager.AddToRolesAsync(user, model.UserRoles);
// special case - always have a in admin
if (user.UserName == "a")
{
await _userManager.AddToRoleAsync(user, "Admin");
}
return(View(model));
}
// GET: UserInRoles/Edit/5
public async Task <IActionResult> Edit(String id)
{
if (id == null)
{
return(BadRequest());
}
var user = await _context.Users.FirstOrDefaultAsync(u => u.UserName == id);
if (user == null)
{
return(NotFound());
}
var viewModel = new UserInRoleViewModel
{
Username = user.UserName,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
UserRoles = (await _userManager.GetRolesAsync(user)) as List <string>
};
ViewBag.Roles = await _context.Roles.Select(r => r.Name).ToListAsync();
return(View(viewModel));
}
public async Task <IActionResult> EditUsersInRole(EditUsersInRoleViewModel model)
{
IdentityRole role = await roleManager.FindByIdAsync(model.RoleId);
if (role == null)
{
return(RoleNotFound(model.RoleId));
}
for (int i = 0; i < model.Users.Count; i++)
{
UserInRoleViewModel currentUser = model.Users[i];
ApplicationUser user = await userManager.FindByIdAsync(currentUser.Id);
bool isCurrentlyInRole = await userManager.IsInRoleAsync(user, role.Name);
if (currentUser.IsRoleSelected && !isCurrentlyInRole)
{
await userManager.AddToRoleAsync(user, role.Name);
}
else if (!currentUser.IsRoleSelected && isCurrentlyInRole)
{
await userManager.RemoveFromRoleAsync(user, role.Name);
}
}
return(RedirectToAction("editrole", new { role.Id }));
}
public async Task <IActionResult> EditUsersInRole(string roleId)
{
IdentityRole role = await roleManager.FindByIdAsync(roleId);
if (role == null)
{
return(RoleNotFound(roleId));
}
var model = new EditUsersInRoleViewModel()
{
RoleId = role.Id
};
List <ApplicationUser> users = await userManager.Users.ToListAsync();
foreach (ApplicationUser user in users)
{
var userInRole = new UserInRoleViewModel
{
Id = user.Id,
Name = user.UserName
};
if (await userManager.IsInRoleAsync(user, role.Name))
{
userInRole.IsRoleSelected = true;
}
model.Users.Add(userInRole);
}
return(View(model));
}
public async Task <IActionResult> EditUsersInRole(string roleTen)
{
if (roleTen == null)
{
return(NotFound());
}
var role = await _roleManager.FindByNameAsync(roleTen);
if (role == null)
{
return(NotFound());
}
var model = new List <UserInRoleViewModel>();
foreach (var user in _userManager.Users)
{
var userInRole = new UserInRoleViewModel
{
TaiKhoan = user.UserName,
Ten = user.Ten
};
if (await _userManager.IsInRoleAsync(user, roleTen))
{
userInRole.IsSelected = true;
}
else
{
userInRole.IsSelected = false;
}
model.Add(userInRole);
}
ViewBag.roleTen = roleTen;
return(View(model));
}
public static UserInRole Attach(UserInRoleViewModel userInRoleViewModel)
{
UserInRole userInRole = new UserInRole();
userInRole.id = userInRoleViewModel.id;
userInRole.RoleId = userInRoleViewModel.RoleId;
userInRole.UserId = userInRoleViewModel.UserId;
return(userInRole);
}
[ValidateAntiForgeryToken] // Prevent Cross Site Request Forgery (CSRF) Attacks by generating and comparing Token automatically
public ActionResult SaveUser(UserInRoleViewModel vm)
{
if (!ModelState.IsValid)
{
var viewModel = new UserInRoleViewModel
{
UserId = vm.UserId,
Username = vm.Username,
Role = vm.Role,
RoleId = vm.RoleId,
IsEnabled = vm.IsEnabled,
Roles = (from role in _context.Roles select role).ToList()
};
return(View("EditUser", viewModel));
}
// modify existing user
var oldUser = UserManager.FindById(vm.UserId);
oldUser.IsEnabled = vm.IsEnabled;
UserManager.Update(oldUser);
oldUser.IsEnabled = vm.IsEnabled;
string oldRoleId = null;
var oldRoleName = string.Empty;
try
{
oldRoleId = oldUser.Roles.SingleOrDefault().RoleId;
oldRoleName = _context.Roles.SingleOrDefault(r => r.Id == oldRoleId).Name;
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
var newRoleName = _context.Roles.SingleOrDefault(r => r.Id == vm.RoleId).Name;
if (string.IsNullOrEmpty(oldRoleId))
{
UserManager.AddToRole(vm.UserId, _context.Roles.SingleOrDefault(r => r.Id == vm.RoleId).Name);
}
else if (oldRoleId != vm.RoleId)
{
UserManager.RemoveFromRole(vm.UserId, oldRoleName);
UserManager.AddToRole(vm.UserId, _context.Roles.SingleOrDefault(r => r.Id == vm.RoleId).Name);
}
//_context.Entry(user).State = EntityState.Modified;
TempData[Constant.Success] = Constant.Update;
//_context.SaveChanges();
return(RedirectToAction("ManageUsers", "Manage"));
}
public ActionResult AddToRole([Bind] UserInRoleViewModel ur)
{
//if (ur == null)
//{
// return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
//}
//var role = roleManager.FindById(id);
//if (role == null)
//{
// return HttpNotFound();
//}
//UserInRoleViewModel ur = new UserInRoleViewModel() { Role = role };
//PopulateUsersDropDownList(ur.UserId);
//return View(ur);
}
public async Task <ActionResult> ManageRole(UserInRoleViewModel userList)
{
AppRole appRole = await RoleManager.FindByIdAsync(userList.RoleID);
if (appRole == null)
{
ViewBag.Error = $"Error occurred while looking for role with ID = {userList.RoleID ?? "NULL ID"}";
return(View("Error"));
}
for (int i = 0; i < userList.IsInRole.Count; i++)
{
AppUser user = await UserManager.FindByNameAsync(userList.Users[i]);
IdentityResult result;
if (userList.IsInRole[i] && !(await UserManager.IsInRoleAsync(user.Id, userList.RoleName)))
{
result = await UserManager.AddToRoleAsync(user.Id, userList.RoleName);
}
else if (!userList.IsInRole[i] && await UserManager.IsInRoleAsync(user.Id, userList.RoleName))
{
result = await UserManager.RemoveFromRoleAsync(user.Id, userList.RoleName);
}
else
{
continue;
}
if (result.Succeeded)
{
if (i < userList.IsInRole.Count)
{
continue;
}
else
{
return(RedirectToAction("EditRole", new { id = userList.RoleID }));
}
}
}
return(RedirectToAction("EditRole", new { id = userList.RoleID }));
}
// GET: Roles/AddToRole/id
public ActionResult AddToRole(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var role = roleManager.FindById(id);
if (role == null)
{
return(HttpNotFound());
}
UserInRoleViewModel ur = new UserInRoleViewModel()
{
Role = role
};
PopulateUsersDropDownList(ur.UserId);
return(View(ur));
}
public async Task GetAllInRolesPerPageAsyncShouldReturnCorrectModelCollection()
{
var teacherId = await this.CreateUserAsync("*****@*****.**", "Teacher", "Teacher", "Teacher");
await this.CreateUserAsync("*****@*****.**", "Student", "Student");
var model = new UserInRoleViewModel()
{
Id = teacherId,
FullName = "Teacher Teacher",
Email = "*****@*****.**",
};
var resultModelCollection = await this.Service.GetAllInRolesPerPageAsync <UserInRoleViewModel>(1, 1);
Assert.Equal(1, resultModelCollection.Count);
Assert.Equal(model.Id, resultModelCollection.First().Id);
Assert.Equal(model.FullName, resultModelCollection.First().FullName);
Assert.Equal(model.Email, resultModelCollection.First().Email);
}
public JsonResult Update(UserInRoleViewModel userInRole)
{
_userInRoleRepo.Delete(x => x.UserId == userInRole.UserId);
foreach (var item in userInRole.Roles)
{
var _userInRole = new UserInRole
{
UserId = userInRole.UserId,
RoleId = new Guid(item)
};
_userInRoleRepo.Create(_userInRole);
}
_unitOfWork.SaveChanges();
var redirectUrl = Definition.Url.User.Item;
return(Result(new Result(Definition.Message.Updated, redirectUrl)));
}
public async Task <IQueryable <UserInRoleViewModel> > QueryUsersInRoles(string[] roles, string[] excludeUserIds)
{
ICollection <ApplicationUser> users = await(from u in _context.Users
join ur in _context.UserRoles on u.Id equals ur.UserId
join r in _context.Roles on ur.RoleId equals r.Id
select u).ToListAsync();
ICollection <ApplicationUser> usersFilteredByIds = new List <ApplicationUser>();
foreach (var user in users)
{
foreach (var excludeUserId in excludeUserIds)
{
if (!(user.Id == excludeUserId))
{
usersFilteredByIds.Add(user);
}
}
}
ICollection <UserInRoleViewModel> usersInRoles = new List <UserInRoleViewModel>();
foreach (var user in usersFilteredByIds)
{
foreach (var role in roles)
{
if (await _userManager.IsInRoleAsync(user, role))
{
UserInRoleViewModel userInRole = new UserInRoleViewModel()
{
User = user,
Role = role
};
usersInRoles.Add(userInRole);
}
}
}
return(usersInRoles.AsQueryable());
}
public async Task GetAllInRolesPerPageAsyncShouldFilterCorectlyWhenSearchCriteriaIsTeacherAndSearchTextIsPassed(string searchCriteria, string searchText)
{
await this.CreateUserAsync("*****@*****.**", "Admin", "Admin", "Administrator");
await this.CreateUserAsync("*****@*****.**", "Student", "Student");
var teacherId = await this.CreateUserAsync("*****@*****.**", "John", "Doe", "Teacher");
var teacherModel = new UserInRoleViewModel()
{
Id = teacherId,
FullName = "John Doe",
Email = "*****@*****.**",
};
var resultModelCollection = await this.Service.GetAllInRolesPerPageAsync <UserInRoleViewModel>(1, 1, searchCriteria, searchText);
Assert.Equal(1, resultModelCollection.Count);
Assert.Equal(teacherModel.Id, resultModelCollection.First().Id);
Assert.Equal(teacherModel.FullName, resultModelCollection.First().FullName);
Assert.Equal(teacherModel.Email, resultModelCollection.First().Email);
}
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(NotFound());
}
var model = new List <UserInRoleViewModel>();
foreach (var user in userManager.Users)
{
var userRoleViewModel = new UserInRoleViewModel
{
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 ActionResult Edit([Bind(Exclude = "UserName")] UserViewModel userVM)
{
if (ModelState.IsValidField("FirstName") && ModelState.IsValidField("LastName") &&
ModelState.IsValidField("Dob") && ModelState.IsValidField("Password") &&
ModelState.IsValidField("RoleId") && ModelState.IsValidField("Email") &&
ModelState.IsValidField("MobileNo") && ModelState.IsValidField("CityId"))
{
if (CheckUserByCityAndRole(userVM))
{
ModelState.AddModelError("UserExist", "User already exist for selected role. Please change the city or role");
var roles = _roleMasterService.Get(r => r.IsActive == true);
var cities = _cityMasterService.Get(r => r.IsActive == true);
userVM.Roles = roles.Select(s => new SelectListItem {
Text = s.RoleName, Value = s.RoleId.ToString()
}).ToList();
userVM.Cities = cities.Select(c => new SelectListItem {
Text = c.CityName, Value = c.CityId.ToString()
}).ToList();
userVM.IsActive = true;
return(View(userVM));
}
var fName = userVM.FirstName;
var lName = userVM.LastName;
var mobileNo = userVM.MobileNo;
string firstCharOfFname =
!String.IsNullOrWhiteSpace(fName) && fName.Length >= 1 ? fName.Substring(0, 1) : fName;
var userName = firstCharOfFname + userVM.LastName;
if (Session["roleId"] == null)
{
return(RedirectToAction("Index"));
}
var userInRoleVM = new UserInRoleViewModel();
var userInRoleMaster = new UserInRole();
var userData = _userService.GetUserById(userVM.UserId);
var userInRole = _userInRoleService.Get().Where(r => r.RoleId == Convert.ToInt32(Session["roleId"])).FirstOrDefault();
userData.UserName = userName;
userData.Password = userVM.Password.Encrypt();
userData.Email = userVM.Email;
userData.MobileNo = userVM.MobileNo;
userData.Address = userVM.Address;
userData.CityId = userVM.CityId;
userData.FirstName = userVM.FirstName;
userData.LastName = userVM.LastName;
userData.Dob = userVM.Dob;
//userData.CompanyID = userVM.CompanyID;
userInRole.RoleId = userVM.RoleId;
userInRole.UserId = userVM.UserId;
_userInRoleService.Update(userInRole);
_userInRoleService.SaveChanges();
_userService.Update(userData);
_userService.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
var roles = _roleMasterService.Get(r => r.IsActive == true);
var cities = _cityMasterService.Get(r => r.IsActive == true);
userVM.Roles = new List <SelectListItem>();
userVM.Cities = new List <SelectListItem>();
userVM.Roles = roles.Select(s => new SelectListItem {
Text = s.RoleName, Value = s.RoleId.ToString()
}).ToList();
userVM.Cities = cities.Select(c => new SelectListItem {
Text = c.CityName, Value = c.CityId.ToString()
}).ToList();
return(View(userVM));
}
}
public static UserInRoleViewModel Detach(UserInRole userInRole)
{
UserInRoleViewModel userInRoleViewModel = new UserInRoleViewModel();
return(userInRoleViewModel);
}
public ActionResult Index()
{
var userStore = new UserStore<User>(this.dbContext);
var userManager = new UserManager<User>(userStore);
var users = userManager.Users.ToList();
var userModels = new List<UserInRoleViewModel>();
string role = GlobalConstants.EngineerRoleName;
foreach (User user in users)
{
if (user.Id == this.User.Identity.GetUserId())
{
continue;
}
var userModel = new UserInRoleViewModel
{
UserId = user.Id,
Username = user.UserName,
IsInRole = userManager.IsInRole(user.Id, role)
};
userModels.Add(userModel);
}
this.ViewBag.RoleName = role;
return this.View(userModels);
}
