public async Task <IActionResult> OnGetAsync(string Id)
{
if (string.IsNullOrEmpty(Id))
{
return(BadRequest());
}
Role role = await RoleManager.FindByIdAsync(Id);
if (role == null)
{
return(NotFound());
}
Model = Mapper.Map(role, Model);
List <ClaimDTO> Roleclaims = RoleManager.GetClaimsAsync(role).GetAwaiter().GetResult().Select(c => new ClaimDTO {
Value = c.Value, Checked = true
}).ToList();
List <ClaimDTO> AllClaims = Enum.GetNames(typeof(CustomClaimType)).Select(c => new ClaimDTO {
Value = c, Checked = false
}).ToList();
//AllClaims.Union(Roleclaims);
AllClaims.ForEach(c =>
{
if (Roleclaims.Contains(c, new ClaimDtoCompare()))
{
c.Checked = true;
}
});
Model.Claims = AllClaims;
return(Page());
}
private async void bindRightList()
{
rightAyncProxy = await Task.Run(() => ServiceHelper.GetRightService());
roleAyncProxy = await Task.Run(() => ServiceHelper.GetRoleService());
IList <RightDisplayModel> allRight = await rightAyncProxy.CallAsync(u => u.GetAllRights());
RoleEditModel roleEditModel = await roleAyncProxy.CallAsync(c => c.GetRoleByCode(this._roleDisplayModel.Code));
for (int i = allRight.Count - 1; i >= 0; i--)
{
bool flag = true;
RightDisplayModel rightDisplayModel = allRight[i];
ListViewItem listViewItem = new ListViewItem();
listViewItem.Content = rightDisplayModel.Name;
listViewItem.Tag = rightDisplayModel;
foreach (RightEditModel sysRight in roleEditModel.SysRights)
{
if (rightDisplayModel.Code == sysRight.RightCode)
{
this.backRight.Items.Add(listViewItem);
flag = false;
break;
}
}
if (flag)
{
this.forceRight.Items.Add(listViewItem);
}
}
}
public async Task <ActionResult> ManageEmployeeAccounts()
{
//return View(await _context.Books.Include(m => m.Genre).ToListAsync());
List <AppUser> allEmployees = new List <AppUser>();
List <AppUser> members = new List <AppUser>();
List <AppUser> nonMembers = new List <AppUser>();
foreach (AppUser user in _userManager.Users)
{
var customerList = await _userManager.IsInRoleAsync(user, "Employee") ? members : nonMembers;
customerList.Add(user);
}
RoleEditModel re = new RoleEditModel();
re.Members = members;
foreach (var employee in re.Members)
{
allEmployees.Add(employee);
}
//return allCustomers;
return(View(allEmployees));
}
public virtual ActionResult EditModel(RoleEditModel model)
{
if (!ModelState.IsValid)
{
return(PartialView(model));
}
try
{
var isNew = model.Id <= 0;
model = _roleService.Save(model);
if (isNew)
{
ModelState.Clear();
model = new RoleEditModel();
}
model.FeedbackMessage = FeedbackMessageModel.CreateSuccessMessage("Saved Successfully.");
}
catch (Exception ex)
{
if (ex.Message == "Duplicate Name")
{
model.FeedbackMessage = FeedbackMessageModel.CreateFailureMessage("A role with same name already exists.");
}
else
{
_logger.Error(string.Format("Some error while add/edit role - {0}", model.Name), ex);
model.FeedbackMessage = FeedbackMessageModel.CreateFailureMessage("Some Error Occured.");
}
}
return(PartialView(model));
}
private async void UserRight()
{
RoleEditModel roleEditModel = await roleAyncProxy.CallAsync(c => c.GetRoleByCode(_roleDisplayModel.Code));
this.listRight.ItemsSource = roleEditModel.SysRights;
this.listUser.ItemsSource = roleEditModel.SysUsers;
}
//public async Task<IActionResult> UpdateClaim(string usid)
//{
// // IdentityRole role = await roleManager.FindByIdAsync(id);
// var use = await _accountManager.GetUsers();
// var clam = await _userManager.GetUserIdAsync();
// List<User> members = new List<User>();
// List<User> nonMembers = new List<User>();
// var listOfUsers = _userManager.Users;
// foreach (User user in listOfUsers)
// {
// var list = await _userManager.IsInRoleAsync(user, rolee.Name) ? members : nonMembers;
// list.Add(user);
// }
// // RoleEditModel smodel = _mapper.Map<RoleEditModel>(rolee);
// var me = new RoleEditModel
// {
// Role = rolee,
// Members = members,
// NonMembers = nonMembers
// };
// return View(me);
//}
public async Task <IActionResult> Update(int id)
{
// IdentityRole role = await roleManager.FindByIdAsync(id);
var rolee = await _accountManager.GetRoleByIdAsync(id);
//User user = new User();
//var clam = await _accountManager.GetUsersClaims(user);
List <User> members = new List <User>();
List <User> nonMembers = new List <User>();
var listOfUsers = _userManager.Users;
foreach (User user in listOfUsers)
{
var list = await _userManager.IsInRoleAsync(user, rolee.Name) ? members : nonMembers;
list.Add(user);
}
// RoleEditModel smodel = _mapper.Map<RoleEditModel>(rolee);
var me = new RoleEditModel
{
Role = rolee,
Members = members,
NonMembers = nonMembers
};
return(View(me));
}
public ActionResult EditRole(RoleEditModel model)
{
if (model.FunctionIDs.Count == 0)
{
ModelState.AddModelError("FunctionIDs", Asiatek.Resource.DataAnnotations.RoleMustHaveOneFunction);
}
if (ModelState.IsValid)
{
var result = RoleBLL.ModifyRoleInfo(model, base.UserIDForLog);
base.DoLog(Model.OperationTypeEnum.Edit, result, "RoleID:" + model.ID);
return(Json(result));
}
else
{
if (IsSuperAdmin)
{
model.FunctionTreeNodes = FunctionBLL.GetAllFunctionsForTree();
}
else
{
model.FunctionTreeNodes = FunctionBLL.GetNormalFunctionsForTree();
}
model.FunctionTreeNodes.ForEach(node =>
{
if (model.FunctionIDs.Contains(node.ID))
{
node.Checked = true;
}
});
return(PartialView("_EditRole", model));
}
}
//public RoleEditModel Insert(RoleEditModel obj)
//{
// var worker = DependencyInjection.Container.Resolve<IUnitOfWork>(); // use same worker for following service
// var service = DependencyInjection.Container.Resolve<IRoleService>(new ParameterOverride("worker", worker));
// var permissionService = DependencyInjection.Container.Resolve<IPermissionService>(new ParameterOverride("worker", worker));
// var role = service.Insert(obj.Target);
// var permissions = permissionService.GetAll();
// foreach (var p in permissions)
// {
// if (obj.PermissionList.Where(x => x.Text == p.Name && x.Checked == true).Count() == 1)
// {
// role.Permissions.Add(p);
// }
// }
// service.Update(role);
// return new RoleEditModel
// {
// Item = role,
// PermissionList = service.GetCheckList()
// };
//}
public void Update(RoleEditModel obj)
{
var role = Worker.GetRepository <Role>().Table
.Where(x => x.Id == (int)obj.Target.Id)
.Include(x => x.Permissions)
.FirstOrDefault();
var permissions = Worker.GetRepository <Permission>().Table.ToList();
foreach (var p in permissions)
{
if (obj.PermissionList.Where(x => x.Text == p.Name && x.Checked == true).Count() == 1)
{
if (!role.Permissions.Any(x => x.Id == p.Id))
{
role.Permissions.Add(p);
}
}
else
{
if (role.Permissions.Any(x => x.Id == p.Id))
{
role.Permissions.Remove(p);
}
}
}
Worker.GetRepository <Role>().Update(role); // update relationship
Worker.GetRepository <Role>().Update(obj.Target); // update flat fields
Worker.SaveChanges();
}
public async Task <IActionResult> EditRole(string id)
{
var role = await _roleManager.FindByIdAsync(id);
if (role == null)
{
return(RedirectToAction("Index"));
}
var roleModel = new RoleEditModel
{
Id = id,
RoleName = role.Name,
Users = new List <string>()
};
var user = await _userManager.Users.ToListAsync();
foreach (var item in user)
{
if (await _userManager.IsInRoleAsync(item, role.Name))
{
roleModel.Users.Add(item.UserName);
}
}
return(View(roleModel));
}
public async Task <IActionResult> Edit(string id)
{
IdentityRole role = await _roleManager.FindByIdAsync(id);
IList <AppUser> nonMembers = new List <AppUser>();
IList <AppUser> allUsers = await _userManager.Users.ToListAsync();
var memebers = (await _userManager.GetUsersInRoleAsync(role.Name)).ToDictionary(u => u.Id, u => u);
foreach (AppUser user in allUsers)
{
if (!memebers.ContainsKey(user.Id))
{
nonMembers.Add(user);
}
}
var model = new RoleEditModel
{
Role = role,
Members = memebers.Values,
NonMembers = nonMembers
};
return(View(model));
}
public async Task <IActionResult> RoleEdit(RoleEditModel model)
{
if (ModelState.IsValid)
{
foreach (var userId in model.IdsToAdd ?? new string[] { })
{
var user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
var result = await _userManager.AddToRoleAsync(user, model.RoleName);
}
}
foreach (var userId in model.IdsToRemove ?? new string[] { })
{
var user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
var result = await _userManager.RemoveFromRoleAsync(user, model.RoleName);
}
}
}
return(RedirectToAction("RoleEdit", "Admin", new
{
id = model.RoleId
}));
}
public RoleEditModel Save(RoleEditModel model)
{
var domain = _roleFactory.CreateDomain(model);
domain.IsActive = true;
var isNew = domain.Id < 1;
if (model.ResetAllOverrides)
{
_roleRepository.OverRideIsTwoFactorAuthRequired(model.Id);
}
if (model.Id > 0 || !_roleRepository.GetRolesByExactName(model.Name).Any())
{
_roleRepository.Save(domain);
}
else
{
throw new Exception("Duplicate Name");
}
if (isNew && domain.ParentId != null && domain.ParentId.Value > 0)
{
_roleAccessControlListService.CreateAccessPermissionsBasedonParentRole(domain.ParentId.Value, domain.Id);
}
model.Id = domain.Id;
return(model);
}
/// <summary>
/// 根据编号查找角色编辑对象
/// </summary>
/// <param name="code">角色编号</param>
public RoleEditModel GetRoleByCode(string rolecode)
{
try
{
RoleEditModel roleEditModel = new RoleEditModel();
Repository<SysRole> sysRoleDal = _unitOfWork.GetRepository<SysRole>();
SysRole sysRole = sysRoleDal.GetObjectByKey(rolecode).Entity;
if (sysRole != null)
{
roleEditModel.InitEditModel(sysRole);
}
return roleEditModel;
}
catch (RepositoryException rex)
{
string msg = rex.Message;
string reason = rex.StackTrace;
throw new FaultException<LCFault>
(new LCFault(msg), reason);
}
catch (Exception ex)
{
string msg = ex.Message;
string reason = ex.StackTrace;
throw new FaultException<LCFault>
(new LCFault(msg), reason);
}
}
public async Task <IActionResult> Edit(string id)
{
IActionResult actionResult = await CheckIdAndRoleAsync(id);
if (actionResult != null)
{
return(actionResult);
}
IdentityRole role = await roleManager.FindByIdAsync(id);
RoleEditModel model = new RoleEditModel()
{
Role = role,
Members = new List <AppUser>(),
NonMembers = new List <AppUser>()
};
foreach (AppUser user in userManager.Users)
{
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.Members = model.Members.Append(user);
}
else
{
model.NonMembers = model.NonMembers.Append(user);
}
}
return(View(model));
}
public async Task <IActionResult> RoleEdit(string id)
{
// Find the role by Role ID
var role = await roleManager.FindByIdAsync(id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role met Id = {id} kan niet worden gevonden";
return(View("NotFound"));
}
var model = new RoleEditModel()
{
RoleId = role.Id,
RoleName = role.Name
};
// Retrieve all the Users
foreach (var user in userManager.Users)
{
// If the user is in this role, add the username to
// Users property of RoleEditModel. This model
// object is then passed to the view for display
if (await userManager.IsInRoleAsync(user, role.Name))
{
model.UserList.Add(user.UserName);
}
}
return(View(model));
}
public async Task <IActionResult> RoleEdit(RoleEditModel model)
{
var role = await roleManager.FindByIdAsync(model.RoleId);
if (role == null)
{
ViewBag.ErrorMessage = $"Role met Id = {model.RoleId} kan niet worden gevonden";
return(View("NotFound"));
}
else
{
role.Name = model.RoleName;
// Update the Role using UpdateAsync
var result = await roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
private async void bindUserList()
{
userAyncProxy = await Task.Run(() => ServiceHelper.GetUserService());
roleAyncProxy = await Task.Run(() => ServiceHelper.GetRoleService());
IList <UserDisplayModel> allUser = await userAyncProxy.CallAsync(u => u.GetAllUser());
RoleEditModel roleEditModel = await roleAyncProxy.CallAsync(c => c.GetRoleByCode(this._roleDisplayModel.Code));
for (int i = allUser.Count - 1; i >= 0; i--)
{
bool flag = true;
UserDisplayModel userDisplayModel = allUser[i];
ListViewItem listViewItem = new ListViewItem();
listViewItem.Content = userDisplayModel.Name;
listViewItem.Tag = userDisplayModel;
foreach (UserEditModel sysUser in roleEditModel.SysUsers)
{
if (userDisplayModel.Code == sysUser.UserCode)
{
this.backUser.Items.Add(listViewItem);
flag = false;
break;
}
}
if (flag)
{
this.forceUser.Items.Add(listViewItem);
}
}
}
public ActionResult CreateRole()
{
var model = new RoleEditModel();
PopulateEditRolePage(model);
return(PartialView("Role/_RoleDetail", model));
}
public Task ModifyAsync(ulong role_id, ulong guild_id, Action <RoleEditModel> action)
{
var mdl = new RoleEditModel();
action(mdl);
return(ModifyGuildRoleAsync(guild_id, role_id, mdl.Name, mdl.Permissions, mdl.Color, mdl.Hoist, mdl.Mentionable, mdl.AuditLogReason));
}
public Task ModifyAsync(Action <RoleEditModel> action)
{
var mdl = new RoleEditModel();
action(mdl);
return(this.ModifyAsync(mdl.Name, mdl.Permissions, mdl.Color, mdl.Hoist, mdl.Mentionable, mdl.AuditLogReason));
}
public ActionResult Edit(RoleEditModel model)
{
roleService.Update(model.Id, model.Name);
permService.UpdatePermIds(model.Id, model.PermissionIds);
return(Json(new AjaxResult {
Status = "ok"
}));
}
private async void roleEdit(RoleEditModel sysRole)
{
string strErrorMsg = string.Empty;
try
{
if (Om == OperationMode.AddMode)
{
roleAyncProxy = await Task.Run(() => ServiceHelper.GetRoleService());
await roleAyncProxy.CallAsync(d => d.Add(sysRole));
this.ShowAutoCloseDialogOwter(UIResources.MsgInfo, "新增角色成功！");
//MessageDialogResult result = await DialogManager.ShowMessageAsync(this, UIResources.MsgInfo, "新增角色成功！", MessageDialogStyle.Affirmative, null);
//AisinoMessageBox.Show("新增角色成功！", UIResources.MsgInfo, MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK);
this.DialogResult = true;
}
else if (Om == OperationMode.EditMode)
{
roleAyncProxy = await Task.Run(() => ServiceHelper.GetRoleService());
await roleAyncProxy.CallAsync(d => d.Update(sysRole, null, null));
this.ShowAutoCloseDialogOwter(UIResources.MsgInfo, "修改角色成功！");
//MessageDialogResult result = await DialogManager.ShowMessageAsync(this, UIResources.MsgInfo, "修改角色成功！", MessageDialogStyle.Affirmative, null);
//AisinoMessageBox.Show("修改角色成功！", UIResources.MsgInfo, MessageBoxButton.OK, MessageBoxImage.Information, MessageBoxResult.OK);
this.DialogResult = true;
}
this.Close();
}
catch (TimeoutException timeProblem)
{
strErrorMsg = timeProblem.Message + UIResources.TimeOut + timeProblem.Message;
}
catch (FaultException <LCFault> af)
{
strErrorMsg = af.Detail.Message;
}
catch (FaultException unknownFault)
{
strErrorMsg = UIResources.UnKnowFault + unknownFault.Message;
}
catch (CommunicationException commProblem)
{
strErrorMsg = UIResources.ConProblem + commProblem.Message + commProblem.StackTrace;
}
catch (Exception ex)
{
strErrorMsg = ex.Message;
}
if (strErrorMsg != string.Empty)
{
await DialogManager.ShowMessageAsync(this, UIResources.MsgError, "操作角色信息失败！原因：" + strErrorMsg, MessageDialogStyle.Affirmative, null);
//AisinoMessageBox.Show(strErrorMsg);
}
}
/// <summary>
/// 根据角色编号获取角色信息（用于编辑）
/// </summary>
/// <param name="roleID"></param>
/// <returns></returns>
public static SelectResult <RoleEditModel> GetRoleByID(int roleID)
{
List <SqlParameter> paras = new List <SqlParameter>()
{
new SqlParameter("@ID", SqlDbType.Int),
};
paras[0].Value = roleID;
string sql = "SELECT ID,RoleName,[Description] FROM Roles WHERE ID=@ID";
List <RoleEditModel> list = ConvertToList <RoleEditModel> .Convert(MSSQLHelper.ExecuteDataTable(CommandType.Text, sql, paras.ToArray()));
RoleEditModel data = null;
string msg = string.Empty;
if (list == null)
{
msg = PromptInformation.DBError;
}
else if (list.Count == 0)
{
msg = PromptInformation.NotExists;
}
else
{
//如果存在角色，查询出角色的功能信息
var roleObj = list[0];
sql = @"SELECT FunctionID FROM dbo.RolesFunctions WHERE RoleID=@RoleID";
paras = new List <SqlParameter>()
{
new SqlParameter("@RoleID", SqlDbType.Int),
};
paras[0].Value = roleObj.ID;
DataTable dt = MSSQLHelper.ExecuteDataTable(CommandType.Text, sql, paras.ToArray());
if (dt == null)
{
msg = PromptInformation.DBError;
}
else
{
var rows = dt.Rows;
roleObj.FunctionIDs = new List <int>();
for (int i = 0; i < rows.Count; i++)
{
roleObj.FunctionIDs.Add(Convert.ToInt32(rows[i][0]));
}
data = roleObj;
}
}
return(new SelectResult <RoleEditModel>()
{
DataResult = data,
Message = msg
});
}
public JsonResult Add(RoleEditModel model)
{
if (string.IsNullOrEmpty(model.Name))
{
return(Json(new
{
Code = 300,
Msg = "Name is not allowed to be empty."
}));
}
if (model.Name.StartsWith("_"))
{
return(Json(new
{
Code = 300,
Msg = "Name is not allowed to start with _."
}));
}
var mongo = new MongoHelper();
var filter = Builders <BsonDocument> .Filter.Eq("Name", model.Name);
var count = mongo.Count(Constant.RoleCollectionName, filter);
if (count > 0)
{
return(Json(new
{
Code = 300,
Msg = "The name is already existed.",
}));
}
var now = DateTime.Now;
var doc = new BsonDocument
{
["ID"] = ObjectId.GenerateNewId(),
["Name"] = model.Name,
["CreateTime"] = now,
["UpdateTime"] = now,
["Status"] = 0,
};
mongo.InsertOne(Constant.RoleCollectionName, doc);
return(Json(new
{
Code = 200,
Msg = "Saved successfully!"
}));
}
public IActionResult Save(RoleEditModel model)
{
if (model.Save(_db))
{
SuccessMessage("The role has been saved.");
return(RedirectToAction("Edit", new { id = model.Role.Id }));
}
ErrorMessage("The role could not be saved.", false);
return(View("Edit", model));
}
public async Task <IActionResult> Edit(RoleEditModel model)
{
using (HttpClient client = new HttpClient())
{
var jsonObject = JsonConvert.SerializeObject(model);
var content = new StringContent(jsonObject.ToString(), Encoding.UTF8, "application/json");
var response = await client.PostAsync(new Uri(Uri, "/api/role"), content);
return(View());
}
}
public async Task <IActionResult> Edit(RoleEditModel model)
{
IdentityResult result;
if (ModelState.IsValid)
{
foreach (var userId in model.IdsToAdd ?? new string[] { })
{
var user = await userManager.FindByIdAsync(userId);
if (user != null)
{
result = await userManager.AddToRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
}
foreach (var userId in model.IdsToDelete ?? new string[] { })
{
var user = await userManager.FindByIdAsync(userId);
if (user != null)
{
result = await userManager.RemoveFromRoleAsync(user, model.RoleName);
if (!result.Succeeded)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
}
}
if (ModelState.IsValid)
{
return(RedirectToAction("Index"));
}
else
{
return(RedirectToAction("Edit", model.RoleId));
}
}
public ActionResult DeleteConfirmed(int id, RoleEditModel roleEdit)
{
try
{
var rolePerson = from p in db.Person_Role
where p.Role_ID == id
select p;
ViewBag.ErrorMsg = "Are you sure you want to delete?";
TempData["Disabled"] = false;
if (rolePerson.Count() != 0)
{
ViewBag.ErrorMsg = "Role cannot be deleted becuase there are persons assigned to the role";
TempData["Disabled"] = true;
return(View(roleEdit));
}
Role r = db.Roles.Find(id);
if (roleEdit.role == null)
{
return(HttpNotFound());
}
if (roleEdit.role.Role_Name == "Super Admin")
{
ViewBag.ErrorMsg = "'Super Admin' role cannot be deleted";
TempData["Disabled"] = true;
return(View(roleEdit));
}
if (roleEdit.role.Role_Name == "Admin")
{
ViewBag.ErrorMsg = "'Admin' role cannot be deleted";
TempData["Disabled"] = true;
return(View(roleEdit));
}
db.Roles.Remove(r);
foreach (var o in roleEdit.actionList)
{
Role_Action ra = db.Role_Action.Find(o.RoleAction_ID);
db.Role_Action.Remove(ra);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch
{
return(View(roleEdit));
}
}
public RoleEditModel CreateRoleEditModel(AppRole role)
{
var roleModel = new RoleEditModel();
var userList = IdentityManager.Users.ToList();
var membersId = role.Users.Select(x => x.UserId);
roleModel.Role = role;
roleModel.Members = userList.Where(x => membersId.Contains(x.Id));
roleModel.NonMembers = userList.Except(roleModel.Members);
return(roleModel);
}
public async Task <ActionResult> Edit(RoleEditModel model)
{
try
{
await roleService.Edit(model.Id, model.RoleName);
return(Redirect(model.Referer));
}
catch (ArgumentException ex)
{
return(Content(ex.Message));
}
}
// GET: Edit
public async Task<ActionResult> Edit(string id)
{
AppRole role = await RoleManager.FindByIdAsync(id);
string[] memberIds = role.Users.Select(x => x.UserId).ToArray();
IEnumerable<AppUser> members = UserManager.Users.Where(x => memberIds.Any(y => y == x.Id));
IEnumerable<AppUser> nonMembers = UserManager.Users.Except(members);
RoleEditModel viewmodel = new RoleEditModel(){ Role = role, Members = members, NonMembers = nonMembers};
return View(viewmodel);
}
