添加项目文件。

This commit is contained in:
fuenmao
2025-09-29 13:48:36 +08:00
parent f61e922f0c
commit 5dc1780ef1
407 changed files with 63703 additions and 0 deletions
@@ -0,0 +1,190 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// <inheritdoc cref="IButtonService"/>
/// </summary>
public class ButtonService : DbRepository<SysResource>, IButtonService
{
private readonly ILogger<ButtonService> _logger;
private readonly IResourceService _resourceService;
private readonly IRelationService _relationService;
public ButtonService(ILogger<ButtonService> logger, IResourceService resourceService, IRelationService relationService)
{
_logger = logger;
_resourceService = resourceService;
_relationService = relationService;
}
/// <inheritdoc/>
public async Task<SqlSugarPagedList<SysResource>> Page(ButtonPageInput input)
{
var query = Context.Queryable<SysResource>().Where(it => it.ParentId == input.ParentId && it.Category == CateGoryConst.RESOURCE_BUTTON)
.WhereIF(!string.IsNullOrEmpty(input.SearchKey), it => it.Title.Contains(input.SearchKey) || it.Path.Contains(input.SearchKey))//根据关键字查询
.OrderByIF(!string.IsNullOrEmpty(input.SortField), $"{input.SortField} {input.SortOrder}").OrderBy(it => it.SortCode);//排序
var pageInfo = await query.ToPagedListAsync(input.PageNum, input.PageSize);//分页
return pageInfo;
}
/// <inheritdoc />
public async Task Add(ButtonAddInput input)
{
await CheckInput(input);//检查参数
var sysResource = input.Adapt<SysResource>();//实体转换
if (await InsertAsync(sysResource))//插入数据
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_BUTTON);//刷新缓存
}
/// <inheritdoc />
public async Task<List<long>> AddBatch(ButtonAddInput input)
{
var sysResources = new List<SysResource>();//按钮列表
var codeList = new List<string> { "Add", "Edit", "Delete", "BatchDelete", "Import", "Export", "BatchEdit" };//code后缀
var titleList = new List<string> { "新增", "编辑", "删除", "批量删除", "导入", "导出", "批量编辑" };//title前缀
var idList = new List<long>();//Id列表
for (var i = 0; i < codeList.Count; i++)
{
var id = CommonUtils.GetSingleId();
sysResources.Add(new SysResource
{
Id = id,
Title = titleList[i] + input.Title,//标题等于前缀输入的值
Code = input.Code + codeList[i],//code等于输入的值加后缀
ParentId = input.ParentId,
SortCode = i + 1
});
idList.Add(id);
}
//遍历列表
foreach (var sysResource in sysResources)
{
await CheckInput(sysResource);//检查按钮参数
}
//添加到数据库
if (await InsertRangeAsync(sysResources))//插入数据
{
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_BUTTON);//刷新缓存
return sysResources.Select(it => it.Id).ToList();
}
return new List<long>();
}
/// <inheritdoc />
public async Task Edit(ButtonEditInput input)
{
await CheckInput(input);//检查参数
var sysResource = input.Adapt<SysResource>();//实体转换
//事务
var result = await Tenant.UseTranAsync(async () =>
{
await UpdateAsync(sysResource);//更新按钮
});
if (result.IsSuccess)//如果成功了
{
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_BUTTON);//资源表按钮刷新缓存
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0002);
}
}
/// <inheritdoc />
public async Task Delete(BaseIdListInput input)
{
//获取所有ID
var ids = input.Ids;
//获取所有按钮集合
var buttonList = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_BUTTON);
#region 处理关系表角色资源信息
//获取所有菜单集合
var menuList = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_MENU);
//获取按钮的父菜单id集合
var parentIds = buttonList.Where(it => ids.Contains(it.Id)).Select(it => it.ParentId.Value.ToString()).ToList();
//获取关系表分类为SYS_ROLE_HAS_RESOURCE数据
var roleResources = await _relationService.GetRelationByCategory(CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE);
//获取相关关系表数据
var relationList = roleResources.Where(it => parentIds.Contains(it.TargetId))//目标ID是父ID中
.Where(it => it.ExtJson != null).ToList();//扩展信息不为空
//遍历关系表
relationList.ForEach(it =>
{
var relationRoleResuorce = it.ExtJson.ToJsonEntity<RelationRoleResource>();//拓展信息转实体
var buttonInfo = relationRoleResuorce.ButtonInfo;//获取按钮信息
if (buttonInfo.Count > 0)
{
// 使用 LINQ 查询找出交集的补集(即不同元素)
var diffArr = buttonInfo.Except(ids).Union(ids.Except(buttonInfo)).ToList();
relationRoleResuorce.ButtonInfo = diffArr;//重新赋值按钮信息
it.ExtJson = relationRoleResuorce.ToJson();//重新赋值拓展信息
}
});
#endregion 处理关系表角色资源信息
//事务
var result = await Tenant.UseTranAsync(async () =>
{
await DeleteByIdsAsync(ids.Cast<object>().ToArray());//删除按钮
if (relationList.Count > 0)
{
await Context.Updateable(relationList).UpdateColumns(it => it.ExtJson).ExecuteCommandAsync();//修改拓展信息
}
});
if (result.IsSuccess)//如果成功了
{
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_BUTTON);//资源表按钮刷新缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE);//关系表刷新角色资源缓存
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0002);
}
}
/// <inheritdoc />
public async Task<SysResource> Detail(BaseIdInput input)
{
var sysResources = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_BUTTON);
var resource = sysResources.Where(it => it.Id == input.Id).FirstOrDefault();
return resource;
}
#region 方法
/// <summary>
/// 检查输入参数
/// </summary>
/// <param name="sysResource"></param>
private async Task CheckInput(SysResource sysResource)
{
//获取所有按钮和菜单
var buttonList = await _resourceService.GetListAsync(new List<string> { CateGoryConst.RESOURCE_BUTTON, CateGoryConst.RESOURCE_MENU });
//判断code是否重复
if (buttonList.Any(it => it.Code == sysResource.Code && it.Id != sysResource.Id))
throw Oops.Bah($"存在重复的按钮编码:{sysResource.Code}");
//判断菜单是否存在
if (!buttonList.Any(it => it.Id == sysResource.ParentId))
throw Oops.Bah($"不存在的父级菜单:{sysResource.ParentId}");
sysResource.Category = CateGoryConst.RESOURCE_BUTTON;//设置分类为按钮
}
#endregion 方法
}
@@ -0,0 +1,53 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
public class ButtonPageInput : BasePageInput
{
/// <summary>
/// 父ID
/// </summary>
[Required(ErrorMessage = "ParentId不能为空")]
public long? ParentId { get; set; }
}
/// <summary>
/// 添加按钮参数
/// </summary>
public class ButtonAddInput : SysResource
{
/// <summary>
/// 父ID
/// </summary>
[Required(ErrorMessage = "ParentId不能为空")]
public override long? ParentId { get; set; }
/// <summary>
/// 标题
/// </summary>
[Required(ErrorMessage = "Title不能为空")]
public override string Title { get; set; }
/// <summary>
/// 编码
/// </summary>
[Required(ErrorMessage = "Code不能为空")]
public override string Code { get; set; }
}
public class ButtonEditInput : ButtonAddInput
{
/// <summary>
/// ID
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public override long Id { get; set; }
}
@@ -0,0 +1,59 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 权限按钮服务
/// </summary>
public interface IButtonService : ITransient
{
/// <summary>
/// 添加按钮
/// </summary>
/// <param name="input">添加参数</param>
/// <returns></returns>
Task Add(ButtonAddInput input);
/// <summary>
/// 批量添加
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<List<long>> AddBatch(ButtonAddInput input);
/// <summary>
/// 删除按钮
/// </summary>
/// <param name="input">删除参数</param>
/// <returns></returns>
Task Delete(BaseIdListInput input);
/// <summary>
/// 编辑按钮
/// </summary>
/// <param name="input">编辑参数</param>
/// <returns></returns>
Task Edit(ButtonEditInput input);
/// <summary>
/// 按钮分页查询
/// </summary>
/// <param name="input">查询条件</param>
/// <returns>按钮分页列表</returns>
Task<SqlSugarPagedList<SysResource>> Page(ButtonPageInput input);
/// <summary>
/// 按钮详情
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<SysResource> Detail(BaseIdInput input);
}
@@ -0,0 +1,127 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 菜单树查询参数
/// </summary>
public class MenuTreeInput
{
/// <summary>
/// 模块
/// </summary>
public long? Module { get; set; }
/// <summary>
/// 关键字
/// </summary>
public string SearchKey { get; set; }
}
/// <summary>
/// 添加菜单参数
/// </summary>
public class MenuAddInput : SysResource, IValidatableObject
{
/// <summary>
/// 父ID
/// </summary>
[Required(ErrorMessage = "ParentId不能为空")]
public override long? ParentId { get; set; }
/// <summary>
/// 标题
/// </summary>
[Required(ErrorMessage = "Title不能为空")]
public override string Title { get; set; }
/// <summary>
/// 菜单类型
/// </summary>
public override string MenuType { get; set; } = SysResourceConst.MENU;
/// <summary>
/// 模块
/// </summary>
[Required(ErrorMessage = "Module不能为空")]
public override long? Module { get; set; }
/// <summary>
/// 路径
/// </summary>
[Required(ErrorMessage = "Path不能为空")]
public override string Path { get; set; }
/// <summary>
/// 图标
/// </summary>
[Required(ErrorMessage = "Icon不能为空")]
public override string Icon { get; set; }
/// <summary>
/// 特殊验证
/// </summary>
/// <param name="validationContext"></param>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
//如果菜单类型是菜单
if (MenuType is SysResourceConst.MENU or SysResourceConst.SUBSET or SysResourceConst.LINK)
{
if (string.IsNullOrEmpty(Name))
yield return new ValidationResult("Name不能为空", new[] { nameof(Name) });
if (string.IsNullOrEmpty(Component))
yield return new ValidationResult("Component不能为空", new[] { nameof(Name) });
if (MenuType is SysResourceConst.SUBSET)//如果是子集
{
if (string.IsNullOrEmpty(ActiveMenu))
yield return new ValidationResult("ActiveMenu不能为空", new[] { nameof(Name) });
IsHome = false;
IsHide = true;
IsFull = false;
IsAffix = false;
IsKeepAlive = true;
}
}
else
{
Name = null;//设置name为空
Component = null;//设置组件为空
}
//设置分类为菜单
Category = CateGoryConst.RESOURCE_MENU;
}
}
/// <summary>
/// 编辑菜单输入参数
/// </summary>
public class MenuEditInput : MenuAddInput
{
/// <summary>
/// ID
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public override long Id { get; set; }
}
/// <summary>
/// 改变模块输入参数
/// </summary>
public class MenuChangeModuleInput : BaseIdInput
{
/// <summary>
/// 模块ID
/// </summary>
[Required(ErrorMessage = "Module不能为空")]
public long? Module { get; set; }
}
@@ -0,0 +1,75 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 菜单服务
/// </summary>
public interface IMenuService : ITransient
{
/// <summary>
/// 添加菜单
/// </summary>
/// <param name="input">添加参数</param>
/// <returns></returns>
Task Add(MenuAddInput input);
/// <summary>
/// 详情
/// </summary>
/// <param name="input">id</param>
/// <returns>详细信息</returns>
Task<SysResource> Detail(BaseIdInput input);
/// <summary>
/// 构建菜单树形结构
/// </summary>
/// <param name="resourceList">菜单列表</param>
/// <param name="parentId">父ID</param>
/// <returns>菜单形结构</returns>
List<SysResource> ConstructMenuTrees(List<SysResource> resourceList, long? parentId = 0);
/// <summary>
/// 获取菜单树
/// </summary>
/// <param name="input">菜单树查询参数</param>
/// <param name="showDisabled">是否显示禁用的</param>
/// <returns>菜单树列表</returns>
Task<List<SysResource>> Tree(MenuTreeInput input, bool showDisabled = true);
/// <summary>
/// 编辑菜单
/// </summary>
/// <param name="input">菜单编辑参数</param>
/// <returns></returns>
Task Edit(MenuEditInput input);
/// <summary>
/// 删除菜单
/// </summary>
/// <param name="input">删除菜单参数</param>
/// <returns></returns>
Task Delete(BaseIdListInput input);
/// <summary>
/// 改变菜单模块
/// </summary>
/// <param name="input">改变菜单模块参数</param>
/// <returns></returns>
Task ChangeModule(MenuChangeModuleInput input);
/// <summary>
/// 快捷方式菜单树
/// </summary>
/// <param name="sysResources">资源列表</param>
/// <returns></returns>
Task<List<SysResource>> ShortcutTree(List<SysResource> sysResources = null);
}
@@ -0,0 +1,264 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// <inheritdoc cref="IMenuService"/>
/// </summary>
public class MenuService : DbRepository<SysResource>, IMenuService
{
private readonly ILogger<MenuService> _logger;
private readonly IResourceService _resourceService;
private readonly IRelationService _relationService;
public MenuService(ILogger<MenuService> logger, IResourceService resourceService, IRelationService relationService)
{
_logger = logger;
_resourceService = resourceService;
_relationService = relationService;
}
/// <inheritdoc/>
public List<SysResource> ConstructMenuTrees(List<SysResource> resourceList, long? parentId = 0)
{
//找下级资源ID列表
var resources = resourceList.Where(it => it.ParentId == parentId).OrderBy(it => it.SortCode).ToList();
if (resources.Count > 0)//如果数量大于0
{
var data = new List<SysResource>();
foreach (var item in resources)//遍历资源
{
item.Children = ConstructMenuTrees(resourceList, item.Id);//添加子节点
data.Add(item);//添加到列表
}
return data;//返回结果
}
return new List<SysResource>();
}
/// <inheritdoc />
public async Task<List<SysResource>> Tree(MenuTreeInput input, bool showDisabled = true)
{
//获取所有菜单
var sysResources = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_MENU);
sysResources = sysResources.WhereIF(input.Module != null, it => it.Module.Value == input.Module.Value)//根据模块查找
.WhereIF(!showDisabled, it => it.Status == CommonStatusConst.ENABLE)//是否显示禁用的
.WhereIF(!string.IsNullOrEmpty(input.SearchKey), it => it.Title == input.SearchKey)//根据关键字查找
.ToList();
//构建菜单树
var tree = ConstructMenuTrees(sysResources);
return tree;
}
/// <inheritdoc />
public async Task<List<SysResource>> ShortcutTree(List<SysResource> sysResources = null)
{
if (sysResources == null)
//获取所有菜单
sysResources = (await _resourceService.GetAllModuleAndMenuAndSpaList())
.Where(it => it.Status == CommonStatusConst.ENABLE).ToList();
// //获取所有单页
// var sysSpas = (await _resourceService.GetConfigsByCategory(CateGoryConst.RESOURCE_SPA))
// .Where(it => it.Status == CommonStatusConst.ENABLE).ToList();
sysResources.ForEach(it =>
{
if (it.MenuType == SysResourceConst.CATALOG)
it.ParentId = it.Module.Value;//目录的父级ID设置为模块ID
});
//构建菜单树
var tree = ConstructMenuTrees(sysResources, null);
//将单页的排前面根据排序码排序
tree = tree.OrderByDescending(it => it.Category == CateGoryConst.RESOURCE_SPA).ThenBy(it => it.SortCode).ToList();
return tree;
}
/// <inheritdoc />
public async Task Add(MenuAddInput input)
{
await CheckInput(input);//检查参数
var sysResource = input.Adapt<SysResource>();//实体转换
if (await InsertAsync(sysResource))//插入数据
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_MENU);//刷新菜单缓存
}
/// <inheritdoc />
public async Task Edit(MenuEditInput input)
{
var resource = await CheckInput(input, true);//检查参数
var sysResource = input.Adapt<SysResource>();//实体转换
var updatePath = resource.Path != input.Path;//是否更新路径
var permissions = new List<SysRelation>();
if (updatePath)
{
//获取所有角色和用户的权限关系
var rolePermissions = await _relationService.GetRelationByCategory(CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION);
var userPermissions = await _relationService.GetRelationByCategory(CateGoryConst.RELATION_SYS_USER_HAS_PERMISSION);
//找到所有匹配的权限
rolePermissions = rolePermissions.Where(it => it.TargetId.Contains(resource.Path)).ToList();
userPermissions = userPermissions.Where(it => it.TargetId.Contains(resource.Path)).ToList();
//更新路径
rolePermissions.ForEach(it => it.TargetId = it.TargetId.Replace(resource.Path, input.Path));
userPermissions.ForEach(it => it.TargetId = it.TargetId.Replace(resource.Path, input.Path));
//添加到权限列表
permissions.AddRange(rolePermissions);
permissions.AddRange(userPermissions);
}
//事务
var result = await Tenant.UseTranAsync(async () =>
{
await UpdateAsync(sysResource);//更新数据
if (permissions.Count > 0)//如果权限列表大于0就更新
{
await Context.Updateable(permissions)
.ExecuteCommandAsync();//更新关系表
}
});
if (result.IsSuccess)//如果成功了
{
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_MENU);//刷新菜单缓存
//刷新关系表缓存
if (updatePath)
{
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION);
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_USER_HAS_PERMISSION);
}
}
}
/// <inheritdoc />
public async Task Delete(BaseIdListInput input)
{
//获取所有ID
var ids = input.Ids;
if (ids.Count > 0)
{
//获取所有菜单和按钮
var resourceList = await _resourceService.GetListAsync(new List<string> { CateGoryConst.RESOURCE_MENU, CateGoryConst.RESOURCE_BUTTON });
//找到要删除的菜单
var sysResources = resourceList.Where(it => ids.Contains(it.Id)).ToList();
//查找内置菜单
var system = sysResources.Where(it => it.Code == SysResourceConst.SYSTEM).FirstOrDefault();
if (system != null)
throw Oops.Bah($"不可删除系统菜单:{system.Title}");
//需要删除的资源ID列表
var resourceIds = new List<long>();
//遍历菜单列表
sysResources.ForEach(it =>
{
//获取菜单所有子节点
var child = _resourceService.GetChildListById(resourceList, it.Id, false);
//将子节点ID添加到删除资源ID列表
resourceIds.AddRange(child.Select(it => it.Id).ToList());
resourceIds.Add(it.Id);//添加到删除资源ID列表
});
ids.AddRange(resourceIds);//添加到删除ID列表
//事务
var result = await Tenant.UseTranAsync(async () =>
{
await DeleteByIdsAsync(ids.Cast<object>().ToArray());//删除菜单和按钮
await Context.Deleteable<SysRelation>()//关系表删除对应SYS_ROLE_HAS_RESOURCE
.Where(it => it.Category == CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE && resourceIds.Contains(SqlFunc.ToInt64(it.TargetId)))
.ExecuteCommandAsync();
});
if (result.IsSuccess)//如果成功了
{
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_MENU);//资源表菜单刷新缓存
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_BUTTON);//资源表按钮刷新缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE);//关系表刷新缓存
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0002);
}
}
}
/// <inheritdoc />
public async Task<SysResource> Detail(BaseIdInput input)
{
var sysResources = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_MENU);
var resource = sysResources.Where(it => it.Id == input.Id).FirstOrDefault();
return resource;
}
/// <inheritdoc />
public async Task ChangeModule(MenuChangeModuleInput input)
{
var sysResource = await Detail(new BaseIdInput { Id = input.Id });
if (sysResource != null)
{
if (sysResource.Module == input.Module)//如果模块ID没变直接返回
return;
if (sysResource.ParentId != 0)
throw Oops.Bah("非顶级菜单不可修改所属模块");
//获取所有菜单和模块
var resourceList = await _resourceService.GetListAsync(new List<string> { CateGoryConst.RESOURCE_MENU, CateGoryConst.RESOURCE_MODULE });
if (!resourceList.Any(it => it.Category == CateGoryConst.RESOURCE_MODULE && it.Id == input.Module.Value))
throw Oops.Bah("不存在的模块");
//获取所有菜单
var menuList = resourceList.Where(it => it.Category == CateGoryConst.RESOURCE_MENU).ToList();
//获取需要改变模块菜单的所有子菜单
var childList = _resourceService.GetChildListById(menuList, input.Id);
childList.ForEach(it => it.Module = input.Module);
//更新数据
await UpdateRangeAsync(childList);
//刷新菜单缓存
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_MENU);
}
}
#region 方法
/// <summary>
/// 检查输入参数
/// </summary>
/// <param name="sysResource"></param>
/// <param name="update"></param>
private async Task<SysResource> CheckInput(SysResource sysResource, bool update = false)
{
//获取所有菜单列表
var menList = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_MENU);
//判断是否有同级且同名的菜单
if (menList.Any(it => it.ParentId == sysResource.ParentId && it.Title == sysResource.Title && it.Id != sysResource.Id))
throw Oops.Bah($"存在重复的菜单名称:{sysResource.Title}");
if (sysResource.ParentId != 0)
{
//获取父级,判断父级ID正不正确
var parent = menList.Where(it => it.Id == sysResource.ParentId).FirstOrDefault();
if (parent != null)
{
if (parent.Module != sysResource.Module)//如果父级的模块和当前模块不一样
throw Oops.Bah("模块与上级菜单不一致");
if (parent.Id == sysResource.Id)
throw Oops.Bah("上级菜单不能选择自己");
}
else
{
throw Oops.Bah($"上级菜单不存在:{sysResource.ParentId}");
}
}
//如果ID大于0表示编辑
if (sysResource.Id > 0 && update)
{
var resource = menList.Where(it => it.Id == sysResource.Id).FirstOrDefault();
if (resource == null)
throw Oops.Bah($"菜单不存在:{sysResource.Id}");
return resource;
}
return null;
}
#endregion 方法
}
@@ -0,0 +1,37 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 模块分页输入
/// </summary>
public class ModulePageInput : BasePageInput
{
}
/// <summary>
/// 添加模块输入
/// </summary>
public class ModuleAddInput : SysResource
{
}
/// <summary>
/// 编辑模块输入
/// </summary>
public class ModuleEditInput : ModuleAddInput
{
/// <summary>
/// ID
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public override long Id { get; set; }
}
@@ -0,0 +1,58 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 模块管理服务
/// </summary>
public interface IModuleService : ITransient
{
/// <summary>
/// 添加模块
/// </summary>
/// <param name="input">添加参数</param>
/// <returns></returns>
Task Add(ModuleAddInput input);
/// <summary>
/// 删除模块
/// </summary>
/// <param name="input">删除参数</param>
/// <returns></returns>
Task Delete(BaseIdListInput input);
/// <summary>
/// 编辑模块
/// </summary>
/// <param name="input">编辑参数</param>
/// <returns></returns>
Task Edit(ModuleEditInput input);
/// <summary>
/// 分页查询
/// </summary>
/// <param name="input">分页参数</param>
/// <returns></returns>
Task<SqlSugarPagedList<SysResource>> Page(ModulePageInput input);
/// <summary>
/// 模块详情
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<SysResource> Detail(BaseIdInput input);
/// <summary>
/// 模块列表
/// </summary>
/// <returns></returns>
Task<List<SysResource>> List();
}
@@ -0,0 +1,161 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// <inheritdoc cref="IModuleService"/>
/// </summary>
public class ModuleService : DbRepository<SysResource>, IModuleService
{
private readonly ILogger<ModuleService> _logger;
private readonly IResourceService _resourceService;
private readonly IRelationService _relationService;
private readonly IEventPublisher _eventPublisher;
private readonly ISysUserService _sysUserService;
public ModuleService(ILogger<ModuleService> logger, IResourceService resourceService, IRelationService relationService,
IEventPublisher eventPublisher, ISysUserService sysUserService)
{
_logger = logger;
_resourceService = resourceService;
_relationService = relationService;
_eventPublisher = eventPublisher;
_sysUserService = sysUserService;
}
/// <inheritdoc/>
public async Task<SqlSugarPagedList<SysResource>> Page(ModulePageInput input)
{
var query = Context.Queryable<SysResource>().Where(it => it.Category == CateGoryConst.RESOURCE_MODULE)//模块
.WhereIF(!string.IsNullOrEmpty(input.SearchKey), it => it.Title.Contains(input.SearchKey))//根据关键字查询
.OrderByIF(!string.IsNullOrEmpty(input.SortField), $"{input.SortField} {input.SortOrder}").OrderBy(it => it.SortCode);//排序
var pageInfo = await query.ToPagedListAsync(input.PageNum, input.PageSize);//分页
return pageInfo;
}
/// <inheritdoc />
public async Task Add(ModuleAddInput input)
{
await CheckInput(input);//检查参数
var sysResource = input.Adapt<SysResource>();//实体转换
if (await InsertAsync(sysResource))//插入数据
{
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_MODULE);//刷新缓存
_sysUserService.DeleteUserFromRedis(UserManager.UserId);
}
}
/// <inheritdoc />
public async Task Edit(ModuleEditInput input)
{
await CheckInput(input);//检查参数
var sysResource = input.Adapt<SysResource>();//实体转换
if (await UpdateAsync(sysResource))//更新数据
{
if (sysResource.Status == CommonStatusConst.DISABLED)//如果禁用
await _eventPublisher.PublishAsync(EventSubscriberConst.CLEAR_MODULE_TOKEN, sysResource.Id);//清除角色下用户缓存
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_MODULE);//刷新缓存
}
}
/// <inheritdoc />
public async Task<SysResource> Detail(BaseIdInput input)
{
var sysResources = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_MODULE);
var resource = sysResources.Where(it => it.Id == input.Id).FirstOrDefault();
return resource;
}
/// <inheritdoc />
public async Task Delete(BaseIdListInput input)
{
//获取所有ID
var ids = input.Ids;
if (ids.Count > 0)
{
//获取所有
var resourceList = await _resourceService.GetListAsync();
//找到要删除的模块
var sysResources = resourceList.Where(it => ids.Contains(it.Id)).ToList();
//查找内置模块
var system = sysResources.Where(it => it.Code == SysResourceConst.SYSTEM).FirstOrDefault();
if (system != null)
throw Oops.Bah($"不可删除系统内置模块:{system.Title}");
if (sysResources.Any(it => it.Status == CommonStatusConst.ENABLE))//如果有启用的模块
throw Oops.Bah($"请先禁用模块再删除");
//获取模块下的所有菜单Id列表
var menuIds = resourceList.Where(it => ids.Contains(it.Module.ToLong()) && it.ParentId.ToLong() == SimpleAdminConst.ZERO)
.Select(it => it.Id).ToList();
//需要删除的资源ID列表
var resourceIds = new List<long>();
//遍历列表
menuIds.ForEach(it =>
{
//获取菜单所有子节点
var child = _resourceService.GetChildListById(resourceList, it, false);
//将子节点ID添加到删除ID列表
resourceIds.AddRange(child.Select(it => it.Id).ToList());
resourceIds.Add(it);//添加到删除ID列表
});
ids.AddRange(resourceIds);
//事务
var result = await Tenant.UseTranAsync(async () =>
{
await DeleteByIdsAsync(ids.Cast<object>().ToArray());//删除菜单和按钮
await Context.Deleteable<SysRelation>()//关系表删除对应SYS_ROLE_HAS_RESOURCE
.Where(it => it.Category == CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE && resourceIds.Contains(SqlFunc.ToInt64(it.TargetId)))
.ExecuteCommandAsync();
});
if (result.IsSuccess)//如果成功了
{
await _resourceService.RefreshCache();//资源表刷新缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE);//关系表刷新缓存
_sysUserService.DeleteUserFromRedis(UserManager.UserId);
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0002);
}
}
}
/// <inheritdoc />
public async Task<List<SysResource>> List()
{
var sysResources = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_MODULE);
return sysResources;
}
#region 方法
/// <summary>
/// 检查输入参数
/// </summary>
/// <param name="sysResource"></param>
private async Task CheckInput(SysResource sysResource)
{
var sysResourceList = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_MODULE);
//判断是否从存在重复模块
var hasSameName = sysResourceList.Any(it => it.Title == sysResource.Title && it.Id != sysResource.Id);
if (hasSameName)
{
throw Oops.Bah($"存在重复的模块:{sysResource.Title}");
}
if (sysResource.Status == CommonStatusConst.DISABLED)//如果禁用
await _eventPublisher.PublishAsync(EventSubscriberConst.CLEAR_MODULE_TOKEN, sysResource.Id);//清除角色下用户缓存
//设置为模块
sysResource.Category = CateGoryConst.RESOURCE_MODULE;
}
#endregion 方法
}
@@ -0,0 +1,130 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 角色查询参数
/// </summary>
public class RolePageInput : PositionPageInput
{
}
/// <summary>
/// 角色添加参数
/// </summary>
public class RoleAddInput : SysRole
{
/// <summary>
/// 名称
/// </summary>
[Required(ErrorMessage = "Name不能为空")]
public override string Name { get; set; }
}
/// <summary>
/// 角色编辑参数
/// </summary>
public class RoleEditInput : RoleAddInput
{
/// <summary>
/// Id
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public override long Id { get; set; }
}
/// <summary>
/// 角色授权资源参数
/// </summary>
public class GrantResourceInput : RoleOwnResourceOutput
{
/// <summary>
/// 角色Id
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public override long Id { get; set; }
/// <summary>
/// 授权资源信息
/// </summary>
[Required(ErrorMessage = "GrantInfoList不能为空")]
public override List<RelationRoleResource> GrantInfoList { get; set; }
/// <summary>
/// 是否代码生成
/// </summary>
public bool IsCodeGen { get; set; }
}
/// <summary>
/// 角色授权资源参数
/// </summary>
public class GrantPermissionInput : RoleOwnPermissionOutput
{
/// <summary>
/// 角色Id
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public override long Id { get; set; }
/// <summary>
/// 授权权限信息
/// </summary>
[Required(ErrorMessage = "GrantInfoList不能为空")]
public override List<RelationRolePermission> GrantInfoList { get; set; }
}
/// <summary>
/// 角色授权用户参数
/// </summary>
public class GrantUserInput
{
/// <summary>
/// Id
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public long Id { get; set; }
/// <summary>
/// 授权权限信息
/// </summary>
[Required(ErrorMessage = "GrantInfoList不能为空")]
public List<long> GrantInfoList { get; set; }
}
/// <summary>
/// 角色选择器参数
/// </summary>
public class RoleSelectorInput : BasePageInput
{
/// <summary>
/// 组织ID
/// </summary>
public long OrgId { get; set; }
/// <summary>
/// 机构ID列表
/// </summary>
public List<long> OrgIds { get; set; }
/// <summary>
/// 角色名称
/// </summary>
public string Name { get; set; }
}
public class RoleTreeInput
{
/// <summary>
/// 机构ID列表
/// </summary>
public List<long> OrgIds { get; set; }
}
@@ -0,0 +1,69 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 角色拥有的资源输出
/// </summary>
public class RoleOwnResourceOutput
{
/// <summary>
/// Id
/// </summary>
public virtual long Id { get; set; }
/// <summary>
/// 已授权资源信息
/// </summary>
public virtual List<RelationRoleResource> GrantInfoList { get; set; }
}
/// <summary>
/// 角色拥有权限输出
/// </summary>
public class RoleOwnPermissionOutput
{
/// <summary>
/// 角色Id
/// </summary>
public virtual long Id { get; set; }
/// <summary>
/// 已授权资源信息
/// </summary>
public virtual List<RelationRolePermission> GrantInfoList { get; set; }
}
/// <summary>
/// 角色树输出参数
/// </summary>
public class RoleTreeOutput
{
/// <summary>
/// 职位Id
/// </summary>
public long Id { get; set; }
/// <summary>
/// 名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 是否是职位
/// </summary>
public bool IsRole { get; set; }
/// <summary>
/// 子项
/// </summary>
public List<RoleTreeOutput> Children { get; set; } = new List<RoleTreeOutput>();
}
@@ -0,0 +1,159 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 角色服务
/// </summary>
public interface ISysRoleService : ITransient
{
#region 查询
/// <summary>
/// 获取所有角色
/// </summary>
/// <returns></returns>
Task<List<SysRole>> GetListAsync();
/// <summary>
/// 根据用户ID获取用户角色集合
/// </summary>
/// <param name="userId">用户ID</param>
/// <returns></returns>
Task<List<SysRole>> GetRoleListByUserId(long userId);
/// <summary>
/// 获取角色拥有权限
/// </summary>
/// <param name="input">角色ID</param>
/// <returns></returns>
Task<RoleOwnPermissionOutput> OwnPermission(BaseIdInput input);
/// <summary>
/// 角色拥有资源
/// </summary>
/// <param name="input">角色id</param>
/// <param name="category">资源类型</param>
/// <returns>角色拥有资源信息</returns>
Task<RoleOwnResourceOutput> OwnResource(BaseIdInput input, string category);
/// <summary>
/// 获取角色下的用户
/// </summary>
/// <param name="input">角色ID</param>
/// <returns></returns>
Task<List<UserSelectorOutPut>> OwnUser(BaseIdInput input);
/// <summary>
/// 分页查询角色
/// </summary>
/// <param name="input">查询参数</param>
/// <returns></returns>
Task<SqlSugarPagedList<SysRole>> Page(RolePageInput input);
/// <summary>
/// 获取角色授权权限选择器
/// </summary>
/// <param name="input">角色ID</param>
/// <returns></returns>
Task<List<string>> RolePermissionTreeSelector(BaseIdInput input);
/// <summary>
/// 角色选择器
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<SqlSugarPagedList<RoleSelectorOutPut>> RoleSelector(RoleSelectorInput input);
/// <summary>
/// 根据id集合获取角色集合
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<List<SysRole>> GetRoleListByIdList(IdListInput input);
/// <summary>
/// 获取角色树
/// </summary>
/// <param name="input">角色树</param>
/// <returns></returns>
Task<List<RoleTreeOutput>> Tree(RoleTreeInput input);
/// <summary>
/// 角色详情
/// </summary>
/// <param name="input">角色Id</param>
/// <returns></returns>
Task<SysRole> Detail(BaseIdInput input);
#endregion
#region 新增
/// <summary>
/// 添加角色
/// </summary>
/// <param name="input">添加参数</param>
/// <returns></returns>
Task Add(RoleAddInput input);
#endregion
#region 编辑
/// <summary>
/// 编辑角色
/// </summary>
/// <param name="input">编辑参数</param>
/// <returns></returns>
Task Edit(RoleEditInput input);
/// <summary>
/// 给角色授权权限
/// </summary>
/// <param name="input">授权信息</param>
/// <returns></returns>
Task GrantPermission(GrantPermissionInput input);
/// <summary>
/// 给角色授权
/// </summary>
/// <param name="input">授权参数</param>
/// <returns></returns>
Task GrantResource(GrantResourceInput input);
/// <summary>
/// 给角色授权用户
/// </summary>
/// <param name="input">授权信息</param>
/// <returns></returns>
Task GrantUser(GrantUserInput input);
#endregion
#region 删除
/// <summary>
/// 刷新缓存
/// </summary>
/// <returns></returns>
Task RefreshCache();
/// <summary>
/// 删除角色
/// </summary>
/// <param name="input">删除参数</param>
/// <returns></returns>
Task Delete(BaseIdListInput input);
#endregion
}
@@ -0,0 +1,589 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <inheritdoc cref="ISysRoleService"/>
//[Injection(Proxy = typeof(GlobalDispatchProxy))]
public class SysRoleService : DbRepository<SysRole>, ISysRoleService
{
private readonly ILogger<SysRoleService> _logger;
private readonly ISimpleCacheService _simpleCacheService;
private readonly IRelationService _relationService;
private readonly ISysOrgService _sysOrgService;
private readonly IResourceService _resourceService;
private readonly IEventPublisher _eventPublisher;
public SysRoleService(ILogger<SysRoleService> logger, ISimpleCacheService simpleCacheService, IRelationService relationService,
ISysOrgService sysOrgService, IResourceService resourceService, IEventPublisher eventPublisher)
{
_logger = logger;
_simpleCacheService = simpleCacheService;
_relationService = relationService;
_sysOrgService = sysOrgService;
_resourceService = resourceService;
_eventPublisher = eventPublisher;
}
#region 查询
/// <summary>
/// 获取所有
/// </summary>
/// <returns></returns>
public override async Task<List<SysRole>> GetListAsync()
{
//先从Redis拿
var sysRoles = _simpleCacheService.Get<List<SysRole>>(SystemConst.CACHE_SYS_ROLE);
if (sysRoles == null)
{
//redis没有就去数据库拿
sysRoles = await base.GetListAsync();
if (sysRoles.Count > 0)
{
//插入Redis
_simpleCacheService.Set(SystemConst.CACHE_SYS_ROLE, sysRoles);
}
}
return sysRoles;
}
/// <inheritdoc/>
public async Task<List<SysRole>> GetRoleListByUserId(long userId)
{
var cods = new List<SysRole>();//角色代码集合
var roleList = await _relationService.GetRelationListByObjectIdAndCategory(userId, CateGoryConst.RELATION_SYS_USER_HAS_ROLE);//根据用户ID获取角色ID
var roleIdList = roleList.Select(x => x.TargetId.ToLong()).ToList();//角色ID列表
if (roleIdList.Count > 0)
{
cods = await GetListAsync(it => roleIdList.Contains(it.Id));
}
return cods;
}
/// <inheritdoc/>
public async Task<SqlSugarPagedList<SysRole>> Page(RolePageInput input)
{
var orgIds = await _sysOrgService.GetOrgChildIds(input.OrgId);//获取下级机构
var query = Context.Queryable<SysRole>()
.WhereIF(input.OrgId > 0, it => orgIds.Contains(it.OrgId.Value))//根据组织
.WhereIF(input.OrgIds != null, it => input.OrgIds.Contains(it.OrgId.Value))//数据权限
.WhereIF(!string.IsNullOrEmpty(input.Status), it => it.Status == input.Status)//根据分类
.WhereIF(!string.IsNullOrEmpty(input.Category), it => it.Category == input.Category)//根据分类
.WhereIF(!string.IsNullOrEmpty(input.SearchKey), it => it.Name.Contains(input.SearchKey))//根据关键字查询
.OrderByIF(!string.IsNullOrEmpty(input.SortField), $"{input.SortField} {input.SortOrder}").OrderBy(it => it.SortCode);//排序
var pageInfo = await query.ToPagedListAsync(input.PageNum, input.PageSize);//分页
return pageInfo;
}
/// <inheritdoc/>
public async Task<List<RoleTreeOutput>> Tree(RoleTreeInput input)
{
var result = new List<RoleTreeOutput>();//返回结果
var sysOrgList = await _sysOrgService.GetListAsync(false);//获取所有机构
var sysRoles = await GetListAsync();//获取所有角色
sysRoles = sysRoles.Where(it => it.Code != SysRoleConst.SUPER_ADMIN).ToList();//排除超管
if (input.OrgIds != null)//根据数据范围查
{
sysOrgList = sysOrgList.Where(it => input.OrgIds.Contains(it.Id)).ToList();//在指定组织列表查询
sysRoles = sysRoles.Where(it => input.OrgIds.Contains(it.OrgId.GetValueOrDefault())).ToList();//在指定职位列表查询
}
var topOrgList = sysOrgList.Where(it => it.ParentId == 0).ToList();//获取顶级机构
var globalRole = sysRoles.Where(it => it.Category == CateGoryConst.ROLE_GLOBAL).ToList();//获取全局角色
if (globalRole.Count > 0)
{
result.Add(new RoleTreeOutput()
{
Id = CommonUtils.GetSingleId(),
Name = "全局角色",
Children = globalRole.Select(it => new RoleTreeOutput
{
Id = it.Id,
Name = it.Name,
IsRole = true
}).ToList()
});//添加全局角色
}
//遍历顶级机构
foreach (var org in topOrgList)
{
var childIds = await _sysOrgService.GetOrgChildIds(org.Id, true, sysOrgList);//获取机构下的所有子级ID
var childRoles = sysRoles.Where(it => it.OrgId != null && childIds.Contains(it.OrgId.Value)).ToList();//获取机构下的所有角色
if (childRoles.Count == 0)
continue;
var roleTreeOutput = new RoleTreeOutput
{
Id = org.Id,
Name = org.Name,
IsRole = false
};//实例化角色树
childRoles.ForEach(it =>
{
roleTreeOutput.Children.Add(new RoleTreeOutput()
{
Id = it.Id,
Name = it.Name,
IsRole = true
});
});
result.Add(roleTreeOutput);
}
return result;
}
/// <inheritdoc />
public async Task<RoleOwnResourceOutput> OwnResource(BaseIdInput input, string category)
{
var roleOwnResource = new RoleOwnResourceOutput { Id = input.Id };//定义结果集
var grantInfoList = new List<RelationRoleResource>();//已授权信息集合
//获取关系列表
var relations = await _relationService.GetRelationListByObjectIdAndCategory(input.Id, category);
//遍历关系表
relations.ForEach(it =>
{
//将扩展信息转为实体
var relationRole = it.ExtJson.ToJsonEntity<RelationRoleResource>();
grantInfoList.Add(relationRole);//添加到已授权信息
});
roleOwnResource.GrantInfoList = grantInfoList;//赋值已授权信息
return roleOwnResource;
}
/// <inheritdoc />
public async Task<RoleOwnPermissionOutput> OwnPermission(BaseIdInput input)
{
var roleOwnPermission = new RoleOwnPermissionOutput { Id = input.Id };//定义结果集
var grantInfoList = new List<RelationRolePermission>();//已授权信息集合
//获取关系列表
var relations = await _relationService.GetRelationListByObjectIdAndCategory(input.Id, CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION);
//遍历关系表
relations.ForEach(it =>
{
//将扩展信息转为实体
var relationPermission = it.ExtJson.ToJsonEntity<RelationRolePermission>();
grantInfoList.Add(relationPermission);//添加到已授权信息
});
roleOwnPermission.GrantInfoList = grantInfoList;//赋值已授权信息
return roleOwnPermission;
}
/// <inheritdoc />
public async Task<List<UserSelectorOutPut>> OwnUser(BaseIdInput input)
{
//获取关系列表
var relations = await _relationService.GetRelationListByTargetIdAndCategory(input.Id.ToString(), CateGoryConst.RELATION_SYS_USER_HAS_ROLE);
var userIds = relations.Select(it => it.ObjectId).ToList();
var userList = await Context.Queryable<SysUser>().Where(it => userIds.Contains(it.Id)).Select<UserSelectorOutPut>().ToListAsync();
return userList;
}
/// <inheritdoc />
public async Task<SqlSugarPagedList<RoleSelectorOutPut>> RoleSelector(RoleSelectorInput input)
{
var orgIds = await _sysOrgService.GetOrgChildIds(input.OrgId);//获取下级组织
//如果机构ID列表不为空
if (input.OrgIds != null)
{
orgIds = orgIds.Where(it => input.OrgIds.Contains(it)).ToList();//包含在机构ID列表中的组织ID
}
var result = await Context.Queryable<SysRole>()
.Where(it => it.Code != SysRoleConst.SUPER_ADMIN)
.WhereIF(input.OrgId == 0, it => it.Category == CateGoryConst.ROLE_GLOBAL)//不传机构ID就是全局角色
.WhereIF(orgIds.Count > 0, it => orgIds.Contains(it.OrgId.Value))//组织ID
.WhereIF(!string.IsNullOrEmpty(input.Name), it => it.Name.Contains(input.Name))//根据关键字查询
.Select<RoleSelectorOutPut>()
.ToPagedListAsync(input.PageNum, input.PageSize);
return result;
}
/// <inheritdoc />
public async Task<List<string>> RolePermissionTreeSelector(BaseIdInput input)
{
var permissionTreeSelectors = new List<string>();//授权树结果集
//获取单页信息
var spa = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_SPA);
var spaIds = spa.Select(it => it.Id).ToList();
if (spaIds.Any())
{
//获取权限授权树
var permissions = _resourceService.PermissionTreeSelector(spa.Select(it => it.Path).ToList());
if (permissions.Count > 0)
permissionTreeSelectors.AddRange(permissions.Select(it => it.PermissionName).ToList());//返回授权树权限名称列表
}
//获取角色资源关系
var relationsRes = await _relationService.GetRelationByCategory(CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE);
var menuIds = relationsRes.Where(it => it.ObjectId == input.Id).Select(it => it.TargetId.ToLong()).ToList();
if (menuIds.Any())
{
//获取菜单信息
var menus = await _resourceService.GetResourcesByIds(menuIds, CateGoryConst.RESOURCE_MENU);
//获取权限授权树
var permissions = _resourceService.PermissionTreeSelector(menus.Select(it => it.Path).ToList());
if (permissions.Count > 0)
permissionTreeSelectors.AddRange(permissions.Select(it => it.PermissionName).ToList());//返回授权树权限名称列表
}
return permissionTreeSelectors;
}
/// <inheritdoc />
public async Task<List<SysRole>> GetRoleListByIdList(IdListInput input)
{
var roles = await GetListAsync();
var roleList = roles.Where(it => input.IdList.Contains(it.Id)).ToList();// 获取指定ID的岗位列表
return roleList;
}
/// <inheritdoc />
public async Task<SysRole> Detail(BaseIdInput input)
{
var roles = await GetListAsync();
var role = roles.Where(it => it.Id == input.Id).FirstOrDefault();
return role;
}
#endregion
#region 新增
/// <inheritdoc />
public async Task Add(RoleAddInput input)
{
await CheckInput(input);//检查参数
var sysRole = input.Adapt<SysRole>();//实体转换
if (await InsertAsync(sysRole))//插入数据
await RefreshCache();//刷新缓存
}
#endregion
#region 编辑
/// <inheritdoc />
public async Task Edit(RoleEditInput input)
{
//判断是否超管
if (input.Code == SysRoleConst.SUPER_ADMIN)
throw Oops.Bah("不可编辑超管角色");
await CheckInput(input);//检查参数
var role = await GetFirstAsync(it => it.Id == input.Id);//获取角色
if (role != null)
{
var permissions = new List<SysRelation>();
//如果改了默认数据权限
if (role.DefaultDataScope.ScopeCategory != input.DefaultDataScope.ScopeCategory)
{
//获取角色授权列表
var relations = await _relationService.GetRelationByCategory(CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION);
//找到当前角色的
permissions = relations.Where(it => it.ObjectId == input.Id).ToList();
permissions.ForEach(it =>
{
var rolePermission = it.ExtJson.ToJsonEntity<RelationRolePermission>();//扩展信息转实体
//如果表里的数据范围是默认数据范围才更新,已经自定义了的数据范围不更新
if (rolePermission.ScopeCategory == role.DefaultDataScope.ScopeCategory
&& Enumerable.SequenceEqual(rolePermission.ScopeDefineOrgIdList, role.DefaultDataScope.ScopeDefineOrgIdList))
{
//重新赋值数据范围
rolePermission.ScopeCategory = input.DefaultDataScope.ScopeCategory;
rolePermission.ScopeDefineOrgIdList = input.DefaultDataScope.ScopeDefineOrgIdList;
it.ExtJson = rolePermission.ToJson();
}
});
}
var sysRole = input.Adapt<SysRole>();//实体转换
//事务
var result = await Tenant.UseTranAsync(async () =>
{
await UpdateAsync(sysRole);//更新角色
if (permissions.Any())//如果有授权权限就更新
await Context.Updateable(permissions).ExecuteCommandAsync();
});
if (result.IsSuccess)//如果成功了
{
await RefreshCache();//刷新缓存
if (permissions.Any())//如果有授权
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION);//关系表刷新SYS_ROLE_HAS_PERMISSION缓存
await _eventPublisher.PublishAsync(EventSubscriberConst.CLEAR_USER_CACHE, new List<long> { input.Id });//清除角色下用户缓存
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0002);
}
}
}
/// <inheritdoc />
public async Task GrantResource(GrantResourceInput input)
{
var allMenus = await _resourceService.GetListByCategory(SysResourceConst.MENU);//获取所有菜单
var spas = await _resourceService.GetListByCategory(SysResourceConst.SPA);
var menuIds = input.GrantInfoList.Select(it => it.MenuId).ToList();//菜单ID
var extJsons = input.GrantInfoList.Select(it => it.ToJson()).ToList();//拓展信息
var relationRoles = new List<SysRelation>();//要添加的角色资源和授权关系表
var sysRole = (await GetListAsync()).Where(it => it.Id == input.Id).FirstOrDefault();//获取角色
if (sysRole != null)
{
#region 角色模块处理
var menusList = allMenus.Where(it => menuIds.Contains(it.Id)).ToList();//获取菜单信息
//获取我的模块信息Id列表
var moduleIds = menusList.Select(it => it.Module.Value).Distinct().ToList();
moduleIds.ForEach(it =>
{
//将角色资源添加到列表
relationRoles.Add(new SysRelation
{
ObjectId = sysRole.Id,
TargetId = it.ToString(),
Category = CateGoryConst.RELATION_SYS_ROLE_HAS_MODULE
});
});
#endregion 角色模块处理
#region 角色资源处理
//遍历菜单列表
for (var i = 0; i < menuIds.Count; i++)
{
//将角色资源添加到列表
relationRoles.Add(new SysRelation
{
ObjectId = sysRole.Id,
TargetId = menuIds[i].ToString(),
Category = CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE,
ExtJson = extJsons?[i]
});
}
#endregion 角色资源处理
#region 角色权限处理.
var relationRolePer = new List<SysRelation>();//要添加的角色有哪些权限列表
var defaultDataScope = sysRole.DefaultDataScope;//获取默认数据范围
//获取菜单信息
var menus = allMenus.Where(it => menuIds.Contains(it.Id)).ToList();
menus.AddRange(spas);//单页id添加到列表
if (menus.Count > 0)
{
//获取权限授权树
var permissions = _resourceService.PermissionTreeSelector(menus.Select(it => it.Path).ToList());
permissions.ForEach(it =>
{
//新建角色权限关系
relationRolePer.Add(new SysRelation
{
ObjectId = sysRole.Id,
TargetId = it.ApiRoute,
Category = CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION,
ExtJson = new RelationRolePermission
{
ApiUrl = it.ApiRoute,
ScopeCategory = defaultDataScope.ScopeCategory,
ScopeDefineOrgIdList = defaultDataScope.ScopeDefineOrgIdList
}.ToJson()
});
});
}
relationRoles.AddRange(relationRolePer);//合并列表
#endregion 角色权限处理.
#region 保存数据库
//事务
var result = await Tenant.UseTranAsync(async () =>
{
var relationRep = ChangeRepository<DbRepository<SysRelation>>();//切换仓储
//如果不是代码生成,就删除老的
if (!input.IsCodeGen)
await relationRep.DeleteAsync(it => it.ObjectId == sysRole.Id && (it.Category == CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION
|| it.Category == CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE
|| it.Category == CateGoryConst.RELATION_SYS_ROLE_HAS_MODULE));
await relationRep.InsertRangeAsync(relationRoles);//添加新的
});
if (result.IsSuccess)//如果成功了
{
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE);//刷新关系缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION);//刷新关系缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_MODULE);//刷新关系缓存
await _eventPublisher.PublishAsync(EventSubscriberConst.CLEAR_USER_CACHE, new List<long> { input.Id });//发送事件清除角色下用户缓存
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0003);
}
#endregion 保存数据库
}
}
/// <inheritdoc />
public async Task GrantPermission(GrantPermissionInput input)
{
var sysRole = (await GetListAsync()).Where(it => it.Id == input.Id).FirstOrDefault();//获取角色
if (sysRole != null)
{
var apiUrls = input.GrantInfoList.Select(it => it.ApiUrl).ToList();//apiUrl列表
var extJsons = input.GrantInfoList.Select(it => it.ToJson()).ToList();//拓展信息
await _relationService.SaveRelationBatch(CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION, input.Id, apiUrls, extJsons,
true);//添加到数据库
await _eventPublisher.PublishAsync(EventSubscriberConst.CLEAR_USER_CACHE, new List<long> { input.Id });//清除角色下用户缓存
}
}
/// <inheritdoc />
public async Task GrantUser(GrantUserInput input)
{
var sysRelations = new List<SysRelation>();//关系列表
//遍历用户ID
input.GrantInfoList.ForEach(it =>
{
sysRelations.Add(new SysRelation
{
ObjectId = it,
TargetId = input.Id.ToString(),
Category = CateGoryConst.RELATION_SYS_USER_HAS_ROLE
});
});
//事务
var result = await Tenant.UseTranAsync(async () =>
{
var relationRep = ChangeRepository<DbRepository<SysRelation>>();//切换仓储
var targetId = input.Id.ToString();//目标ID转string
await relationRep.DeleteAsync(it => it.TargetId == targetId && it.Category == CateGoryConst.RELATION_SYS_USER_HAS_ROLE);//删除老的
await relationRep.InsertRangeAsync(sysRelations);//添加新的
});
if (result.IsSuccess)//如果成功了
{
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_USER_HAS_ROLE);//刷新关系表SYS_USER_HAS_ROLE缓存
await _eventPublisher.PublishAsync(EventSubscriberConst.CLEAR_USER_CACHE, new List<long> { input.Id });//清除角色下用户缓存
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0003);
}
}
#endregion
#region 删除
/// <inheritdoc />
public async Task Delete(BaseIdListInput input)
{
//获取所有ID
var ids = input.Ids;
if (ids.Count > 0)
{
var sysRoles = await GetListAsync();//获取所有角色
var hasSuperAdmin = sysRoles.Any(it => it.Code == SysRoleConst.SUPER_ADMIN && ids.Contains(it.Id));//判断是否有超级管理员
if (hasSuperAdmin) throw Oops.Bah("不可删除系统内置超管角色");
//数据库是string所以这里转下
var targetIds = ids.Select(it => it.ToString()).ToList();
//定义删除的关系
var delRelations = new List<string>
{
CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE,
CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION,
CateGoryConst.RELATION_SYS_ROLE_HAS_MODULE
};
//事务
var result = await Tenant.UseTranAsync(async () =>
{
await DeleteByIdsAsync(ids.Cast<object>().ToArray());//删除按钮
var relationRep = ChangeRepository<DbRepository<SysRelation>>();//切换仓储
//删除关系表角色与资源关系,角色与权限关系
await relationRep.DeleteAsync(it => ids.Contains(it.ObjectId) && delRelations.Contains(it.Category));
//删除关系表角色与用户关系
await relationRep.DeleteAsync(it => targetIds.Contains(it.TargetId) && it.Category == CateGoryConst.RELATION_SYS_USER_HAS_ROLE);
});
if (result.IsSuccess)//如果成功了
{
await RefreshCache();//刷新缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_USER_HAS_ROLE);//关系表刷新SYS_USER_HAS_ROLE缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_RESOURCE);//关系表刷新Relation_SYS_ROLE_HAS_RESOURCE缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_PERMISSION);//关系表刷新Relation_SYS_ROLE_HAS_PERMISSION缓存
await _relationService.RefreshCache(CateGoryConst.RELATION_SYS_ROLE_HAS_MODULE);//关系表刷新RELATION_SYS_ROLE_HAS_MODULE缓存
await _eventPublisher.PublishAsync(EventSubscriberConst.CLEAR_USER_CACHE, ids);//清除角色下用户缓存
}
else
{
//写日志
_logger.LogError(result.ErrorMessage, result.ErrorException);
throw Oops.Oh(ErrorCodeEnum.A0002);
}
}
}
/// <inheritdoc />
public async Task RefreshCache()
{
_simpleCacheService.Remove(SystemConst.CACHE_SYS_ROLE);//删除KEY
await GetListAsync();//重新缓存
}
#endregion
#region 方法
/// <summary>
/// 检查输入参数
/// </summary>
/// <param name="sysRole"></param>
private async Task CheckInput(SysRole sysRole)
{
//判断分类
if (sysRole.Category != CateGoryConst.ROLE_GLOBAL && sysRole.Category != CateGoryConst.ROLE_ORG)
throw Oops.Bah($"角色所属分类错误:{sysRole.Category}");
//如果是机构角色orgId不能为空
if (sysRole is { Category: CateGoryConst.ROLE_ORG, OrgId: null })
throw Oops.Bah("orgId不能为空");
if (sysRole.Category == CateGoryConst.ROLE_GLOBAL)//如果是全局
sysRole.OrgId = null;//机构id设null
var sysRoles = await GetListAsync();//获取所有
var repeatName = sysRoles.Any(it => it.OrgId == sysRole.OrgId && it.Name == sysRole.Name && it.Id != sysRole.Id);//是否有重复角色名称
if (repeatName)//如果有
{
if (sysRole.OrgId == null)
throw Oops.Bah($"存在重复的全局角色:{sysRole.Name}");
throw Oops.Bah($"同组织下存在重复的角色:{sysRole.Name}");
}
//如果code没填
if (string.IsNullOrEmpty(sysRole.Code))
{
sysRole.Code = RandomHelper.CreateRandomString(10);//赋值Code
}
else
{
//判断是否有相同的Code
if (sysRoles.Any(it => it.Code == sysRole.Code && it.Id != sysRole.Id))
throw Oops.Bah($"存在重复的编码:{sysRole.Code}");
}
}
#endregion 方法
}
@@ -0,0 +1,64 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 单页输入参数
/// </summary>
public class SpaPageInput : BasePageInput
{
/// <summary>
/// 菜单类型
/// </summary>
public string MenuType { get; set; }
}
/// <summary>
/// 单页输入参数
/// </summary>
public class SpaAddInput : SysResource
{
/// <summary>
/// 标题
/// </summary>
[Required(ErrorMessage = "Title不能为空")]
public override string Title { get; set; }
/// <summary>
/// 菜单类型
/// </summary>
[Required(ErrorMessage = "Title不能为空")]
public override string MenuType { get; set; }
/// <summary>
/// 路径
/// </summary>
[Required(ErrorMessage = "Path不能为空")]
public override string Path { get; set; }
/// <summary>
/// 图标
/// </summary>
[Required(ErrorMessage = "Icon不能为空")]
public override string Icon { get; set; }
}
/// <summary>
/// 单页修改参数
/// </summary>
public class SpaEditInput : SpaAddInput
{
/// <summary>
/// ID
/// </summary>
[IdNotNull(ErrorMessage = "Id不能为空")]
public override long Id { get; set; }
}
@@ -0,0 +1,52 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// 单页服务
/// </summary>
public interface ISpaService : ITransient
{
/// <summary>
/// 添加单页
/// </summary>
/// <param name="input">添加参数</param>
/// <returns></returns>
Task Add(SpaAddInput input);
/// <summary>
/// 删除单页
/// </summary>
/// <param name="input">删除参数</param>
/// <returns></returns>
Task Delete(BaseIdListInput input);
/// <summary>
/// 编辑单页
/// </summary>
/// <param name="input">编辑参数</param>
/// <returns></returns>
Task Edit(SpaEditInput input);
/// <summary>
/// 分页查询
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<SqlSugarPagedList<SysResource>> Page(SpaPageInput input);
/// <summary>
/// 详情
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
Task<SysResource> Detail(BaseIdInput input);
}
@@ -0,0 +1,130 @@
// Copyright (c) 2022-Now 少林寺驻北固山办事处大神父王喇嘛
//
// SimpleAdmin 基于 Apache License Version 2.0 协议发布,可用于商业项目,但必须遵守以下补充条款:
// 1.请不要删除和修改根目录下的LICENSE文件。
// 2.请不要删除和修改SimpleAdmin源码头部的版权声明。
// 3.分发源码时候,请注明软件出处 https://gitee.com/dotnetmoyu/SimpleAdmin
// 4.基于本软件的作品,只能使用 SimpleAdmin 作为后台服务,除外情况不可商用且不允许二次分发或开源。
// 5.请不得将本软件应用于危害国家安全、荣誉和利益的行为,不能以任何形式用于非法为目的的行为。
// 6.任何基于本软件而产生的一切法律纠纷和责任,均于我司无关。
namespace SimpleAdmin.System;
/// <summary>
/// <inheritdoc cref="ISpaService"/>
/// </summary>
public class SpaService : DbRepository<SysResource>, ISpaService
{
private readonly IResourceService _resourceService;
public SpaService(IResourceService resourceService)
{
_resourceService = resourceService;
}
/// <inheritdoc/>
public async Task<SqlSugarPagedList<SysResource>> Page(SpaPageInput input)
{
var query = Context.Queryable<SysResource>().Where(it => it.Category == CateGoryConst.RESOURCE_SPA)//单页
.WhereIF(!string.IsNullOrEmpty(input.MenuType), it => it.MenuType == input.MenuType)//根据菜单类型查询
.WhereIF(!string.IsNullOrEmpty(input.SearchKey), it => it.Title.Contains(input.SearchKey) || it.Path.Contains(input.SearchKey))//根据关键字查询
.OrderByIF(!string.IsNullOrEmpty(input.SortField), $"{input.SortField} {input.SortOrder}").OrderBy(it => it.SortCode);//排序
var pageInfo = await query.ToPagedListAsync(input.PageNum, input.PageSize);//分页
return pageInfo;
}
/// <inheritdoc />
public async Task Add(SpaAddInput input)
{
await CheckInput(input);//检查参数
input.Code = RandomHelper.CreateRandomString(10);//code取随机值
var sysResource = input.Adapt<SysResource>();//实体转换
if (await InsertAsync(sysResource))//插入数据
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_SPA);//刷新缓存
}
/// <inheritdoc />
public async Task Edit(SpaEditInput input)
{
await CheckInput(input);//检查参数
var sysResource = input.Adapt<SysResource>();//实体转换
if (await UpdateAsync(sysResource))//更新数据
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_SPA);//刷新缓存
}
/// <inheritdoc />
public async Task Delete(BaseIdListInput input)
{
//获取所有ID
var ids = input.Ids;
if (ids.Count > 0)
{
//获取所有
var resourceList = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_SPA);
//找到要删除的
var sysresources = resourceList.Where(it => ids.Contains(it.Id)).ToList();
//查找内置单页面
var system = sysresources.Where(it => it.Code == SysResourceConst.SYSTEM).FirstOrDefault();
if (system != null)
throw Oops.Bah($"不可删除系统内置单页面:{system.Title}");
//删除菜单
await DeleteAsync(sysresources);
await _resourceService.RefreshCache(CateGoryConst.RESOURCE_SPA);//刷新缓存
}
}
/// <inheritdoc />
public async Task<SysResource> Detail(BaseIdInput input)
{
var sysResources = await _resourceService.GetListByCategory(CateGoryConst.RESOURCE_SPA);
var resource = sysResources.Where(it => it.Id == input.Id).FirstOrDefault();
return resource;
}
#region 方法
/// <summary>
/// 检查输入参数
/// </summary>
/// <param name="sysResource"></param>
private async Task CheckInput(SysResource sysResource)
{
//判断菜单类型
if (sysResource.MenuType == SysResourceConst.MENU)//如果是菜单
{
if (string.IsNullOrEmpty(sysResource.Name))
{
throw Oops.Bah("单页名称不能为空");
}
if (string.IsNullOrEmpty(sysResource.Component))
{
throw Oops.Bah("组件地址不能为空");
}
}
else if (sysResource.MenuType == SysResourceConst.IFRAME || sysResource.MenuType == SysResourceConst.LINK)//如果是内链或者外链
{
// sysResource.Name = RandomHelper.CreateNum(10);//设置name为随机数
sysResource.Name = null;//设置name为标题
sysResource.Component = null;
}
else
{
throw Oops.Bah($"单页类型错误:{sysResource.MenuType}");//都不是
}
if (sysResource.IsHome)
{
var spas = await _resourceService.GetListByCategory(SysResourceConst.SPA);//获取所有单页
if (spas.Any(it => it.IsHome && it.Id != sysResource.Id))//如果有多个主页
{
throw Oops.Bah("已存在首页,请取消其他主页后再试");
}
sysResource.IsHide = false;//如果是主页,则不隐藏
sysResource.IsAffix = true;//如果是主页,则固定
}
//设置为单页
sysResource.Category = CateGoryConst.RESOURCE_SPA;
}
#endregion 方法
}