public IActionResult AddRole(AddRoleViewModel addRoleViewModel)
{
if (ModelState.IsValid)
{
IdentityRole role = new IdentityRole()
{
Name = addRoleViewModel.Name
};
IdentityResult result = _roleManager.CreateAsync(role).Result;
if (result.Succeeded)
{
return(RedirectToAction("RoleManagement"));
}
else
{
foreach (var resultError in result.Errors)
{
if (resultError.Code == "DuplicateRoleName")
{
ModelState.AddModelError("Name", _sharedLocalizer["ErrorDuplicateRecord"]);
}
}
}
}
return(View(addRoleViewModel));
}
public IActionResult EditRole(int roleId)
{
var roleModel = _RoleInfoService.GetRole(roleId);
if (roleModel == null)
{
return(NotFound());
}
var vm = new AddRoleViewModel
{
IsEdit = true,
RoleInfo = roleModel
};
var allMenu = _MenuService.GetMenuList();
IList <TreeMenu> treeMenuList = new List <TreeMenu>();
var pMenus = allMenu.Where(p => p.MenuPId == 0);
foreach (var item in pMenus)
{
TreeMenu treeMenu = new TreeMenu
{
ParentMenu = item,
SubMenus = allMenu.Where(p => p.MenuPId == item.MenuId).ToList()
};
treeMenuList.Add(treeMenu);
}
vm.MenuList = treeMenuList;
vm.RoleMenus = _MenuService.GetMenusByRoleIds(roleId);
return(View("AddRole", vm));
}
public async Task <IActionResult> AddNewRole(AddRoleViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
var role = new Role(vm.Name)
{
Name = vm.Name
};
IdentityResult result = await _roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("RoleManagement", _roleManager.Roles));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(vm));
}
public async Task <IActionResult> AddRole([FromBody] AddRoleViewModel model)
{
//EnsureDatabaseCreated(_applicationDbContext);
if (ModelState.IsValid)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user == null)
{
return(StatusCode(StatusCodes.Status400BadRequest));
}
var roles = await _userManager.GetRolesAsync(user);
if (roles.Contains(model.Role))
{
return(StatusCode(StatusCodes.Status409Conflict));
}
var roleName = string.IsNullOrEmpty(model.Role) ? "User" : model.Role;
await _userManager.AddToRoleAsync(user, roleName);
return(Ok(user));
}
// If we got this far, something failed.
return(BadRequest(ModelState));
}
//add role
public async Task <IActionResult> AddNewRole(AddRoleViewModel addRoleViewModel)
{
if (!ModelState.IsValid)
{
return(View(addRoleViewModel));
}
// new role name
var role = new IdentityRole
{
Name = addRoleViewModel.RoleName
};
IdentityResult result = await _roleManager.CreateAsync(role);
//result is a success
if (result.Succeeded)
{
//redirect to a role list
return(RedirectToAction(RManagement, _roleManager.Roles));
}
//somthing went wrong
foreach (IdentityError error in result.Errors)
{
//send an error message
ModelState.AddModelError("", error.Description);
}
return(View(addRoleViewModel));
}
public IActionResult UpdateRole(AddRoleViewModel updateRole)
{
IBaseService <SysRole, Guid> baseService = _roleService as IBaseService <SysRole, Guid>;
var entity = baseService.Get(x => x.Name == updateRole.RoleId).FirstOrDefault();
if (entity == null)
{
return(FailedMsg("更新出错,该角色不存在"));
}
entity.NormalizedName = updateRole.RoleInfo;
entity.State = updateRole.RoleState;
entity.LastModifyUserId = UserInfoSession.UserId;
entity.LastModifyTime = DateTime.Now;
var userStr = updateRole.RoleUsers;
var userArray = userStr.Split(',');
var ids = userArray.Select(x => x.Substring(0, x.IndexOf('(')));
var userList = (_userService.GetUIdList(ids.ToList()));
var flag = _roleService.UpdateRole(entity, userList);
if (flag)
{
return(UpdateSuccessMsg());
}
return(FailedMsg("添加角色失败"));
}
public async Task <IActionResult> CreateRole()
{
var role = new AddRoleViewModel();
ViewBag.statusMessage = TempData["ResultFaild"];
return(View(role));
}
public async Task <IActionResult> AddRole(AddRoleViewModel addRoleViewModel)
{
if (!ModelState.IsValid)
{
return(View(addRoleViewModel)); //daca validarea esueaza => returnare acelasi view
}
var role = new IdentityRole
{
Name = addRoleViewModel.RoleName
};
IdentityResult result = await _roleManager.CreateAsync(role); //crearea rolului cu datele primite din front
if (result.Succeeded)
{
return(RedirectToAction("RoleManagement", _roleManager.Roles));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(addRoleViewModel));
}
private async void AddRoleButton_Click(object sender, RoutedEventArgs e)
{
try
{
await SearchUser();
var allRoles = Enumerable.Empty <Role>();
var addRoleViewModel = new AddRoleViewModel
{
CurrentUser = _viewModel.CurrentUser,
AllRoles = allRoles,
CurrentRole = allRoles.FirstOrDefault()
};
var addRoleWindow = _kernel.Get <AddRoleWindow>(new ConstructorArgument("viewModel", addRoleViewModel));
addRoleWindow.Owner = this;
addRoleWindow.ShowInTaskbar = false;
if (!addRoleWindow.ShowDialog().Value)
{
return;
}
_viewModel.CurrentRole = _viewModel.CurrentUser.Roles.LastOrDefault();
}
catch (Exception ex)
{
_messageBoxFacade.ShowError(ex);
}
}
public ActionResult Add(AddRoleViewModel model)
{
try
{
if (!ModelState.IsValid)
{
throw new ArgumentException("Thông tin vai trò không hợp lệ");
}
Role role = new Role();
role.RoleName = model.RoleName;
role.Description = model.Description;
db.Roles.Add(role);
db.SaveChanges();
// Write action log
string actionLogData = "roleId=" + role.RoleId + ", name=" + role.RoleName;
ActionLog.WriteLog(ActionLog.ADD_ROLE_INFO, actionLogData, User.Identity.Name, Request.ServerVariables["REMOTE_ADDR"]);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(View(model));
}
public async Task <IActionResult> CreateRole(AddRoleViewModel viewModel)
{
// check roles
var token = HttpContext.Session.GetString("Token");
var id = new Guid(HttpContext.Session.GetString("UserId"));
var roles = await _manageRole.GetRoleByUserId(token, id);
var rolosAccess = roles.data.Any(x => x.RoleName == CommonController.ADD);
if (rolosAccess == false)
{
return(Redirect("/Role/AccessDenied"));
}
;
// end check roles
var rs = await _manageRole.AddRole(token, viewModel);
if (rs.statusCode == 200)
{
TempData["Result"] = "Create Success";
return(Redirect("/Role/Index"));
}
else
{
TempData["ResultFaild"] = "Create Faild";
return(Redirect("/Role/Index"));
}
}
public async Task <IActionResult> AddNewRole(AddRoleViewModel addRoleViewModel)
{
if (addRoleViewModel == null)
{
throw new ArgumentNullException(nameof(addRoleViewModel));
}
if (!ModelState.IsValid)
{
return(View(addRoleViewModel));
}
var role = new IdentityRole
{
Name = addRoleViewModel.RoleName
};
IdentityResult result = await _roleManager.CreateAsync(role).ConfigureAwait(true);
if (result.Succeeded)
{
return(RedirectToAction("RoleManagement", _roleManager.Roles));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(addRoleViewModel));
}
public async Task <ActionResult> AddRole(
AddRoleViewModel addRoleViewModel)
{
if (!ModelState.IsValid)
{
return(View(addRoleViewModel));
}
var role = new ApplicationRole
{
Name = addRoleViewModel.Name
};
IdentityResult result = await RoleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("RoleManagement", RoleManager.Roles));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
return(View(addRoleViewModel));
}
public async Task <IActionResult> AddNewRole(AddRoleViewModel addRoleViewModel)
{
if (!ModelState.IsValid)
{
return(View(addRoleViewModel));
}
var role = new IdentityRole
{
Name = addRoleViewModel.RoleName
};
IdentityResult result = await roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(addRoleViewModel));
}
public async Task <IActionResult> AddRole(AddRoleViewModel vm)
{
if (ModelState.IsValid)
{
BTRole newRole = new BTRole
{
Name = vm.Name,
Description = vm.Description
};
IdentityResult result = await roleMgr.CreateAsync(newRole);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Admin"));
}
// iterate over all errors and add them to ModelState
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
// If the role add failed repost to the View with existing data from the View Model
return(View(vm));
}
public virtual async Task <ActionResult> Create(AddRoleViewModel viewModel)
{
if (_roleManager.CheckForExisByName(viewModel.Name, null))
{
this.AddErrors("Name", "این گروه قبلا در سیستم ثبت شده است");
}
if (!ModelState.IsValid)
{
return(new JsonNetResult
{
Data =
new
{
success = false,
View = this.RenderPartialViewToString(MVC.Role.Views._Create, viewModel)
}
});
}
var newRole = await _roleManager.AddRole(viewModel);
return(new JsonNetResult
{
Data =
new
{
success = true,
View = this.RenderPartialViewToString(MVC.Role.Views._RoleItem, newRole)
}
});
}
public async Task <IActionResult> AddANewRole(AddRoleViewModel addRole)
{
if (ModelState.IsValid)
{
var role = await _roleManager.FindByNameAsync(addRole.RoleName);
if (role == null)
{
var newRole = new IdentityRole()
{
Name = addRole.RoleName
};
var result = await _roleManager.CreateAsync(newRole);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(RedirectToAction("ListRoles"));
}
public IActionResult Add([FromBody] AddRoleViewModel model)
{
var role = roleService.Add(new M_Role {
Name = model.Name
});
return(APIResult.成功.SetData("id", role.Id));
}
public virtual ActionResult Create()
{
var viewModel = new AddRoleViewModel
{
IsActive = true
};
PopulatePermissions();
return View(viewModel);
}
public async Task <RoleViewModel> AddRole(AddRoleViewModel viewModel)
{
var role = _mappingEngine.Map <Role>(viewModel);
_roles.Add(role);
await _unitOfWork.SaveChangesAsync();
return(await GetRole(role.Id));
}
public virtual ActionResult Create()
{
var viewModel = new AddRoleViewModel
{
IsActive = true
};
PopulatePermissions();
return(View(viewModel));
}
public ActionResult Add()
{
/*
* User access add role page
*/
// create view model
var model = new AddRoleViewModel();
return(View(model));
}
public Task <bool> AddRole(AddRoleViewModel viewModel)
{
if (viewModel.PermissionNames == null || viewModel.PermissionNames.Length < 1)
{
return(Task.FromResult(false));
}
var role = _mappingEngine.Map <Role>(viewModel);
role.XmlPermission = _permissionService.GetPermissionsAsXml(viewModel.PermissionNames);
_roles.Add(role);
return(Task.FromResult(true));
}
public async Task <IActionResult> AddRole(AddRoleViewModel vm)
{
var role = vm.RoleName;
var roleManager = _serviceProvider.GetRequiredService <RoleManager <CustomRole> >();
if (!await roleManager.RoleExistsAsync(role))
{
await roleManager.CreateAsync(new CustomRole(role));
}
return(RedirectToAction("Index", "Home"));
}
public Task <string> AddRoleAccess([FromBody] AddRoleViewModel model)
{
AddRoleDomainModel dmodel = new AddRoleDomainModel();
dmodel.RoleName = model.RoleName;
dmodel.UpdatedBy = "190455";
dmodel.DeleteFlag = model.DeleteFlag;
dmodel.updatedDate = DateTime.Now;
var result = _iConfigAccessInterface.AddRoleAccess(dmodel);
return(result);
}
public void Add(AddRoleViewModel roleModel)
{
var role = new Role
{
Name = roleModel.Name
};
using (var context = new OmegaContext())
{
context.Roles.Add(role);
context.SaveChanges();
}
}
public async Task <ActionResult> Add(AddRoleViewModel model)
{
if (ModelState.IsValid)
{
var result = await RoleManager.CreateAsync(new Role(model.Name));
if (result.Succeeded)
{
return(RedirectToAction("List"));
}
AddErrors(result);
}
return(View());
}
public async Task <IActionResult> AddRole(AddRoleViewModel model)
{
if (ModelState.IsValid)
{
var role = RoleDTOToAddRoleMapper.Instance.MapBack(model);
var result = await adminService.AddRole(role);
if (result.Succeeded)
{
return(RedirectToAction(nameof(GetAllRoles), "Admin", new { area = "Admin" }));
}
AddModelErrors(result);
}
return(View(model));
}
public AddRoleWindow(AddRoleViewModel viewModel, MessageBoxFacade messageBoxFacade)
{
if (viewModel == null)
{
throw new ArgumentNullException(nameof(viewModel));
}
if (messageBoxFacade == null)
{
throw new ArgumentNullException(nameof(messageBoxFacade));
}
InitializeComponent();
DataContext = viewModel;
_viewModel = viewModel;
_messageBoxFacade = messageBoxFacade;
}
public async Task <ActionResult> AddRole(AddRoleViewModel role)
{
if (!UserManager.IsInRoleAsync(role.UserId, role.RoleName).Result)
{
var result = await UserManager.AddToRoleAsync(role.UserId, role.RoleName);
if (!result.Succeeded)
{
throw new Exception(result.Errors.First());
}
}
ViewBag.controller = "Users";
ViewBag.action = "GetUsers";
ViewBag.confirmation = "Rol asignado";
return(View("Confirm"));
}
public async Task <ActionResult> UserRoles(int id, AddRoleViewModel model)
{
try
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(id);
TempData.Add(GlobalTypes.Message, new AlertResult(AlertStatusId.Success, "Kayıt güncelleme işlemi başarıyla gerçekleştirildi."));
}
}
catch (Exception)
{
TempData.Add(GlobalTypes.Message, new AlertResult(AlertStatusId.Error, "Hata", "İşlem sırasında hata oluştu. Lütfen Daha sonra tekrar deneyiniz."));
}
return(View(model));
}
//[CheckReferrer]
public virtual async Task<ActionResult> Create(AddRoleViewModel viewModel)
{
if (!ModelState.IsValid)
{
this.NotyError("لطفا فیلد های مورد نظر را با دقت وارد کنید");
PopulatePermissions(viewModel.PermissionNames);
return View(viewModel);
}
if (!await _roleManager.AddRole(viewModel))
{
this.NotyWarning("لطفا برای گروه کاربری مورد نظر ، دسترسی تعیین کنید");
PopulatePermissions();
return View(viewModel);
}
await _unitOfWork.SaveChangesAsync();
this.NotySuccess("عملیات ثبت گروه کاربری جدید با موفقیت انجام شد");
return RedirectToAction(MVC.Administrator.Role.ActionNames.List, MVC.Administrator.Role.Name);
}
