fix 设备组差异

Src/Dlhis.Basic/Device/Filters/AssignPermissionLimitAttribute.cs

@@ -10,13 +10,13 @@ public class AssignPermissionLimitAttribute : Attribute, IAsyncActionFilter
 {
     public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
     {
-        var currentUser = context.HttpContext.RequestServices.GetRequiredService<ICurrentUser>();
-        var redisCache = context.HttpContext.RequestServices.GetRequiredService<RedisCache>();
-
-        var currentTenantId = currentUser.GetStringTenantId();
-
-        await using var handler = await redisCache.LockAsync($"permission:generate:{currentTenantId}", expiry: TimeSpan.FromMinutes(3));
-        handler.Acquired.ThrowIfFalse("请勿频繁分配");
+        // var currentUser = context.HttpContext.RequestServices.GetRequiredService<ICurrentUser>();
+        // var redisCache = context.HttpContext.RequestServices.GetRequiredService<RedisCache>();
+        //
+        // var currentTenantId = currentUser.GetStringTenantId();
+        //
+        // await using var handler = await redisCache.LockAsync($"permission:generate:{currentTenantId}", expiry: TimeSpan.FromMinutes(3));
+        // handler.Acquired.ThrowIfFalse("请勿频繁分配");
         await next();
     }
 }

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

@@ -18,8 +18,8 @@ public interface IDevicePermissionAnalyzeService : IScopeDependency
 
     Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
         List<string> userNos,
-        string ignoreAssignValue = null,
-        params AssignTypeEnumType[] ignoreAssignTypes
+        DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
+        string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null
     );
 
     Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request);

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

@@ -52,7 +52,7 @@ public abstract class BasePermissionAnalyzeService : IPermissionAnalyzeService
         var gainfoNos = await GetGainfoNosAsync(request.GetActualAssignValue());
 
         var userTenantDeviceCodes = devicesToDelete.IsPresent() && request.AssignType != AssignTypeEnumType.Tenant
-            ? await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(gainfoNos, request.GetActualAssignValue(), request.AssignType)
+            ? await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(gainfoNos, request.UniqueType, request.GetActualAssignValue(), request.AssignType)
             : new Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>();
 
         var tasksToAdd = new List<DeviceTaskEntity>();
@@ -63,7 +63,8 @@ public abstract class BasePermissionAnalyzeService : IPermissionAnalyzeService
             if (userTenantDeviceCodes.Any())
             {
                 var myDeviceCodes = userTenantDeviceCodes[gainfoNo].SelectMany(x => x.AssignTypes).SelectMany(x => x.Codes);
-                currentDevicesToDelete = devicesToDelete.Where(p => codesToDelete.Except(myDeviceCodes).Contains(p.Code));
+                var actToDeleteCodes = codesToDelete.Except(myDeviceCodes);
+                currentDevicesToDelete = devicesToDelete.Where(p => actToDeleteCodes.Contains(p.Code));
             }
 
             tasksToAdd.AddRange(devicesToAdd.Select(x => new DeviceTaskEntity

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

@@ -134,8 +134,8 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
 
     public async Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
         List<string> userNos,
-        string ignoreAssignValue = null,
-        params AssignTypeEnumType[] ignoreAssignTypes)
+        DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
+        string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null)
     {
         var gainfos = await _dbContext.Queryable<GainfoEntity>().Where(x => userNos.Contains(x.No)).ToListAsync();
         if (!gainfos.Any()) return new Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>();
@@ -148,9 +148,9 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
         var gainfoGroups = await _dbContext.Queryable<GainfoGroupEntity>().ToListAsync();
 
         var devicePermissions = await _dbContext.Queryable<DevicePermissionEntity>()
-            .WhereIF(ignoreAssignTypes.IsPresent(), x => !ignoreAssignTypes.Contains(x.AssignType) && x.AssignValue != ignoreAssignValue)
             .Select<DevicePermissionDto>()
             .ToListAsync();
+
         var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
         var deviceRelationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().ToListAsync();
         var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();
@@ -160,7 +160,10 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
         gainfos.ParallelForEach(gainfo =>
         {
             var internalIgnoreAssignTypes = new List<AssignTypeEnumType>();
-            internalIgnoreAssignTypes.AddRange(ignoreAssignTypes);
+
+            if (ignoreAssignType.HasValue)
+                internalIgnoreAssignTypes.Add(ignoreAssignType.Value);
+
             if (gainfo.Type == GainfoUserTypeEnumType.Outsource && (enableFactoryPermissions.FirstOrDefault(x => x.TenantId == gainfo.Factory)?.EnableOutsourceDown ?? true) == false)
             {
                 internalIgnoreAssignTypes.Add(AssignTypeEnumType.Tenant);
@@ -174,7 +177,8 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
                 UserGainfoGroupCodes = gainfoGroupRelationships.Where(x => x.UserNo == gainfo.No).Select(x => x.GroupCode),
                 DeviceCodes = devices.WhereIf(gainfo.Type == GainfoUserTypeEnumType.Outsource, x => x.Type != DeviceTypeEnumType.Meal).Select(x => x.Code), //外包人员不允许餐饮
                 IgnoreAssignValue = ignoreAssignValue,
-                IgnoreAssignTypeTypes = internalIgnoreAssignTypes
+                IgnoreAssignTypes = internalIgnoreAssignTypes,
+                IgnoreUniqueType = ignoreUniqueType
             };
 
             var codes = GetAssignDeviceCodesInternal(analyzePack,
@@ -201,8 +205,14 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
     {
         var deviceDtos = new List<TenantAssignTypeDeviceCode>();
 
+        var uniqueTypes = new[] { DeviceAssignmentTypeEnumType.Device, DeviceAssignmentTypeEnumType.Group };
         foreach (var assignType in new[] { AssignTypeEnumType.User, AssignTypeEnumType.Group, AssignTypeEnumType.Department, AssignTypeEnumType.Tenant })
         {
+            if (analyzePack.IgnoreAssignTypes.Contains(assignType) && analyzePack.IgnoreAssignValue.IsEmpty())
+            {
+                continue;
+            }
+
             var assignValues = assignType switch
             {
                 AssignTypeEnumType.User => new[] { analyzePack.UserNo },
@@ -213,30 +223,16 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
                 _ => throw new ArgumentOutOfRangeException()
             };
 
-            foreach (var assignValue in assignValues.WhereIf(analyzePack.IgnoreAssignTypeTypes.Contains(assignType), x => x != analyzePack.IgnoreAssignValue))
+
+            var data = assignValues.SelectMany(x => uniqueTypes.Select(p => new { assignValue = x, uniqueType = p })).ToList();
+            var needRemove = data.Where(x => x.assignValue == analyzePack.IgnoreAssignValue && x.uniqueType == analyzePack.IgnoreUniqueType);
+            data = data.ExceptBy(needRemove, x => new { x.assignValue, x.uniqueType }).ToList();
+
+            foreach (var item in data)
             {
                 deviceDtos.AddRange(GetCurrentAssignTypePermissions(devicePermissions, gainfoGroups, departments,
-                    DeviceAssignmentTypeEnumType.Device, assignType, assignValue));
-
-                var groupItems = GetCurrentAssignTypePermissions(devicePermissions, gainfoGroups, departments,
-                    DeviceAssignmentTypeEnumType.Group, assignType, assignValue);
-
-                foreach (var groupItem in groupItems)
-                {
-                    foreach (var assignTypeDeviceCodeItem in groupItem.AssignTypes)
-                    {
-                        var r = new List<Guid>();
-                        foreach (var code in assignTypeDeviceCodeItem.Codes)
-                        {
-                            r.AddRange(RecursionHelper.HandlerDeviceGroupNextCodes(code, deviceGroups));
-                        }
-
-                        assignTypeDeviceCodeItem.OriginalCodes = r;
-                        assignTypeDeviceCodeItem.Codes = deviceGroupRelationships.Where(x => r.Contains(x.GroupCode)).Select(x => x.DeviceCode);
-                    }
-                }
-
-                deviceDtos.AddRange(groupItems);
+                    deviceGroups, deviceGroupRelationships,
+                    item.uniqueType, assignType, item.assignValue));
             }
         }
 
@@ -265,6 +261,8 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
         List<DevicePermissionDto> devicePermissions,
         List<GainfoGroupEntity> gainfoGroups,
         List<DepartmentEntity> departments,
+        List<DeviceGroupEntity> deviceGroups,
+        List<DeviceGroupRelationshipEntity> deviceGroupRelationships,
         DeviceAssignmentTypeEnumType uniqueType,
         AssignTypeEnumType assignType,
         string assignValue)
@@ -287,7 +285,8 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
             assignValues = RecursionHelper.HandlerGainfoGroupPreviousCodes(Guid.Parse(assignValue), gainfoGroups).Select(x => x.ToString()).ToList();
         }
 
-        return devicePermissions
+
+        var r = devicePermissions
             .Where(x => x.UniqueType == uniqueType)
             .Where(x => x.AssignType == assignType)
             .Where(x => assignValues.Contains(x.AssignValue))
@@ -304,6 +303,27 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
                 })
             })
             .ToList();
+
+        if (uniqueType == DeviceAssignmentTypeEnumType.Group)
+        {
+            foreach (var groupItem in r)
+            {
+                foreach (var assignTypeDeviceCodeItem in groupItem.AssignTypes)
+                {
+                    var nextItems = new List<Guid>();
+                    foreach (var code in assignTypeDeviceCodeItem.Codes)
+                    {
+                        nextItems.AddRange(RecursionHelper.HandlerDeviceGroupNextCodes(code, deviceGroups));
+                    }
+
+                    nextItems = nextItems.Distinct().ToList();
+                    assignTypeDeviceCodeItem.OriginalCodes = nextItems;
+                    assignTypeDeviceCodeItem.Codes = deviceGroupRelationships.Where(x => nextItems.Contains(x.GroupCode)).Select(x => x.DeviceCode);
+                }
+            }
+        }
+
+        return r;
     }
 
     private async Task ChunkInsertAsync<T>(List<T> batch) where T : class, new()
@@ -315,9 +335,12 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
     }
 
 
-    public async Task<Dictionary<string, IEnumerable<UserTenantDeviceCodeDto>>> GetUserAssignDeviceCodesInTenantAsync(List<string> userNos, string ignoreAssignValue = null, params AssignTypeEnumType[] ignoreAssignTypes)
+    public async Task<Dictionary<string, IEnumerable<UserTenantDeviceCodeDto>>> GetUserAssignDeviceCodesInTenantAsync(
+        List<string> userNos,
+        DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
+        string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null)
     {
-        var result = await GetUserAssignDeviceCodesWithTypeInTenantAsync(userNos, ignoreAssignValue, ignoreAssignTypes);
+        var result = await GetUserAssignDeviceCodesWithTypeInTenantAsync(userNos, ignoreUniqueType, ignoreAssignValue, ignoreAssignType);
 
         return result.ToDictionary(x => x.Key, x => x.Value.GroupBy(p => p.Tenant).Select(item =>
         {