public void UpdateAccountGroup(RoleDetailViewModel viewModel)
{
SqlDb_Ultis.ExeNonStored("Tbl_DetailRoleUpDate",
"@Id", viewModel.Id,
"@GroupAccId", viewModel.GroupAccId,
"@Role", viewModel.Role);
}
public ActionResult AssignPermission(RoleDetailViewModel model)
{
if (model != null)
{
int RoleId = model.RoleDetail.Select(x => x.RoleId).FirstOrDefault();
//Delete All the Roles
//List<RoleDetailModel> _lst = _usersContext.RoleDetails.Where(z => z.RoleId == RoleId).ToList();
List <RoleDetail> _lst = _RoleDetailService.GetRoleDetails().Where(c => c.RoleId == RoleId).ToList();
foreach (RoleDetail roled in _lst)
{
_RoleDetailService.DeleteRoleDetail(roled);
}
//Insert All New Roles
foreach (var modelObj in model.RoleDetail)
{
RoleDetailModel Roles = new RoleDetailModel();
Roles.FormId = modelObj.FormId;
Roles.RoleId = modelObj.RoleId;
Roles.IsCreate = modelObj.IsCreate;
Roles.IsDelete = modelObj.IsDelete;
Roles.IsDownload = modelObj.IsDownload;
Roles.IsView = modelObj.IsView;
Roles.IsEdit = modelObj.IsEdit;
Roles.IsDetail = modelObj.IsDetail;
Roles.CreateDate = DateTime.Now;
// _RoleDetailService.InsertRoleDetail(Roles);
}
}
return(RedirectToAction("Index", "Role"));
}
public async Task <IActionResult> Edit(int id)
{
PageTitle = "Edit Role";
var viewModel = new RoleDetailViewModel
{
Role = await _roleService.GetByIdAsync(id),
Action = nameof(Edit),
SelectedPermissions = await _roleService.GetPermissionsForRoleAsync(id)
};
viewModel.UnselectedPermissions = (await _roleService.GetAllPermissionsAsync())
.Except(viewModel.SelectedPermissions);
if (viewModel.Role.IsAdmin)
{
ShowAlertWarning("Permissions for the System Administrator role cannot be modified. This role always has all permissions.");
}
var usersInRoles = await _roleService.GetUserCountForRolesAsync(new[] { id });
viewModel.UsersInRole = usersInRoles?.ContainsKey(id) == true ? usersInRoles[id] : 0;
return(View("Detail", viewModel));
}
public ActionResult RoleDetail(string id)
{
var role = context.Roles.Find(id);
RoleDetailViewModel vm = new RoleDetailViewModel();
vm.RoleName = role.Name;
vm.RoleId = role.Id;
vm.UsersUitRole = new List <ApplicationUser>();
foreach (var userrole in role.Users)
{
vm.UsersUitRole.Add(context.Users.Find(userrole.UserId));
vm.SelectUser = new List <SelectListItem>();
foreach (var user in context.Users)
{
if (!vm.UsersUitRole.Contains(user))
{
vm.SelectUser.Add(new SelectListItem {
Text = user.UserName, Value = user.Id
});
}
}
}
return(View(vm));
}
public ActionResult AssignPermission(int RoleId)
{
ViewBag.RoleId = RoleId;
// ViewData["RoleName"] = db.Roles.Where(z => z.RoleId == RoleId).Select(z => z.RoleName).FirstOrDefault().ToString();
ViewData["RoleName"] = _RoleService.GetRoles().Where(c => c.RoleId == RoleId).Select(c => c.RoleName).FirstOrDefault().ToString();
List <CommunicationApp.Entity.Form> lstControllerName = _FormService.GetForms();
ViewBag.lstControllerName = lstControllerName;
List <CommunicationApp.Entity.RoleDetail> lstRoleDetail = _RoleDetailService.GetRoleDetails();
ViewBag.lstRoleDetail = lstRoleDetail;
var model = new RoleDetailViewModel();
foreach (var roleDetail in lstControllerName)
{
var _lst = lstRoleDetail.Where(z => z.RoleId == RoleId && z.FormId == roleDetail.FormId).FirstOrDefault();
bool _IsCreate = false;
bool _IsEdit = false;
bool _IsDelete = false;
bool _IsView = false;
bool _IsDownload = false;
bool _IsDetail = false;
try
{
_IsCreate = _lst.IsCreate;
_IsDelete = _lst.IsDelete;
_IsDownload = _lst.IsDownload;
_IsEdit = _lst.IsEdit;
_IsView = _lst.IsView;
_IsDetail = _lst.IsDetail;
}
catch (Exception ex) {
string ErrorMsg = ex.Message.ToString();
ErrorLogging.LogError(ex);
}
var editorViewModel = new RoleDetailEditorViewModel()
{
RoleId = RoleId,
FormId = roleDetail.FormId,
FormName = roleDetail.FormName,
IsCreate = _IsCreate,
IsEdit = _IsEdit,
IsDelete = _IsDelete,
IsView = _IsView,
IsDetail = _IsDetail,
IsDownload = _IsDownload
};
model.RoleDetail.Add(editorViewModel);
}
return(View(model));
}
public RoleDetailViewModel GetAccountGroupById(Guid Id)
{
DataTable dtb = SqlDb_Ultis.ExeStoredToDataTable("Tbl_DetailRoleSelectByID", "@Id", Id);
RoleDetailViewModel accgr = new RoleDetailViewModel();
foreach (DataRow item in dtb.Rows)
{
accgr = Ultis.GetItem <RoleDetailViewModel>(item);
}
return(accgr);
}
public void TestRoleDetailViewModel()
{
RoleDTO roleDTO = new RoleDTO()
{
Id = 1, RoleName = "FakeName", Version = 0
};
RoleDetailViewModel viewModel = new RoleDetailViewModel(roleDTO, false);
Assert.AreEqual(roleDTO, viewModel.Model);
Assert.AreEqual(Strings.RoleDetailViewModel_DisplayName, viewModel.DisplayName);
}
public async Task <IActionResult> Create()
{
PageTitle = "Create Role";
var viewModel = new RoleDetailViewModel
{
Action = nameof(Create),
UnselectedPermissions = await _roleService.GetAllPermissionsAsync()
};
return(View("Detail", viewModel));
}
public void Constructor_Always_ReturnsIdentity(
long id,
string name,
IReadOnlyList <int> grantedPermissionIds)
{
var result = new RoleDetailViewModel(
id,
name,
grantedPermissionIds);
result.Id.ShouldBe(id);
result.Name.ShouldBe(name);
result.GrantedPermissionIds.ShouldBe(grantedPermissionIds);
}
public async Task <IActionResult> Edit(RoleDetailViewModel model)
{
model.SelectedPermissions = model.Permissions?.Split(',') ?? new string[] { };
if (ModelState.IsValid)
{
await _roleService.EditAsync(model.Role, model.SelectedPermissions);
ShowAlertSuccess($"Saved Role \"{model.Role.Name}\"!");
return(RedirectToAction(nameof(Edit), new { id = model.Role.Id }));
}
model.UnselectedPermissions = (await _roleService.GetAllPermissionsAsync())
.Except(model.SelectedPermissions);
PageTitle = "Edit Role";
return(View("Detail", model));
}
public async Task <IActionResult> Create(RoleDetailViewModel model)
{
if (ModelState.IsValid)
{
var permissionList = model.Permissions?.Split(',') ?? new string[] { };
var role = await _roleService.AddAsync(model.Role, permissionList);
ShowAlertSuccess($"Added Role \"{role.Name}\"!");
return(RedirectToAction(nameof(Edit), new { id = role.Id }));
}
model.UnselectedPermissions = (await _roleService.GetAllPermissionsAsync())
.Except(model.SelectedPermissions);
PageTitle = "Create Role";
return(View("Detail", model));
}
public IActionResult Details(string id)
{
if (!ModelState.IsValid)
{
return(NotFoundView());
}
Result <RoleDetailViewModel> result = _roleDataService.GetDetails(id);
if (result.Failure)
{
return(NotFoundView());
}
RoleDetailViewModel roleDetails = result.Value;
return(View(roleDetails));
}
public ActionResult RoleDetail(string id)
{
ApplicationDbContext context = new ApplicationDbContext();
var role = context.Roles.Find(id);
RoleDetailViewModel vm = new RoleDetailViewModel();
vm.RoleName = role.Name;
vm.RoleId = role.Id;
vm.UsersUitRole = (from user in context.Users
where user.Roles.Any(r => r.RoleId == id)
select user).ToList();
vm.SelectUser = new List <SelectListItem>();
foreach (var user in context.Users)
{
vm.SelectUser.Add(new SelectListItem {
Text = user.UserName, Value = user.Id
});
}
return(View(vm));
}
public Result <RoleDetailViewModel> GetDetails(string id)
{
SelectSpecification <RoleEntity, RoleDetailViewModel> roleSpecification = new SelectSpecification <RoleEntity, RoleDetailViewModel>();
roleSpecification.AddFilter(x => x.Id == id);
roleSpecification.AddSelect(x => new RoleDetailViewModel(
x.Id,
x.Name,
x.Description));
RoleDetailViewModel roleDetail = _roleRepository.Get(roleSpecification);
if (roleDetail == null)
{
_logger.LogWarning($"Role with id {id} does not exist");
return(Result.Fail <RoleDetailViewModel>("no_role", "No Role"));
}
return(Result.Ok(roleDetail));
}
public async Task <ActionResultResponse <RoleDetailViewModel> > Detail(string tenantId, string languageId, string id)
{
var roleInfo = await _roleRepository.FindByIdAsync(id, new CancellationToken());
if (roleInfo == null)
{
return new ActionResultResponse <RoleDetailViewModel>
{
Code = -1,
Message = _resourceService.GetString("Role does not exists.")
}
}
;
if (roleInfo.TenantId != tenantId)
{
return new ActionResultResponse <RoleDetailViewModel>
{
Code = -403,
Message = _resourceService.GetString("You do not have permission to view this role.")
}
}
;
var roleDetail = new RoleDetailViewModel
{
Id = roleInfo.Id,
Name = roleInfo.Name,
Description = roleInfo.Description,
ConcurrencyStamp = roleInfo.ConcurrencyStamp,
RolesPagesViewModels = await _rolePageRepository.GetsByRoleId(languageId, id),
Users = await _userRoleRepository.GetUserByRoleId(id)
};
return(new ActionResultResponse <RoleDetailViewModel>
{
Data = roleDetail
});
}
public void TestRoleDetailViewModel()
{
RoleDTO roleDTO = new RoleDTO() {Id = 1, RoleName = "FakeName", Version = 0};
RoleDetailViewModel viewModel = new RoleDetailViewModel(roleDTO, false);
Assert.AreEqual(roleDTO, viewModel.Model);
Assert.AreEqual(Strings.RoleDetailViewModel_DisplayName, viewModel.DisplayName);
}
public JsonResult Save(RoleDetailViewModel viewModel)
{
viewModel.Role = viewModel.Role == "null" ? String.Empty: viewModel.Role;
_iRoleDetailService.InsertAccountGroup(viewModel);
return(Json(new { success = 1, msg = "OK" }));
}
public async Task <IActionResult> Edit(string id, [Bind(nameof(RoleDetailViewModel.Id), nameof(RoleDetailViewModel.SelectedPermissions), nameof(RoleDetailViewModel.RoleName), nameof(RoleDetailViewModel.InitialPermissionList))] RoleDetailViewModel m)
{
if (id == null)
{
return(NotFound());
}
if (ModelState.IsValid)
{
var applicationRole = await Rdb.Roles.Include(lo => lo.Claims).SingleOrDefaultAsync(lo => lo.Id == id && lo.TenantId == TenantId);
if (applicationRole == null)
{
return(NotFound());
}
try
{
applicationRole.Name = m.RoleName;
applicationRole.NormalizedName = m.RoleName.ToLower();
applicationRole.ConcurrencyStamp = Guid.NewGuid().ToString();
var selectedRoleClaims = new List <RoleClaim>();
foreach (var p in m.SelectedPermissions.ConvertAll(s => Parse.ParseEnum <PermissionNames>(s)))
{
selectedRoleClaims.Add(PermissionHelpers.CreateIdentityRoleClaim(p));
}
foreach (var p in selectedRoleClaims)
{
if (applicationRole.Claims.All(x => x.ClaimType != p.ClaimType))
{
applicationRole.Claims.Add(p);
}
}
var rolesClaimsToRemove =
applicationRole.Claims.Where(x => !selectedRoleClaims.Any(p2 => p2.ClaimType == x.ClaimType) &&
!ApiClaimTypes.Any(p3 => p3 == x.ClaimType)).ToList();
applicationRole.Claims.Remove(rolesClaimsToRemove);
Rdb.Update(applicationRole);
await Rdb.SaveChangesAsync();
SetToast(AspHelpers.ToastMessages.Saved);
}
catch (DbUpdateConcurrencyException)
{
if (!ApplicationRoleExists(applicationRole.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToIndex());
}
return(View(m));
}
