fix 优化任务分配速度

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

@@ -10,9 +10,12 @@ public interface IDevicePermissionService : IScopeDependency
     /// <summary>
     /// 保存设备权限
     /// </summary>
-    /// <param name="reuqest"></param>
+    /// <param name="request"></param>
     /// <returns></returns>
-    Task AssignAsync(DevicePermissionSaveRequest reuqest);
+    Task AssignAsync(DevicePermissionSaveRequest request);
+
+
+    Task GeneratePermissionsAsync(long id);
 
     /// <summary>
     /// 获取分配的权限

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

@@ -5,11 +5,14 @@ using Dlhis.Entity.Device.Entities;
 using Dlhis.Entity.Device.Enums;
 using Dlhis.Entity.Sys.Entities;
 using Dlhis.Entity.Sys.Enums;
+using Dlhis.Scheduled.Api;
 using Kurisu.AspNetCore.Authentication.Abstractions;
 using Kurisu.AspNetCore.DataAccess.Entity;
 using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
+using Kurisu.AspNetCore.Utils;
 using Kurisu.AspNetCore.Utils.Extensions;
 using SqlSugar;
+using GeneratePermissionIdRequest = Dlhis.Scheduled.Api.Request.GeneratePermissionIdRequest;
 
 namespace Dlhis.Basic.Device.Services.Implements;
 
@@ -17,44 +20,85 @@ public class DevicePermissionService : IDevicePermissionService
 {
     private readonly IDbContext _dbContext;
     private readonly ICurrentUser _currentUser;
+    private readonly RedisCache _redisCache;
+    private readonly IHangfireApi _hangfireApi;
 
-    public DevicePermissionService(IDbContext dbContext, ICurrentUser currentUser)
+    public DevicePermissionService(IDbContext dbContext, ICurrentUser currentUser, RedisCache redisCache, IHangfireApi hangfireApi)
     {
         _dbContext = dbContext;
         _currentUser = currentUser;
+        _redisCache = redisCache;
+        _hangfireApi = hangfireApi;
     }
 
     public async Task AssignAsync(DevicePermissionSaveRequest request)
     {
+        var currentTenantId = _currentUser.GetStringTenantId();
+
+        await using var handler = await _redisCache.LockAsync($"permission:generate:{currentTenantId}");
+        handler.Acquired.ThrowIfFalse("请勿频繁分配设备权限");
+
         var tenantId = request.AssignType == AssignTypeEnumType.Department ? request.TenantId : _currentUser.GetStringTenantId();
+        request.TenantId = tenantId;
 
-        await GenerateDeviceTasksAsync(async () =>
+        var json = request.ToJson();
+        var id = await _dbContext.InsertReturnIdentityAsync(new DevicePermissionAssignmentEntity
         {
-            //删除当前匹配的基地权限
-            var p = await _dbContext.Queryable<DevicePermissionEntity>()
-                .Where(x => x.AssignType == request.AssignType)
-                .Where(x => x.AssignValue == request.AssignValue)
-                .Where(x => x.UniqueType == request.UniqueType)
-                .Where(x => x.TenantId == tenantId)
-                .ToListAsync();
+            Assignment = json,
+            IsHandler = false,
+            Result = null,
+            TenantId = currentTenantId
+        });
 
-            await _dbContext.DeleteReallyAsync(p);
+        await _hangfireApi.GeneratePermissionsAsync(new GeneratePermissionIdRequest()
+        {
+            Id = id
+        });
+    }
 
-            //保存配置的权限
-            if (request.Codes.IsPresent())
+    public async Task GeneratePermissionsAsync(long id)
+    {
+        var assignment = await _dbContext.Queryable<DevicePermissionAssignmentEntity>().SingleAsync(x => x.Id == id);
+        if (assignment == null) return;
+        if (assignment.IsHandler) return;
+
+        try
+        {
+            var request = assignment.Assignment.ToObject<DevicePermissionSaveRequest>();
+
+            await GenerateDeviceTasksAsync(async () =>
             {
-                var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
-                {
-                    AssignType = request.AssignType,
-                    AssignValue = request.AssignValue,
-                    UniqueType = request.UniqueType,
-                    UniqueValue = code,
-                    TenantId = tenantId
-                }).ToList();
+                //删除当前匹配的基地权限
+                var p = await _dbContext.Queryable<DevicePermissionEntity>()
+                    .Where(x => x.AssignType == request.AssignType)
+                    .Where(x => x.AssignValue == request.AssignValue)
+                    .Where(x => x.UniqueType == request.UniqueType)
+                    .Where(x => x.TenantId == request.TenantId)
+                    .ToListAsync();
 
-                await _dbContext.InsertAsync(devicePermissions);
-            }
-        }, null);
+                await _dbContext.DeleteReallyAsync(p);
+
+                //保存配置的权限
+                if (request.Codes.IsPresent())
+                {
+                    var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
+                    {
+                        AssignType = request.AssignType,
+                        AssignValue = request.AssignValue,
+                        UniqueType = request.UniqueType,
+                        UniqueValue = code,
+                        TenantId = request.TenantId
+                    }).ToList();
+
+                    await _dbContext.InsertAsync(devicePermissions);
+                }
+            }, null);
+        }
+        finally
+        {
+            assignment.IsHandler = true;
+            await _dbContext.UpdateAsync(assignment);
+        }
     }
 
     public async Task<List<Guid>> GetAssignmentsAsync(DeviceAssignmentTypeEnumType uniqueType, AssignTypeEnumType assignType, string assignValue)