307 lines
10 KiB
C#
307 lines
10 KiB
C#
using Dlhis.Entity.Sys.Entities;
|
|
using Dlhis.Entity.Sys.Enums;
|
|
using Dlhis.Sys.Identity.Services;
|
|
using Dlhis.Sys.Menu.Request;
|
|
using Dlhis.Sys.Menu.Response;
|
|
using Kurisu.AspNetCore.Authentication.Abstractions;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
using Mapster;
|
|
|
|
namespace Dlhis.Sys.Menu.Services.Implements;
|
|
|
|
public class MenuService : IMenuService
|
|
{
|
|
private readonly IDbContext _dbContext;
|
|
private readonly ICurrentUser _currentUser;
|
|
private readonly IUserService _userService;
|
|
|
|
public MenuService(IDbContext dbContext, ICurrentUser currentUser, IUserService userService)
|
|
{
|
|
_dbContext = dbContext;
|
|
_currentUser = currentUser;
|
|
_userService = userService;
|
|
}
|
|
|
|
public async Task<List<MenuResponse>> GetListAsync(PlatformEnumType platform)
|
|
{
|
|
var result = await _dbContext.Queryable<MenuEntity>()
|
|
.Where(x => x.Platform == platform)
|
|
.OrderBy(x => x.Sequence)
|
|
.Select<MenuResponse>()
|
|
.ToListAsync();
|
|
|
|
var top = result.Where(x => x.PCode.IsEmpty()).ToList();
|
|
foreach (var menu in top)
|
|
{
|
|
RecursionGetNext(menu, result);
|
|
}
|
|
|
|
return top;
|
|
}
|
|
|
|
|
|
public async Task<string> SaveMenuAsync(SaveMenuRequest request)
|
|
{
|
|
await CheckAsync(request);
|
|
|
|
if (!request.Id.HasValue)
|
|
{
|
|
var entity = request.Adapt<MenuEntity>();
|
|
await _dbContext.InsertAsync(entity);
|
|
return entity.Code;
|
|
}
|
|
else
|
|
{
|
|
var entity = await _dbContext.Queryable<MenuEntity>().Where(x => x.Id == request.Id).FirstAsync();
|
|
await ChangeIfCodeEditAsync(entity.Code, request.Code);
|
|
|
|
request.Adapt(entity);
|
|
|
|
await _dbContext.UpdateAsync(entity);
|
|
return entity.Code;
|
|
}
|
|
}
|
|
|
|
public async Task AssignmentAsync(MenuPermissionAssignmentRequest request)
|
|
{
|
|
//清空覆盖
|
|
var permissionsToDelete = await _dbContext.Queryable<MenuPermissionEntity>()
|
|
.Where(x => x.UniqueType == request.UniqueType)
|
|
.Where(x => x.UniqueValue == request.UniqueValue)
|
|
.ToListAsync();
|
|
|
|
await _dbContext.DeleteAsync(permissionsToDelete);
|
|
|
|
var permissions = request.Codes.Distinct().Select(x => new MenuPermissionEntity
|
|
{
|
|
Code = x,
|
|
UniqueType = request.UniqueType,
|
|
UniqueValue = request.UniqueValue
|
|
}).ToList();
|
|
|
|
await _dbContext.InsertAsync(permissions);
|
|
}
|
|
|
|
public async Task<List<string>> GetAssignmentCodesAsync(AssignTypeEnumType uniqueType, string uniqueData)
|
|
{
|
|
var permissionCodes = await _dbContext.Queryable<MenuPermissionEntity>()
|
|
.Where(x => x.UniqueType == uniqueType)
|
|
.Where(x => x.UniqueValue == uniqueData)
|
|
.Select(x => x.Code)
|
|
.ToListAsync();
|
|
|
|
// var menus = await GetListAsync(PlatformEnumType.PCAdmin);
|
|
//
|
|
// foreach (var menu in menus)
|
|
// {
|
|
// RecursionHandler(menu, permissionCodes, permissionCodes.Contains(menu.Code));
|
|
// }
|
|
|
|
return permissionCodes;
|
|
|
|
// static bool RecursionHandler(MenuResponse current, List<string> innerPermissions, bool add)
|
|
// {
|
|
// if (add) innerPermissions.Add(current.Code);
|
|
//
|
|
// foreach (var menu in current.Items)
|
|
// {
|
|
// var currentAdd = RecursionHandler(menu, innerPermissions, add || innerPermissions.Contains(menu.Code));
|
|
// if (currentAdd && !innerPermissions.Contains(current.Code))
|
|
// {
|
|
// innerPermissions.Add(current.Code);
|
|
// }
|
|
// }
|
|
//
|
|
// return add;
|
|
// }
|
|
}
|
|
|
|
public async Task<List<string>> GetAllAssignmentPermissionsAsync()
|
|
{
|
|
var menus = await GetCurrentMenusAsync();
|
|
return GetPermissions(menus).ToList();
|
|
|
|
IEnumerable<string> GetPermissions(List<MenuResponse> innerMenuResponses)
|
|
{
|
|
foreach (var item in innerMenuResponses)
|
|
{
|
|
yield return item.Permission;
|
|
|
|
foreach (var item1 in GetPermissions(item.Items))
|
|
{
|
|
yield return item1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public async Task<List<MenuResponse>> GetCurrentMenusAsync()
|
|
{
|
|
//我能看到的权限code,非permissions
|
|
var allCodes = await GetAllAssignmentCodesAsync();
|
|
if (!allCodes.Any())
|
|
{
|
|
//todo 管理员
|
|
if (_currentUser.GetIntSubjectId() == 1)
|
|
{
|
|
return await GetListAsync(PlatformEnumType.PCAdmin);
|
|
}
|
|
|
|
return new List<MenuResponse>();
|
|
}
|
|
|
|
var allMenus = await _dbContext.Queryable<MenuEntity>()
|
|
.Where(x => x.Platform == PlatformEnumType.PCAdmin)
|
|
.Where(x => x.Visible)
|
|
.Where(x => allCodes.Contains(x.Code))
|
|
.Select<MenuResponse>()
|
|
.ToListAsync();
|
|
|
|
//获取顶级数据
|
|
var menus = await _dbContext.Queryable<MenuEntity>()
|
|
.Where(x => x.Platform == PlatformEnumType.PCAdmin)
|
|
.Where(x => x.Visible)
|
|
.Where(x => string.IsNullOrEmpty(x.PCode))
|
|
.Select<MenuResponse>()
|
|
.ToListAsync();
|
|
|
|
foreach (var menu in menus)
|
|
{
|
|
RecursionGetNext(menu, allMenus);
|
|
}
|
|
|
|
menus.RemoveAll(x => !x.Items.Any());
|
|
return menus;
|
|
}
|
|
|
|
public async Task<bool> IsPass(IEnumerable<string> p)
|
|
{
|
|
var permissions = await GetAllAssignmentPermissionsAsync();
|
|
return permissions.Count == 0 || permissions.All(x => p.Contains(x));
|
|
}
|
|
|
|
public async Task ResetAsync(List<SaveMenuRequest> request)
|
|
{
|
|
var currentMenus = await _dbContext.Queryable<MenuEntity>().Where(x => x.Platform == PlatformEnumType.PCAdmin).ToListAsync();
|
|
await _dbContext.Client.Deleteable(currentMenus).ExecuteCommandAsync();
|
|
|
|
foreach (var item in request)
|
|
{
|
|
item.Sequence = currentMenus.FirstOrDefault(x => x.Code == item.Code)?.Sequence ?? item.Sequence;
|
|
var code = await SaveMenuAsync(item);
|
|
if (item.Items?.Any() == true)
|
|
{
|
|
item.Items.ForEach(x => x.PCode = code);
|
|
await RecursionSaveNextAsync(item.Items);
|
|
}
|
|
}
|
|
|
|
//递归处理下一级
|
|
async Task RecursionSaveNextAsync(List<SaveMenuRequest> menus)
|
|
{
|
|
foreach (var item in menus)
|
|
{
|
|
item.Sequence = currentMenus.FirstOrDefault(x => x.Code == item.Code)?.Sequence ?? item.Sequence;
|
|
var code = await SaveMenuAsync(item);
|
|
|
|
if (item.Items?.Any() == true)
|
|
{
|
|
item.Items.ForEach(x => x.PCode = code);
|
|
await RecursionSaveNextAsync(item.Items);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//****************************************************************** help methods ******************************************************************************
|
|
|
|
|
|
private static void RecursionGetNext(MenuResponse current, List<MenuResponse> menus)
|
|
{
|
|
var nextMenus = menus.Where(x => x.PCode == current.Code).ToList();
|
|
current.Items = nextMenus;
|
|
foreach (var menu in nextMenus)
|
|
{
|
|
RecursionGetNext(menu, menus);
|
|
}
|
|
}
|
|
|
|
private async Task CheckAsync(SaveMenuRequest request)
|
|
{
|
|
//检查重复code
|
|
(await _dbContext.Queryable<MenuEntity>()
|
|
.Where(x => x.Code == request.Code)
|
|
.WhereIF(request.Id.HasValue, x => x.Id != request.Id).AnyAsync())
|
|
.ThrowIfTrue($"{request.Title}存在重复code");
|
|
|
|
//检查name
|
|
(await _dbContext.Queryable<MenuEntity>()
|
|
.Where(x => x.Name == request.Name)
|
|
.WhereIF(request.Id.HasValue, x => x.Id != request.Id).AnyAsync())
|
|
.ThrowIfTrue($"{request.Title}存在重复name");
|
|
|
|
|
|
//判断权限重复
|
|
if (request.Permission.IsPresent())
|
|
{
|
|
(await _dbContext.Queryable<MenuEntity>()
|
|
.Where(x => x.Permission == request.Permission && (request.MenuType == MenuEnumType.Menu || request.MenuType == MenuEnumType.Button))
|
|
.WhereIF(request.Id.HasValue, x => x.Id != request.Id)
|
|
.AnyAsync())
|
|
.ThrowIfTrue($"{request.Title}存在重复权限标识");
|
|
}
|
|
|
|
//request.PCode
|
|
var pMenu = await _dbContext.Queryable<MenuEntity>().Where(x => x.Code == request.PCode).SingleAsync();
|
|
if (request.MenuType == MenuEnumType.Folder)
|
|
{
|
|
//request.PCode = null;
|
|
if (string.IsNullOrEmpty(request.PCode))
|
|
{
|
|
request.PCode = null;
|
|
}
|
|
}
|
|
else if (request.MenuType == MenuEnumType.Menu)
|
|
{
|
|
pMenu.ThrowIfNull($"{request.Title}的上级菜单不存在");
|
|
(pMenu.MenuType != MenuEnumType.Folder).ThrowIfTrue($"{request.Title}菜单上级需要为目录");
|
|
}
|
|
else if (request.MenuType == MenuEnumType.Button)
|
|
{
|
|
pMenu.ThrowIfNull($"{request.Title}的上级菜单不存在");
|
|
(pMenu.MenuType != MenuEnumType.Menu).ThrowIfTrue($"{request.Title}按钮上级需要为菜单");
|
|
}
|
|
}
|
|
|
|
private async Task<List<string>> GetAllAssignmentCodesAsync()
|
|
{
|
|
var user = await _userService.GetUserByIdAsync(_currentUser.GetIntSubjectId());
|
|
|
|
//user
|
|
var userCodes = await GetAssignmentCodesAsync(AssignTypeEnumType.User, user.Id.ToString());
|
|
|
|
//role
|
|
var roleCodes = await GetAssignmentCodesAsync(AssignTypeEnumType.Role, user.RoleId.ToString());
|
|
|
|
return userCodes.Concat(roleCodes).Distinct().ToList();
|
|
}
|
|
|
|
|
|
private async Task ChangeIfCodeEditAsync(string beforeCode, string pCode)
|
|
{
|
|
if (beforeCode != pCode)
|
|
{
|
|
//修改下级的PCode为当前的code
|
|
var menus = await _dbContext.Queryable<MenuEntity>().Where(x => x.PCode == beforeCode).ToListAsync();
|
|
menus.ForEach(x => { x.PCode = pCode; });
|
|
|
|
//修改权限code为当前的code,避免权限丢失
|
|
var permissions = await _dbContext.Queryable<MenuPermissionEntity>().Where(x => x.Code == beforeCode).ToListAsync();
|
|
permissions.ForEach(x => { x.Code = pCode; });
|
|
|
|
await _dbContext.UpdateAsync(menus);
|
|
await _dbContext.UpdateAsync(permissions);
|
|
}
|
|
}
|
|
} |