/// <summary>
/// 检查用户信息
/// </summary>
/// <param name="entity"></param>
/// <param name="broker"></param>
private void CheckUserInfo(BaseEntity entity, IPersistBroker broker)
{
var allowUpdateRole = new SysRoleService(broker).AllowCreateOrUpdateRole(entity["roleid"].ToString());
AssertUtil.CheckBoolean <SpException>(!allowUpdateRole, $"你没有权限修改角色为[{entity["roleidName"]}]", "2ABD2CBA-A7CB-4F61-841F-7CD4E6C1BD69");
AssertUtil.CheckBoolean <SpException>(entity.Id == "00000000-0000-0000-0000-000000000000", "系统管理员信息禁止更新", "");
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
this.hidDepartId.Value = "";
this.hidRoleId.Value = "";
this.hidRowsCount.Value = "";
if (Session["loginUser"] == null)
{
Response.Redirect("/admin/login.aspx");
return;
}
if (roleId > 0)
{
SysRole role = SysRoleService.GetSysRoleById(roleId);
if (role != null)
{
this.lblRoleName.Text = role.RoleName;
this.lblRoleDesc.Text = role.RoleDesc;
Department depart = DepartmentService.GetDepartmentByID(role.DepartmentId);
this.lblDepartment.Text = depart.Name;
this.hidDepartId.Value = role.DepartmentId.ToString();
this.hidRoleId.Value = role.Id.ToString();
//加载权限树
LoadLevelTree(role.Id, role.DepartmentId);
}
}
}
}
public JsonResult List(SysRoleViewModel viewModel, PageInfo pageInfo)
{
QueryCollection queries = new QueryCollection();
if (!string.IsNullOrEmpty(viewModel.Name))
{
queries.Add(new Query {
Name = "Name", Operator = Query.Operators.Contains, Value = viewModel.Name
});
}
else if (!string.IsNullOrEmpty(viewModel.Code))
{
queries.Add(new Query {
Name = "Code", Operator = Query.Operators.Contains, Value = viewModel.Code
});
}
var list = SysRoleService.GetListByPage(queries.AsExpression <SysRole>(), x => true, pageInfo.Limit, pageInfo.Page, out int totalCount, true).Select(x => new
{
x.Id,
x.Name,
x.Code,
x.EnabledMark,
x.Remark
}).ToList();
return(Json(Pager.Paging(list, totalCount), JsonRequestBehavior.AllowGet));
}
private async Task SetRoleList()
{
//获取所有角色
var sysRoleService = new SysRoleService();
ViewBag.SysRoleList = await sysRoleService.GetAllSysRole();
}
public async Task <ActionResult> DeleteSysRole(Guid id)
{
var sysRoleService = new SysRoleService();
await sysRoleService.RemoveSysRole(id);
return(RedirectToAction(nameof(SysRoleList)));
}
/// <summary>
/// 用户角色管理
/// </summary>
/// <returns></returns>
public ActionResult UserRoleManage()
{
if (string.IsNullOrWhiteSpace(action))
{
return(View());
}
JsonResult result = new JsonResult();
SysRoleService roleService = GetService <SysRoleService>();
XT_UserService userService = GetService <XT_UserService>();
List <XT_ROLE> roles = null;
string roleId = null;
switch (action)
{
case "GetRoles":
roles = roleService.SelectByUser(GetCurrerUser().ID);
List <ZTreeItemData> ztreeList = ZTreeItemData.CreateZTreeData("0", "根节点");
foreach (XT_ROLE role in roles)
{
ztreeList.Add(new ZTreeItemData()
{
name = role.ROLE_NAME,
Id = role.ID,
PId = role.PARENT_ID,
});
}
result.Data = ztreeList;
break;
case "GetAllUsers":
//roles= roleService.SelectByUser(GetCurrerUser().ID);
result.Data = userService.SelectAll();
break;
case "GetRoleUser":
roleId = GetParams("roleId");
result.Data = userService.SelectByRoleId(roleId);
break;
case "saveUserRole":
List <XT_USER_ROLE> user_role_list = GetParams <List <XT_USER_ROLE> >("user_role_list");
roleId = GetParams("roleId");
SysRoleUserService roleUserService = GetService <SysRoleUserService>();
roleUserService.DeleteByRoleId(roleId);
if (user_role_list != null)
{
foreach (XT_USER_ROLE user_role in user_role_list)
{
user_role.ROLE_ID = roleId;
roleUserService.InsertOrUpdate(user_role);
}
}
result.Data = true;
break;
}
return(result);
}
public EditUserModel(SysRoleService sysRoleService,
IMapper mapper,
SysUserService sysUserService)
{
_sysUserService = sysUserService;
_sysRoleService = sysRoleService;
_mapper = mapper;
}
public DeleteUserModel(SysUserService sysUserService,
SysUserJwtService sysUserJwtService,
SysRoleService sysRoleService)
{
_sysUserJwtService = sysUserJwtService;
_sysUserService = sysUserService;
_sysRoleService = sysRoleService;
}
public RolePrmModel(SysRoleService sysRoleService,
IMapper mapper,
SysCategoryService sysCategoryService)
{
_sysCategoryService = sysCategoryService;
_mapper = mapper;
_sysRoleService = sysRoleService;
}
public PagesRolePermissionModel(SysMenuService sysMenuService, SysRoleService sysRoleService, SysPermissionService sysPermissionService)
{
CurrentMenu = "Role";
_sysRoleService = sysRoleService;
_sysPermissionService = sysPermissionService;
//_sysRoleMenuService = sysRoleMenuService;
_sysMenuService = sysMenuService;
}
/// <summary>
///
/// </summary>
/// <param name="sysRoleService"></param>
/// <param name="sysUserService"></param>
/// <param name="sysCategoryService"></param>
/// <param name="mapper"></param>
public SysRoleController(SysRoleService sysRoleService,
SysUserService sysUserService,
SysCategoryService sysCategoryService,
IMapper mapper)
{
_sysCategoryService = sysCategoryService;
_sysUserService = sysUserService;
_mapper = mapper;
_sysRoleService = sysRoleService;
}
public async Task <ActionResult> EditSysRole(SysRoleViewModel model)
{
if (ModelState.IsValid)
{
var sysRoleService = new SysRoleService();
await sysRoleService.EditSysRole(model.Id, model.RoleName, model.SortOrder);
}
return(RedirectToAction(nameof(SysRoleList)));
}
public JsonResult ChangePasswordPost(FormCollection collection)
{
var service = new SysUserService();
SysUser user = service.Login(collection["UserCode"], collection["OldPwd"]);
if (user == null || string.Compare(user.Pwd, collection["OldPwd"], false) != 0)
{
return(Json(new { success = false, msg = "<=OldPwdNotMatched>" }));
}
else
{
if (string.Compare(collection["NewPwd"], collection["ConfirmPwd"], false) != 0)
{
return(Json(new { success = false, msg = "<=NewPwdNotMatched>" }));
}
if (string.Compare(collection["NewPwd"], user.Pwd, false) == 0)
{
return(Json(new { success = false, msg = "<=ForbidMatchOldPwd>" }));
}
string errorMsg = string.Empty;
user.PasswordDate = DateTime.Now.Date;
user.Pwd = collection["NewPwd"];
TryUpdateModel <SysUser>(user);
//判断新密码规则,Operator不受密码规则控制
var _sysUserRoleService = new SysUserRoleService();
var _sysRoleService = new SysRoleService();
var sysUserRole = _sysUserRoleService.GetList().Where(o => o.SysUserId == user.SysUserId).Select(o => o.SysRoleId).Distinct().ToList();
var sysRole = _sysRoleService.GetList().Where(o => sysUserRole.Contains(o.SysRoleId) || o.SysRoleId == user.RoleId).ToList();
if (sysRole.Count() > 0 && (sysRole.Count() != 1 || sysRole.Where(o => o.RoleCode.Contains("Operator")).Count() <= 0))
{
if (!this.PassWordIsValid(user.Pwd))
{
return(Json(new { success = false, msg = "<=PasswordError>" }, JsonRequestBehavior.AllowGet));
}
}
if (!ModelState.IsValid)
{
List <string> errorList = ModelStateExtension.GetModelError(ViewData);
string str = string.Join(",", errorList.ToArray());
return(Json(new { success = false, msg = str }, JsonRequestBehavior.AllowGet));
}
bool success = service.Save(user, out errorMsg);
if (!success)
{
return(Json(new { success = false, msg = errorMsg }));
}
FormsService.SignIn(collection["UserCode"], false);
return(Json(new { success = true, msg = "<=ModifySuccess>" }));
}
}
public async Task <ActionResult> DetailsSysRole(Guid?id)
{
var sysRoleService = new SysRoleService();
if (id == null || !await sysRoleService.ExistsSysRole(id.Value))
{
return(RedirectToAction(nameof(SysRoleList)));
}
return(View(await sysRoleService.GetOneSysRoleById(id.Value)));
}
public async Task <ActionResult> EditSysRole(Guid id)
{
var sysRoleService = new SysRoleService();
var data = await sysRoleService.GetOneSysRoleById(id);
return(View(new SysRoleViewModel()
{
Id = data.Id,
RoleName = data.RoleName,
SortOrder = data.SortOrder,
}));
}
/// <summary>
/// 邮箱激活用户
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public string ActivateUser(string id)
{
return(Broker.ExecuteTransaction(() =>
{
var data = GetData(id);
if (data == null)
{
return "激活失败";
}
if (data.expire_time < DateTime.Now)
{
return "激活失败，激活链接已过期";
}
#region 创建用户
var model = JsonConvert.DeserializeObject <LoginRequest>(data.login_request.ToString());
var role = new SysRoleService(Broker).GetGuest();
var user = new user_info()
{
Id = Guid.NewGuid().ToString(),
code = model.code,
password = model.password,
name = model.code.Split("@")[0],
mailbox = model.code,
roleid = role.Id,
roleidName = role.name,
stateCode = 1,
stateCodeName = "启用"
};
Broker.Create(user, false);
var _authUser = new auth_user()
{
Id = user.user_infoId,
name = user.name,
code = user.code,
roleid = user.roleid,
roleidName = user.roleidName,
user_infoid = user.user_infoId,
is_lock = false,
is_lockName = "否",
last_login_time = DateTime.Now,
password = model.password
};
Broker.Create(_authUser);
#endregion
data.is_active = true;
Broker.Update(data);
return "激活成功";
}));
}
public ActionResult Test2(string name)
{
T_SysRoles role = new T_SysRoles();
role.Guid = Guid.NewGuid().ToString("N");
role.Name = "超级管理员";
role.Description = "拥有所有的权限";
role.CreateUser = 1;
role.CreateTime = DateTime.Now;
SysRoleService.AddEntity(role);
return(null);
}
public UserDetailsModel(SysRoleService sysRoleService,
SysUserService sysUserService,
SysUserJwtService sysUserJwtService,
SysUserLoginService sysUserLoginService,
ActivityLogService activityLogService)
{
_activityLogService = activityLogService;
_sysUserLoginService = sysUserLoginService;
_sysUserService = sysUserService;
_sysRoleService = sysRoleService;
_sysUserJwtService = sysUserJwtService;
}
public ActionResult Delete(int id)
{
try
{
SysRoleService.DeleteBy(x => x.Id == id);
return(WriteSuccess("数据删除成功"));
}
catch (Exception ex)
{
return(WriteError(ex));
}
}
public WorkContext(SysUserAuthentication sysUserAuthentication,
SysRoleService sysRoleService,
IHttpContextAccessor httpContextAccessor,
SysCategoryService sysCategoryService,
SysUserService sysUserService)
{
_sysRoleService = sysRoleService;
_sysCategoryService = sysCategoryService;
_sysUserAuthentication = sysUserAuthentication;
_httpContextAccessor = httpContextAccessor;
_sysUserService = sysUserService;
}
public ActionResult UpdateEnabledMark(int id, int enabledMark)
{
SysRole entity = new SysRole
{
Id = id,
EnabledMark = enabledMark,
UpdateTime = DateTime.Now,
UpdateUserId = UserManager.GetCurrentUserInfo().Id
};
SysRoleService.Update(entity, new string[] { "EnabledMark", "UpdateTime", "UpdateUserId" });
return(WriteSuccess("更新成功"));
}
public async Task <ActionResult> CreateSysRole(SysRoleViewModel model)
{
if (ModelState.IsValid)
{
ISysRoleService sysRoleSvc = new SysRoleService();
await sysRoleSvc.CreateSysRole(model.RoleName, model.SortOrder);
return(RedirectToAction(nameof(SysRoleList)));
}
ModelState.AddModelError("", @"您录入的信息有误");
return(View());
}
public ActionResult Edit(int id, SysRoleViewModel viewModel)
{
if (ModelState.IsValid == false)
{
return(WriteError("实体验证失败"));
}
viewModel.Id = id;
viewModel.UpdateTime = DateTime.Now;
viewModel.UpdateUserId = UserManager.GetCurrentUserInfo().Id;
SysRole entity = viewModel.EntityMap();
SysRoleService.Update(entity, new string[] { "Name", "Code", "EnabledMark", "Remark", "UpdateTime", "UpdateUserId" });
return(WriteSuccess());
}
public ActionResult BatchDel(string idsStr)
{
try
{
var idsArray = idsStr.Substring(0, idsStr.Length).Split(',');
int[] ids = Array.ConvertAll <string, int>(idsArray, int.Parse);
var result = SysRoleService.DeleteBy(x => ids.Contains(x.Id)) > 0 ? WriteSuccess("数据删除成功") : WriteError("数据删除失败");
return(result);
}
catch (Exception ex)
{
return(WriteError(ex));
}
}
/// <summary>
/// 角色名称
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
protected string GetRoleName(object roleId)
{
int id = Convert.ToInt32(roleId);
SysRole item = SysRoleService.GetSysRoleById(id);
if (item != null)
{
return(item.RoleName);
}
else
{
return("");
}
}
/// <summary>
///
/// </summary>
public SysUserController(SysUserService sysUserService,
SysRoleService sysRoleService,
SysUserLoginService sysUserLoginLogService,
ActivityLogService activityLogService,
SysUserJwtService sysUserJwtService,
IMapper mapper)
{
_sysUserJwtService = sysUserJwtService;
_sysUserLoginLogService = sysUserLoginLogService;
_sysRoleService = sysRoleService;
_sysUserService = sysUserService;
_activityLogService = activityLogService;
_mapper = mapper;
}
/// <summary>
/// 加载数据
/// </summary>
private void LoadData()
{
this.txtPass.Text = "";
this.txtPassAgain.Text = "";
this.txtRealName.Text = "";
this.txtUserName.Text = "";
//加载角色
DataSet dsRole = SysRoleService.GetList("");
if (dsRole.Tables[0].Rows.Count > 0)
{
this.ddlRole.DataSource = dsRole;
ddlRole.DataTextField = "roleName";
ddlRole.DataValueField = "id";
ddlRole.DataBind();
}
ddlRole.Items.Insert(0, new ListItem("请选择", "0"));
if (Request.QueryString["useAdmin"] != null)
{
string useAdmin = Request.QueryString["useAdmin"];
if (useAdmin == "1")
{
ScriptManager.RegisterStartupScript(this.UpdatePanel1, this.GetType(), "", "alert('操作成功!');", true);
}
else
{
ScriptManager.RegisterStartupScript(this.UpdatePanel1, this.GetType(), "", "alert('操作失败!');", true);
}
}
if (Request.QueryString["delAdmin"] != null)
{
string delAdmin = Request.QueryString["delAdmin"];
if (delAdmin == "1")
{
ScriptManager.RegisterStartupScript(this.UpdatePanel1, this.GetType(), "", "alert('删除成功!');", true);
}
else
{
ScriptManager.RegisterStartupScript(this.UpdatePanel1, this.GetType(), "", "alert('删除失败!');", true);
}
}
DataSet ds = AdminUserService.GetList("");
if (ds.Tables[0].Rows.Count > 0)
{
this.repInfo.DataSource = ds;
repInfo.DataBind();
}
}
public async Task <ActionResult> SysRoleList(int pageIndex = 1, int pageSize = 20)
{
//总页码、当前页码、可显示总页码
var sysRoleSvc = new SysRoleService();
//当前第n页数据
var sysRole = await sysRoleSvc.GetAllSysRole(pageIndex, pageSize, false);
//总个数
var dataCount = await sysRoleSvc.GetDataCount();
//绑定分页
var list = new PagedList <SysRoleDto>(sysRole, pageIndex, pageSize, dataCount);
return(View(list));
}
public void GetUserMenu()
{
string userId = "cf9d52cc-0500-4829-9611-fd0056961469";
ISysUserService sysUserService = new SysUserService();
//通过用户id获取权限菜单数据
IEnumerable <SysPrivilege> sysUserPrivileges = sysUserService.GetPrivilege(userId);
sysUserPrivileges = sysUserPrivileges.Where(x => x.PrivilegeAccess == PrivilegeAccess.Menu).ToList();
//通过用户id获取角色，通过角色获取权限菜单数据
IEnumerable <SysRole> sysRoles = sysUserService.GetRoles(userId);
ISysRoleService sysRoleService = new SysRoleService();
SysRole[] sysRoles1 = sysRoles.ToArray();
//一个用户是否会有多个角色？
for (int i = 0; i < sysRoles1.Count(); i++)
{
string roleId = sysRoles1[0].SysId;
IEnumerable <SysPrivilege> sysRolePrivileges = sysRoleService.GetPrivilege(roleId);
//排除同用户权限相同菜单数据
SysPrivilege[] sysUserPrivileges1 = sysUserPrivileges.ToArray();
for (int j = 0; j < sysUserPrivileges1.Length; j++)
{
sysRolePrivileges =
sysRolePrivileges.Where(
x =>
x.PrivilegeAccessKey != sysUserPrivileges1[j].PrivilegeAccessKey &&
x.PrivilegeAccess == PrivilegeAccess.Menu).ToList();
}
sysUserPrivileges = sysUserPrivileges.Union(sysRolePrivileges);
}
//sysUserPrivileges结果为最终菜单权限
List <SysMenu> sysMenus = new List <SysMenu>();
ISysMenuService sysMenuService = new SysMenuService();
foreach (SysPrivilege sysUserPrivilege in sysUserPrivileges)
{
string menuId = sysUserPrivilege.PrivilegeAccessKey;
SysMenu sysMenu = sysMenuService.GetSysMenuById(menuId).ToArray()[0];
sysMenus.Add(sysMenu);
}
sysMenus = sysMenus.Where(x => x.IsVisible == 1).OrderBy(x => x.MenuOrder).ToList();
}
public async Task <ActionResult> SysUserEdit(Guid id)
{
//获取用户信息
var sysUserService = new SysUserService();
var data = await sysUserService.GetOneSysUserById(id);
List <Guid> roleIds = new List <Guid>();
foreach (var t in data.SysUserRoles.Where(a => !a.IsRemoved))
{
roleIds.Add(t.SysRoleId);
}
//权限集合
List <SelectListItem> selectList = new List <SelectListItem>();
var list = await new SysDepartService().GetAllSysDepart();
foreach (var item in list)
{
selectList.Add(data.SysDepartId == item.Id
? new SelectListItem {
Text = item.DepartName, Value = item.Id.ToString(), Selected = true
}
: new SelectListItem {
Text = item.DepartName, Value = item.Id.ToString()
});
}
ViewBag.SysDepartList = selectList;
//获取所有角色
var sysRoleService = new SysRoleService();
ViewBag.SysRoleList = await sysRoleService.GetAllSysRole();
return(View(new SysUserViewModel()
{
Id = data.Id,
RealName = data.RealName,
UserName = data.UserName,
SysRoleIds = roleIds.ToArray(),
CreateTime = data.CreateTime.ToString("yyyy-dd-MM")
}));
}
