public async Task <IEditPermissionViewModel <TRole, TViewModel> > GetEditPermissionViewModel <TRole, TViewModel>(string userId, string roleId) where TViewModel : class, new()
{
var user = await _userRepository.GetAsync(userId);
var userRolePermissions = user.Roles.FirstOrDefault(ur => ur.RoleId == roleId).Role.Permissions;
var model = new EditPermissionViewModel
{
UserId = userId,
Role = _roleRepository.Get(roleId),
RoleId = roleId
};
var allPermissions = await _permissionManagerFacade.GetAll();
model.Permissions = allPermissions.Select(p => new IdentityPermissionViewModel
{
Description = p.Description,
Id = p.Id,
Name = p.Name,
IsSelected = userRolePermissions.Select(rp => rp.PermissionId).Contains(p.Id)
});
return(model as IEditPermissionViewModel <TRole, TViewModel>);
}
public async Task <IActionResult> EditPermission(int id)
{
var viewModel = new EditPermissionViewModel();
var response = await _adminService.GetPermission(new GetPermissionRequest()
{
Id = id
});
if (!response.IsSuccessful)
{
AddNotifications(response);
return(View(viewModel));
}
viewModel.Key = response.Permission.Key;
viewModel.Request = new UpdatePermissionRequest()
{
Id = response.Permission.Id,
Name = response.Permission.Name,
Description = response.Permission.Description,
GroupName = response.Permission.Group_Name,
};
return(View(viewModel));
}
public async Task <JsonResult> EditPermissionPartialView(EditPermissionViewModel model)
{
if (!ModelState.IsValid)
{
return(Json(new { success = false, message = "Model is not valid" }));
}
var entity = _applicationDbContext.Permissions.SingleOrDefault(x => x.Id == model.PermissionId);
if (entity == null)
{
return(Json(new { success = false, message = "Permission not found" }));
}
entity.Changed = DateTime.Now;
entity.Description = model.Description;
entity.PermissionName = model.PermissionName;
try
{
await _applicationDbContext.SaveChangesAsync();
//var onlineUsers = hub.GetOnlineUsers();
//await User.RefreshOnlineUsersClaims(ApplicationDbContext, signInManager, onlineUsers);
return(Json(new { success = true, message = "Save successful " }));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public async Task <ActionResult> EditPermission(EditPermissionViewModel model)
{
var result = await _roleRepository.UpdateRolePermissions <IdentityPermissionViewModel>(model);
if (result.Succeeded)
{
return(RedirectToAction("EditPermission", new { userId = model.UserId, roleId = model.RoleId, message = UsersMessageId.PermissionsAddedSuccess }));
}
AddErrors(result);
return(View(model));
}
public async Task Edit_permission_should_return_model()
{
var model = new EditPermissionViewModel() as IEditPermissionViewModel <IdentityRole, IdentityPermissionViewModel>;
_mappingManager.Setup(x => x.GetRolePermissionsMapper()
.GetEditPermissionViewModel <IdentityRole, IdentityPermissionViewModel>("", ""))
.Returns(Task.FromResult(model));
var result = await _controller.EditPermission("", "") as ViewResult;
Assert.That(result.ViewData.Model, Is.EqualTo(model));
}
public async Task Edit_permission_should_rederict_edit_permission_action_whith_success_message()
{
var model = new EditPermissionViewModel();
_roleRepository.Setup(x => x.UpdateRolePermissions(model))
.Returns(Task.FromResult(IdentityResult.Success));
var result = await _controller.EditPermission(model) as RedirectToRouteResult;
Assert.That(result.RouteValues["action"], Is.EqualTo("EditPermission"));
Assert.That(result.RouteValues["message"], Is.EqualTo(UsersMessageId.PermissionsAddedSuccess));
}
public async Task <IActionResult> EditPermission(UpdatePermissionRequest request)
{
if (ModelState.IsValid)
{
var response = await _adminService.UpdatePermission(request);
if (response.IsSuccessful)
{
AddNotifications(response);
return(RedirectToAction(nameof(AdminController.PermissionManagement)));
}
AddFormErrors(response);
}
var viewModel = new EditPermissionViewModel(request);
return(View(viewModel));
}
public IActionResult EditPermissionPartialView(Guid?id)
{
if (!id.HasValue)
{
return(NotFound());
}
var permission = _applicationDbContext.Permissions.AsNoTracking().FirstOrDefault(x => x.Id == id);
if (permission == null)
{
return(NotFound());
}
var model = new EditPermissionViewModel
{
Description = permission.Description,
PermissionName = permission.PermissionName,
PermissionId = permission.Id
};
return(PartialView("Partial/EditPermissionPartialView", model));
}
public async Task <ActionResult> Edit([Bind(Include = "Name,Id")] EditPermissionViewModel editPermission, params string[] selectedRole)
{
if (ModelState.IsValid)
{
var permission = await PermissionManager.FindByIdAsync(editPermission.Id);
if (permission == null)
{
return(HttpNotFound());
}
permission.Name = editPermission.Name;
var permissionRoles = await PermissionManager.GetRolesByIdAsync(permission.Id);
selectedRole = selectedRole ?? new string[] { };
var result = await PermissionManager.AddToRolesAsync(permission.Id, selectedRole.Except(permissionRoles).ToArray <string>());
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
result = await PermissionManager.RemoveFromRolesAsync(permission.Id, permissionRoles.Except(selectedRole).ToArray <string>());
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Something failed.");
return(View());
}
public async Task UpdateRolePermissionsShouldSuccess()
{
var repository = Repository as RoleRepository;
string roleId = Guid.NewGuid().ToString("N");
var role = new IdentityRole {
Id = roleId
};
var permission1Id = Guid.NewGuid().ToString("N");
var permission1 = new IdentityPermission {
Name = "1", Id = permission1Id
};
var permission2Id = Guid.NewGuid().ToString("N");
var permission2 = new IdentityPermission {
Name = "2", Id = permission2Id
};
var p3 = new IdentityPermission {
Name = "3"
};
var p4 = new IdentityPermission {
Name = "4"
};
var allPermissions = new List <IdentityPermission>
{
permission1,
permission2,
p3,
p4
};
_permissionManager.Setup(x => x.GetAll())
.Returns(Task.FromResult(allPermissions.AsEnumerable()));
_roleManager.Setup(x => x.FindByIdAsync(roleId))
.Returns(Task.FromResult(role));
var userPermission1 = new IdentityRolePermission
{
Permission = permission1,
PermissionId = permission1Id,
Role = role,
RoleId = roleId
};
var userPermission2 = new IdentityRolePermission
{
Permission = permission2,
PermissionId = permission2Id,
Role = role,
RoleId = roleId
};
role.Permissions = new List <IdentityRolePermission>
{
userPermission1,
userPermission2
};
var permissions = new List <IdentityPermissionViewModel>
{
new IdentityPermissionViewModel {
Id = permission1.Id, IsSelected = false
},
new IdentityPermissionViewModel {
Id = permission2.Id, IsSelected = false
},
new IdentityPermissionViewModel {
Id = p3.Id, IsSelected = true
},
new IdentityPermissionViewModel {
Id = p3.Id, IsSelected = true
}
};
IEditPermissionViewModel <IdentityRole, IdentityPermissionViewModel> model = new EditPermissionViewModel
{
Permissions = permissions,
Role = role,
RoleId = roleId
};
var result = await repository.UpdateRolePermissions(model);
Assert.IsTrue(result.Succeeded);
}
