1
0

PermissionService.cs 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417
  1. using Admin.Core.Common.Attributes;
  2. using Admin.Core.Common.BaseModel;
  3. using Admin.Core.Common.Cache;
  4. using Admin.Core.Common.Configs;
  5. using Admin.Core.Common.Output;
  6. using Admin.Core.Model.Admin;
  7. using Admin.Core.Repository;
  8. using Admin.Core.Repository.Admin;
  9. using Admin.Core.Service.Admin.Permission.Input;
  10. using Admin.Core.Service.Admin.Permission.Output;
  11. using Microsoft.Extensions.DependencyInjection;
  12. using System;
  13. using System.Collections.Generic;
  14. using System.Linq;
  15. using System.Threading.Tasks;
  16. namespace Admin.Core.Service.Admin.Permission
  17. {
  18. public class PermissionService : BaseService, IPermissionService
  19. {
  20. private readonly AppConfig _appConfig;
  21. private readonly IPermissionRepository _permissionRepository;
  22. private readonly IRoleRepository _roleRepository;
  23. private readonly IRepositoryBase<RolePermissionEntity> _rolePermissionRepository;
  24. private readonly IRepositoryBase<TenantPermissionEntity> _tenantPermissionRepository;
  25. private readonly IRepositoryBase<UserRoleEntity> _userRoleRepository;
  26. private readonly IRepositoryBase<PermissionApiEntity> _permissionApiRepository;
  27. public PermissionService(
  28. AppConfig appConfig,
  29. IPermissionRepository permissionRepository,
  30. IRoleRepository roleRepository,
  31. IRepositoryBase<RolePermissionEntity> rolePermissionRepository,
  32. IRepositoryBase<TenantPermissionEntity> tenantPermissionRepository,
  33. IRepositoryBase<UserRoleEntity> userRoleRepository,
  34. IRepositoryBase<PermissionApiEntity> permissionApiRepository
  35. )
  36. {
  37. _appConfig = appConfig;
  38. _permissionRepository = permissionRepository;
  39. _roleRepository = roleRepository;
  40. _rolePermissionRepository = rolePermissionRepository;
  41. _tenantPermissionRepository = tenantPermissionRepository;
  42. _userRoleRepository = userRoleRepository;
  43. _permissionApiRepository = permissionApiRepository;
  44. }
  45. /// <summary>
  46. /// 清除权限下关联的用户权限缓存
  47. /// </summary>
  48. /// <param name="permissionIds"></param>
  49. /// <returns></returns>
  50. private async Task ClearUserPermissionsAsync(List<long> permissionIds)
  51. {
  52. var userIds = await _userRoleRepository.Select.Where(a =>
  53. _rolePermissionRepository
  54. .Where(b => b.RoleId == a.RoleId && permissionIds.Contains(b.PermissionId))
  55. .Any()
  56. ).ToListAsync(a => a.UserId);
  57. foreach (var userId in userIds)
  58. {
  59. await Cache.DelAsync(string.Format(CacheKey.UserPermissions, userId));
  60. }
  61. }
  62. public async Task<IResponseOutput> GetAsync(long id)
  63. {
  64. var result = await _permissionRepository.GetAsync(id);
  65. return ResponseOutput.Ok(result);
  66. }
  67. public async Task<IResponseOutput> GetGroupAsync(long id)
  68. {
  69. var result = await _permissionRepository.GetAsync<PermissionGetGroupOutput>(id);
  70. return ResponseOutput.Ok(result);
  71. }
  72. public async Task<IResponseOutput> GetMenuAsync(long id)
  73. {
  74. var result = await _permissionRepository.GetAsync<PermissionGetMenuOutput>(id);
  75. return ResponseOutput.Ok(result);
  76. }
  77. public async Task<IResponseOutput> GetApiAsync(long id)
  78. {
  79. var result = await _permissionRepository.GetAsync<PermissionGetApiOutput>(id);
  80. return ResponseOutput.Ok(result);
  81. }
  82. public async Task<IResponseOutput> GetDotAsync(long id)
  83. {
  84. var entity = await _permissionRepository.Select
  85. .WhereDynamic(id)
  86. .IncludeMany(a => a.Apis.Select(b => new ApiEntity { Id = b.Id }))
  87. .ToOneAsync();
  88. var output = Mapper.Map<PermissionGetDotOutput>(entity);
  89. return ResponseOutput.Ok(output);
  90. }
  91. public async Task<IResponseOutput> GetListAsync(string key, DateTime? start, DateTime? end)
  92. {
  93. if (end.HasValue)
  94. {
  95. end = end.Value.AddDays(1);
  96. }
  97. var data = await _permissionRepository
  98. .WhereIf(key.NotNull(), a => a.Path.Contains(key) || a.Label.Contains(key))
  99. .WhereIf(start.HasValue && end.HasValue, a => a.CreatedTime.Value.BetweenEnd(start.Value, end.Value))
  100. .OrderBy(a => a.ParentId)
  101. .OrderBy(a => a.Sort)
  102. .ToListAsync(a=> new PermissionListOutput { ApiPaths = string.Join(";", _permissionApiRepository.Where(b=>b.PermissionId == a.Id).ToList(b => b.Api.Path)) });
  103. return ResponseOutput.Ok(data);
  104. }
  105. public async Task<IResponseOutput> AddGroupAsync(PermissionAddGroupInput input)
  106. {
  107. var entity = Mapper.Map<PermissionEntity>(input);
  108. var id = (await _permissionRepository.InsertAsync(entity)).Id;
  109. return ResponseOutput.Ok(id > 0);
  110. }
  111. public async Task<IResponseOutput> AddMenuAsync(PermissionAddMenuInput input)
  112. {
  113. var entity = Mapper.Map<PermissionEntity>(input);
  114. var id = (await _permissionRepository.InsertAsync(entity)).Id;
  115. return ResponseOutput.Ok(id > 0);
  116. }
  117. public async Task<IResponseOutput> AddApiAsync(PermissionAddApiInput input)
  118. {
  119. var entity = Mapper.Map<PermissionEntity>(input);
  120. var id = (await _permissionRepository.InsertAsync(entity)).Id;
  121. return ResponseOutput.Ok(id > 0);
  122. }
  123. [Transaction]
  124. public async Task<IResponseOutput> AddDotAsync(PermissionAddDotInput input)
  125. {
  126. var entity = Mapper.Map<PermissionEntity>(input);
  127. var id = (await _permissionRepository.InsertAsync(entity)).Id;
  128. if (input.ApiIds != null && input.ApiIds.Any())
  129. {
  130. var permissionApis = input.ApiIds.Select(a => new PermissionApiEntity { PermissionId = id, ApiId = a });
  131. await _permissionApiRepository.InsertAsync(permissionApis);
  132. }
  133. return ResponseOutput.Ok(id > 0);
  134. }
  135. public async Task<IResponseOutput> UpdateGroupAsync(PermissionUpdateGroupInput input)
  136. {
  137. var result = false;
  138. if (input != null && input.Id > 0)
  139. {
  140. var entity = await _permissionRepository.GetAsync(input.Id);
  141. entity = Mapper.Map(input, entity);
  142. result = (await _permissionRepository.UpdateAsync(entity)) > 0;
  143. }
  144. return ResponseOutput.Result(result);
  145. }
  146. public async Task<IResponseOutput> UpdateMenuAsync(PermissionUpdateMenuInput input)
  147. {
  148. var result = false;
  149. if (input != null && input.Id > 0)
  150. {
  151. var entity = await _permissionRepository.GetAsync(input.Id);
  152. entity = Mapper.Map(input, entity);
  153. result = (await _permissionRepository.UpdateAsync(entity)) > 0;
  154. }
  155. return ResponseOutput.Result(result);
  156. }
  157. public async Task<IResponseOutput> UpdateApiAsync(PermissionUpdateApiInput input)
  158. {
  159. var result = false;
  160. if (input != null && input.Id > 0)
  161. {
  162. var entity = await _permissionRepository.GetAsync(input.Id);
  163. entity = Mapper.Map(input, entity);
  164. result = (await _permissionRepository.UpdateAsync(entity)) > 0;
  165. }
  166. return ResponseOutput.Result(result);
  167. }
  168. [Transaction]
  169. public async Task<IResponseOutput> UpdateDotAsync(PermissionUpdateDotInput input)
  170. {
  171. if (!(input?.Id > 0))
  172. {
  173. return ResponseOutput.NotOk();
  174. }
  175. var entity = await _permissionRepository.GetAsync(input.Id);
  176. if (!(entity?.Id > 0))
  177. {
  178. return ResponseOutput.NotOk("权限点不存在!");
  179. }
  180. Mapper.Map(input, entity);
  181. await _permissionRepository.UpdateAsync(entity);
  182. await _permissionApiRepository.DeleteAsync(a => a.PermissionId == entity.Id);
  183. if (input.ApiIds != null && input.ApiIds.Any())
  184. {
  185. var permissionApis = input.ApiIds.Select(a => new PermissionApiEntity { PermissionId = entity.Id, ApiId = a });
  186. await _permissionApiRepository.InsertAsync(permissionApis);
  187. }
  188. //清除用户权限缓存
  189. await ClearUserPermissionsAsync(new List<long> { entity.Id });
  190. return ResponseOutput.Ok();
  191. }
  192. [Transaction]
  193. public async Task<IResponseOutput> DeleteAsync(long id)
  194. {
  195. //递归查询所有权限点
  196. var ids = _permissionRepository.Select
  197. .Where(a => a.Id == id)
  198. .AsTreeCte()
  199. .ToList(a => a.Id);
  200. //删除权限关联接口
  201. await _permissionApiRepository.DeleteAsync(a => ids.Contains(a.PermissionId));
  202. //删除相关权限
  203. await _permissionRepository.DeleteAsync(a => ids.Contains(a.Id));
  204. //清除用户权限缓存
  205. await ClearUserPermissionsAsync(ids);
  206. return ResponseOutput.Ok();
  207. }
  208. public async Task<IResponseOutput> SoftDeleteAsync(long id)
  209. {
  210. //递归查询所有权限点
  211. var ids = _permissionRepository.Select
  212. .Where(a => a.Id == id)
  213. .AsTreeCte()
  214. .ToList(a => a.Id);
  215. //删除权限
  216. await _permissionRepository.SoftDeleteAsync(a => ids.Contains(a.Id));
  217. //清除用户权限缓存
  218. await ClearUserPermissionsAsync(ids);
  219. return ResponseOutput.Ok();
  220. }
  221. [Transaction]
  222. public async Task<IResponseOutput> AssignAsync(PermissionAssignInput input)
  223. {
  224. //分配权限的时候判断角色是否存在
  225. var exists = await _roleRepository.Select.DisableGlobalFilter("Tenant").WhereDynamic(input.RoleId).AnyAsync();
  226. if (!exists)
  227. {
  228. return ResponseOutput.NotOk("该角色不存在或已被删除!");
  229. }
  230. //查询角色权限
  231. var permissionIds = await _rolePermissionRepository.Select.Where(d => d.RoleId == input.RoleId).ToListAsync(m => m.PermissionId);
  232. //批量删除权限
  233. var deleteIds = permissionIds.Where(d => !input.PermissionIds.Contains(d));
  234. if (deleteIds.Any())
  235. {
  236. await _rolePermissionRepository.DeleteAsync(m => m.RoleId == input.RoleId && deleteIds.Contains(m.PermissionId));
  237. }
  238. //批量插入权限
  239. var insertRolePermissions = new List<RolePermissionEntity>();
  240. var insertPermissionIds = input.PermissionIds.Where(d => !permissionIds.Contains(d));
  241. //防止租户非法授权
  242. if (_appConfig.Tenant && User.TenantType == TenantType.Tenant)
  243. {
  244. var masterDb = ServiceProvider.GetRequiredService<IFreeSql>();
  245. var tenantPermissionIds = await masterDb.GetRepositoryBase<TenantPermissionEntity>().Select.Where(d => d.TenantId == User.TenantId).ToListAsync(m => m.PermissionId);
  246. insertPermissionIds = insertPermissionIds.Where(d => tenantPermissionIds.Contains(d));
  247. }
  248. if (insertPermissionIds.Any())
  249. {
  250. foreach (var permissionId in insertPermissionIds)
  251. {
  252. insertRolePermissions.Add(new RolePermissionEntity()
  253. {
  254. RoleId = input.RoleId,
  255. PermissionId = permissionId,
  256. });
  257. }
  258. await _rolePermissionRepository.InsertAsync(insertRolePermissions);
  259. }
  260. //清除角色下关联的用户权限缓存
  261. var userIds = await _userRoleRepository.Select.Where(a => a.RoleId == input.RoleId).ToListAsync(a => a.UserId);
  262. foreach (var userId in userIds)
  263. {
  264. await Cache.DelAsync(string.Format(CacheKey.UserPermissions, userId));
  265. }
  266. return ResponseOutput.Ok();
  267. }
  268. [Transaction]
  269. public async Task<IResponseOutput> SaveTenantPermissionsAsync(PermissionSaveTenantPermissionsInput input)
  270. {
  271. //获得租户db
  272. var ib = ServiceProvider.GetRequiredService<IdleBus<IFreeSql>>();
  273. var tenantDb = ib.GetTenantFreeSql(ServiceProvider, input.TenantId);
  274. //查询租户权限
  275. var permissionIds = await _tenantPermissionRepository.Select.Where(d => d.TenantId == input.TenantId).ToListAsync(m => m.PermissionId);
  276. //批量删除租户权限
  277. var deleteIds = permissionIds.Where(d => !input.PermissionIds.Contains(d));
  278. if (deleteIds.Any())
  279. {
  280. await _tenantPermissionRepository.DeleteAsync(m => m.TenantId == input.TenantId && deleteIds.Contains(m.PermissionId));
  281. //删除租户下关联的角色权限
  282. await tenantDb.GetRepositoryBase<RolePermissionEntity>().DeleteAsync(a => deleteIds.Contains(a.PermissionId));
  283. }
  284. //批量插入租户权限
  285. var tenatPermissions = new List<TenantPermissionEntity>();
  286. var insertPermissionIds = input.PermissionIds.Where(d => !permissionIds.Contains(d));
  287. if (insertPermissionIds.Any())
  288. {
  289. foreach (var permissionId in insertPermissionIds)
  290. {
  291. tenatPermissions.Add(new TenantPermissionEntity()
  292. {
  293. TenantId = input.TenantId,
  294. PermissionId = permissionId,
  295. });
  296. }
  297. await _tenantPermissionRepository.InsertAsync(tenatPermissions);
  298. }
  299. //清除租户下所有用户权限缓存
  300. var userIds = await tenantDb.GetRepositoryBase<UserEntity>().Select.Where(a => a.TenantId == input.TenantId).ToListAsync(a => a.Id);
  301. if(userIds.Any())
  302. {
  303. foreach (var userId in userIds)
  304. {
  305. await Cache.DelAsync(string.Format(CacheKey.UserPermissions, userId));
  306. }
  307. }
  308. return ResponseOutput.Ok();
  309. }
  310. public async Task<IResponseOutput> GetPermissionList()
  311. {
  312. var permissions = await _permissionRepository.Select
  313. .WhereIf(_appConfig.Tenant && User.TenantType == TenantType.Tenant, a =>
  314. _tenantPermissionRepository
  315. .Where(b => b.PermissionId == a.Id && b.TenantId == User.TenantId)
  316. .Any()
  317. )
  318. .OrderBy(a => a.ParentId)
  319. .OrderBy(a => a.Sort)
  320. .ToListAsync(a => new { a.Id, a.ParentId, a.Label, a.Type });
  321. var apis = permissions
  322. .Where(a => a.Type == PermissionType.Dot)
  323. .Select(a => new { a.Id, a.ParentId, a.Label });
  324. var menus = permissions
  325. .Where(a => (new[] { PermissionType.Group, PermissionType.Menu }).Contains(a.Type))
  326. .Select(a => new
  327. {
  328. a.Id,
  329. a.ParentId,
  330. a.Label,
  331. Apis = apis.Where(b => b.ParentId == a.Id).Select(b => new { b.Id, b.Label })
  332. });
  333. return ResponseOutput.Ok(menus);
  334. }
  335. public async Task<IResponseOutput> GetRolePermissionList(long roleId = 0)
  336. {
  337. var permissionIds = await _rolePermissionRepository
  338. .Select.Where(d => d.RoleId == roleId)
  339. .ToListAsync(a => a.PermissionId);
  340. return ResponseOutput.Ok(permissionIds);
  341. }
  342. public async Task<IResponseOutput> GetTenantPermissionList(long tenantId)
  343. {
  344. var permissionIds = await _tenantPermissionRepository
  345. .Select.Where(d => d.TenantId == tenantId)
  346. .ToListAsync(a => a.PermissionId);
  347. return ResponseOutput.Ok(permissionIds);
  348. }
  349. }
  350. }