public ActionResult Edit(int id)
{
RoleFormViewModel viewModel =
_roleManagementService.CreateFormViewModelFor(id);
return(View(viewModel));
}
public ActionResult Create()
{
RoleFormViewModel viewModel =
_roleManagementService.CreateFormViewModel();
return(View(viewModel));
}
public ActionResult Create(Role role)
{
if (ViewData.ModelState.IsValid)
{
role.LastUpdateTimeStamp = DateTime.Now;
role.LastUpdateUser = GetCurrentUser().Id;
ActionConfirmation saveOrUpdateConfirmation =
_roleManagementService.SaveOrUpdate(role);
if (saveOrUpdateConfirmation.WasSuccessful)
{
TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()] =
saveOrUpdateConfirmation.Message;
return(RedirectToAction("Index"));
}
}
else
{
role = null;
}
RoleFormViewModel viewModel =
_roleManagementService.CreateFormViewModelFor(role);
return(View(viewModel));
}
public void CreateRole(RoleFormViewModel viewModel)
{
_context.Roles.Add(new IdentityRole()
{
Name = viewModel.RoleName
});
}
public async Task <IActionResult> Edit(string id)
{
// Find the role by Role ID
var role = await _roleManager.FindByIdAsync(id).ConfigureAwait(true);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found";
return(View("NotFound"));
}
var modelView = new RoleFormViewModel
{
Id = role.Id,
Name = role.Name
};
// Retrieve all users
foreach (var user in _userManager.Users)
{
// If the user is in this role, add the username to
// Users property of RoleViewModel. This model
// object is then passed to the view for display
if (await _userManager.IsInRoleAsync(user, role.Name).ConfigureAwait(true))
{
modelView.Users.Add(user.UserName);
}
}
return(View(modelView));
}
public RoleFormViewModel CreateFormViewModelFor(Role role)
{
RoleFormViewModel viewModel = CreateFormViewModel();
viewModel.Role = role;
return(viewModel);
}
/// <summary>
/// 保存角色
/// </summary>
/// <param name="roleFormViewModel">角色视图模型</param>
/// <returns>保存结果</returns>
public ActionResult Save(RoleFormViewModel roleFormViewModel)
{
RoleBll bll = new RoleBll();
Role role = new Role();
string error;
if (ModelState.IsValid)
{
role.RoleName = roleFormViewModel.RoleName;
role.Id = roleFormViewModel.Id == null?0:int.Parse(roleFormViewModel.Id.ToString());
role.Code = roleFormViewModel.Code;
role.Description = roleFormViewModel.Description;
role.LastChangeTime = DateTime.Now;
role.LastChangeUser = int.Parse(Session["UserId"].ToString());
try
{
bll.SaveRole(role);
}
catch (Exception e)
{
error = "保存出错,请重试";
return(Json(error, JsonRequestBehavior.AllowGet));
}
return(Json("access", JsonRequestBehavior.AllowGet));
}
else
{
error = "模型验证未通过";
return(Json(error, JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> Edit(RoleFormViewModel modelView)
{
var role = await _roleManager.FindByIdAsync(modelView.Id).ConfigureAwait(true);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {modelView.Id} cannot be found";
return(View("NotFound"));
}
else
{
role.Id = modelView.Id;
role.Name = modelView.Name;
// Update the Role using UpdateAsync
var result = await _roleManager.UpdateAsync(role).ConfigureAwait(true);
if (result.Succeeded)
{
return(RedirectToAction("Roles", modelView));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View("RoleForm", modelView));
}
}
public async Task <IActionResult> Edit(string id)
{
if (id == null)
{
_logger.LogInformation("Id é nulo");
return(RedirectToAction(nameof(Error), new { message = "Id nulo" }));
}
if (!_cache.TryGetValue("role", out list))
{
list = await _roleManager.Roles.ToListAsync();
_cache.Set("role", list, cacheOptions);
}
else
{
list = _cache.Get("role") as List <Role>;
}
var obj = list.Find(x => x.Id == id);
if (obj == null)
{
_logger.LogInformation("Nível o nível de acesso não existe");
return(RedirectToAction(nameof(Error), new { message = "Id não encontrado" }));
}
var viewModel = new RoleFormViewModel {
Description = obj.Description, Name = obj.Name, Id = obj.Id, NormalizedName = obj.NormalizedName, ConcurrencyStamp = obj.ConcurrencyStamp
};
return(View(viewModel));
}
public ActionResult Create()
{
var viewModel = new RoleFormViewModel()
{
Heading = "Maslshop - Create New Role"
};
return(View(viewModel));
}
public ActionResult Create(RoleFormViewModel viewModel)
{
if (ModelState.IsValid)
{
_unitOfWork.Roles.CreateRole(viewModel);
_unitOfWork.Complete();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public void CanCreateFormViewModel()
{
// Establish Context
var viewModelToExpect = new RoleFormViewModel();
// Act
RoleFormViewModel viewModelRetrieved =
roleManagementService.CreateFormViewModel();
// Assert
viewModelRetrieved.ShouldNotBeNull();
viewModelRetrieved.Role.ShouldBeNull();
}
public ActionResult Edit(RoleFormViewModel viewModel)
{
if (ModelState.IsValid)
{
_unitOfWork.Roles.GetRole(viewModel.RoleId).Name = viewModel.RoleName;
_unitOfWork.Complete();
return(RedirectToAction("Index"));
}
return(View(viewModel));
}
public void CanInitEdit()
{
// Establish Context
var viewModel = new RoleFormViewModel();
_roleManagementService.Expect(r => r.CreateFormViewModelFor(1))
.Return(viewModel);
// Act
ViewResult result = _rolesController.Edit(1).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as RoleFormViewModel).ShouldNotBeNull();
}
public ActionResult Edit(string roleId)
{
if (_unitOfWork.Roles.GetRole(roleId) == null)
{
return(HttpNotFound());
}
var viewModel = new RoleFormViewModel
{
Heading = "Maslshop - Edit Role",
RoleId = roleId,
RoleName = _unitOfWork.Roles.GetRole(roleId).Name
};
return(View(viewModel));
}
public async Task <IActionResult> Add(RoleFormViewModel model)
{
if (!ModelState.IsValid)
{
return(View("Index", await _roleManager.Roles.ToListAsync()));
}
if (await _roleManager.RoleExistsAsync(model.Name))
{
ModelState.AddModelError("Name", "Role is Existe!");
return(View("Index", await _roleManager.Roles.ToListAsync()));
}
await _roleManager.CreateAsync(new IdentityRole(model.Name.Trim()));
return(RedirectToAction(nameof(Index)));
}
public void CanCreateFormViewModelForRole()
{
// Establish Context
var viewModelToExpect = new RoleFormViewModel();
Role role =
RoleInstanceFactory.CreateValidTransientRole();
roleRepository.Expect(r => r.Get(1))
.Return(role);
// Act
RoleFormViewModel viewModelRetrieved =
roleManagementService.CreateFormViewModelFor(1);
// Assert
viewModelRetrieved.ShouldNotBeNull();
viewModelRetrieved.Role.ShouldNotBeNull();
viewModelRetrieved.Role.ShouldEqual(role);
}
public async Task <ActionResult> Edit(string id)
{
if (string.IsNullOrEmpty(id))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//var role = RoleManager.Roles.FirstOrDefault(r => r.Id == id);
var role = await RoleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {id} cannot be found";
return(View("NotFound"));
//return HttpNotFound();
}
var viewModel = new RoleFormViewModel(role);
return(View("RoleForm", viewModel));
}
/// <summary>
/// 返回编辑页部分视图
/// </summary>
/// <param name="id">角色ID</param>
/// <returns>部分视图</returns>
public ActionResult RoleDetail(int id = 0)
{
RoleFormViewModel roleForm = new RoleFormViewModel();
if (id != 0)
{
RoleBll bll = new RoleBll();
Role role = bll.GetRoleById(id);
if (role != null)
{
roleForm.RoleName = role.RoleName;
roleForm.Id = role.Id;
roleForm.Description = role.Description;
roleForm.Code = role.Code;
}
else
{
return(PartialView("CreatAndEdit", roleForm));
}
}
return(PartialView("CreatAndEdit", roleForm));
}
public async Task <IActionResult> Create(RoleFormViewModel model)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole
{
Name = model.Name
};
IdentityResult result = await _roleManager.CreateAsync(identityRole).ConfigureAwait(true);
if (result.Succeeded)
{
RedirectToAction("index", "Home");
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <IActionResult> Create(RoleFormViewModel model)
{
if (ModelState.IsValid)
{
var identityRole = new IdentityRole
{
Name = model.Name
};
var result = await _roleManager.CreateAsync(identityRole).ConfigureAwait(false);
if (result.Succeeded)
{
return(RedirectToAction("Roles", "Administration"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View("RoleForm", model));
}
public void CannotUpdateInvalidRoleFromForm()
{
// Establish Context
var roleFromForm = new Role();
var viewModelToExpect = new RoleFormViewModel();
var testUser = PersonInstanceFactory.CreateValidTransientPerson();
testUser.SetAssignedIdTo(1);
_authenticationProvider.Expect(r => r.GetLoggedInUser()).Return("testuser");
_personManagementService.Expect(r => r.GetByUserName(Arg <string> .Is.Anything)).Return(testUser);
_roleManagementService.Expect(r => r.UpdateWith(roleFromForm, 0))
.Return(ActionConfirmation.CreateFailureConfirmation("not updated"));
_roleManagementService.Expect(r => r.CreateFormViewModelFor(roleFromForm))
.Return(viewModelToExpect);
// Act
ViewResult result =
_rolesController.Edit(roleFromForm).AssertViewRendered();
// Assert
result.ViewData.Model.ShouldNotBeNull();
(result.ViewData.Model as RoleFormViewModel).ShouldNotBeNull();
}
public RoleFormViewModel CreateFormViewModel()
{
var viewModel = new RoleFormViewModel();
return(viewModel);
}
public ActionResult Create()
{
var viewModel = new RoleFormViewModel();
return(View("RoleForm", viewModel));
}
public async Task <ActionResult> Save(RoleFormViewModel viewModel)
{
//IdentityResult result;
if (!ModelState.IsValid)
{
return(View("RoleForm", viewModel));
}
// Create New Role Case
if (string.IsNullOrEmpty(viewModel.Id))
{
if (!RoleManager.RoleExists(viewModel.Name))
{
IdentityResult result = await RoleManager.CreateAsync(new IdentityRole(viewModel.Name));
//HandleAddResult(result); // Create Role in DB
if (result.Succeeded)
{
ViewBag.Message = "Record(s) created successfully.";
return(List());
}
else
{
ViewBag.Message = "Error occurred while created Record(s)";
Logger.LogInfo($"New user created successfully.");
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
return(View("RoleForm", viewModel));
}
}
else
{
ModelState.AddModelError("", "Role already exist.");
return(View("RoleForm", viewModel));
}
//return List();
//return RedirectToAction("List", "Roles", new { area = "AccessControl" });
}
else
{
// Edit Role Case
//var roleInDB = _context.Roles.FirstOrDefault(r => r.Id == viewModel.Id);
var role = await RoleManager.FindByIdAsync(viewModel.Id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {viewModel.Id} cannot be found";
return(View("NotFound"));
//return HttpNotFound();
}
role.Name = viewModel.Name;
IdentityResult result = await RoleManager.UpdateAsync(role);
//HandleUpdateResult(_context.SaveChanges());
//HandleUpdateResult(result);
if (result.Succeeded)
{
ViewBag.Message = "Record(s) updated successfully.";
Logger.LogInfo($"Role with ID {viewModel.Id} is updated successfully.");
return(List());
}
else
{
ViewBag.Message = "Error occurred while updating Record(s)";
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
return(View("RoleForm", viewModel));
}
//return List();
//return RedirectToAction("List", "Roles", new { area = "AccessControl" });
}
}
