/// <summary>
/// 加载一个部门及子部门全部Roles
/// </summary>
public GridData Load(Guid orgId, int pageindex, int pagesize)
{
if (pageindex < 1)
{
pageindex = 1; //TODO:如果列表为空新增加一个用户后，前端会传一个0过来，奇怪？？
}
IEnumerable <Role> roles;
int total = 0;
if (orgId == Guid.Empty)
{
roles = _repository.LoadRoles(pageindex, pagesize);
total = _repository.GetCount();
}
else
{
roles = _repository.LoadInOrgs(pageindex, pagesize, GetSubOrgIds(orgId));
total = _repository.GetRoleCntInOrgs(orgId);
}
var rolevms = new List <RoleVM>();
foreach (var role in roles)
{
RoleVM rolevm = role;
var orgs = _orgRepository.LoadByRole(role.Id);
rolevm.Organizations = string.Join(",", orgs.Select(u => u.Name).ToList());
rolevm.OrganizationIds = string.Join(",", orgs.Select(u => u.Id).ToList());
rolevms.Add(rolevm);
}
var result = new GridData
{
records = total,
total = (int)Math.Ceiling((double)total / pagesize),
rows = rolevms.ToList(),
page = pageindex
};
return(result);
}
public IActionResult Register([FromBody] UserVM model)
{
if (ModelState.IsValid)
{
RoleVM rvm = new RoleVM()
{
Name = model.Role
};
if (!roleContext.IsExist(rvm).Result)
{
ModelState.AddModelError("",
"role does ont exsit!");
return(new BadRequestObjectResult(ModelState));
}
if (userContext.IsExist(model).Result)
{
ModelState.AddModelError("",
"User is already exsit!");
return(new BadRequestObjectResult(ModelState));
}
var Output = userContext.Add(model);
if (Output.Result == true)
{
string confirmationToken = userContext.GetEmailConfirmationToken(model).Result;
var user = userContext.GetUserByUserVM(model).Result;
string confirmationLink = Url.Action("ConfirmEmail", "Account",
new {
userid = user.Id,
token = confirmationToken
},
protocol: HttpContext.Request.Scheme);
var result = sentEmail.SendEmailAsync(user.Email, "Confirm your Email", confirmationLink);
return(Ok(true));
}
}
// If we got this far, something failed, redisplay form
return(new BadRequestObjectResult(ModelState));
}
public async Task <IActionResult> Create(RoleVM model)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole
{
Name = model.RoleName
};
IdentityResult result = await roleManager.CreateAsync(identityRole).ConfigureAwait(true);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Administration"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(model));
}
public async Task <List <string> > EditAsync(RoleVM model)
{
if (model.xID == 0)
{
throw new ArgumentNullException("no identifier provided");
}
var xDBModel = uow.RoleRepository.GetByID(model.xID);
if (xDBModel != null)
{
xDBModel.Name = model.xName;
xDBModel.xDescription = model.xDescription;
uow.RoleRepository.Update(xDBModel);
await uow.SaveChangesAsync();
return(new List <string>());
}
return(new List <string> {
"آیتم مورد نظر در سیستم موجود نمیباشد"
});
}
public async Task <IActionResult> Create(RoleVM model)
{
if (ModelState.IsValid)
{
IdentityRole role = new IdentityRole
{
Name = model.Name
};
var result = await roleManager.CreateAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home", new { area = "" }));
}
foreach (var err in result.Errors)
{
ModelState.AddModelError("", err.Description);
}
}
return(View(model));
}
public IActionResult Index(RoleVM roleVM)
{
var newRole = new IdentityRole();
newRole.Id = roleVM.RoleName;
newRole.Name = roleVM.RoleName;
newRole.NormalizedName = roleVM.RoleName;
if (!_roleManager.RoleExistsAsync(newRole.Name).Result)
{
IdentityResult result = _roleManager.CreateAsync(newRole).Result;
if (!result.Succeeded)
{
ViewBag.Message = "Error, failed at adding";
}
else
{
ViewBag.Message = "Role successfully added.";
}
}
return(View());
}
public async Task <IActionResult> Index()
{
var member = await _memberClient.GetCurrentClient();
if (member != null)
{
RoleVM userRole = await _memberClient.GetCurrentClientInfo();
return(userRole.RoleName switch
{
"Administrator" => RedirectToAction("ShowAllRoles", "Administration"),
"Director" => RedirectToAction("Index", "Principal"),
"Profesor" => RedirectToAction("Index", "Teacher"),
"Student" => RedirectToAction("Index", "Student"),
_ => View(new IndexVM
{
Username = member.UserName,
Name = member.FirstName + " " + member.LastName,
Role = userRole.RoleName
}),
});
// GET: Roles/Edit/5
public async Task <IActionResult> Edit(string id)
{
if (id == null)
{
return(NotFound());
}
var applicationRole = await _roleManager.FindByIdAsync(id); //_context.ApplicationRole.FindAsync(id);
if (applicationRole == null)
{
return(NotFound());
}
RoleVM roleVM = new RoleVM()
{
Id = id, Name = applicationRole.Name, Description = applicationRole.Description
};
return(View(roleVM));
}
public List <UserVM> FindByProperty(Dictionary <string, string> search, string orderBy)
{
List <UserVM> listVM = new List <UserVM>();
foreach (User user in _userDALManageFacade.FindUser(search, orderBy))
{
UserVM userVM = mapper.Map <UserVM>(user);
foreach (UserRole userRole in user.UserRoles)
{
RoleVM roleVM = mapper.Map <RoleVM>(userRole.UserolIdroleNavigation);
userVM.ListRole.Add(roleVM);
}
foreach (ImgStorage img in user.ImgStorages)
{
ImageVM imageVM = mapper.Map <ImageVM>(img);
userVM.ListImg.Add(imageVM);
}
listVM.Add(userVM);
}
return(listVM);
}
public IActionResult GetById(string Id)
{
RoleVM data = null;
//client.DefaultRequestHeaders.Add("Authorization", HttpContext.Session.GetString("token"));
var resTask = client.GetAsync("" + Id);
resTask.Wait();
var result = resTask.Result;
if (result.IsSuccessStatusCode)
{
var json = JsonConvert.DeserializeObject(result.Content.ReadAsStringAsync().Result).ToString();
data = JsonConvert.DeserializeObject <RoleVM>(json);
}
else
{
ModelState.AddModelError(string.Empty, "Server Error.");
}
return(Json(data));
}
//==================Role========================================
private void savebtnrole_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrWhiteSpace(nametxtroleBox.Text))
{
MessageBox.Show("Please Fill Name Role Blank TextBox");
}
else
{
var push = new RoleVM(nametxtroleBox.Text);
var result = rolescontroller.Insert(push);
if (result)
{
MessageBox.Show("Insert Successfully");
LoadGridRole();
}
else
{
MessageBox.Show("Insert Failed");
}
CleaningRole();
}
}
public async Task <RoleVM> GetCurrentClientInfo()
{
var user = await _userManager.GetUserAsync(HttpContext.User);
var roles = _roleManager.Roles.ToList();
RoleVM userRole = new RoleVM
{
RoleName = "none"
};
foreach (var role in roles)
{
if (await _userManager.IsInRoleAsync(user, role.Name))
{
userRole.RoleName = role.Name;
break;
}
}
return(userRole);
}
public IHttpActionResult UpdateRoleFunctions([FromBody] JObject data)
{
try
{
RoleVM roleVM = data.SelectToken("RoleObj").ToObject <RoleVM>();
bool status = manageRole.UpdateFunctionAccessDetails(roleVM);
if (status)
{
return(Json(new { status = true, message = "Successfully Updated" }));
}
else
{
return(Json(new { status = false, message = "Update Failed" }));
}
}
catch (Exception ex)
{
return(Json(new { status = false, message = "Unknown error occurred" }));
}
}
public async Task <List <RoleVM> > GetAll()
{
List <RoleVM> list = new List <RoleVM>();
var getData = await _context.Roles.Where(x => x.isDelete == false).ToListAsync();
if (getData.Count == 0)
{
return(null);
}
foreach (var item in getData)
{
var user = new RoleVM()
{
Id = item.Id,
Name = item.Name,
CreateData = item.CreateData,
UpdateDate = item.UpdateDate
};
list.Add(user);
}
return(list);
}
public IActionResult Put(RoleVM item)
{
try
{
var role = _context.Roles.Find(item.ID);
if (role != null)
{
role.Name = item.RoleName;
role.Description = item.RoleDesc;
_context.SaveChanges();
return(Ok());
}
return(NotFound());
}
catch (Exception ex)
{
return(NotFound());
}
}
public async Task <IActionResult> Roles(RoleVM viewModel)
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var role = new IdentityRole
{
Name = viewModel.AddRole.Name
};
var result = await _roleManager.CreateAsync(role);
if (!result.Succeeded)
{
return(View(viewModel));
}
var model = new RoleVM
{
IdentityRole = _userRepository.GetRoles(),
};
return(View(model));
}
public ActionResult UpdateAccess(Guid?roleId = null)
{
var role = _roleRepository.GetById(roleId ?? Guid.Empty);
if (role == null)
{
return(null);
}
AccessMenuVM vm = new AccessMenuVM();
vm.Role = RoleVM.GetDTO(role);
var criteria = new MenuRoleMapCriteria {
RoleId = role.Id
};
var specification = new MenuRoleMapSpecification(criteria);
var menuMapList = _menuRoleMapRepository.Find(specification).OrderBy(x => x.Menu.Order).ToList();
vm.Menus = menuMapList.Select(x => MenuRoleMapVM.GetDTO(x)).ToList();
return(PartialView("_AccessMenuView", vm));
}
public JsonResult List()
{
List <Role> roleList = new List <Role>();
try
{
roleList = _rb.GetAll();
}
catch (Exception ex)
{
return(Json(ex, JsonRequestBehavior.AllowGet));
}
List <RoleVM> roleVMList = new List <RoleVM>();
foreach (var item in roleList)
{
RoleVM roleVm = new RoleVM();
roleVm.Id = item.Id;
roleVm.Name = item.Name;
roleVMList.Add(roleVm);
}
return(Json(roleVMList, JsonRequestBehavior.AllowGet));
}
public IActionResult deleteRole(string id)
{
if (id != null)
{
var result = roleManager.FindByIdAsync(id);
if (result.Result != null)
{
RoleVM role = new RoleVM()
{
Name = result.Result.Name,
id = result.Result.Id
};
return(View(role));
}
}
else
{
return(View("index", "Home"));
}
ModelState.AddModelError("", "Invalid Data");
return(View());
}
public async Task <IActionResult> CreateRole(RoleVM roleVM)
{
if (ModelState.IsValid)
{
var identityRole = new IdentityRole
{
Name = roleVM.RoleName
};
var result = await _roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ResultErrors(result);
}
}
return(View(roleVM));
}
public async Task <WrapperRoleListVM> Update(string id, RoleVM vm)
{
IEnumerable <Role> ItemDB = await _repositoryWrapper.Role.FindByConditionAsync(x => x.Id == id && x.FactoryId == vm.FactoryId);
var ItemUpdated = _utilService.GetMapper().Map <RoleVM, Role>(vm, ItemDB.ToList().FirstOrDefault());
_repositoryWrapper.Role.Update(ItemUpdated);
await _repositoryWrapper.Role.SaveChangesAsync();
this._utilService.LogInfo("Successful In Updating Item Cateory");
var dataParam = new GetDataListVM()
{
FactoryId = vm.FactoryId,
PageNumber = 1,
PageSize = 10,
TotalRows = 0
};
WrapperRoleListVM data = await GetListPaged(dataParam);
return(data);
}
public async Task <IActionResult> Create(RoleVM role)
{
if (ModelState.IsValid)
{
IdentityRole identityRole = new IdentityRole();
identityRole.Name = role.RoleName;
var roleExist = await roleManager.RoleExistsAsync(identityRole.Name);
if (!roleExist)
{
var result = await roleManager.CreateAsync(identityRole);
if (result.Succeeded)
{
return(View("Create"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
else
{
ModelState.AddModelError("", "الصلاحية تم ادخالها ");
return(View(role));
}
}
return(View(role));
////////////////////////////////////////// Another Code //////////////////////////////////////////
//var roleExist = await roleManager.RoleExistsAsync(role.RoleName);
//if (!roleExist)
//{
// var result = await roleManager.CreateAsync(new IdentityRole(role.RoleName));
//}
//return View();
}
private void myRadDataForm_EditEnding(object sender, EditEndingEventArgs e)
{
if (myRadDataForm.CanCommitEdit && e.EditAction == EditAction.Commit)
{
List <SysModule> modules = new List <SysModule>();
RadTreeView tv = this.GetMPTreeView();
//由于tv.CheckedItems不会包含未展开子节点（即使子节点被选中），因此咱们换一种方式
foreach (var item in tv.CheckedItems)
{
ModuleTreeItem mti = (ModuleTreeItem)item;
modules.Add(mti.Module);
}
//以下方式同样木有用
//IList dataSource = tv.ItemsSource as IList;
////dataSource是object集合，但是竟然能用ModuleTreeItem的对象去枚举，第一次知道，不知道其它集合类型会否有类似用法
//foreach (ModuleTreeItem mti in dataSource)
//{
// RadTreeViewItem container = tv.ContainerFromItemRecursive(mti);
// if (container != null && container.CheckState != ToggleState.Off)
// {
// modules.Add(mti.Module);
// if (mti.Children.Count > 0)
// modules.AddRange(GetCheckedChildrenModules(tv, mti));
// }
//}
var role = (SysRoleBO)myRadDataForm.CurrentItem;
role.Modules = modules;
SetOPAndIMAccess(role);
RoleVM _dataContext = new RoleVM();
UIHelper.AddOrUpdateRecord <SysRole>(myRadDataForm, _dataContext, e);
if (myRadDataForm.Mode == RadDataFormMode.AddNew && !e.Cancel)
{
RadGridView1.Rebind();//重新绑定，将创建者反馈到界面上
}
}
}
public async Task <IActionResult> createRole(RoleVM model)
{
if (ModelState.IsValid)
{
var role = new IdentityRole {
Name = model.Name
};
var result = await roleManager.CreateAsync(role);
if (result.Succeeded)
{
ViewBag.success = "Role " + model.Name + " Add Successfully";
return(View());
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError("", item.Description);
}
}
}
return(View(model));
}
public async Task <IActionResult> CreateRole(RoleVM Role)
{
if (ModelState.IsValid)
{
if (await _RoleManager.RoleExistsAsync(Role.Name))
{
return(BadRequest("Role is already exist."));
}
Role.Name = Role.Name.ToUpper();
var IdentityRole = new IdentityRole
{
Name = Role.Name
};
var result = await _RoleManager.CreateAsync(IdentityRole);
if (result.Succeeded)
{
return(Ok(result));
}
}
return(BadRequest("Error occurred while adding role"));
}
public ActionResult PostRoles(RoleVM vm)
{
if (ModelState.IsValid)
{
_unitOfWork.Roles.AddRole(new ApplicationRole {
Name = vm.Name
});
_unitOfWork.Complete();
var model = new RoleVM
{
Roles = _unitOfWork.Roles.GetAll(),
Name = ""
};
return(PartialView("_RolePartialTBodyDiv", model));
}
else
{
ModelState.AddModelError("", "could not save");
return(PartialView("_RolePartialTBodyDiv", ModelState));
}
}
public async Task <WrapperRoleListVM> Add(RoleVM vm)
{
var entityToAdd = _utilService.GetMapper().Map <RoleVM, Role>(vm);
//string uniqueIdTask =await _repositoryWrapper.Role.GetUniqueId();
//// Todo need to aandle unique id from db
//entityToAdd.UniqueId = uniqueIdTask;
entityToAdd = _repositoryWrapper.Role.Create(entityToAdd);
await _repositoryWrapper.Role.SaveChangesAsync();
this._utilService.LogInfo("Successful In saving Item Category");
var dataParam = new GetDataListVM()
{
FactoryId = vm.FactoryId,
PageNumber = 1,
PageSize = 10,
TotalRows = 0
};
WrapperRoleListVM data = await GetListPaged(dataParam);
return(data);
}
public List <UserVM> searchUser(string name, string code)
{
List <RoleVM> roleVMlist;
List <UserVM> userVMlist = new List <UserVM>();
List <MenuVM> menuVMlist;
var userlist = _iUserDAL.findbyproperty(name, code);
foreach (User user in userlist)
{
UserVM userVM = _iMapper.Map <UserVM>(user);
roleVMlist = new List <RoleVM>();
foreach (UserRole userRole in user.UserRoles)
{
if (userRole.UserolActiveflag == true)
{
Role role = userRole.UserolIdroleNavigation;
RoleVM roleVM = _iMapper.Map <RoleVM>(role);
menuVMlist = new List <MenuVM>();
foreach (Auth auth in userRole.UserolIdroleNavigation.Auths)
{
if (auth.AuthActiveflag == true && auth.AuthPermission == true)
{
Menu menu = auth.AuthIdmenuNavigation;
MenuVM menuVM = _iMapper.Map <MenuVM>(menu);
menuVMlist.Add(menuVM);
}
}
roleVM.menuVMlist = menuVMlist;
roleVMlist.Add(roleVM);
}
}
userVM.roleVMlist = roleVMlist;
userVMlist.Add(userVM);
}
return(userVMlist);
}
public async Task <IActionResult> DeleteRole(RoleVM roleVM)
{
var role = await _roleManager.FindByIdAsync(roleVM.Id);
if (role != null)
{
var result = await _roleManager.DeleteAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
ResultErrors(result);
}
}
else
{
ModelState.AddModelError("", "Nie znaleziono roli.");
}
return(View("Index", _roleManager.Roles));
}
public JsonResult UpdateRole(RoleVM role, string navId)
{
if (ModelState.IsValid)
{
UpdateInfo updateInfo = new UpdateInfo()
{
dynamicData = new
{
role.SysNo,
role.RoleName,
StatusDB = (int)role.Status,
role.Description,
ModifyDate = DateTime.Now,
ModifyUserSysNo = AccountManager.Current.CurrentUser.SysNo
}
};
bool status = _roleBizProcess.UpdateRole(updateInfo);
string message = status ? "修改角色成功" : "修改角色失败";
return(this.ReturnDWZOperate(navId, message, status, ReturnDWZType.ReturnRefrash));
}
return(this.ReturnDWZError("验证角色信息失败"));
}
