public async Task <ActionResult> Role(RoleIndexModel model)
{
await SearchRoleAsync(model);
await PopulateRolePageAsync(model);
return(PartialView("Role/_RoleResult", model));
}
// GET: Role
public ActionResult Index()
{
RoleIndexModel role = new RoleIndexModel();
role.Roles = Service.GetAll();
role.NewRole = new RoleViewModels();
return(View(role));
}
public IActionResult Index()
{
var model = new RoleIndexModel()
{
CurrentAdmin = CurrentAdmin,
};
return(View(model));
}
public ActionResult Create(RoleIndexModel model)
{
if (ModelState.IsValid)
{
Service.Add(model.NewRole);
}
return(RedirectToAction("index", "Role"));
}
public async Task <ActionResult> Role()
{
SetTitle("Phân quyền");
var model = new RoleIndexModel();
await SearchRoleAsync(model);
await PopulateRolePageAsync(model);
return(View(model));
}
// GET: Role
public ActionResult Index(RoleIndexModel model, int?page)
{
var currentPage = page.HasValue ? page.Value - 1 : 0;
var pageSize = 10;
int total = 0;
var lst = _roleService.GetByFilter(model.KeyWord, currentPage, pageSize, out total);
model.AppRoles = new PagedList <Role>(lst, currentPage, pageSize, total);
return(View(model));
}
public PartialViewResult ActionDetails(int?actionID)
{
var viewModel = new RoleIndexModel();
if (actionID != null)
{
ViewBag.ActionID = actionID;
viewModel.Actions = db.Actions.Where(
i => i.Action_ID == actionID);
}
return(PartialView("ActionDetails", viewModel));
}
private async Task SearchRoleAsync(RoleIndexModel model)
{
var response = await _roleService.FindAsync(new RoleFindRequest
{
Name = model.Name,
PageSize = model.Paging.PageSize,
PageNumber = model.Paging.PageNumber,
Sort = model.Sort
});
model.Results = _mapper.Map <List <RoleModel> >(response.Results);
model.Paging.TotalRecords = response.TotalRecords;
}
public PartialViewResult RoleDetails(int?id)
{
var viewModel = new RoleIndexModel();
viewModel.Roles = db.Roles
.Include(i => i.Role_Action.Select(x => x.Action));
if (id != null)
{
ViewBag.RoleID = id.Value;
viewModel.RoleActions = db.Roles.Single(
i => i.Role_ID == id.Value).Role_Action;
}
return(PartialView("RoleDetails", viewModel));
}
public async Task <IActionResult> ManageRolesAssignment(RoleIndexModel model, string option)
{
if (ModelState.IsValid)
{
if (option == "Assign")
{
return(await AssignUserToRole(model).ConfigureAwait(false));
}
else
{
return(await RemoveUserFromRole(model).ConfigureAwait(false));
}
}
return(RedirectToAction("ManageRoles", "Management"));
}
public ActionResult Delete(int?id, RoleIndexModel roleIndex)
{
if (id == null)
{
TempData["Error"] = "Please select a role before selecting delete";
return(RedirectToAction("Index", roleIndex));
}
ViewBag.ErrorMsg = "Are you sure you want to delete?";
TempData["Disabled"] = false;
RoleEditModel roleModel = new RoleEditModel();
roleModel.role = db.Roles.Find(id);
roleModel.actionList = db.Role_Action.Where(
i => i.Role_ID == id.Value).ToList();
if (roleModel.role == null)
{
return(HttpNotFound());
}
if (roleModel.role.Role_Name == "Super Admin")
{
ViewBag.ErrorMsg = "'Super Admin' role cannot be deleted";
TempData["Disabled"] = true;
return(View(roleModel));
}
if (roleModel.role.Role_Name == "Admin")
{
ViewBag.ErrorMsg = "'Admin' role cannot be deleted";
TempData["Disabled"] = true;
return(View(roleModel));
}
var rolePerson = from p in db.Person_Role
where p.Role_ID == id
select p;
if (rolePerson.Count() != 0)
{
ViewBag.ErrorMsg = "Role cannot be deleted becuase there are persons assigned to the role";
TempData["Disabled"] = true;
return(View(roleModel));
}
return(RedirectToAction("Index"));
}
public IActionResult Index()
{
var roles = _roleManager.Roles
.Select(role => new RoleViewModel
{
Id = role.Id,
Name = role.Name,
Description = role.Description
});
var model = new RoleIndexModel
{
RolesList = roles
};
return(View(model));
}
public ActionResult Index(string search)
{
var viewModel = new RoleIndexModel();
viewModel.Roles = db.Roles
.Include(i => i.Role_Action.Select(x => x.Action));
if (search != null)
{
viewModel.Roles = (viewModel.Roles.Where(x => x.Role_Name.ToLower().StartsWith(search.ToLower())));
}
if (viewModel.Roles.Count() == 0)
{
TempData["Error"] = "No roles match search criteria";
}
return(View(viewModel));
}
public async Task <IActionResult> RemoveUserFromRole(RoleIndexModel model)
{
if (model != null)
{
if (!string.IsNullOrEmpty(model.UpdateModel.User) &&
!string.IsNullOrEmpty(model.UpdateModel.Role))
{
var user = await _userManager.FindByNameAsync(model.UpdateModel.User)
.ConfigureAwait(false);
await _userManager.RemoveFromRoleAsync(user, model.UpdateModel.Role)
.ConfigureAwait(false);
}
}
return(RedirectToAction("ManageRoles", "Management"));
}
public ActionResult Edit(int?id, RoleIndexModel roleIndex)
{
if (id == null)
{
TempData["Error"] = "Please select a role before selecting update";
return(RedirectToAction("Index", roleIndex));
}
RoleEditModel roleModel = new RoleEditModel();
roleModel.role = db.Roles.Find(id);
if (roleModel.role == null)
{
return(HttpNotFound());
}
roleModel.actionList = db.Role_Action.Where(
i => i.Role_ID == id.Value).ToList();
return(View(roleModel));
}
public IActionResult ManageRoles()
{
var listingModel = _user.GetAll()
.Select(result => new RoleListingModel
{
FullName = result.FirstName + " " + result.LastName,
Username = result.UserName,
EmailAddress = result.Email,
Roles = _user.GetAllRolesAsync(result, ',').Result
});
var model = new RoleIndexModel
{
UserRoles = listingModel,
Usernames = _userManager.Users.Select(user => user.UserName).ToList(),
Roles = _roleManager.Roles.Select(role => role.Name).ToList()
};
return(View(model));
}
public ActionResult Index(RoleIndexModel model)
{
model.InitSortInfo();
if (string.IsNullOrWhiteSpace(model.SortBy))
{
model.SortBy = "Name";
}
var filter = new FindRequest
{
Name = model.Name,
SortOption = new SortOption(new[] { new SortItem(model.SortBy, model.SortDirection.Value) }),
PageOption = new PageOption { PageSize = model.Pagination.PageSize, PageNumber = model.Pagination.CurrentPageIndex }
};
var response = ServiceHelper.Role.ExecuteDispose(s => s.FindRoles(filter));
model.Results = response.Results.MapList<RoleModel>();
model.Pagination.TotalRecords = response.TotalRecords;
return View(model);
}
private async Task PopulateRolePageAsync(RoleIndexModel model)
{
model.Paging.PageClickFunction = "comdy.role.search({0})";
model.PopulateCreatedUser(await _userService.GetReferencesAsync());
}
