public async Task <IActionResult> ManageRolesInUser(string userId)
{
ViewBag.UserId = userId;
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"The User Id {userId} was not found";
return(View("Not Found"));
}
else
{
var userRoles = new List <ManageRolesViewModel>();
foreach (var role in _roleManager.Roles)
{
var roleView = new ManageRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name,
};
if (await _userManager.IsInRoleAsync(user, role.Name))
{
roleView.IsSelected = true;
}
userRoles.Add(roleView);
}
return(View(userRoles));
}
}
public IActionResult ManageRoles()
{
ViewData["Message"] = "User Role Management Page";
ManageRolesViewModel viewModel = new ManageRolesViewModel(_userManager, _roleManager);
return(View(viewModel));
}
public JsonResult FillRole(string username)
{
ManageRolesViewModel rolesViewModel = new ManageRolesViewModel();
List <IdentityRole> lsRoles = new List <IdentityRole>();
if (db.Roles.Any())
{
lsRoles = db.Roles.ToList();
}
rolesViewModel.AllRoles = lsRoles;
rolesViewModel.UserName = username;
rolesViewModel.slUsers = Utility.GetUsers();
rolesViewModel.RoleChoices = Utility.GetRoles();
IdentityUser user = UserManager.FindByName(rolesViewModel.UserName);
if (user != null)
{
rolesViewModel.SelectedRoles = user.Roles.Select(m => m.RoleId).ToList();
MultiSelectList sl = new MultiSelectList(rolesViewModel.RoleChoices, "Value", "Text", rolesViewModel.SelectedRoles);
MvcHtmlString result = Utility.CheckBoxList("chklistitem", sl);
rolesViewModel.roleChks = result.ToHtmlString();
}
else
{
rolesViewModel.roleChks = string.Empty;
}
return(Json(rolesViewModel, JsonRequestBehavior.AllowGet));
}
public async Task <IHttpActionResult> ManageUserRoles(ManageRolesViewModel rolesData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ApplicationUser user = await UserManager.FindByEmailAsync(rolesData.Email);
var roles = rolesData.Roles.Split(',');
// Admin role
if (roles.Contains(ROLE_ADMIN))
{
UserManager.AddToRole(user.Id, ROLE_ADMIN);
}
else
{
UserManager.RemoveFromRole(user.Id, ROLE_ADMIN);
}
// Employee role
if (roles.Contains(ROLE_COMERCIAL))
{
UserManager.AddToRole(user.Id, ROLE_COMERCIAL);
}
else
{
UserManager.RemoveFromRole(user.Id, ROLE_COMERCIAL);
}
return(Ok());
}
public ActionResult AddRole(ManageRolesViewModel rolesViewModel)
{
if (ModelState.IsValid)
{
if (db.Roles.Where(x => x.Name == rolesViewModel.RoleName).Any())
{
ViewBag.ErrorMessage = "A role already exists with this Name.";
return(View(rolesViewModel));
}
else
{
try
{
IdentityRole identityRole = new IdentityRole {
Name = rolesViewModel.RoleName
};
db.Roles.Add(identityRole);
db.SaveChanges();
return(RedirectToAction("Roles"));
}
catch (Exception e)
{
ViewBag.ErrorMessage = e.Message;
return(View(rolesViewModel));
}
}
}
return(View(rolesViewModel));
}
public async Task <IActionResult> Manage(string userId)
{
ViewBag.userId = userId;
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with Id = {userId} cannot be found";
return(View("NotFound"));
}
ViewBag.UserName = user.UserName;
var model = new List <ManageRolesViewModel>();
foreach (var role in _roleManager.Roles)
{
var manageVm = new ManageRolesViewModel
{
RoleId = role.Id,
RoleName = role.Name,
User = user
};
model.Add(manageVm);
}
return(View(model));
}
public ActionResult ManageRole(ManageRolesViewModel manageRoleVm)
{
var eroles = EUserRoles.ToList();
if (!eroles.Contains(manageRoleVm.Role))
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
ViewBag.SelectList = eroles.Select(x => new SelectListItem()
{
Text = x, Value = x
});
ApplicationUser user = _context.Users
.FirstOrDefault(u => u.Email.Equals(manageRoleVm.EmailAddress, StringComparison.CurrentCultureIgnoreCase));
if (user.Email == "*****@*****.**")
{
manageRoleVm.SuccessMessage = "Cannot change the subdivision.mapping User Role";
return(View("ManageRole", manageRoleVm));
}
var roleStore = new RoleStore <IdentityRole>(new ApplicationDbContext());
var roleManager = new RoleManager <IdentityRole>(roleStore);
if (roleManager.Roles.FirstOrDefault(x => x.Name == manageRoleVm.Role) == null)
{
roleManager.Create(new IdentityRole(manageRoleVm.Role));
}
user.Roles.Clear();
UserManager.AddToRole(user.Id, manageRoleVm.Role);
manageRoleVm.SuccessMessage = $"{manageRoleVm.EmailAddress} now operates as within {manageRoleVm.Role}";
_context.SaveChanges();
return(View("ManageRole", manageRoleVm));
}
public ActionResult Index()
{
ManageRolesViewModel model = new ManageRolesViewModel();
model.Roles = new SelectList(Roles.GetAllRoles());
model.RoleList = Roles.GetAllRoles();
return(View(model));
}
public virtual ActionResult Index()
{
ManageRolesViewModel model = new ManageRolesViewModel();
model.Roles = new SelectList(roleService.GetAllRoles());
model.RoleList = roleService.GetAllRoles();
return(View(model));
}
public ActionResult ManageRoles(int pageNumber = 1, int pageSize = 5)
{
ManageRolesViewModel manageRolesViewModel = new ManageRolesViewModel()
{
PagedListOfRoles = _RoleManager.Roles.OrderBy(x => x.Name).ToPagedList(pageNumber, pageSize)
};
return(View(manageRolesViewModel));
}
public async Task <IActionResult> Index()
{
var roles = await _roleManager.Roles.ToArrayAsync();
var model = new ManageRolesViewModel {
Roles = roles
};
return(View(model));
}
public ManageRolesView(ManageRolesViewModel vm) : base(vm)
{
InitializeComponent();
vm.CreatedItemInList.RegisterHandler(interaction =>
{
ManageDataGrid.ScrollIntoView(interaction.Input);
ManageDataGrid.SelectedItem = interaction.Input;
interaction.SetOutput(Unit.Default);
});
}
public ActionResult Roles()
{
ManageRolesViewModel rolesViewModel = new ManageRolesViewModel();
List <IdentityRole> lsRoles = new List <IdentityRole>();
if (db.Roles.Any())
{
lsRoles = db.Roles.ToList();
}
rolesViewModel.AllRoles = lsRoles;
return(View(rolesViewModel));
}
public ActionResult ManageRoles(ManageRolesViewModel vm)
{
if (ModelState.IsValid)
{
using (var UC = new UserControl())
{
UC.ChangeUserRole(vm.UserId, vm.SelectedRol);
return(RedirectToAction("Index"));
}
}
return(View(vm));
}
public ViewResult ManageRoles(string id)
{
var appUserDto = _userDataProvider.GetApplicationUserDetailsById(id);
var rolesDto = _roleDataProvider.GetAllRoles();
var viewModel = new ManageRolesViewModel()
{
AppUser = appUserDto,
AllRoles = new SelectList(rolesDto, "RoleId", "RoleName")
};
return(View(viewModel));
}
/// <summary>
/// </summary>
/// <param name="id">User Id</param>
/// <returns></returns>
public ActionResult ManageRoles(long id)
{
var user = UserManager.GetUser(id);
var manageRole = new ManageRolesViewModel();
manageRole.AllRoles = RoleManager.GetRoles();
manageRole.UserInRoles = RoleManager.GetUserRolesAsApplicationRole(id).ToList();
manageRole.UserDisplayName = user.DisplayName;
manageRole.UserId = user.UserID;
return(View(manageRole));
}
public async Task <IActionResult> Index()
{
var identiyProviderRoles = await roleService.GetExternalRoles();
var localRoles = await roleService.GetRoles();
var model = new ManageRolesViewModel
{
IdentiyProviderRoles = identiyProviderRoles,
LocalRoles = localRoles
};
return(View(model));
}
public async Task <IActionResult> ManageRoles(string authorizedAction = null, int?roleId = null)
{
var list = await _cachedSecurityService.ListAllSecurityRoleDetails();
var model = new ManageRolesViewModel()
{
AllRoles = _mapper.Map <List <SecurityRoleDetail>, List <SecurityRoleViewModel> >(list.ToList())
};
model.Roles = model.AllRoles.Where(x =>
(String.IsNullOrEmpty(authorizedAction) || x.IsAuthorized(authorizedAction)) &&
(roleId == null || x.Id == roleId.Value)).ToList();
return(View(model));
}
public ActionResult UserRoles(ManageRolesViewModel rolesViewModel)
{
string sp = Request.Form["chklistitem"];
List <string> lsRoleIDs = new List <string>();
string sUserName = rolesViewModel.UserName;
if (sp != null)
{
lsRoleIDs = sp.Split(',').ToList();
}
RemoveRolesForUser(sUserName);
AddRolesForUser(sUserName, lsRoleIDs);
return(RedirectToAction("UserRoles"));
}
public ActionResult DeleteRole(Guid?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
IdentityRole role = db.Roles.Where(x => x.Id == id.ToString()).SingleOrDefault();
if (role == null)
{
return(HttpNotFound());
}
ManageRolesViewModel rolesViewModel = new ManageRolesViewModel();
rolesViewModel.role = role;
return(View(rolesViewModel));
}
// GET: Usuarios/Edit/5
public ActionResult ManageRoles(string id)
{
using (var UC = new UserControl())
{
var user = UC.FindUserById(id);
if (user != null)
{
var vm = new ManageRolesViewModel();
vm.UserName = user.UserName;
vm.UserId = user.UserId;
vm.SelectedRol = UC.GetUserRole(id);
vm.Roles = UC.GetRoles();
return(View(vm));
}
return(RedirectToAction("Index"));
}
}
public virtual ActionResult Index([DefaultValue(0)] int Id)
{
try
{
sw.Organisation organisation;
ManageRolesViewModel model = new ManageRolesViewModel();
if (System.Web.Security.Roles.IsUserInRole(Settings.Default.OrganisationAdminRole) && !System.Web.Security.Roles.IsUserInRole("ADMINISTRATOR"))
{
GetOrganisation objGetOrganisation = new GetOrganisation();
MembershipUser user = Membership.GetUser(User.Identity.Name);
organisation = objGetOrganisation.byUser(user);
if (organisation == null)
{
throw new Exception("Could not find Organisation");
}
Id = organisation.Id;
}
if (Id != 0)
{
organisation = (swdb.Organisation.Where(x => x.Id == Id)).FirstOrDefault();
if (organisation == null)
{
throw new Exception("Could not find Organisation");
}
var roles = (organisation.Roles.Select(x => x.RoleName)).ToArray();
model.Roles = new SelectList(roles);
model.RoleList = roles;
model.objOrganisation = organisation;
model.AvailableRoles = new SelectList(roleService.GetAllRoles().Except(roles));
//model.Id = Id;
}
else
{
model.Roles = new SelectList(roleService.GetAllRoles());
model.RoleList = roleService.GetAllRoles();
}
return(View(model));
}
catch (Exception ex)
{
// Log with Elmah
TempData["message"] = Settings.Default.GenericExceptionMessage;
return(RedirectToAction("Index", "Home", new { area = "Admin" }));
}
}
public async Task <IActionResult> DowngradeUser(ManageRolesViewModel model)
{
if (ModelState.IsValid && model.SelectedUserID != 0)
{
var knud = _tomasos.Kund.SingleOrDefault(k => k.KundId == model.SelectedUserID);
var user = await _userManager.FindByIdAsync(knud.IdentityId);
await _userManager.RemoveFromRoleAsync(user, "Premium");
await _userManager.AddToRoleAsync(user, "Regular");
}
else
{
return(RedirectToAction("ManageRoles"));
}
return(RedirectToAction("ManageRoles"));
}
private ManageRolesViewModel GenerateManageRolesViewModel(string id)
{
if (string.IsNullOrWhiteSpace(id))
{
return(null);
}
ApplicationUser foundUser = UserRepository.GetUserById(id);
if (foundUser == null)
{
return(null);
}
string currentAdminUserId = User.Identity.GetUserId();
ManageRolesViewModel model = ManageRolesViewModel.CreateNewViewModel(currentAdminUserId, foundUser, UserRoleRepository.GetAllUserRoles(), DbContext);
return(model);
}
public ActionResult UserRoles()
{
ManageRolesViewModel rolesViewModel = new ManageRolesViewModel();
List <IdentityRole> lsRoles = new List <IdentityRole>();
if (db.Roles.Any())
{
lsRoles = db.Roles.ToList();
}
rolesViewModel.AllRoles = lsRoles;
//rolesViewModel.UserName = User.Identity.Name;
rolesViewModel.slUsers = Utility.GetUsers();
rolesViewModel.RoleChoices = Utility.GetRoles();
if (rolesViewModel.UserName != null)
{
IdentityUser user = UserManager.FindByName(rolesViewModel.UserName);
rolesViewModel.SelectedRoles = user.Roles.Select(m => m.RoleId).ToList();
}
return(View(rolesViewModel));
}
public ActionResult ManageRoles()
{
var model = this._userRepository.All().ToList();
var viewModel = new ManageRolesViewModel()
{
Users = model.Select(x =>
new UserViewModel()
{
Id = x.Id,
UserName = x.UserName,
RoleId = x.Roles.FirstOrDefault()?.RoleId,
}).ToList(),
Roles = this._roleManager.Roles.Select(x => new SelectListItem()
{
Value = x.Id, Text = x.Name,
}).ToList()
};
return(View(viewModel));
}
// GET: ManageRoles
public ActionResult Index(ManageRolesViewModel model)
{
model.AvailableUsers = UserManager.Users.ToList();
string firstUserId;
if (model.CurrentUserId != null)
{
firstUserId = model.CurrentUserId;
}
else
{
firstUserId = model.AvailableUsers.First().Id;
}
model.AvailableRoles = GetRoles(firstUserId);
model.CurrentUserId = firstUserId;
return(View(model));
}
public ActionResult SearchRole(ManageRolesViewModel manageRoleVm)
{
ApplicationUser user = _context.Users
.FirstOrDefault(u => u.Email.Equals(manageRoleVm.EmailAddress, StringComparison.CurrentCultureIgnoreCase));
if (user == null)
{
ModelState.AddModelError("", "Email Address was not found");
return(View("ManageRole", manageRoleVm));
}
// This controller is setup in a way where roles don't overlap.
var firstRole = user.Roles.FirstOrDefault();
manageRoleVm.Role = firstRole == null ? EUserRoles.Applicant : _context.Roles.First(x => x.Id == firstRole.RoleId).Name;
ViewBag.SelectList = EUserRoles.ToList().Select(x => new SelectListItem()
{
Text = x, Value = x
});
return(View("ManageRole", manageRoleVm));
}
public List <ManageRolesViewModel> GetRolesInfo()
{
IQueryable <ApplicationUser> users = UserManager.Users;
var resultados = new List <ManageRolesViewModel>();
foreach (var user in users)
{
var resultado = new ManageRolesViewModel {
Email = user.Email
};
List <string> roleIds = new List <string>();
foreach (var role in user.Roles)
{
roleIds.Add(role.RoleId);
}
resultado.Roles = String.Join(",", roleIds);
resultados.Add(resultado);
}
return(resultados);
}
public async Task <IActionResult> ManageRoles(string id)
{
var user = await userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var roles = roleManager.Roles;
var userRoles = await userManager.GetRolesAsync(user);
var model = new List <ManageRolesViewModel>();
foreach (IdentityRole role in roles)
{
ManageRolesViewModel manageRolesViewModel = new ManageRolesViewModel
{
RoleID = role.Id,
RoleName = role.Name,
};
if (userRoles.Contains(role.Name))
{
manageRolesViewModel.IsSelected = true;
}
else
{
manageRolesViewModel.IsSelected = false;
}
model.Add(manageRolesViewModel);
}
ViewBag.FullName = user.FullName;
ViewBag.UserID = user.Id;
return(View(model));
}
