public ActionResult AssignRole(string id)
{
var admin = "Admin";
var dev = "Developer";
var pjm = "Project Manager";
var sub = "Submitter";
var roles = DbContext.Roles.Select(n => n.Name).ToList();
var selectedUser = DbContext.Users
.Where(p => p.Id == id)
.Select(n => new UserForAssignRoleViewModel
{
Id = n.Id,
UserName = n.UserName
}).FirstOrDefault();
selectedUser.IsAdmin = UserRoleHelper.IsUserInRole(selectedUser.Id, admin);
selectedUser.IsDev = UserRoleHelper.IsUserInRole(selectedUser.Id, dev);
selectedUser.IsPm = UserRoleHelper.IsUserInRole(selectedUser.Id, pjm);
selectedUser.IsSub = UserRoleHelper.IsUserInRole(selectedUser.Id, sub);
var model = new AssignRoleViewModel();
model.User = selectedUser;
model.Roles.AddRange(roles);
return(View(model));
}
public IActionResult AssignRole()
{
var usersViewModel = new List <UserViewModel>();
var rolesViewModel = new List <RoleViewModel>();
foreach (var user in this.dbContext.Users)
{
var userViewModel = new UserViewModel
{
UserName = user.UserName,
};
usersViewModel.Add(userViewModel);
}
foreach (var role in this.dbContext.Roles)
{
var roleViewModel = new RoleViewModel
{
Name = role.Name,
};
rolesViewModel.Add(roleViewModel);
}
var assignRoleViewModel = new AssignRoleViewModel
{
Users = usersViewModel,
Roles = rolesViewModel,
};
return(this.View(assignRoleViewModel));
}
public async Task <IActionResult> AssignRole(AssignRoleViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(model.UserId);
var role = await _roleManager.FindByIdAsync(model.RoleId);
var assignRole = await _userManager.AddToRoleAsync(user, role.Name);
if (assignRole.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "Bir hata oluştu, tekrar deneyiniz!");
var roleAssignationErrors = assignRole.Errors.Select(x => x.Description);
ModelState.AddModelError(string.Empty,
string.Join(", ", roleAssignationErrors));
}
}
return(View(model));
}
public async Task <IActionResult> AssignRole(AssignRoleViewModel model)
{
var user = await _userManager.FindByIdAsync(model.UserId);
if (user != null)
{
var roleList = await _userManager.GetRolesAsync(user);
if (roleList != null)
{
var resultDeleted = await _userManager.RemoveFromRolesAsync(user, roleList);
}
var result = await _userManager.AddToRoleAsync(user, model.RoleName);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Account"));
}
}
else
{
return(NotFound());
}
return(View(model));
}
public async Task <IActionResult> UnAssignRole(AssignRoleViewModel AR)
{
//check if there is at least one manager
var mRole = await _userManager.FindByNameAsync(AR.RollName);
var ManagersList = _context.UserRoles.Select(m => m).Where(m => m.RoleId == mRole.Id).ToList();
if (ManagersList.Count <= 1)
{
return(RedirectToAction("RolesIndex"));
}
//get user by ID
var user = await _userManager.FindByEmailAsync(AR.UserEmail);
//Assign a role to this user
var result = await _userManager.RemoveFromRoleAsync(user, AR.RollName);
if (result.Succeeded)
{
//if Succeeded, go to Staff list (Role Detail)
return(RedirectToAction("RolesDetails"));
}
//if not return bad request
return(BadRequest());
}
public async Task <IActionResult> RevokeRole(string userId)
{
AssignRoleViewModel model = new AssignRoleViewModel();
model.UserId = userId;
var user = await _userManager.FindByIdAsync(userId);
var userRolesStrList = await _userManager.GetRolesAsync(user);
if (userRolesStrList.Any())
{
var userRoles = _roleManager.Roles.Where(x => userRolesStrList.Contains(x.Name)).ToList();
model.RoleList = userRoles.Select(x => new SelectListItem
{
Selected = false,
Text = x.Name,
Value = x.Id
}).ToList();
}
else
{
model.RoleList = new List <SelectListItem>();
}
return(View(model));
}
public IActionResult AssignRole()
{
var Users = userManager.Users.ToList();
var roles = roleManager.Roles.ToList();
List <string> listRoles = new List <string>();
foreach (var item in roles)
{
listRoles.Add(item.Name);
}
List <AssignRoleViewModel> List = new List <AssignRoleViewModel>();
foreach (var item in Users)
{
AssignRoleViewModel model = new AssignRoleViewModel();
model.UserId = item.Id;
model.UserName = item.UserName;
model.Email = item.Email;
model.RoleName = userManager.GetRolesAsync(item).Result.Count != 0 ? userManager.GetRolesAsync(item).Result[0] : "";
model.Roles = listRoles;
List.Add(model);
}
return(View(List));
}
public async Task <IActionResult> AssignRole(string Id)
{
var userId = this.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
var currentUser = await _userManager.FindByIdAsync(userId);
ViewBag.userId = userId;
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id {userId} cannot be found 1";
return(View("NotFound"));
}
var model = new List <AssignRoleViewModel>();
foreach (var role in _roleManager.Roles)
{
var assignRoleViewModel = new AssignRoleViewModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _userManager.IsInRoleAsync(user, assignRoleViewModel.RoleName))
{
assignRoleViewModel.IsSelected = true;
}
else
{
assignRoleViewModel.IsSelected = false;
}
model.Add(assignRoleViewModel);
}
return(View(model));
}
public IActionResult AssignRole(string id)
{
TempData["UserId"] = id;
UserApp user = GetUserById(id);
ViewBag.UserName = user.UserName;
IQueryable <RoleApp> roles = RoleManager.Roles;
List <string> userRoles = UserManager.GetRolesAsync(user).Result as List <string>;
List <AssignRoleViewModel> assignRoleViewModels = new List <AssignRoleViewModel>();
foreach (RoleApp role in roles)
{
AssignRoleViewModel assignRoleVM = new AssignRoleViewModel()
{
RoleId = role.Id,
RoleName = role.Name,
IsExist = false
};
if (userRoles.Contains(role.Name))
{
assignRoleVM.IsExist = true;
}
assignRoleViewModels.Add(assignRoleVM);
}
return(View(assignRoleViewModels));
}
public ActionResult Assign(AssignRoleViewModel assignRoleViewModel)
{
try
{
if (ModelState.IsValid)
{
var autoUsermaster = AutoMapper.Mapper.Map <SavedMenuRoles>(assignRoleViewModel);
if (!_savedRoles.CheckRoleAlreadyExists(autoUsermaster))
{
_savedRoles.SaveRole(autoUsermaster);
TempData["MessageAssigned_Menu"] = "Menus Assigned to Roles Successfully";
return(RedirectToAction("Assign", "AssignRolestoMenu"));
}
else
{
TempData["AlreadyAssignedMessage_Menu"] = "Menu to this Role is already assigned";
var menuList = _menu.GetAllActiveMenu();
var rolesList = _role.GetAllActiveRoles();
assignRoleViewModel = new AssignRoleViewModel()
{
Menulist = menuList,
RolesList = rolesList,
MenuId = assignRoleViewModel.MenuId,
RoleId = assignRoleViewModel.RoleId
};
}
return(View(assignRoleViewModel));
}
else
{
var menuList = _menu.GetAllActiveMenu();
var rolesList = _role.GetAllActiveRoles();
assignRoleViewModel = new AssignRoleViewModel()
{
Menulist = menuList,
RolesList = rolesList,
MenuId = assignRoleViewModel.MenuId,
RoleId = assignRoleViewModel.RoleId
};
return(View(assignRoleViewModel));
}
}
catch (Exception)
{
throw;
}
}
public ActionResult AssignRole(AssignRoleViewModel viewModel)
{
if (viewModel.CurrentRole != viewModel.NewRole)
{
DbManager.ChangeRoleOfUser(viewModel.UserId, viewModel.CurrentRole, viewModel.NewRole);
}
return(RedirectToAction("Index"));
}
public ActionResult AssignRole(AssignRoleViewModel model)
{
if (model.userId == 0)
{
ModelState.AddModelError("userId", "Please select user");
}
if (model.RoleId == 0)
{
ModelState.AddModelError("RoleId", "Please select Role");
}
if (ModelState.IsValid)
{
var id = model.userId;
var userData = _db.AspNetUsers.Where(x => x.Id == id).FirstOrDefault();
_db.UpdateUserRole(userData.Id, model.RoleId);
var RoleData = _db.AspNetRoles.Where(x => x.Id == model.RoleId).FirstOrDefault();
var menuList = _db.Menu_List.ToList();
List <UserMenu> UserMenuList = _db.UserMenus.Where(x => x.UserID == userData.Id).ToList();
if (UserMenuList.Count > 0)
{
foreach (var item in UserMenuList)
{
_db.UserMenus.Remove(item);
_db.SaveChanges();
}
}
var defaultMenus = _RolesManagementMethod.getDefaultMenuByRoleId(model.RoleId);
foreach (var item in defaultMenus)
{
int menuId = 0;
var test = menuList.Where(x => x.ID == item.MenuKey);
if (test != null)
{
menuId = test.FirstOrDefault().ID;
}
//int menuId = menuList.Where(x => x.ID == item.MenuKey).FirstOrDefault().ID;
UserMenu userMenu = new UserMenu();
userMenu.MenuID = menuId;
userMenu.UserID = userData.Id;
userMenu.CreatedDate = DateTime.Now;
userMenu.CreatedBy = SessionProxy.UserId;
userMenu.IsActive = true;
userMenu.MenuKey = item.MenuKey;
_db.UserMenus.Add(userMenu);
_db.SaveChanges();
}
return(RedirectToAction("AssignRole"));
}
else
{
model.UserList = _AssignRoleMethod.BindUsersDropdown();
model.RoleList = _AssignRoleMethod.BindRolesDropdown();
return(View(model));
}
}
public ActionResult AssignRole()
{
AssignRoleViewModel model = new AssignRoleViewModel();
model.UserNameList = _AssignRoleMethod.BindUserNamesDropdown();
model.UserList = _AssignRoleMethod.BindUsersDropdown();
model.RoleList = _AssignRoleMethod.BindRolesDropdown();
return(View(model));
}
public async Task <IActionResult> RemoveFromRole([FromBody] AssignRoleViewModel data)
{
var result = await _authorize.RemoveFromRole(User, data.UserId, data.RoleId);
if (result)
{
return(Ok(null, InfoMessages.CommonInfoMessage));
}
return(BadRequest(ErrorMessages.CommonErrorMessage));
}
public ActionResult AssignUserToRole()
{
var db = new ApplicationDbContext();
var roles = db.Roles.ToList();
var users = db.Users.ToList();
AssignRoleViewModel model = new AssignRoleViewModel();
model.Users = users;
model.Roles = roles;
return(View(model));
}
public ActionResult AssignRoleToPage()
{
var db = new ApplicationDbContext();
var dbs = new VidlyDbFirstEntities1();
var pages = dbs.Pages.ToList();
var roles = db.Roles.ToList();
AssignRoleViewModel model = new AssignRoleViewModel();
model.Pages = pages;
model.Roles = roles;
return(View(model));
}
public ActionResult AssignRole(AssignRoleViewModel vm)
{
using (var context = new ApplicationDbContext())
{
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var role = _roleRepo.GetById(vm.RoleID);
manager.AddToRole(vm.UserID, role.Name);
vm.Roles = manager.GetRoles(vm.UserID);
vm.User = _repo.GetById(vm.UserID);
}
ViewBag.RoleID = new SelectList(_roleRepo.Get(), "Id", "Name", vm.RoleID);
return View(vm);
}
public ActionResult AssignUserRole(string UserId)
{
fillUserData();
ViewBag.SelectedRole = new SelectList(db.Roles, "Id", "Name");
var roleViewModel = new AssignRoleViewModel()
{
UserId = UserId,
UserName = db.Users.Find(UserId).UserName
};
return(View(roleViewModel));
}
public async Task <IActionResult> AssignRole(string id, string userName)
{
var roleList = await _roleManager.Roles.ToListAsync();
ViewBag.Role = new SelectList(roleList, "Name", "Name");
AssignRoleViewModel data = new AssignRoleViewModel
{
UserId = id,
UserName = userName
};
return(View(data));
}
public ActionResult AssignRole(string id)
{
AssignRoleViewModel vm = new AssignRoleViewModel();
using (var context = new ApplicationDbContext())
{
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
vm.Roles = manager.GetRoles(id);
vm.UserID = id;
vm.User = _repo.GetById(id);
}
ViewBag.RoleID = new SelectList(_roleRepo.Get(), "Id", "Name");
return View(vm);
}
public IActionResult AssignRole()
{
//Get all the Register users
var users = userManager.Users.ToList();
//Next i need all the roles
var roles = roleManager.Roles.ToList();
//Getting all the Role from IDENTITYRole that have all the filed
// i am stroing all the role in the ListRoles
List <string> listRoles = new List <string>();
foreach (var item in roles)
{
listRoles.Add(item.Name);
}
//Now i have to create a list of our view model
//and i need to fill this list
List <AssignRoleViewModel> list = new List <AssignRoleViewModel>();
foreach (var item in users)
{
//we create an object of AssignRoleViewModel
AssignRoleViewModel model = new AssignRoleViewModel();
// These 3 we cab get easily from users table
model.UserId = item.Id;
model.UserName = item.UserName;
model.Email = item.Email;
//
//I want to know whether this user has some role or not
//So i want to get that role name
// If the user have already some role this count will not b equal to zero
//so we are trying to get the role name
//if not we assign it to null tenary opertator
//condition_expression ? first_expression : second_expression;
//So this line of code will check in the datbase whether this current user has a role or not and
//if it has a role it will get the role name
model.RoleName = userManager.GetRolesAsync(item).Result.Count != 0 ? userManager.GetRolesAsync(item).Result[0] : "";
model.Roles = listRoles;
list.Add(model);
}
//passing our list of AssignRoleViewModel
return(View(list));
}
public ActionResult AssignRole(string userId, string username)
{
if (userId.Equals(""))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var currentRole = DbManager.GetRoleByUserId(userId);
var rolesSelectList = DbManager.GetRolesSelectList();
var viewModel = new AssignRoleViewModel(currentRole, rolesSelectList, userId, username);
return(View(viewModel));
}
public IActionResult AssignRole(string userId)
{
List <SelectListItem> roleList = _roleManager.Roles.Select(x => new SelectListItem
{
Value = x.Id,
Selected = true,
Text = x.Name
}).ToList();
AssignRoleViewModel roleModel = new AssignRoleViewModel
{
UserId = userId,
RoleList = roleList
};
return(View(roleModel));
}
public async Task <IActionResult> AssignRole(string id)
{
List <SelectListItem> roleList = _roleManager.Roles.Select(x => new SelectListItem
{
Text = x.Name,
Value = x.Id,
Selected = false
}).ToList();
AssignRoleViewModel model = new AssignRoleViewModel
{
UserId = id,
RoleList = roleList
};
return(View(model));
}
public async Task <IActionResult> RevokeRole(AssignRoleViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(model.UserId);
var role = await _roleManager.FindByIdAsync(model.RoleId);
var result = await _userManager.RemoveFromRoleAsync(user, role.Name);
if (result.Succeeded)
{
return(RedirectToAction("UserDetail", new { userId = model.UserId }));
}
ModelState.AddModelError(string.Empty, "Bir hata oluştu, lütfen tekrar deneyiniz!");
}
return(View(model));
}
public IActionResult RolesAssign(string UserEmail)
{
if (UserEmail != null)
{
//if the a role as chosen, set the data to a model.
AssignRoleViewModel ar = new AssignRoleViewModel()
{
UserEmail = UserEmail,
};
//send the model with the data. So the RoleName input will be auto filled
return(View(ar));
}
else
{
//if not just send a empty model
AssignRoleViewModel model = new AssignRoleViewModel();
return(View(model));
}
}
public async Task <IActionResult> AssignRole([FromBody] AssignRoleViewModel assignRoleViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!await _authService.UserExists(assignRoleViewModel.UserName))
{
return(NotFound(string.Format(_errorLocalizer["UserNotExist"].Value, assignRoleViewModel.UserName)));
}
if (await _userService.AssignRoleAsync(assignRoleViewModel))
{
return(Ok());
}
return(BadRequest(string.Format(_errorLocalizer["FailedRoleUpdate"].Value, assignRoleViewModel.UserName)));
}
/// <summary>
/// this is a assign role get method which displays a view which allows an admin
/// to assign roles to users
/// </summary>
/// <returns></returns>
public IActionResult AssignRole()
{
var users = _repo.ReadAllUsers();
var roles = _repo.ReadAllRoles();
var model = new AssignRoleViewModel
{
};
foreach (var user in users)
{
model.UserNames.Add(user.UserName);
}
foreach (var role in roles)
{
model.RoleNames.Add(role.Name);
}
return(View(model));
}
public async Task <ActionResult> AssignRole(AssignRoleViewModel vm)
{
// Récupération de notre user by id
var user = await UserManager.FindByIdAsync(vm.UserId);
// Rolemanager
var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>());
// Si utiliateur a déjà le profil decoche // sinon on lui affecte le profil
if (UserManager.IsInRole(vm.UserId, vm.Role))
{
await UserManager.RemoveFromRoleAsync(vm.UserId, vm.Role);
}
else
{
await UserManager.AddToRoleAsync(vm.UserId, vm.Role);
}
return(RedirectToAction("Index", "Manage"));
}
public ActionResult AssignRoleToPage(PageRole model, AssignRoleViewModel pgr)
{
var db = new VidlyDbFirstEntities1();
//next line is to get at the items in the list i have on my view, thats what i am yet to achieve
foreach (var item in pgr.ListOfPages)
{
var page = db.Pages.SingleOrDefault(c => c.Name == item);
var pg = new PageRole
{
RoleId = model.RoleId,
PageID = page.Id
};
db.PageRoles.Add(pg);
}
return(View());
}
public async Task <IActionResult> AssignRole(AssignRoleViewModel model)
{
if (ModelState.IsValid)
{
var user = await _userManager.FindByIdAsync(model.UserId);
var role = await _roleManager.FindByIdAsync(model.RoleId);
var assignRole = await _userManager.AddToRoleAsync(user, role.Name);
if (assignRole.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError(string.Empty, "Rol atanırken bir hata oluştu");
}
}
return(View(model));
}
public ActionResult Assign()
{
try
{
var menuList = _menu.GetAllActiveMenu();
var rolesList = _role.GetAllActiveRoles();
AssignRoleViewModel assignRoleViewModel = new AssignRoleViewModel()
{
Menulist = menuList,
RolesList = rolesList
};
return(View(assignRoleViewModel));
}
catch (Exception)
{
throw;
}
}
