diff --git a/Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs b/Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs
index b9bfc754..a81487da 100644
--- a/Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs
+++ b/Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs
@@ -1,11 +1,11 @@
-using Dlhis.Basic.DataPermissions;
-using Dlhis.Basic.Device;
-using Dlhis.Basic.Device.Request;
+using Dlhis.Basic.Device.Dtos;
 using Dlhis.Basic.Device.Response;
 using Dlhis.Basic.Device.Services;
 using Dlhis.Basic.Organization.Request;
 using Dlhis.Basic.Organization.Response;
 using Dlhis.Entity.Basic.Entity;
+using Dlhis.Entity.Device.Entities;
+using Dlhis.Entity.Device.Enums;
 using Dlhis.Entity.Sys.Entities;
 using Dlhis.Entity.Sys.Enums;
 using Kurisu.AspNetCore.Authentication.Abstractions;
@@ -19,18 +19,15 @@ public class GainfoGroupService : IGainfoGroupService
 {
     private readonly IDbContext _dbContext;
     private readonly ICurrentUser _currentUser;
-    private readonly IMyDataPermissionService _myDataPermissionService;
-    private readonly INamedResolver _namedResolver;
+    private readonly IDevicePermissionAnalyzeService _devicePermissionAnalyzeService;
 
     public GainfoGroupService(IDbContext dbContext,
         ICurrentUser currentUser,
-        IMyDataPermissionService myDataPermissionService,
-        INamedResolver namedResolver)
+        IDevicePermissionAnalyzeService devicePermissionAnalyzeService)
     {
         _dbContext = dbContext;
         _currentUser = currentUser;
-        _myDataPermissionService = myDataPermissionService;
-        _namedResolver = namedResolver;
+        _devicePermissionAnalyzeService = devicePermissionAnalyzeService;
     }
 
     public async Task<List<GainfoGroupTreeResponse>> GetTreeAsync()
@@ -96,16 +93,19 @@ public class GainfoGroupService : IGainfoGroupService
         var relations = await _dbContext.Queryable<GainfoGroupRelationshipEntity>()
             .Where(x => x.GroupCode == request.GroupCode)
             .ToListAsync();
-        await _dbContext.DeleteAsync(relations);
 
-        var userNos = await _dbContext.Queryable<GainfoEntity>()
+
+        var presentUserNos = await _dbContext.Queryable<GainfoEntity>()
             .Where(x => request.UserNos.Contains(x.No) || request.UserNos.Contains(x.Code)) //NO和工号匹配
             .Select(x => x.No)
             .ToListAsync();
 
         //(userNos.Count != request.UserNos.Count).ThrowIfTrue("存在权限外人员,无法添加");
 
-        var entities = userNos.Select(x => new GainfoGroupRelationshipEntity
+        var r = await PermissionResetAsync(request.GroupCode, relations.Select(x => x.UserNo).Distinct().ToList(), presentUserNos);
+
+        await _dbContext.DeleteAsync(relations);
+        var entities = presentUserNos.Select(x => new GainfoGroupRelationshipEntity
         {
             GroupCode = request.GroupCode,
             UserNo = x
@@ -113,61 +113,127 @@ public class GainfoGroupService : IGainfoGroupService
 
         await _dbContext.InsertAsync(entities);
 
-        return await PermissionResetAsync(request.GroupCode);
+
+        return r;
     }
 
 
-    private async Task<DevicePermissionAssignResponse> PermissionResetAsync(Guid groupCode)
+    private async Task<DevicePermissionAssignResponse> PermissionResetAsync(Guid groupCode, List<string> beforeUserNos, List<string> presentUserNos)
     {
+        var usersToAdd = presentUserNos.Except(beforeUserNos).ToList();
+        var usersToDelete = beforeUserNos.Except(presentUserNos).ToList();
+        if (usersToAdd.IsEmpty() && usersToDelete.IsEmpty())
+        {
+            return new DevicePermissionAssignResponse(0, 0);
+        }
+
         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 => 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();
+        //var result = new List<DevicePermissionAssignResponse>();
+        var deviceGroups = dps.Any(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
+            ? await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync()
+            : new List<DeviceGroupEntity>(0);
 
-        dps.AddRange(dps2);
-
-        var analyzeService = _namedResolver.GetService<IPermissionAnalyzeService>(PermissionAnalyzeConstants.GetTypeName(AssignTypeEnumType.Group));
-
-        var result = new List<DevicePermissionAssignResponse>();
-
-        foreach (var devicePermissionGroup in dps.GroupBy(x => new { x.AssignValue, x.TenantId, x.UniqueType, x.Type }))
+        //只会循环2次
+        var deviceCodes = new List<Guid>();
+        foreach (var devicePermissionGroup in dps.GroupBy(x => x.UniqueType))
         {
-            var assignValue = devicePermissionGroup.Key.AssignValue;
-            var tenantId = devicePermissionGroup.Key.TenantId;
-            var uniqueType = devicePermissionGroup.Key.UniqueType;
-            var type = devicePermissionGroup.Key.Type;
-
             var codes = devicePermissionGroup.Select(x => x.UniqueValue).Distinct().ToList();
 
-            var r = await analyzeService.AnalyzeAsync(new DevicePermissionSaveRequest
+            if (devicePermissionGroup.Key == DeviceAssignmentTypeEnumType.Group)
             {
-                AssignType = AssignTypeEnumType.Group,
-                AssignValue = assignValue,
-                UniqueType = uniqueType,
-                Codes = codes,
-                TenantId = tenantId,
-                Type = type
-            });
+                deviceCodes.AddRange(await GetDeviceCodeByGroupAsync(codes, deviceGroups));
+            }
 
-            result.Add(r);
+            deviceCodes.AddRange(codes);
         }
 
-        return new DevicePermissionAssignResponse(result.Sum(x => x.AddCount), result.Sum(x => x.DeleteCount));
+        deviceCodes = deviceCodes.Distinct().ToList();
+        var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => deviceCodes.Contains(x.Code)).ToListAsync();
+
+        var userTenantDeviceCodes = usersToDelete.IsPresent() && dps.Exists(x => x.AssignType != AssignTypeEnumType.Tenant)
+            ? await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(beforeUserNos.Union(presentUserNos).ToList(), groupCode.ToString(), AssignTypeEnumType.Group)
+            : new Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>();
+
+        var addTasks = new List<DeviceTaskEntity>();
+        var deleteTasks = new List<DeviceTaskEntity>();
+        foreach (var device in devices)
+        {
+            foreach (var item in usersToDelete)
+            {
+                var myDeviceCodes = userTenantDeviceCodes[item].SelectMany(x => x.AssignTypes).SelectMany(x => x.Codes);
+                if (myDeviceCodes.Any(x => x == device.Code))
+                {
+                    continue;
+                }
+
+                deleteTasks.Add(new DeviceTaskEntity
+                {
+                    Type = DeviceTaskEnumType.Delete,
+                    DeviceType = device.Type,
+                    UserId = null,
+                    UserNo = item,
+                    DeviceUniqueNo = device.UniqueNo,
+                    Status = DeviceTaskStatusEnumType.Wait,
+                    Version = 0,
+                    ResultMessage = null,
+                    CancellationId = 0,
+                    Source = DeviceTaskSourceEnumType.Manually,
+                    Priority = 0,
+                    TenantId = device.TenantId
+                });
+            }
+
+            foreach (var item in usersToAdd)
+            {
+                addTasks.Add(new DeviceTaskEntity
+                {
+                    Type = DeviceTaskEnumType.Add,
+                    DeviceType = device.Type,
+                    UserId = null,
+                    UserNo = item,
+                    DeviceUniqueNo = device.UniqueNo,
+                    Status = DeviceTaskStatusEnumType.Wait,
+                    Version = 0,
+                    ResultMessage = null,
+                    CancellationId = 0,
+                    Source = DeviceTaskSourceEnumType.Manually,
+                    Priority = 0,
+                    TenantId = device.TenantId
+                });
+            }
+        }
+
+        await _dbContext.InsertAsync(addTasks);
+        await _dbContext.InsertAsync(deleteTasks);
+
+        return new DevicePermissionAssignResponse(addTasks.Count, deleteTasks.Count);
+    }
+
+    /// <summary>
+    /// 获取分组下的deviceCode
+    /// </summary>
+    /// <param name="codes"></param>
+    /// <param name="deviceGroups"></param>
+    /// <returns></returns>
+    private async Task<List<Guid>> GetDeviceCodeByGroupAsync(List<Guid> codes, List<DeviceGroupEntity> deviceGroups)
+    {
+        var result = new List<Guid>();
+        codes.ForEach(groupCode => result.AddRange(RecursionHelper.HandlerDeviceGroupNextCodes(groupCode, deviceGroups)));
+
+        result = result.Distinct().ToList();
+
+        return await _dbContext.Queryable<DeviceGroupRelationshipEntity>()
+            .Where(x => result.Contains(x.GroupCode))
+            .Select(x => x.DeviceCode)
+            .Distinct()
+            .ToListAsync();
     }