/// <summary>
/// 获取 指定 用户的 "可访问部门" 列表.
/// 可访问部门包含 用户当前部门 与 用户当前部门的下属部门.
/// </summary>
/// <param name="userCode"> 用户代码 </param>
/// <returns></returns>
public List<MR_DEPT> GetUserAccessAbleDeptList(string userCode)
{
// 预期要返回的结果.
List<MR_DEPT> resultList = new List<MR_DEPT>();
// 开始查询处理.
using (MyRuleEntities context = new MyRuleEntities())
{
// 首先查询用户.
MR_USER mrUser = context.MR_USER.FirstOrDefault(p => p.USER_CODE == userCode);
if (mrUser == null)
{
// 用户不存在.
return resultList;
}
// 延迟查询 用户的 直属部门.
foreach (MR_DEPT mrDept in mrUser.MR_DEPT)
{
// 如果结果列表中没有数据， 那么加入结果列表.
if (resultList.Count(p => p.DEPT_CODE == mrDept.DEPT_CODE) == 0)
{
// 加入 用户的 直属部门.
resultList.Add(mrDept);
// 查询这个部门的下属部门.
List<MR_DEPT> allSubDeptList = mrDept.GetAllSubMrDeptList();
foreach (MR_DEPT subDept in allSubDeptList)
{
// 如果结果列表中没有数据， 那么加入结果列表.
if (resultList.Count(p => p.DEPT_CODE == subDept.DEPT_CODE) == 0)
{
// 加入 用户的 直属部门 的 下属部门.
resultList.Add(subDept);
}
}
}
}
}
// 返回结果列表.
return resultList;
}
/// <summary>
/// 获取 指定 用户的 "可访问模块" 列表.
/// 可访问模块包含 用户直接可访问模块 与 用户直接可访问模块的下属模块.
/// </summary>
/// <param name="userCode"> 用户代码 </param>
/// <returns></returns>
public List<MR_MODULE> GetUserAccessAbleModuleList(string userCode)
{
// 开始查询处理并返回.
using (MyRuleEntities context = new MyRuleEntities())
{
return GetUserAccessAbleModuleList(context, userCode);
}
}
/// <summary>
/// 获取 指定 用户的 全部的 "可访问模块" 列表.
/// 可访问模块包含 用户直接可访问模块 与 用户直接可访问模块的下属模块.
/// 以及 用户的角色 直接可访问模块 与 用户的角色直接可访问模块的下属模块.
/// </summary>
/// <param name="context"></param>
/// <param name="userCode"></param>
/// <returns></returns>
private List<MR_MODULE> GetAllUserAccessAbleModuleList(MyRuleEntities context, string userCode)
{
// 预期要返回的结果.
List<MR_MODULE> resultList = new List<MR_MODULE>();
// 首先查询用户.
MR_USER mrUser = context.MR_USER.FirstOrDefault(p => p.USER_CODE == userCode);
if (mrUser == null)
{
// 用户不存在.
return resultList;
}
// 将 用户 直接 可访问的 模块列表， 加入结果列表.
resultList.AddRange( GetUserAccessAbleModuleList(context, userCode));
// 然后 遍历 用户的角色.
foreach (MR_ROLE mrRole in mrUser.MR_ROLE)
{
// 将 用户的角色 的 可访问的 模块列表， 加入结果列表. （重复的不加入）
foreach (MR_MODULE oneModule in GetRoleAccessAbleModuleList(context, mrRole.ROLE_CODE))
{
if (resultList.Count(p => p.MODULE_CODE == oneModule.MODULE_CODE) == 0)
{
resultList.Add(oneModule);
}
}
}
// 返回.
return resultList;
}
/// <summary>
/// 获取 指定角色 对指定模块 的 "可访问动作" 列表.
/// 可访问动作，包含 当前模块的 默认可用动作 与 针对角色授权了的动作.
/// </summary>
/// <param name="context"></param>
/// <param name="roleCode"></param>
/// <param name="moduleCode"></param>
/// <returns></returns>
private List<MR_ACTION> GetRoleAccessAbleActionList(MyRuleEntities context, string roleCode, string moduleCode)
{
// 预期结果.
List<MR_ACTION> resultList = new List<MR_ACTION>();
// 首先查询角色.
MR_ROLE mrRole = context.MR_ROLE.FirstOrDefault(p => p.ROLE_CODE == roleCode);
if (mrRole == null)
{
// 角色不存在.
return resultList;
}
// 然后从 用户所拥有的所有模块的列表中， 查询有没有参数指定的模块.
MR_MODULE mrModule = GetRoleAccessAbleModuleList(context, roleCode).FirstOrDefault(p => p.MODULE_CODE == moduleCode);
if (mrModule == null)
{
// 模块不存在 或者 角色 没有访问此模块的权限.
return resultList;
}
// 遍历模块下的 动作.
foreach (MR_ACTION mrAction in mrModule.MR_ACTION)
{
if (mrAction.DEFAULT_RULE == 1)
{
// 默认动作， 自动拥有权限.
resultList.Add(mrAction);
}
else
{
// 非默认动作，需要 角色有相应的授权.
if (mrRole.MR_ACTION.Count(p => p.ACTION_CODE == mrAction.ACTION_CODE) > 0)
{
// 用户 有这个动作的 授权.
resultList.Add(mrAction);
}
}
}
// 返回.
return resultList;
}
/// <summary>
/// 获取 指定 角色的 "可访问模块" 列表.
/// 可访问模块包含 角色直接可访问模块 与 角色直接可访问模块的下属模块.
/// </summary>
/// <param name="context"></param>
/// <param name="roleCode"></param>
/// <returns></returns>
private List<MR_MODULE> GetRoleAccessAbleModuleList(MyRuleEntities context, string roleCode)
{
// 预期要返回的结果.
List<MR_MODULE> resultList = new List<MR_MODULE>();
// 首先查询角色.
MR_ROLE mrRole = context.MR_ROLE.FirstOrDefault(p => p.ROLE_CODE == roleCode);
if (mrRole == null)
{
// 角色不存在.
return resultList;
}
// 延迟查询 角色的 直接可访问模块.
foreach (MR_MODULE mrModule in mrRole.MR_MODULE)
{
// 如果结果列表中没有数据， 那么加入结果列表.
if (resultList.Count(p => p.MODULE_CODE == mrModule.MODULE_CODE) == 0)
{
// 加入 用户的 直接可访问模块.
resultList.Add(mrModule);
// 查询这个部门的下属部门.
List<MR_MODULE> allSubModuleList = mrModule.GetAllSubMrModuleList();
foreach (MR_MODULE subModule in allSubModuleList)
{
// 如果结果列表中没有数据， 那么加入结果列表.
if (resultList.Count(p => p.MODULE_CODE == subModule.MODULE_CODE) == 0)
{
// 加入 用户的 直属部门 的 下属部门.
resultList.Add(subModule);
}
}
}
}
// 返回结果列表.
return resultList;
}
/// <summary>
/// 获取 指定 用户的 "可访问模块" 列表.
/// 可访问模块包含 用户直接可访问模块 与 用户直接可访问模块的下属模块.
/// </summary>
/// <param name="context"></param>
/// <param name="userCode"> 用户代码 </param>
/// <returns></returns>
private List<MR_MODULE> GetUserAccessAbleModuleList(MyRuleEntities context, string userCode)
{
// 预期要返回的结果.
List<MR_MODULE> resultList = new List<MR_MODULE>();
// 首先查询用户.
MR_USER mrUser = context.MR_USER.FirstOrDefault(p => p.USER_CODE == userCode);
if (mrUser == null)
{
// 用户不存在.
return resultList;
}
// 延迟查询 用户的 直接可访问模块.
foreach (MR_MODULE mrModule in mrUser.MR_MODULE)
{
// 如果结果列表中没有数据， 那么加入结果列表.
if (resultList.Count(p => p.MODULE_CODE == mrModule.MODULE_CODE) == 0)
{
// 加入 用户的 直接可访问模块.
resultList.Add(mrModule);
// 查询这个部门的下属部门.
List<MR_MODULE> allSubModuleList = mrModule.GetAllSubMrModuleList();
foreach (MR_MODULE subModule in allSubModuleList)
{
// 如果结果列表中没有数据， 那么加入结果列表.
if (resultList.Count(p => p.MODULE_CODE == subModule.MODULE_CODE) == 0)
{
// 加入 用户的 直属部门 的 下属部门.
resultList.Add(subModule);
}
}
}
}
// 返回结果列表.
return resultList;
}
/// <summary>
/// 获取 指定用户 对指定模块 全部的 "可访问动作" 列表.
/// 可访问动作，包含 当前模块的 默认可用动作 与 针对用户授权了的动作.
/// 以及针对 用户的角色授权了的动作.
/// </summary>
/// <param name="userCode"> 用户代码 </param>
/// <param name="moduleCode"> 模块代码 </param>
/// <returns></returns>
public List<MR_ACTION> GetAllUserAccessAbleActionList(string userCode, string moduleCode)
{
// 预期结果.
List<MR_ACTION> resultList = new List<MR_ACTION>();
// 开始查询处理.
using (MyRuleEntities context = new MyRuleEntities())
{
// 首先查询用户.
MR_USER mrUser = context.MR_USER.FirstOrDefault(p => p.USER_CODE == userCode);
if (mrUser == null)
{
// 用户不存在.
return resultList;
}
// 然后从 用户所拥有的所有模块的列表中， 查询有没有参数指定的模块.
MR_MODULE mrModule = GetAllUserAccessAbleModuleList(context, userCode).FirstOrDefault(p => p.MODULE_CODE == moduleCode);
if (mrModule == null)
{
// 模块不存在 或者 用户 与 用户的角色 没有访问此模块的权限.
return resultList;
}
// 首先加入 用户可访问的 动作.
resultList.AddRange( GetUserAccessAbleActionList(context, userCode, moduleCode) );
// 然后 遍历 用户的角色.
foreach (MR_ROLE mrRole in mrUser.MR_ROLE)
{
// 将 用户的角色 的 可访问的 动作列表， 加入结果列表. （重复的不加入）
foreach (MR_ACTION oneAction in GetRoleAccessAbleActionList(context, mrRole.ROLE_CODE, moduleCode))
{
if (resultList.Count(p => p.ACTION_CODE == oneAction.ACTION_CODE) == 0)
{
resultList.Add(oneAction);
}
}
}
}
// 返回.
return resultList;
}
/// <summary>
/// 获取 指定角色 对指定模块 的 "可访问动作" 列表.
/// 可访问动作，包含 当前模块的 默认可用动作 与 针对角色授权了的动作.
/// </summary>
/// <param name="roleCode"> 角色代码 </param>
/// <param name="moduleCode"> 模块代码 </param>
/// <returns></returns>
public List<MR_ACTION> GetRoleAccessAbleActionList(string roleCode, string moduleCode)
{
// 开始查询处理. 并返回.
using (MyRuleEntities context = new MyRuleEntities())
{
return GetRoleAccessAbleActionList(context, roleCode, moduleCode);
}
}