public ActionResult RolePermission(string roleId)
{
#region Create Role Permissions
List <RolePermissionsViewModel> rolePermissions = new List <RolePermissionsViewModel>();
foreach (var item in db.Permissions.ToList())
{
if (item.ParentId != null)
{
RolePermissionsViewModel permission = new RolePermissionsViewModel()
{
PermissionID = item.Id,
PermissionTitle = item.Title,
ControllerName = item.ControllerName,
Access = db.RolePermissions
.Where(a => a.RoleId == roleId && a.PermissionId == item.Id).Any()
};
rolePermissions.Add(permission);
}
}
#endregion
ViewBag.RoleName = db.Roles.Find(roleId).Name;
ViewBag.RoleID = roleId;
ViewBag.TreeItems = rolePermissions.OrderBy(a => a.PermissionTitle).Select(r => new TreeViewItemModel()
{
Text = r.PermissionTitle,
Id = r.PermissionID.ToString(),
Checked = r.Access
}).ToList();
return(View(rolePermissions));
}
/// <summary>
/// Assigns the role permission.
/// </summary>
/// <param name="role">The role.</param>
/// <returns></returns>
public Response <RolePermissionsViewModel> AssignRolePermission(RolePermissionsViewModel role)
{
string apiUrl = baseRoute + "assignRolePermission";
var response = communicationManager.Post <RolePermissionsModel, Response <RolePermissionsModel> >(role.ToEntity(), apiUrl);
return(response.ToModel());
}
public JsonResult AssignRolePermission(RolePermissionsViewModel role)
{
var response = securityRepository.AssignRolePermission(role);
ClearCache(response);
return(Json(response, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> PermissionsList(long roleId)
{
var vm = new RolePermissionsViewModel(roleId);
vm.PermissionOptions = await getPermissionsService.GetAllPermissionsAsync();
return(View("PermissionsList", vm));
}
public static RolePermissionsModel ToEntity(this RolePermissionsViewModel model)
{
if (model == null)
{
return(null);
}
var role = new RoleModel();
if (model.Role != null)
{
var roleModel =
role = model.Role.ToEntity();
}
var Modules = new List <ModuleModel>();
if (model.Modules != null)
{
model.Modules.ForEach(delegate(ModuleViewModel modules)
{
var transformedModel = modules.ToEntity();
Modules.Add(transformedModel);
}
);
}
else
{
Modules = null;
}
var Features = new List <FeatureModel>();
if (model.Features != null)
{
model.Features.ForEach(delegate(FeatureViewModel features)
{
var transformedModel = features.ToEntity();
Features.Add(transformedModel);
}
);
}
else
{
Features = null;
}
var entity = new RolePermissionsModel
{
Role = role,
Modules = Modules,
Features = Features
};
return(entity);
}
public ActionResult AddRolePermissions(short roleId)
{
RolePermissionsViewModel viewModel = new RolePermissionsViewModel();
GetRolesResponse rolesResponse = roleService.GetRoles(new GetRolesRequest()
{
AccountId = this.Identity.ToAccountID()
});
if (rolesResponse != null && !rolesResponse.RoleViewModel.Any(r => r.RoleId == roleId))
return RedirectToAction("NotFound", "Error");
GetModulesResponse modulesResponse = roleService.GetModules(new GetModulesRequest()
{
AccountID = this.Identity.ToAccountID()
});
if (!this.Identity.IsSTAdmin())
{
if(rolesResponse.SubscriptionId == 2)
rolesResponse.RoleViewModel = rolesResponse.RoleViewModel.Where(s => s.RoleName != "Account Administrator");
else
rolesResponse.RoleViewModel = rolesResponse.RoleViewModel.Where(s => s.RoleName != "Account Administrator" && s.RoleName != "Marketing Administrator" && s.RoleName != "Sales Administrator" && s.RoleName != "Marketing");
modulesResponse.ModuleViewModel = modulesResponse.ModuleViewModel.Where(s => s.ModuleId != (byte)AppModules.AccountSettings);
}
viewModel.Modules = modulesResponse.ModuleViewModel;
viewModel.Roles = rolesResponse.RoleViewModel;
GetModulesForRoleResponse response = roleService.GetModulesForRole(new GetModulesForRoleRequest()
{
roleId = roleId
});
foreach (var item in response.moduleIds)
{
foreach (var module in viewModel.Modules)
{
if (module.ModuleId == item)
{
module.IsSelected = true;
}
if (module.SubModules != null)
{
foreach (var submodule in module.SubModules)
{
if (submodule.ModuleId == item)
{
submodule.IsSelected = true;
}
}
}
}
}
viewModel.SelectedRole = roleId;
return View("RolePermissions", viewModel);
}
public ActionResult Index()
{
var model = new RolePermissionsViewModel
{
RolesGridViewModel = GetRolesGridViewModel(),
PermissionsTreeViewModel = GetPermissionsTreeViewModel(),
GetRolePermissionsUrl = Url.RouteUrl("GetRolePermissions"),
UpdateRolePermissionsUrl = Url.RouteUrl("RolePermissionsUpdate")
};
return(View(model));
}
public JsonResult EditPermission(RolePermissionsViewModel permission)
{
try
{
var role = _db.AspNetRoles.Find(permission.Id.ToString());
var rolePermissions = _db.RolePermissions.Where(x => x.RoleId == role.Id);
foreach (var rolePermission in rolePermissions)
{
_db.RolePermissions.Remove(rolePermission);
}
_db.SaveChanges();
if (role != null)
{
if (!string.IsNullOrWhiteSpace(permission.RoleName))
{
role.Name = permission.RoleName;
}
if (!string.IsNullOrWhiteSpace(permission.RoleFriendlyName))
{
role.FriendlyName = permission.RoleFriendlyName;
}
if (!string.IsNullOrWhiteSpace(permission.RoleDescription))
{
role.Description = permission.RoleDescription;
}
_db.Entry(role).State = EntityState.Modified;
var permissions = permission.Permissions.Split(',');
var newRolePermission = new RolePermission();
foreach (var perm in permissions)
{
var permId = int.Parse(perm);
var existRolePermission = _db.RolePermissions.Any(x => x.RoleId == role.Id.ToString() && x.PermissionId == permId);
if (existRolePermission)
{
//Role Permission Already Exist
continue;
}
newRolePermission.RoleId = role.Id;
newRolePermission.PermissionId = int.Parse(perm);
_db.RolePermissions.Add(newRolePermission);
_db.SaveChanges();
}
}
}
catch (Exception ex)
{
LogHelper.LogException(User.Identity.Name, ex, "Error While adding Role Permission (Post)");
return(null);
}
return(Json(permission, JsonRequestBehavior.AllowGet));
}
public void AssignRolePermission_Success()
{
// Act
var lstRolePermissionsViewModel = new List <RolePermissionsViewModel>();
var rolePermissionsViewModel = new RolePermissionsViewModel();
var role = new RoleViewModel();
role.RoleID = 1;
rolePermissionsViewModel.Role = role;
var modules = new List <ModuleViewModel>();
var permissions = new List <PermissionViewModel>();
permissions.Add(new PermissionViewModel()
{
PermissionID = 1
});
rolePermissionsViewModel.Modules = modules;
modules.Add(new ModuleViewModel()
{
ModuleID = 1, Permissions = permissions
});
lstRolePermissionsViewModel.Add(new RolePermissionsViewModel {
Role = role, Modules = modules
});
var features = new List <FeatureViewModel>();
var permissionFeature = new List <PermissionViewModel>();
permissionFeature.Add(new PermissionViewModel()
{
PermissionID = 1
});
features.Add(new FeatureViewModel()
{
FeatureID = 1, Permissions = permissionFeature
});
rolePermissionsViewModel.Features = features;
lstRolePermissionsViewModel.Add(new RolePermissionsViewModel {
Role = role, Features = features
});
var result = controller.AssignRolePermission(rolePermissionsViewModel);
var jsonResponse = result as JsonResult;
var data = result.Data;
var modelResponse = data as Response <RolePermissionsViewModel>;
var rowAffected = modelResponse.RowAffected;
// Assert
Assert.IsTrue(rowAffected > 0);
}
public PartialViewResult EditPermission(int id)
{
try
{
var permissionsGroups = _db.Permissions.Where(r => r.Status != (int)GeneralEnums.StatusEnum.Deleted).GroupBy(x => x.PageName);
var rolePermissions = _db.RolePermissions.Where(x => x.RoleId == id.ToString() && x.Permission.Status != (int)GeneralEnums.StatusEnum.Deleted);
var currentRole = _db.AspNetRoles.FirstOrDefault(x => x.Id == id.ToString());
if (currentRole == null)
{
//Role not exist
return(null);
}
var result = new RolePermissionsViewModel
{
Id = id,
RoleName = currentRole.Name,
RoleFriendlyName = currentRole.FriendlyName,
RoleDescription = currentRole.Description,
PermissionGroups = new List <PermissionGroups>()
};
foreach (var permissions in permissionsGroups)
{
result.PermissionGroups.Add(new PermissionGroups
{
PageName = permissions.Key,
PermissionsKey = permissions.Select(x => new PermissionViewModel
{
Id = x.Id,
Status = x.Status,
PageUrl = x.PageUrl,
PermissionKey = x.PermissionKey,
PageName = x.PageName,
Description = x.Description,
CreatedBy = x.CreatedBy,
CreatedOn = x.CreatedOn,
DeletedOn = x.DeletedOn,
IsSelected = rolePermissions.Any(r => r.PermissionId == x.Id)
}).ToDictionary(x => x.Id)
});
}
return(PartialView("_RolePermission", result));
}
catch (Exception ex)
{
LogHelper.LogException(User.Identity.Name, ex, "Error While editing Permission (Get)");
return(null);
}
}
public JsonResult InsertRolePermissions(string rolePermissionViewodel)
{
RolePermissionsViewModel PermissionViewodel = JsonConvert.DeserializeObject<RolePermissionsViewModel>(rolePermissionViewodel);
InsertRolePermissionsResponse response = roleService.InsertRolePermissions(new InsertRolePermissionsRequest()
{
rolePermissionsViewModel = PermissionViewodel
});
if (response.Exception == null)
{
int accountId = this.Identity.ToAccountID();
cachingService.AddUserPermissions(accountId);
}
return Json(new
{
success = true,
response = ""
}, JsonRequestBehavior.AllowGet);
}
public ActionResult RolePermissionsGVPAddNew([ModelBinder(typeof(DevExpressEditorsBinder))] App.Marriage.Models.RoleMV.RolePermissionsViewModel item)
{
var model = new RolePermissionsViewModel();
//if (ModelState.IsValid)
//{
try
{
// Insert here a code to insert the new item in your model
}
catch (Exception e)
{
ViewData["EditError"] = e.Message;
}
//}
//else
// ViewData["EditError"] = "Please, correct all errors.";
return(PartialView("~/Views/RolePermissions/_RolePermissionsGVP.cshtml", model));
}
public ActionResult RolePermissionsGVPUpdate([ModelBinder(typeof(DevExpressEditorsBinder))] App.Marriage.Models.RoleMV.RolePermissionsViewModel item)
{
//if (ModelState.IsValid)
//{
try
{
RolePermissionsDAL RP = new RolePermissionsDAL(item.Id);
RP.RolePermissions.IsActive = item.IsActive;
RP.Update();
// Insert here a code to update the item in your model
}
catch (Exception e)
{
ViewData["EditError"] = e.Message;
}
//}
//else
// ViewData["EditError"] = "Please, correct all errors.";
var model = RolePermissionsViewModel.GetRolePermissionsList();
return(PartialView("~/Views/RolePermissions/_RolePermissionsGVP.cshtml", model));
}
public ActionResult RolePermissionsGVP()
{
var model = RolePermissionsViewModel.GetRolePermissionsList();
return(PartialView("~/Views/RolePermissions/_RolePermissionsGVP.cshtml", model));
}
public PartialViewResult EditRolePermission(int roleId)
{
var rolePermissions = new RolePermissionsViewModel(roleId, CurrentUser.UserId);
return(PartialView(rolePermissions));
}
public ActionResult Details(string id)
{
if (string.IsNullOrEmpty(id))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
RoleViewModel roleVM;
using (ApplicationDbContext context = new ApplicationDbContext())
{
IdentityRole role = context.Roles.Find(id);
if (role == null)
{
return(HttpNotFound());
}
roleVM = new RoleViewModel()
{
Id = role.Id, Name = role.Name
};
}
var empCategories = DbContext.EmployeeCategories.FirstOrDefault(x => x.RoleName == roleVM.Name);
if (empCategories == null)
{
DbContext.EmployeeCategories.Add(new EmployeeCategories()
{
RoleName = roleVM.Name,
});
empCategories = DbContext.EmployeeCategories.FirstOrDefault(x => x.RoleName == roleVM.Name);
if (empCategories == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
}
var categories = DbContext.Category.ToList();
var categorylist = new List <CategoryViewModel>();
foreach (var cat in categories)
{
if (empCategories.Categories.Contains(cat))
{
categorylist.Add(new CategoryViewModel()
{
Name = cat.Name,
Id = cat.Id,
Active = true,
});
}
}
RolePermissionsViewModel rp = new RolePermissionsViewModel()
{
Role = roleVM,
Categories = categorylist,
};
return(View(rp));
}