fix 权限数据优化

Src/Dlhis.Basic/DataPermissions/GetDataPermissionService.cs

@@ -56,14 +56,18 @@ public class GetDataPermissionService : IGetDataPermissions, ISingletonDependenc
             if (deviceGroupCodes.Any())
             {
                 var data = db.Queryable<DeviceGroupEntity>().ToList();
-                //开始递归处理
+
-                var tops = data.Where(x => !x.PCode.HasValue).ToList();
+                var myDeviceGroupCodes = new List<Guid>();
-                tops.ForEach(x => { DeviceGroupRecursionGetNext(x, data, deviceGroupCodes, deviceGroupCodes.Contains(x.Code)); });
+                foreach (Guid deviceGroupCode in deviceGroupCodes)
-                deviceGroupCodes = deviceGroupCodes.Distinct().ToList();
+                {
+                    myDeviceGroupCodes.AddRange(RecursionHelper.HandlerDeviceGroupNextCodes(deviceGroupCode, data));
+                }
+
+                myDeviceGroupCodes = myDeviceGroupCodes.Distinct().ToList();
 
                 if (deviceCodeProperty != null)
                 {
-                    deviceCodes = db.Queryable<DeviceGroupRelationshipEntity>().Where(x => deviceGroupCodes.Contains(x.GroupCode)).Select(x => x.DeviceCode).ToList();
+                    deviceCodes = db.Queryable<DeviceGroupRelationshipEntity>().Where(x => myDeviceGroupCodes.Contains(x.GroupCode)).Select(x => x.DeviceCode).ToList();
                 }
 
                 if (deviceGroupCodeProperty != null)
@@ -82,39 +86,50 @@ public class GetDataPermissionService : IGetDataPermissions, ISingletonDependenc
 
         return dict;
     }
-
-    static void DeviceGroupRecursionGetNext(DeviceGroupEntity current, List<DeviceGroupEntity> data, List<Guid> result, bool add)
-    {
-        var next = data.Where(x => x.PCode == current.Code).ToList();
-        foreach (var item in next)
-        {
-            if (add)
-            {
-                result.Add(item.Code);
-            }
-
-            DeviceGroupRecursionGetNext(item, data, result, result.Contains(item.Code));
-        }
-    }
 }
 
 public interface IMyDataPermissionService : IScopeDependency
 {
-    List<Guid> GetMyDeviceCodes();
+    (bool, List<Guid>) GetMyDeviceCodes();
+    (bool, List<Guid>) GetMyDeviceGroupCodes();
 }
 
 public class MyDataPermissionService : IMyDataPermissionService
 {
     private readonly IGetDataPermissions _getDataPermissions;
+    private readonly ICurrentUser _currentUser;
 
-    public MyDataPermissionService(IGetDataPermissions getDataPermissions)
+    public MyDataPermissionService(IGetDataPermissions getDataPermissions, ICurrentUser currentUser)
     {
         _getDataPermissions = getDataPermissions;
+        _currentUser = currentUser;
     }
 
     /// <inheritdoc />
-    public List<Guid> GetMyDeviceCodes()
+    public (bool, List<Guid>) GetMyDeviceCodes()
     {
-        return _getDataPermissions.GetData<DeviceEntity>().FirstOrDefault().Value ?? new List<Guid>();
+        var codes = new List<Guid>();
+
+        var disableFilter = _currentUser.GetRole() is "admin" or "tenant-admin";
+        if (!disableFilter)
+        {
+            codes = _getDataPermissions.GetData<DeviceEntity>().FirstOrDefault().Value ?? new List<Guid>();
+        }
+
+        return (!disableFilter, codes);
+    }
+
+    /// <inheritdoc />
+    public (bool, List<Guid>) GetMyDeviceGroupCodes()
+    {
+        var codes = new List<Guid>();
+
+        var disableFilter = _currentUser.GetRole() is "admin" or "tenant-admin";
+        if (!disableFilter)
+        {
+            codes = _getDataPermissions.GetData<DeviceGroupEntity>().FirstOrDefault().Value ?? new List<Guid>();
+        }
+
+        return (!disableFilter, codes);
     }
 }

Src/Dlhis.Basic/Device/Services/IDevicePermissionAnalyzeService.cs

@@ -2,6 +2,7 @@ using Dlhis.Basic.Device.Dtos;
 using Dlhis.Basic.Device.Request;
 using Dlhis.Basic.Device.Response;
 using Dlhis.Basic.Organization.Dto;
+using Dlhis.Entity.Sys.Entities;
 using Dlhis.Entity.Sys.Enums;
 
 namespace Dlhis.Basic.Device.Services;
@@ -11,6 +12,8 @@ namespace Dlhis.Basic.Device.Services;
 /// </summary>
 public interface IDevicePermissionAnalyzeService : IScopeDependency
 {
+    Task<List<DevicePermissionEntity>> GetDevicePermissions(DevicePermissionSaveRequest request);
+    
     Task<DevicePermissionAssignResponse> GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos);
 
     Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(List<string> userNos, params AssignTypeEnumType[] ignoreAssignTypes);

Src/Dlhis.Basic/Device/Services/Implements/BasePermissionAnalyzeService.cs

@@ -1,4 +1,3 @@
-using Dlhis.Basic.DataPermissions;
 using Dlhis.Basic.Device.Dtos;
 using Dlhis.Basic.Device.Request;
 using Dlhis.Basic.Device.Response;
@@ -12,7 +11,6 @@ using Kurisu.AspNetCore.DataAccess.Entity;
 using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
 using Kurisu.AspNetCore.Scope;
 using Kurisu.AspNetCore.Utils.Extensions;
-using SqlSugar;
 
 namespace Dlhis.Basic.Device.Services.Implements;
 
@@ -21,31 +19,26 @@ namespace Dlhis.Basic.Device.Services.Implements;
 /// </summary>
 public abstract class BasePermissionAnalyzeService : IPermissionAnalyzeService
 {
-    private readonly ICurrentUser _currentUser;
-    private readonly IMyDataPermissionService _myDataPermissionService;
     private readonly IDevicePermissionAnalyzeService _devicePermissionAnalyzeService;
 
     protected IDbContext DbContext { get; }
 
     protected BasePermissionAnalyzeService(IServiceProvider serviceProvider)
     {
-        _currentUser = serviceProvider.GetService<ICurrentUser>();
+        ICurrentUser currentUser = serviceProvider.GetService<ICurrentUser>();
-        _myDataPermissionService = serviceProvider.GetService<IMyDataPermissionService>();
         DbContext = serviceProvider.GetService<IDbContext>();
-        CurrentTenantId = _currentUser.GetStringTenantId();
+        CurrentTenantId = currentUser.GetStringTenantId();
         _devicePermissionAnalyzeService = serviceProvider.GetService<IDevicePermissionAnalyzeService>();
     }
 
     private string CurrentTenantId { get; }
 
-    protected ISugarQueryable<DevicePermissionEntity> DevicePermission => DbContext.Queryable<DevicePermissionEntity>();
-
     public async Task<DevicePermissionAssignResponse> AnalyzeAsync(DevicePermissionSaveRequest request)
     {
         await CheckWhetherAssignToTopDeviceGroupAsync(request);
         await CheckAssignedToTenantAsync(request);
 
-        var dps = await GetAssignedDevicePermissionsAsync(request);
+        var dps = await _devicePermissionAnalyzeService.GetDevicePermissions(request);
 
         (List<Guid> codesToAdd, List<Guid> codesToDelete) = await GetDiffAsync(request.UniqueType, dps, request.Codes);
         if (codesToAdd.IsEmpty() && codesToDelete.IsEmpty())
@@ -225,35 +218,6 @@ public abstract class BasePermissionAnalyzeService : IPermissionAnalyzeService
         }
     }
 
-    private List<Guid> GetMyUniqueValues(DeviceAssignmentTypeEnumType uniqueType)
-    {
-        var searchAll = _currentUser.GetRole() is "admin" or "tenant-admin";
-        if (!searchAll && uniqueType == DeviceAssignmentTypeEnumType.Device)
-        {
-            return _myDataPermissionService.GetMyDeviceCodes();
-        }
-
-        return new List<Guid>();
-    }
-
-    /// <summary>
-    /// 获取当前分配对应的现有权限
-    /// </summary>
-    /// <param name="request"></param>
-    /// <returns></returns>
-    private async Task<List<DevicePermissionEntity>> GetAssignedDevicePermissionsAsync(DevicePermissionSaveRequest request)
-    {
-        var myData = GetMyUniqueValues(request.UniqueType);
-
-        return await DevicePermission.Where(x => x.AssignType == request.AssignType
-                                                 && x.AssignValue == request.GetActualAssignValue()
-                                                 && x.UniqueType == request.UniqueType
-                                                 && x.Type == request.Type
-                                                 && x.TenantId == CurrentTenantId)
-            .WhereIF(myData.Any(), x => myData.Contains(x.UniqueValue))
-            .ToListAsync();
-    }
-
     /// <summary>
     /// 获取现在权限与当前的分配之间的deviceCode差异
     /// </summary>

Src/Dlhis.Basic/Device/Services/Implements/DeviceGroupService.cs

@@ -1,4 +1,5 @@
-using Dlhis.Basic.Device.Request;
+using Dlhis.Basic.DataPermissions;
+using Dlhis.Basic.Device.Request;
 using Dlhis.Basic.Device.Response;
 using Dlhis.Entity.Basic.Entity;
 using Dlhis.Entity.Device.Entities;
@@ -18,16 +19,19 @@ public class DeviceGroupService : IDeviceGroupService
     private readonly IDbContext _dbContext;
     private readonly ICurrentUser _currentUser;
     private readonly INamedResolver _namedResolver;
+    private readonly IMyDataPermissionService _myDataPermissionService;
     private readonly ITenantApi _tenantApi;
 
     public DeviceGroupService(IDbContext dbContext,
         ICurrentUser currentUser,
         INamedResolver namedResolver,
+        IMyDataPermissionService myDataPermissionService,
         ITenantApi tenantApi)
     {
         _dbContext = dbContext;
         _currentUser = currentUser;
         _namedResolver = namedResolver;
+        _myDataPermissionService = myDataPermissionService;
         _tenantApi = tenantApi;
     }
 
@@ -123,11 +127,12 @@ public class DeviceGroupService : IDeviceGroupService
 
     private async Task<DevicePermissionAssignResponse> PermissionResetAsync(Guid groupCode)
     {
-        var deviceGroups = RecursionHelper.HandlerDeviceGroupPreviousCodes(groupCode, await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync());
+        var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
+        var deviceGroupCodes = RecursionHelper.HandlerDeviceGroupPreviousCodes(groupCode, deviceGroups);
 
         var dps = await _dbContext.Queryable<DevicePermissionEntity>()
             .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
-            .Where(x => deviceGroups.Contains(x.UniqueValue))
+            .Where(x => deviceGroupCodes.Contains(x.UniqueValue))
             .ToListAsync();
 
         var result = new List<DevicePermissionAssignResponse>();

Src/Dlhis.Basic/Device/Services/Implements/DevicePermissionAnalyzeService.cs

@@ -32,6 +32,25 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
         _myDataPermissionService = myDataPermissionService;
     }
 
+
+    public async Task<List<DevicePermissionEntity>> GetDevicePermissions(DevicePermissionSaveRequest request)
+    {
+        var currentTenantId = _currentUser.GetStringTenantId();
+
+        (bool enableDeviceFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
+        (bool enableDeviceGroupFilter, List<Guid> deviceGroupCodes) = _myDataPermissionService.GetMyDeviceGroupCodes();
+
+        return await _dbContext.Queryable<DevicePermissionEntity>().Where(x => x.AssignType == request.AssignType
+                                                                               && x.AssignValue == request.GetActualAssignValue()
+                                                                               && x.UniqueType == request.UniqueType
+                                                                               && x.Type == request.Type
+                                                                               && x.TenantId == currentTenantId)
+            .WhereIF(enableDeviceFilter && request.UniqueType == DeviceAssignmentTypeEnumType.Device, x => deviceCodes.Contains(x.UniqueValue))
+            .WhereIF(enableDeviceGroupFilter && request.UniqueType == DeviceAssignmentTypeEnumType.Group, x => deviceGroupCodes.Contains(x.UniqueValue))
+            .ToListAsync();
+    }
+
+
     public async Task<DevicePermissionAssignResponse> GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos)
     {
         var before = await GetUserAssignDeviceCodesInTenantAsync(userNos);
@@ -365,13 +384,13 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
     {
         var currentAssignValue = request.AssignType == AssignTypeEnumType.Department ? request.TenantId + ":" + request.AssignValue : request.AssignValue;
 
-        var deviceCodes = _currentUser.GetRole() is "admin" or "tenant-admin" ? new List<Guid>() : _myDataPermissionService.GetMyDeviceCodes();
+        (bool enableFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
 
         return await _dbContext.Queryable<DevicePermissionEntity>()
             .Where(x => x.AssignType == request.AssignType)
             .Where(x => x.AssignValue == currentAssignValue)
             .Where(x => x.UniqueType == request.UniqueType)
-            .WhereIF(deviceCodes.Any() && request.UniqueType == DeviceAssignmentTypeEnumType.Device, x => deviceCodes.Contains(x.UniqueValue))
+            .WhereIF(enableFilter && request.UniqueType == DeviceAssignmentTypeEnumType.Device, x => deviceCodes.Contains(x.UniqueValue))
             .Where(x => x.Type == request.Type)
             .Select(x => x.UniqueValue)
             .ToListAsync();

Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs

@@ -1,4 +1,5 @@
-using Dlhis.Basic.Device;
+using Dlhis.Basic.DataPermissions;
+using Dlhis.Basic.Device;
 using Dlhis.Basic.Device.Request;
 using Dlhis.Basic.Device.Response;
 using Dlhis.Basic.Device.Services;
@@ -18,12 +19,17 @@ public class GainfoGroupService : IGainfoGroupService
 {
     private readonly IDbContext _dbContext;
     private readonly ICurrentUser _currentUser;
+    private readonly IMyDataPermissionService _myDataPermissionService;
     private readonly INamedResolver _namedResolver;
 
-    public GainfoGroupService(IDbContext dbContext, ICurrentUser currentUser, INamedResolver namedResolver)
+    public GainfoGroupService(IDbContext dbContext,
+        ICurrentUser currentUser,
+        IMyDataPermissionService myDataPermissionService,
+        INamedResolver namedResolver)
     {
         _dbContext = dbContext;
         _currentUser = currentUser;
+        _myDataPermissionService = myDataPermissionService;
         _namedResolver = namedResolver;
     }
 
@@ -81,7 +87,7 @@ public class GainfoGroupService : IGainfoGroupService
         if (request.UserNos.IsPresent())
         {
             var pGrp = await _dbContext.Queryable<GainfoGroupEntity>().Where(x => x.Code == request.GroupCode).FirstAsync();
-            (pGrp?.Editable == false && pGrp?.IsDefault == true).ThrowIfTrue("不可分配人员到当前分组");
+            (pGrp is { Editable: false, IsDefault: true }).ThrowIfTrue("不可分配人员到当前分组");
         }
 
         var existsNextGroup = await _dbContext.Queryable<GainfoGroupEntity>().Where(x => x.PCode == request.GroupCode).AnyAsync();
@@ -113,13 +119,28 @@ public class GainfoGroupService : IGainfoGroupService
 
     private async Task<DevicePermissionAssignResponse> PermissionResetAsync(Guid groupCode)
     {
-        var gainfoGroups = RecursionHelper.HandlerGainfoGroupPreviousCodes(groupCode, await _dbContext.Queryable<GainfoGroupEntity>().ToListAsync()).Select(x => x.ToString());
+        var gainfoGroups = await _dbContext.Queryable<GainfoGroupEntity>().ToListAsync();
+        var gainfoGroupCodes = RecursionHelper.HandlerGainfoGroupPreviousCodes(groupCode, gainfoGroups).Select(x => x.ToString());
+
+        (bool enableDeviceFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
+        (bool enableDeviceGroupFilter, List<Guid> deviceGroupCodes) = _myDataPermissionService.GetMyDeviceGroupCodes();
 
         var dps = await _dbContext.Queryable<DevicePermissionEntity>()
             .Where(x => x.AssignType == AssignTypeEnumType.Group)
-            .Where(x => gainfoGroups.Contains(x.AssignValue))
+            .Where(x => gainfoGroupCodes.Contains(x.AssignValue))
+            .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Device)
+            .WhereIF(enableDeviceFilter, x => deviceCodes.Contains(x.UniqueValue))
             .ToListAsync();
 
+        var dps2 = await _dbContext.Queryable<DevicePermissionEntity>()
+            .Where(x => x.AssignType == AssignTypeEnumType.Group)
+            .Where(x => gainfoGroupCodes.Contains(x.AssignValue))
+            .Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
+            .WhereIF(enableDeviceGroupFilter, x => deviceGroupCodes.Contains(x.UniqueValue))
+            .ToListAsync();
+
+        dps.AddRange(dps2);
+
         var analyzeService = _namedResolver.GetService<IPermissionAnalyzeService>(PermissionAnalyzeConstants.GetTypeName(AssignTypeEnumType.Group));
 
         var result = new List<DevicePermissionAssignResponse>();