using Admin.NET.Core;
|
using Furion.DatabaseAccessor;
|
using Furion.DatabaseAccessor.Extensions;
|
using Furion.DependencyInjection;
|
using Furion.DynamicApiController;
|
using Furion.FriendlyException;
|
using Mapster;
|
using Microsoft.AspNetCore.Mvc;
|
using Microsoft.EntityFrameworkCore;
|
using Admin.NET.Core.Entity.WmsBase;
|
|
namespace Admin.NET.Application
|
{
|
/// <summary>
|
/// 系统菜单服务
|
/// </summary>
|
[ApiDescriptionSettings(Name = "Menu", Order = 146)]
|
[Route("api")]
|
public class SysMenuService : ISysMenuService, IDynamicApiController, ITransient
|
{
|
private readonly IRepository<SysMenu> _sysMenuRep; // 菜单表仓储
|
private readonly IRepository<WmsPdaPower> _wmsPdaPower; // PDA菜单表仓储
|
private readonly IRepository<SysDictData> _sysDictData;
|
private readonly IRepository<WmsRolePdaMenu> _wmsRolePdaMenu;
|
private readonly ISysCacheService _sysCacheService;
|
private readonly ISysUserRoleService _sysUserRoleService;
|
private readonly ISysRoleMenuService _sysRoleMenuService;
|
|
/// <summary>
|
/// 构造函数
|
/// </summary>
|
/// <param name="sysMenuRep"></param>
|
/// <param name="sysCacheService"></param>
|
/// <param name="sysUserRoleService"></param>
|
/// <param name="sysRoleMenuService"></param>
|
public SysMenuService(IRepository<SysMenu> sysMenuRep,
|
IRepository<WmsPdaPower> wmsPdaPower,
|
IRepository<SysDictData> sysDictData,
|
IRepository<WmsRolePdaMenu> wmsRolePdaMenu,
|
ISysCacheService sysCacheService,
|
ISysUserRoleService sysUserRoleService,
|
ISysRoleMenuService sysRoleMenuService)
|
{
|
_sysMenuRep = sysMenuRep;
|
_wmsPdaPower = wmsPdaPower;
|
_sysDictData = sysDictData;
|
_wmsRolePdaMenu = wmsRolePdaMenu;
|
_sysCacheService = sysCacheService;
|
_sysUserRoleService = sysUserRoleService;
|
_sysRoleMenuService = sysRoleMenuService;
|
}
|
|
/// <summary>
|
/// 获取用户权限(按钮权限标识集合)
|
/// </summary>
|
/// <param name="userId"></param>
|
/// <returns></returns>
|
[NonAction]
|
public async Task<List<string>> GetLoginPermissionList(long userId)
|
{
|
var permissions = await _sysCacheService.GetPermission(userId); // 先从缓存里面读取
|
if (permissions == null || permissions.Count < 1)
|
{
|
if (!CurrentUserInfo.IsSuperAdmin && userId != 0)
|
{
|
var roleIdList = await _sysUserRoleService.GetUserRoleIdList(userId);
|
var menuIdList = await _sysRoleMenuService.GetRoleMenuIdList(roleIdList);
|
permissions = await _sysMenuRep.DetachedEntities.Where(u => menuIdList.Contains(u.Id))
|
.Where(u => u.Type == MenuType.BTN)
|
.Where(u => u.Status == CommonStatus.ENABLE)
|
.Select(u => u.Permission).ToListAsync();
|
}
|
else
|
{
|
permissions = await _sysMenuRep.DetachedEntities
|
.Where(u => u.Type == MenuType.BTN)
|
.Where(u => u.Status == CommonStatus.ENABLE)
|
.Select(u => u.Permission).ToListAsync();
|
}
|
await _sysCacheService.SetPermission(userId, permissions); // 缓存结果
|
}
|
return permissions;
|
}
|
|
/// <summary>
|
/// 获取所有权限(按钮权限标识集合)
|
/// </summary>
|
/// <returns></returns>
|
[NonAction]
|
public async Task<List<string>> GetAllPermissionList()
|
{
|
return await GetLoginPermissionList(0);
|
}
|
|
/// <summary>
|
/// 获取用户AntDesign菜单集合
|
/// </summary>
|
/// <param name="userId"></param>
|
/// <param name="appCode"></param>
|
/// <returns></returns>
|
[NonAction]
|
public async Task<List<AntDesignTreeNode>> GetLoginMenusAntDesign(long userId, string appCode)
|
{
|
var antDesignTreeNodes = await _sysCacheService.GetMenu(userId, appCode); // 先从缓存里面读取
|
if (antDesignTreeNodes == null || antDesignTreeNodes.Count < 1)
|
{
|
var sysMenuList = new List<SysMenu>();
|
// 管理员则展示所有系统菜单
|
if (CurrentUserInfo.IsSuperAdmin)
|
{
|
sysMenuList = await _sysMenuRep.DetachedEntities
|
.Where(u => u.Status == CommonStatus.ENABLE)
|
.Where(u => u.Application == appCode)
|
.Where(u => u.Type != MenuType.BTN)
|
//.Where(u => u.Weight != (int)MenuWeight.DEFAULT_WEIGHT)
|
.OrderBy(u => u.Sort).ThenBy(u => u.Id).ToListAsync();
|
}
|
else
|
{
|
// 非管理员则获取自己角色所拥有的菜单集合
|
var roleIdList = await _sysUserRoleService.GetUserRoleIdList(userId);
|
var menuIdList = await _sysRoleMenuService.GetRoleMenuIdList(roleIdList);
|
sysMenuList = await _sysMenuRep.DetachedEntities
|
.Where(u => menuIdList.Contains(u.Id))
|
.Where(u => u.Status == CommonStatus.ENABLE)
|
.Where(u => u.Application == appCode)
|
.Where(u => u.Type != MenuType.BTN)
|
.OrderBy(u => u.Sort).ThenBy(u => u.Id).ToListAsync();
|
}
|
// 转换成登录菜单
|
antDesignTreeNodes = sysMenuList.Select(u => new AntDesignTreeNode
|
{
|
Id = u.Id,
|
Pid = u.Pid,
|
Path = u.OpenType == MenuOpenType.OUTER ? u.Link : u.Router,
|
Name = u.Code,
|
Component = u.Component,
|
Redirect = u.OpenType == MenuOpenType.OUTER ? u.Link : u.Redirect,
|
Meta = new Meta
|
{
|
Title = u.Name,
|
Icon = u.Icon,
|
Show = u.Visible == YesOrNot.Y.ToString(),
|
Link = u.Link,
|
Target = u.OpenType == MenuOpenType.OUTER ? "_blank" : ""
|
}
|
}).ToList();
|
await _sysCacheService.SetMenu(userId, appCode, antDesignTreeNodes); // 缓存结果
|
}
|
return antDesignTreeNodes;
|
}
|
|
/// <summary>
|
/// 获取用户菜单所属的应用编码集合
|
/// </summary>
|
/// <param name="userId"></param>
|
/// <returns></returns>
|
[NonAction]
|
public async Task<List<string>> GetUserMenuAppCodeList(long userId)
|
{
|
var roleIdList = await _sysUserRoleService.GetUserRoleIdList(userId);
|
var menuIdList = await _sysRoleMenuService.GetRoleMenuIdList(roleIdList);
|
return await _sysMenuRep.DetachedEntities.Where(u => menuIdList.Contains(u.Id))
|
.Where(u => u.Status == CommonStatus.ENABLE)
|
.Select(u => u.Application).ToListAsync();
|
}
|
|
/// <summary>
|
/// 系统菜单列表（树表）
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysMenu/list")]
|
public async Task<dynamic> GetMenuList([FromQuery] GetMenuListInput input)
|
{
|
var application = !string.IsNullOrEmpty(input.Application?.Trim());
|
var name = !string.IsNullOrEmpty(input.Name?.Trim());
|
var menus = await _sysMenuRep.DetachedEntities.Where((application, u => u.Application == input.Application.Trim()),
|
(name, u => EF.Functions.Like(u.Name, $"%{input.Name.Trim()}%")))
|
.Where(u => u.Status == CommonStatus.ENABLE).OrderBy(u => u.Sort)
|
.ProjectToType<MenuOutput>()
|
.ToListAsync();
|
return new TreeBuildUtil<MenuOutput>().Build(menus);
|
}
|
|
/// <summary>
|
/// 系统菜单列表（树表）
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysMenu/listpda")]
|
public async Task<List<wmsPdaPowerMenuOutput>> GetMenuListPda([FromQuery] QueryRoleInput input)
|
{
|
var wmsPdaPowerList = await _wmsPdaPower.DetachedEntities.Where(u => 1 == 1).ProjectToType<WmsPdaPowerOutput>().ToListAsync();
|
var dicDataList = await _sysDictData.Where(p => p.TypeId == 383290718294085).ToListAsync();
|
var wmsRolePdaMenuList = await _wmsRolePdaMenu.DetachedEntities.Where(p => p.SysRoleId == input.Id).ToListAsync();
|
|
|
foreach (var item in wmsRolePdaMenuList)
|
{
|
var model = wmsPdaPowerList.Where(p => p.Id == item.PdaMenuId).FirstOrDefault();
|
if (model != null)
|
{
|
wmsPdaPowerList.Where(p => p.Id == item.PdaMenuId).FirstOrDefault().IsCheck = true;
|
}
|
}
|
var listData = new List<wmsPdaPowerMenuOutput>();
|
foreach (var item in dicDataList)
|
{
|
var enumValue = LesWorkShopType.FAPAOCHEJIAN;
|
if (item.Code == "1") enumValue = LesWorkShopType.FAPAOCHEJIAN;
|
else if(item.Code=="2") enumValue = LesWorkShopType.JIAOHEBANCHEJIAN;
|
else if (item.Code == "3") enumValue = LesWorkShopType.JHBCJ;
|
else if (item.Code == "4") enumValue = LesWorkShopType.RSBCJ;
|
else if (item.Code == "5") enumValue = LesWorkShopType.YLKCJ;
|
else enumValue = LesWorkShopType.TY;
|
listData.Add(new wmsPdaPowerMenuOutput()
|
{
|
WorkShopName = item.Value,
|
WmsPdaPowerOutput = wmsPdaPowerList.Where(n => n.WorkShopType == enumValue).ToList()
|
});
|
}
|
return listData;
|
}
|
|
/// <summary>
|
/// 创建Pids格式
|
/// 如果pid是0顶级节点，pids就是 [0];
|
/// 如果pid不是顶级节点，pids就是 pid菜单的 pids + [pid] + ,
|
/// </summary>
|
/// <param name="pid"></param>
|
/// <returns></returns>
|
private async Task<string> CreateNewPids(long pid)
|
{
|
if (pid == 0L)
|
{
|
return "[0],";
|
}
|
else
|
{
|
var pmenu = await _sysMenuRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == pid);
|
return pmenu.Pids + "[" + pid + "],";
|
}
|
}
|
|
/// <summary>
|
/// 增加和编辑时检查参数
|
/// </summary>
|
/// <param name="input"></param>
|
private static void CheckMenuParam(MenuInput input)
|
{
|
var type = input.Type;
|
var router = input.Router;
|
var permission = input.Permission;
|
var openType = input.OpenType;
|
|
if (type.Equals((int)MenuType.DIR))
|
{
|
if (string.IsNullOrEmpty(router))
|
throw Oops.Oh(ErrorCode.D4001);
|
}
|
else if (type.Equals((int)MenuType.MENU))
|
{
|
if (string.IsNullOrEmpty(router))
|
throw Oops.Oh(ErrorCode.D4001);
|
if (string.IsNullOrEmpty(openType.ToString()))
|
throw Oops.Oh(ErrorCode.D4002);
|
}
|
else if (type.Equals((int)MenuType.BTN))
|
{
|
if (string.IsNullOrEmpty(permission))
|
throw Oops.Oh(ErrorCode.D4003);
|
if (!permission.Contains(":"))
|
throw Oops.Oh(ErrorCode.D4004);
|
// 判断该资源是否存在
|
//permission = ":" + permission;
|
//var urlSet = resourceCache.getAllResources();
|
//if (!urlSet.Contains(permission.Replace(":","/")))
|
// throw Oops.Oh(ErrorCode.meu1005);
|
}
|
}
|
|
/// <summary>
|
/// 增加系统菜单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysMenu/add")]
|
public async Task AddMenu(AddMenuInput input)
|
{
|
var isExist = await _sysMenuRep.DetachedEntities.AnyAsync(u => u.Code == input.Code); // u.Name == input.Name
|
if (isExist)
|
throw Oops.Oh(ErrorCode.D4000);
|
|
// 校验参数
|
CheckMenuParam(input.Adapt<MenuInput>());
|
|
var menu = input.Adapt<SysMenu>();
|
menu.Pids = await CreateNewPids(input.Pid);
|
menu.Status = CommonStatus.ENABLE;
|
await menu.InsertAsync();
|
|
// 清除缓存
|
await _sysCacheService.DelByPatternAsync(CommonConst.CACHE_KEY_MENU);
|
await _sysCacheService.DelByPatternAsync(CommonConst.CACHE_KEY_PERMISSION);
|
}
|
|
/// <summary>
|
/// 删除系统菜单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysMenu/delete")]
|
[UnitOfWork]
|
public async Task DeleteMenu(DeleteMenuInput input)
|
{
|
var childIdList = await _sysMenuRep.DetachedEntities.Where(u => u.Pids.Contains(input.Id.ToString()))
|
.Select(u => u.Id).ToListAsync();
|
childIdList.Add(input.Id);
|
|
var menus = await _sysMenuRep.Where(u => childIdList.Contains(u.Id)).ToListAsync();
|
await _sysMenuRep.DeleteAsync(menus);
|
|
// 级联删除该菜单及子菜单对应的角色-菜单表信息
|
await _sysRoleMenuService.DeleteRoleMenuListByMenuIdList(childIdList);
|
|
// 清除缓存
|
await _sysCacheService.DelByPatternAsync(CommonConst.CACHE_KEY_MENU);
|
await _sysCacheService.DelByPatternAsync(CommonConst.CACHE_KEY_PERMISSION);
|
}
|
|
/// <summary>
|
/// 更新系统菜单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysMenu/edit"),]
|
public async Task UpdateMenu(UpdateMenuInput input)
|
{
|
// Pid和Id不能一致，一致会导致无限递归
|
if (input.Id == input.Pid)
|
throw Oops.Oh(ErrorCode.D4006);
|
|
var isExist = await _sysMenuRep.DetachedEntities.AnyAsync(u => u.Code == input.Code && u.Id != input.Id); // u.Name == input.Name
|
if (isExist)
|
throw Oops.Oh(ErrorCode.D4000);
|
|
// 校验参数
|
CheckMenuParam(input.Adapt<MenuInput>());
|
// 如果是编辑，父id不能为自己的子节点
|
var childIdList = await _sysMenuRep.DetachedEntities.Where(u => u.Pids.Contains(input.Id.ToString()))
|
.Select(u => u.Id).ToListAsync();
|
if (childIdList.Contains(input.Pid))
|
throw Oops.Oh(ErrorCode.D4006);
|
|
var oldMenu = await _sysMenuRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == input.Id);
|
|
// 生成新的pids
|
var newPids = await CreateNewPids(input.Pid);
|
|
// 是否更新子应用的标识
|
var updateSubAppsFlag = false;
|
// 是否更新子节点的pids的标识
|
var updateSubPidsFlag = false;
|
|
// 如果应用有变化
|
if (input.Application != oldMenu.Application)
|
{
|
// 父节点不是根节点不能移动应用
|
if (oldMenu.Pid != 0L)
|
throw Oops.Oh(ErrorCode.D4007);
|
updateSubAppsFlag = true;
|
}
|
// 父节点有变化
|
if (input.Pid != oldMenu.Pid)
|
updateSubPidsFlag = true;
|
|
// 开始更新所有子节点的配置
|
if (updateSubAppsFlag || updateSubPidsFlag)
|
{
|
// 查找所有叶子节点，包含子节点的子节点
|
var menuList = await _sysMenuRep.Where(u => EF.Functions.Like(u.Pids, $"%{oldMenu.Id}%")).ToListAsync();
|
// 更新所有子节点的应用为当前菜单的应用
|
if (menuList.Count > 0)
|
{
|
// 更新所有子节点的application
|
if (updateSubAppsFlag)
|
{
|
menuList.ForEach(u =>
|
{
|
u.Application = input.Application;
|
});
|
}
|
|
// 更新所有子节点的pids
|
if (updateSubPidsFlag)
|
{
|
menuList.ForEach(u =>
|
{
|
//ly-0415 原代码
|
// 子节点pids组成 = 当前菜单新pids + 当前菜单id + 子节点自己的pids后缀
|
//var oldParentCodesPrefix = oldMenu.Pids + "[" + oldMenu.Id + "],";
|
//var oldParentCodesSuffix = u.Pids[oldParentCodesPrefix.Length..];
|
//var menuParentCodes = newPids + "[" + oldMenu.Id + "]," + oldParentCodesSuffix;
|
|
//ly-0415 改后代码
|
// 子节点pids组成 = 当前菜单新pids + 当前菜单id + 子节点自己的pids后缀
|
var oldParentCodesPrefix = oldMenu.Pids + "[" + oldMenu.Id + "],";
|
// var oldParentCodesSuffix = u.Pids[oldParentCodesPrefix.Length..];
|
var menuParentCodes = newPids + "[" + oldMenu.Id + "],";
|
|
u.Pids = menuParentCodes;
|
});
|
}
|
}
|
}
|
|
// 更新当前菜单
|
oldMenu = input.Adapt<SysMenu>();
|
oldMenu.Pids = newPids;
|
await oldMenu.UpdateAsync(ignoreNullValues: true);
|
|
// 清除缓存
|
await _sysCacheService.DelByPatternAsync(CommonConst.CACHE_KEY_MENU);
|
await _sysCacheService.DelByPatternAsync(CommonConst.CACHE_KEY_PERMISSION);
|
}
|
|
/// <summary>
|
/// 获取系统菜单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysMenu/detail")]
|
public async Task<dynamic> GetMenu(QueryMenuInput input)
|
{
|
return await _sysMenuRep.DetachedEntities.FirstOrDefaultAsync(u => u.Id == input.Id);
|
}
|
|
/// <summary>
|
/// 获取系统菜单树，用于新增、编辑时选择上级节点
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysMenu/tree")]
|
public async Task<dynamic> GetMenuTree([FromQuery] GetMenuTreeInput input)
|
{
|
var application = !string.IsNullOrEmpty(input.Application?.Trim());
|
var menus = await _sysMenuRep.DetachedEntities
|
.Where(application, u => u.Application == input.Application.Trim())
|
.Where(u => u.Status == CommonStatus.ENABLE)
|
.Where(u => u.Type == MenuType.DIR || u.Type == MenuType.MENU)
|
.OrderBy(u => u.Sort)
|
.Select(u => new MenuTreeOutput
|
{
|
Id = u.Id,
|
ParentId = u.Pid,
|
IntValue = u.Id,
|
Title = u.Name,
|
Weight = u.Weight
|
}).ToListAsync();
|
return new TreeBuildUtil<MenuTreeOutput>().Build(menus);
|
}
|
|
/// <summary>
|
/// 获取系统菜单树，用于给角色授权时选择
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpGet("sysMenu/treeForGrant")]
|
public async Task<dynamic> TreeForGrant([FromQuery] TreeForGrantInput input)
|
{
|
var menuIdList = new List<long>();
|
if (!CurrentUserInfo.IsSuperAdmin)
|
{
|
var roleIdList = await _sysUserRoleService.GetUserRoleIdList(CurrentUserInfo.UserId);
|
menuIdList = await _sysRoleMenuService.GetRoleMenuIdList(roleIdList);
|
}
|
|
var application = !string.IsNullOrEmpty(input.Application?.Trim());
|
var menus = await _sysMenuRep.DetachedEntities
|
.Where(application, u => u.Application == input.Application.Trim())
|
.Where(u => u.Status == CommonStatus.ENABLE)
|
.Where(menuIdList.Count > 0, u => menuIdList.Contains(u.Id))
|
.OrderBy(u => u.Sort).Select(u => new MenuTreeOutput
|
{
|
Id = u.Id,
|
ParentId = u.Pid,
|
IntValue = u.Id,
|
Title = u.Name,
|
Weight = u.Weight
|
}).ToListAsync();
|
return new TreeBuildUtil<MenuTreeOutput>().Build(menus);
|
}
|
|
/// <summary>
|
/// 根据应用编码判断该机构下是否有状态为正常的菜单
|
/// </summary>
|
/// <param name="appCode"></param>
|
/// <returns></returns>
|
[NonAction]
|
public async Task<bool> HasMenu(string appCode)
|
{
|
return await _sysMenuRep.DetachedEntities.AnyAsync(u => u.Application == appCode && u.Status != CommonStatus.DELETED);
|
}
|
|
/// <summary>
|
/// 根据系统应用切换菜单
|
/// </summary>
|
/// <param name="input"></param>
|
/// <returns></returns>
|
[HttpPost("sysMenu/change")]
|
public async Task<List<AntDesignTreeNode>> ChangeAppMenu(ChangeAppMenuInput input)
|
{
|
return await GetLoginMenusAntDesign(CurrentUserInfo.UserId, input.Application);
|
}
|
}
|
}
|
