public bool SaveRole(RoleUserModel model)
{
try
{
AppUserRole tbl = new AppUserRole();
if (model.Id > 0)
{
tbl = db.AppUserRoles.Find(model.Id);
tbl.RoleId = model.RoleId;
tbl.UserId = model.UserId;
db.SaveChanges();
}
else
{
tbl.RoleId = model.RoleId;
tbl.UserId = model.UserId;
db.AppUserRoles.Add(tbl);
db.SaveChanges();
}
return(true);
}
catch {
return(false);
}
}
public async Task <IActionResult> EditRolesInUser(string userId)
{
ViewBag.userId = userId;
var result = await _userManager.FindByIdAsync(userId);
if (result == null)
{
ViewBag.ErrorMessage = $"User with id :{userId} cannot be found";
return(View("NotFound"));
}
//This to ensure we wait for the 1st database call
//to finish, before we make another call to scoped identity
var roles = await _roleManager.Roles.ToListAsync();
//RoleUser --> RoleUserModel
var model = new List <RoleUserModel>();
foreach (var role in roles)
{
var roleUserModel = new RoleUserModel
{
RoleId = role.Id,
RoleName = role.Name
};
//
if (await _userManager.IsInRoleAsync(result, role.Name))
{
roleUserModel.IsSelected = true;
}
else
{
roleUserModel.IsSelected = false;
}
//userRoleModel.IsSelected = (await _userManager.IsInRoleAsync(user, result.Name)) ? true : false;
model.Add(roleUserModel);
}
//UserRoleModel --> UserRoleViewModel
var roleUserViewModel = new List <RoleUserViewModel>();
foreach (var role in model)
{
var roleUser = new RoleUserViewModel
{
RoleId = role.RoleId,
RoleName = role.RoleName,
IsSelected = role.IsSelected
};
roleUserViewModel.Add(roleUser);
}
return(View(roleUserViewModel));
}
public async Task <IActionResult> AssignRoleToUser([FromBody] RoleUserModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
int companyId = int.Parse(HttpContext.User.Claims.Where(c => c.Type == ClaimTypes.NameIdentifier).FirstOrDefault().Value);
var result = await _userRoleService.AssignRoleToUser(model, companyId);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public ActionResult AddBoMon(string Id)
{
RoleUserModel model = new RoleUserModel();
if (!string.IsNullOrEmpty(Id))
{
var rm = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
var _role = rm.Roles;
ViewBag.RoleName = _role.Select(x => new SelectListItem {
Text = x.Name, Value = x.Name
});
model.UserId = Id;
model.RoleName = UserManager.GetRoles(Id).FirstOrDefault();
}
return(View(model));
}
public async Task <IHttpActionResult> AssignRole([FromBody] RoleUserModel user)
{
string email = user.Email;
string roleToAssign = user.Role;
if (roleToAssign == null)
{
return(this.BadRequest("No roles are specified to this user."));
}
//find the user we want to assign roles to
var ExistingUser = await this.UserManager.FindByEmailAsync(email);
if (ExistingUser == null)
{
return(NotFound());
}
//check if the user currently has any roles
var currentRoles = this.UserManager.GetRoles(ExistingUser.Id);
//remove user from current roles, if any
if (currentRoles.Count != 0)
{
IdentityResult removeResult = await this.UserManager.RemoveFromRolesAsync(ExistingUser.Id, currentRoles[0]);
if (!removeResult.Succeeded)
{
ModelState.AddModelError("", "Failed to remove user roles"); return(BadRequest(ModelState));
}
}
//assign user to the new roles
IdentityResult addResult = await this.UserManager.AddToRolesAsync(ExistingUser.Id, roleToAssign);
if (!addResult.Succeeded)
{
ModelState.AddModelError("", "Failed to add user roles");
return(BadRequest(ModelState));
}
return(Ok(new { userId = ExistingUser.Id, rolesAssigned = roleToAssign }));
}
public async Task <IActionResult> EditRolesInUser(List <RoleUserViewModel> model, string userId)
{
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
ViewBag.ErrorMessage = $"User with id :{userId} cannot be found";
return(View("NotFound"));
}
var roleUsersModel = new List <RoleUserModel>();
for (int i = 0; i < model.Count; i++)
{
var roleUserModel = new RoleUserModel
{
RoleId = model[i].RoleId,
RoleName = model[i].RoleName,
IsSelected = model[i].IsSelected
};
roleUsersModel.Add(roleUserModel);
}
var roles = await _userManager.GetRolesAsync(user);
var result = await _userManager.RemoveFromRolesAsync(user, roles);
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot remove user existing roles");
return(View(model));
}
result = await _userManager.AddToRolesAsync(user,
roleUsersModel.Where(x => x.IsSelected).Select(x => x.RoleName));
if (!result.Succeeded)
{
ModelState.AddModelError("", "Cannot add selected roles");
return(View(model));
}
return(RedirectToAction("EditUser", new { Id = userId }));
}
public string addUserRole(string userid, string roleids)
{
RoleUserBLL roleuserbll = new RoleUserBLL();
int result = 0;
//1.delete all roles by userid
result = roleuserbll.deleteRolesByUserid(userid);
//2.add all roles according to params ‘roleids’
foreach (string roleid in roleids.Split(";".ToCharArray()))
{
if (roleid != "")
{
RoleUserModel roleuser = new RoleUserModel();
roleuser.role_id = int.Parse(roleid);
roleuser.user_id = int.Parse(userid);
result = roleuser.Insert();
}
}
return(new MyHttpResult(result > 0 ? true : false, "").ToString());
}
public async Task <GeneralModel> AssignRoleToUser(RoleUserModel model, int companyId)
{
using (var _context = _dbcontext())
{
var user = await _context.Users.FindAsync(model.UserId);
var role = await _context.Roles.FindAsync(model.RoleId);
if (user == null)
{
return(new GeneralModel {
Success = false,
Message = "User not Found"
});
}
else if (role == null)
{
return(new GeneralModel {
Success = false,
Message = "Role not Found"
});
}
var UserRole = new UserRole {
Users = user,
Roles = role,
CompanyId = companyId,
DateCreated = DateTime.Now
};
_context.UserRoles.Add(UserRole);
await _context.SaveChangesAsync();
var result = new GeneralModel {
Success = true,
Message = "Role Assigned to User"
};
return(result);
}
}
public async Task <IActionResult> GestionRolesUser(string idUser)
{
ViewBag.IdUser = idUser;
var user = await _gestionUser.FindByIdAsync(idUser);
if (user == null)
{
ViewBag.ErrorMessage = $"The user with id = {idUser} not find";
return(View("Error"));
}
var model = new List <RoleUserModel>();
foreach (var role in _gestionRoles.Roles)
{
var roleUserModel = new RoleUserModel
{
RoleId = role.Id,
RoleName = role.Name
};
if (await _gestionUser.IsInRoleAsync(user, role.Name))
{
roleUserModel.IsSelect = true;
}
else
{
roleUserModel.IsSelect = false;
}
model.Add(roleUserModel);
}
return(View(model));
}
public RoleUserModel DetailRole(int Id)
{
var tbl = (from a in db.AppUserRoles
join r in db.AppRoles on a.RoleId equals r.Id
join u in db.AppUsers on a.UserId equals u.Id
where u.Id == Id
select new RoleUserModel
{
Id = a.Id,
UserId = Id,
UserName = u.UserName,
Role = r.Role,
RoleId = r.Id
}).FirstOrDefault();
if (tbl != null)
{
return(tbl);
}
RoleUserModel model = new RoleUserModel();
model.UserId = Id;
return(model);
}
private List<RoleUserModel> GetRoleUserListQuery([FromUri] JqGridSearchModel searchModel, out int totalNumber, int maxRecords = Constants.DEFAULT_MAX_RECORDS_RETURN)
{
var query = _roleService.Query();
var gridData = Util.GetGridData<Role>(searchModel, query);
int totalRecords = gridData.TotalNumber;
var data = gridData.Items;
var dataListTemp = data.SelectMany(u => _userService.Query(), (r, u) => new { r, u })
.Where(x => x.u.Roles.Contains(x.r)).OrderBy(x => x.r.Id).Select(x => new { x.r.Id, x.r.Name, x.r.Description, x.u }).ToList();
var roles = data.ToList();
List<RoleUserModel> dataList = new List<RoleUserModel>();
foreach (Role role in roles)
{
RoleUserModel roleUser = new RoleUserModel { Id = role.Id, Description = role.Description, Name = role.Name };
var users = dataListTemp.Where(x => x.Id == role.Id).Select(x => x.u).ToList();
foreach (var user in users)
roleUser.Users.Add(new RoleUserModel.User { Id = user.ID, UserName = user.Username, FirstName = user.FirstName, LastName = user.LastName });
dataList.Add(roleUser);
}
totalNumber=totalRecords;
return dataList;
}
public ActionResult SaveRole(RoleUserModel model)
{
bool status = new UserDao().SaveRole(model);
return(Json(new { status = status }, JsonRequestBehavior.AllowGet));
}
public AccessController()
{
roleManager = new RoleManager();
roleUserModel = new RoleUserModel();
userManager = new UserManager();
}
