feat 按设备,设备组,营业点维度添加人员

Src/Dlhis.Basic/Device/Controllers/DevicePermissionsController.cs

@@ -1,4 +1,5 @@
 using Dlhis.Basic.Device.Dtos;
+using Dlhis.Basic.Device.Filters;
 using Dlhis.Basic.Device.Request;
 using Dlhis.Basic.Device.Services;
 using Dlhis.Basic.Organization.Dto;
@@ -29,11 +30,25 @@ public class DevicePermissionsController : ControllerBase
     [HttpPost("assign")]
     [Transactional]
     [IgnoreTenant]
+    [AssignPermissionLimit]
     public async Task AssignAsync(DevicePermissionSaveRequest request)
     {
         await _devicePermissionService.AssignAsync(request);
     }
 
+    /// <summary>
+    /// 分配权限到设备/设备组/营业点
+    /// </summary>
+    /// <param name="request"></param>
+    [HttpPost("assign-unique")]
+    [Transactional]
+    [IgnoreTenant]
+    [AssignPermissionLimit]
+    public async Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
+    {
+        await _devicePermissionService.AssignToUniqueAsync(request);
+    }
+
     [AllowAnonymous]
     [HttpPost("assignment-generate")]
     [Transactional]

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

@@ -0,0 +1,24 @@
+using Kurisu.AspNetCore.Authentication.Abstractions;
+using Kurisu.AspNetCore.Utils;
+using Kurisu.AspNetCore.Utils.Extensions;
+using Microsoft.AspNetCore.Mvc.Filters;
+
+namespace Dlhis.Basic.Device.Filters;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class AssignPermissionLimitAttribute : Attribute, IAsyncActionFilter
+{
+    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+    {
+        var redisCache = context.HttpContext.RequestServices.GetRequiredService<RedisCache>();
+        var currentUser = context.HttpContext.RequestServices.GetRequiredService<ICurrentUser>();
+
+        var currentTenantId = currentUser.GetStringTenantId();
+
+        await using (var handler = await redisCache.LockAsync($"permission:generate:{currentTenantId}"))
+        {
+            handler.Acquired.ThrowIfFalse("请勿频繁分配设备权限");
+            await next();
+        }
+    }
+}

Src/Dlhis.Basic/Device/Request/DevicePermissionsAssignToDeviceRequest.cs

@@ -0,0 +1,49 @@
+using System.ComponentModel.DataAnnotations;
+using Dlhis.Entity.Sys.Enums;
+using Kurisu.AspNetCore.Utils.Extensions;
+
+namespace Dlhis.Basic.Device.Request;
+
+public class DevicePermissionsAssignToDeviceRequest : IValidatableObject
+{
+    /// <summary>
+    /// 分配类型
+    /// </summary>
+    public DeviceAssignmentTypeEnumType UniqueType { get; set; }
+
+    /// <summary>
+    /// 分配值
+    /// </summary>
+    public Guid UniqueValue { get; set; }
+
+    /// <summary>
+    /// 来源
+    /// </summary>
+    public AssignTypeEnumType AssignType { get; set; }
+
+    /// <summary>
+    /// 来源值
+    /// </summary>
+    public List<string> Values { get; set; }
+
+    /// <summary>
+    /// 只删除权限
+    /// </summary>
+    public bool IsDelete { get; set; }
+
+    /// <summary>
+    /// AssignType == AssignTypeEnumType.Department 需要传入
+    /// </summary>
+    public string TenantId { get; set; }
+
+    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
+    {
+        if (AssignType == AssignTypeEnumType.Department)
+        {
+            if (TenantId.IsEmpty())
+            {
+                yield return new ValidationResult("请明确具体的厂区", new[] { nameof(TenantId) });
+            }
+        }
+    }
+}

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

@@ -16,6 +16,12 @@ public interface IDevicePermissionService : IScopeDependency
     /// <returns></returns>
     Task AssignAsync(DevicePermissionSaveRequest request);
 
+    /// <summary>
+    /// 分配到设备
+    /// </summary>
+    /// <param name="request"></param>
+    /// <returns></returns>
+    Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request);
 
     Task GeneratePermissionsAsync(long id);
 
@@ -67,6 +73,6 @@ public interface IDevicePermissionService : IScopeDependency
 
     Task<int> ReGeneratePermissionUsersInfoAsync(PermissionUsersInfoDto beforeDto);
 
-    
+
     Task<Pagination<GainfoDto>> GetGainfoPageByDeviceAsync(DeviceWithGainfoRequest request);
 }

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

@@ -6,16 +6,13 @@ 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.Dto;
 using Kurisu.AspNetCore.DataAccess.Entity;
 using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
 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;
 
@@ -23,27 +20,16 @@ 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,
-        RedisCache redisCache,
-        IHangfireApi hangfireApi)
+        ICurrentUser currentUser)
     {
         _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();
 
         await GenerateDeviceTasksAsync(async () =>
@@ -75,6 +61,43 @@ public class DevicePermissionService : IDevicePermissionService
         }, null);
     }
 
+    public async Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
+    {
+        var tenantId = request.AssignType == AssignTypeEnumType.Department ? request.TenantId : _currentUser.GetStringTenantId();
+
+        await GenerateDeviceTasksAsync(async () =>
+        {
+            //删除当前匹配的基地权限
+            var p = await _dbContext.Queryable<DevicePermissionEntity>()
+                .Where(x => x.UniqueType == request.UniqueType)
+                .Where(x => x.UniqueValue == request.UniqueValue)
+                .Where(x => x.AssignType == request.AssignType)
+                .Where(x => request.Values.Contains(x.AssignValue))
+                .Where(x => x.TenantId == tenantId)
+                .ToListAsync();
+
+            await _dbContext.DeleteReallyAsync(p);
+
+            if (!request.IsDelete)
+            {
+                //保存配置的权限
+                if (request.Values.IsPresent())
+                {
+                    var devicePermissions = request.Values.Select(v => new DevicePermissionEntity
+                    {
+                        AssignType = request.AssignType,
+                        AssignValue = v,
+                        UniqueType = request.UniqueType,
+                        UniqueValue = request.UniqueValue,
+                        TenantId = tenantId
+                    }).ToList();
+
+                    await _dbContext.InsertAsync(devicePermissions);
+                }
+            }
+        }, null);
+    }
+
     public async Task GeneratePermissionsAsync(long id)
     {
         var assignment = await _dbContext.Queryable<DevicePermissionAssignmentEntity>().SingleAsync(x => x.Id == id);