public async Task <IActionResult> Create(NewRoleViewModel viewModel)
{
var identityRole = new IdentityRole(viewModel.JobName);
await roleManager.CreateAsync(identityRole);
return(RedirectToAction("Index"));
}
public ActionResult Create(NewRoleViewModel newRoleModel)
{
ControllerResult result = ControllerResult.SuccResult;
Role role = new Role()
{
Name = newRoleModel.RoleName,
Description = newRoleModel.RoleDesc,
Code = newRoleModel.RoleCode
};
string errorMsg = string.Empty;
bool addResult = roleService.AddNewRole(role, out errorMsg);
if (!addResult)
{
result = ControllerResult.FailResult;
result.ErroMsg = errorMsg;
}
else
{
LogUserAction("进行新增角色操作，角色名称{0}，角色编码{1}".Fmt(newRoleModel.RoleName, newRoleModel.RoleCode));
}
return(Content(result.ToJson()));
}
public ActionResult RoleList()
{
var viewModel = new NewRoleViewModel()
{
Roles = _context.RolesS.ToList(),
};
return(View(viewModel));
}
public ActionResult NewRole(string id)
{
NewRoleViewModel ViewModel = new NewRoleViewModel()
{
Url = Url.RouteUrl("SecurityApp_Role", new { Action = "CreateRole" }),
Title = "创建角色",
MasterViewModel = this.MasterViewModel
};
return(Result(ViewModel));
}
public ViewResult CreateRole()
{
var viewModel = new NewRoleViewModel
{
Permissions = ApplicationPermissions.All.Select(p => new RolePermissionViewModel
{
PermissionName = p,
Assigned = false,
}).ToList(),
};
return(View(viewModel));
}
public NewRoleViewModel GetNewRoleViewModel(Result result = null)
{
StatusAlertViewModel statusAlert = null;
if (result != null)
{
statusAlert = StatusAlertViewExtension.Get(result);
}
NewRoleViewModel newRoleViewModel = new NewRoleViewModel(
statusAlert: statusAlert,
roleTypes: GetRoleTypesList());
return(newRoleViewModel);
}
public async Task <IActionResult> Post([FromBody] NewRoleViewModel model)
{
if (ModelState.IsValid)
{
IdentityRole role = new IdentityRole
{
Name = model.Name
};
await this.roleManager.CreateAsync(role);
return(CreatedAtAction("GetRole", new { id = role.Id }));
}
else
{
return(UnprocessableEntity());
}
}
public async Task <IActionResult> EditRole(Guid id, NewRoleViewModel model)
{
if (ModelState.IsValid)
{
AppIdentityRole role = await _roleManager.FindByIdAsync(id.ToString());
role.Name = model.RoleName;
role.Description = model.Description;
IdentityResult result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Roles"));
}
}
return(View(model));
}
public async Task <IActionResult> New(NewRoleViewModel model)
{
if (ModelState.IsValid)
{
var role = new Role
{
Name = model.Name,
Description = model.Description
};
var roleResult = await _roleManager.CreateAsync(role);
if (roleResult.Succeeded)
{
return(RedirectToAction("Index"));
}
}
return(View(model));
}
public async Task <IActionResult> CreateRole([FromForm] NewRoleViewModel model, CancellationToken cancellationToken)
{
if (!ModelState.IsValid)
{
return(View("CreateRole", model));
}
var roleId = await roleService.CreateRole(model.Name, cancellationToken);
var permissions = model.Permissions
.Where(p => p.Assigned)
.Select(p => p.PermissionName);
await roleService.AssignRolePermissions(roleId, permissions, cancellationToken);
TempData[TempDataAddedRole] = true;
return(RedirectToAction("Index"));
}
public async Task <IActionResult> NewRole(NewRoleViewModel model)
{
if (ModelState.IsValid)
{
AppIdentityRole applicationRole = new AppIdentityRole {
DateCreated = DateTime.Now
};
applicationRole.Name = model.RoleName;
applicationRole.Description = model.Description;
IdentityResult roleRuslt = await _roleManager.CreateAsync(applicationRole);
if (roleRuslt.Succeeded)
{
return(RedirectToAction("Roles"));
}
}
return(View(model));
}
public async Task <IActionResult> EditRole(Guid id)
{
if (!String.IsNullOrEmpty(id.ToString()))
{
AppIdentityRole appIdentityRole = await _roleManager.FindByIdAsync(id.ToString());
if (appIdentityRole != null)
{
NewRoleViewModel model = new NewRoleViewModel
{
RoleName = appIdentityRole.Name,
Description = appIdentityRole.Description
};
return(View(model));
}
return(NotFound());
}
return(BadRequest());
}
public async Task <IActionResult> New(NewRoleRequest newRoleRequest)
{
if (!ModelState.IsValid)
{
NewRoleViewModel newRoleViewModel = _roleDataService.GetNewRoleViewModel();
return(View(newRoleViewModel));
}
Result <string> result = await _roleService.AddRole(newRoleRequest, GetUserId());
if (result.Failure)
{
ModelState.AddErrors(result.Errors);
NewRoleViewModel newRoleViewModel = _roleDataService.GetNewRoleViewModel(result);
return(View(newRoleViewModel));
}
return(RedirectToAction(nameof(Details), new { id = result.Value }));
}
public async Task <JsonResult> NewRole(NewRoleViewModel model)
{
JsonResult result = new JsonResult();
result.JsonRequestBehavior = JsonRequestBehavior.AllowGet;
if (!ModelState.IsValid)
{
var Errors = new List <string>();
foreach (ModelState modelState in ViewData.ModelState.Values)
{
foreach (ModelError error in modelState.Errors)
{
Errors.Add(error.ErrorMessage.ToString());
}
}
result.Data = new { Success = false, Errors = Errors };
return(result);
}
else
{
try
{
result.Data = new { Success = await ControlPanelService.Instance.NewRole(new IdentityRole()
{
Name = model.Name
}) };
}
catch (Exception ex)
{
result.Data = new { Success = false, Errors = ex.InnerException.Message };
}
}
return(result);
}
public ActionResult NewRole(string ID)
{
NewRoleViewModel model = new NewRoleViewModel();
return(PartialView("_NewRole", model));
}
public IActionResult New()
{
NewRoleViewModel newRoleViewModel = _roleDataService.GetNewRoleViewModel();
return(View(newRoleViewModel));
}
public NewRolePage()
{
InitializeComponent();
BindingContext = new NewRoleViewModel();
}
public async Task <HttpResponseMessage> PostAsync(NewRoleViewModel role)
{
await applicationService.CreateAsync(role.Name, role.RoleGroup);
return(await CreateResponse(HttpStatusCode.Created, Language.SuccessOperation));
}
public async Task<HttpResponseMessage> PostAsync(NewRoleViewModel role)
{
await applicationService.CreateAsync(role.Name, role.RoleGroup);
return await CreateResponse(HttpStatusCode.Created, Language.SuccessOperation);
}
