fix 开启多线程

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

@@ -93,6 +93,12 @@ public class DevicePermissionsController : ControllerBase
         return await _devicePermissionService.GetGainfoPageByDeviceAsync(request);
     }
 
+    [HttpPost("gainfos/reset")]
+    [CrossTenant]
+    public async Task ResetGainfoPageByDeviceAsync(DeviceGainfoReset request)
+    {
+        await _devicePermissionService.ResetGainfoPageByDeviceAsync(request);
+    }
 
     [HttpGet("userPermissionCodes")]
     [IgnoreTenant]

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

@@ -0,0 +1,6 @@
+namespace Dlhis.Basic.Device.Request;
+
+public class DeviceGainfoReset
+{
+    public Guid Code { get; set; }
+}

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

@@ -64,4 +64,11 @@ public interface IDevicePermissionService : IScopeDependency
     Task<List<Guid>> GetAssignDeviceCodesAsync(string userCode);
 
     Task<Pagination<DeviceGainfoResponse>> GetGainfoPageByDeviceAsync(DeviceWithGainfoRequest request);
+
+    /// <summary>
+    /// 重新下载设备中所有人员
+    /// </summary>
+    /// <param name="request"></param>
+    /// <returns></returns>
+    Task ResetGainfoPageByDeviceAsync(DeviceGainfoReset request);
 }

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

@@ -47,6 +47,8 @@ public class DevicePermissionService : IDevicePermissionService
 
     public async Task<DevicePermissionAssignResponse> AssignAsync(DevicePermissionSaveRequest request)
     {
+        await CheckAssignTopDoorDeviceGroupAsync(request);
+
         var currentTenantId = _currentUser.GetStringTenantId();
         var role = _currentUser.GetRole();
         var isAll = role is "admin" or "tenant-admin";
@@ -54,138 +56,50 @@ public class DevicePermissionService : IDevicePermissionService
 
         if (request.AssignType == AssignTypeEnumType.Tenant && request.UniqueType == DeviceAssignmentTypeEnumType.Device)
         {
-            var p = await _dbContext.Queryable<DevicePermissionEntity>()
+            return await AssignDeviceToTenantAsync(currentTenantId, isAll, deviceCodes, request);
-                .Where(x => x.AssignType == AssignTypeEnumType.Tenant)
-                .Where(x => x.AssignValue == request.AssignValue)
-                .Where(x => x.UniqueType == request.UniqueType)
-                .WhereIF(request.UniqueType == DeviceAssignmentTypeEnumType.Device && !isAll, x => deviceCodes.Contains(x.UniqueValue))
-                .Where(x => x.Type == request.Type)
-                .Where(x => x.TenantId == currentTenantId)
-                .ToListAsync();
-
-
-            var gainfoNos = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == request.AssignValue).Select(x => x.No).ToListAsync();
-
-            var beforeDeviceCodes = p.Select(x => x.UniqueValue).ToList();
-            var presentDeviceCodes = request.Codes.IsPresent() ? request.Codes : new List<Guid>();
-
-            var addDeviceCodes = presentDeviceCodes.Except(beforeDeviceCodes).ToList();
-            var deleteDeviceCodes = beforeDeviceCodes.Except(presentDeviceCodes).ToList();
-
-            await _dbContext.DeleteAsync(p);
-            //保存配置的权限
-            if (request.Codes.IsPresent())
-            {
-                var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
-                {
-                    AssignType = request.AssignType,
-                    AssignValue = request.AssignValue,
-                    UniqueType = request.UniqueType,
-                    UniqueValue = code,
-                    Type = request.Type,
-                    TenantId = currentTenantId
-                }).ToList();
-
-                await _dbContext.InsertAsync(devicePermissions);
-            }
-
-            var allDeviceCodes = addDeviceCodes.Concat(deleteDeviceCodes).ToList();
-            var devices = await _dbContext.Queryable<DeviceEntity>()
-                .Where(x => allDeviceCodes.Contains(x.Code))
-                .Select(x => new { x.Code, x.UniqueNo, x.Type, x.TenantId })
-                .ToListAsync();
-
-            var tasks = new List<DeviceTaskEntity>();
-            foreach (var gainfoNo in gainfoNos)
-            {
-                tasks.AddRange(addDeviceCodes.Select(x =>
-                {
-                    var d = devices.First(item => item.Code == x);
-                    return new DeviceTaskEntity
-                    {
-                        Type = DeviceTaskEnumType.Add,
-                        DeviceType = d.Type,
-                        UserId = null,
-                        UserNo = gainfoNo,
-                        DeviceUniqueNo = d.UniqueNo,
-                        Status = DeviceTaskStatusEnumType.Wait,
-                        Version = 0,
-                        ResultMessage = null,
-                        CancellationId = 0,
-                        Source = DeviceTaskSourceEnumType.Manually,
-                        Priority = 0,
-                        TenantId = d.TenantId,
-                    };
-                }).ToList());
-
-                tasks.AddRange(deleteDeviceCodes.Select(x =>
-                {
-                    var d = devices.First(item => item.Code == x);
-                    return new DeviceTaskEntity
-                    {
-                        Type = DeviceTaskEnumType.Delete,
-                        DeviceType = d.Type,
-                        UserId = null,
-                        UserNo = gainfoNo,
-                        DeviceUniqueNo = d.UniqueNo,
-                        Status = DeviceTaskStatusEnumType.Wait,
-                        Version = 0,
-                        ResultMessage = null,
-                        CancellationId = 0,
-                        Source = DeviceTaskSourceEnumType.Manually,
-                        Priority = 0,
-                        TenantId = d.TenantId,
-                    };
-                }).ToList());
-            }
-
-            await _dbContext.InsertAsync(tasks);
-            return new DevicePermissionAssignResponse
-            {
-                AddCount = addDeviceCodes.Count * gainfoNos.Count,
-                DeleteCount = deleteDeviceCodes.Count * gainfoNos.Count
-            };
         }
-        else
+
+        // if (request.AssignType == AssignTypeEnumType.Tenant && request.UniqueType == DeviceAssignmentTypeEnumType.Group)
+        // {
+        //     return await AssignDeviceGroupToTenantAsync(currentTenantId, request);
+        // }
+
+        _parallelService.Enable = true;
+        return await GenerateDeviceTasksAsync(async () =>
         {
-            await CheckAssignTopDoorDeviceGroupAsync(request);
+            request.AssignValue = request.AssignType == AssignTypeEnumType.Department ? request.TenantId + ":" + request.AssignValue : request.AssignValue;
 
-            return await GenerateDeviceTasksAsync(async () =>
+            await _dbContext.IgnoreAsync<ITenantId>(async () =>
             {
-                request.AssignValue = request.AssignType == AssignTypeEnumType.Department ? request.TenantId + ":" + request.AssignValue : request.AssignValue;
+                //删除当前匹配的基地权限
+                var p = await _dbContext.Queryable<DevicePermissionEntity>()
+                    .Where(x => x.AssignType == request.AssignType)
+                    .Where(x => x.AssignValue == request.AssignValue)
+                    .Where(x => x.UniqueType == request.UniqueType)
+                    .WhereIF(request.UniqueType == DeviceAssignmentTypeEnumType.Device && !isAll, x => deviceCodes.Contains(x.UniqueValue))
+                    .Where(x => x.Type == request.Type)
+                    .Where(x => x.TenantId == currentTenantId)
+                    .ToListAsync();
 
-                await _dbContext.IgnoreAsync<ITenantId>(async () =>
+                await _dbContext.DeleteAsync(p);
+
+                //保存配置的权限
+                if (request.Codes.IsPresent())
                 {
-                    //删除当前匹配的基地权限
+                    var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
-                    var p = await _dbContext.Queryable<DevicePermissionEntity>()
-                        .Where(x => x.AssignType == request.AssignType)
-                        .Where(x => x.AssignValue == request.AssignValue)
-                        .Where(x => x.UniqueType == request.UniqueType)
-                        .WhereIF(request.UniqueType == DeviceAssignmentTypeEnumType.Device && !isAll, x => deviceCodes.Contains(x.UniqueValue))
-                        .Where(x => x.Type == request.Type)
-                        .Where(x => x.TenantId == currentTenantId)
-                        .ToListAsync();
-
-                    await _dbContext.DeleteAsync(p);
-
-                    //保存配置的权限
-                    if (request.Codes.IsPresent())
                     {
-                        var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
+                        AssignType = request.AssignType,
-                        {
+                        AssignValue = request.AssignValue,
-                            AssignType = request.AssignType,
+                        UniqueType = request.UniqueType,
-                            AssignValue = request.AssignValue,
+                        UniqueValue = code,
-                            UniqueType = request.UniqueType,
+                        Type = request.Type,
-                            UniqueValue = code,
+                        TenantId = currentTenantId
-                            Type = request.Type,
+                    }).ToList();
-                            TenantId = currentTenantId
-                        }).ToList();
 
-                        await _dbContext.InsertAsync(devicePermissions);
+                    await _dbContext.InsertAsync(devicePermissions);
-                    }
+                }
-                });
+            });
-            }, null);
+        }, null);
-        }
     }
 
     private async Task CheckAssignTopDoorDeviceGroupAsync(DevicePermissionSaveRequest request)
@@ -204,6 +118,195 @@ public class DevicePermissionService : IDevicePermissionService
         }
     }
 
+
+    public async Task<DevicePermissionAssignResponse> AssignDeviceToTenantAsync(string currentTenantId, bool isAll, List<Guid> deviceCodes, DevicePermissionSaveRequest request)
+    {
+        var p = await _dbContext.Queryable<DevicePermissionEntity>()
+            .Where(x => x.AssignType == AssignTypeEnumType.Tenant)
+            .Where(x => x.AssignValue == request.AssignValue)
+            .Where(x => x.UniqueType == request.UniqueType)
+            .WhereIF(request.UniqueType == DeviceAssignmentTypeEnumType.Device && !isAll, x => deviceCodes.Contains(x.UniqueValue))
+            .Where(x => x.Type == request.Type)
+            .Where(x => x.TenantId == currentTenantId)
+            .ToListAsync();
+
+        var gainfoNos = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == request.AssignValue).Select(x => x.No).ToListAsync();
+
+        var beforeDeviceCodes = p.Select(x => x.UniqueValue).ToList();
+        var presentDeviceCodes = request.Codes.IsPresent() ? request.Codes : new List<Guid>();
+
+        var addDeviceCodes = presentDeviceCodes.Except(beforeDeviceCodes).ToList();
+        var deleteDeviceCodes = beforeDeviceCodes.Except(presentDeviceCodes).ToList();
+
+        await _dbContext.DeleteAsync(p);
+        //保存配置的权限
+        if (request.Codes.IsPresent())
+        {
+            var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
+            {
+                AssignType = request.AssignType,
+                AssignValue = request.AssignValue,
+                UniqueType = request.UniqueType,
+                UniqueValue = code,
+                Type = request.Type,
+                TenantId = currentTenantId
+            }).ToList();
+
+            await _dbContext.InsertAsync(devicePermissions);
+        }
+
+        var allDeviceCodes = addDeviceCodes.Concat(deleteDeviceCodes).ToList();
+        var devices = await _dbContext.Queryable<DeviceEntity>()
+            .Where(x => allDeviceCodes.Contains(x.Code))
+            .Select(x => new { x.Code, x.UniqueNo, x.Type, x.TenantId })
+            .ToListAsync();
+
+        var tasks = new List<DeviceTaskEntity>();
+        foreach (var gainfoNo in gainfoNos)
+        {
+            tasks.AddRange(addDeviceCodes.Select(x =>
+            {
+                var d = devices.First(item => item.Code == x);
+                return new DeviceTaskEntity
+                {
+                    Type = DeviceTaskEnumType.Add,
+                    DeviceType = d.Type,
+                    UserId = null,
+                    UserNo = gainfoNo,
+                    DeviceUniqueNo = d.UniqueNo,
+                    Status = DeviceTaskStatusEnumType.Wait,
+                    Version = 0,
+                    ResultMessage = null,
+                    CancellationId = 0,
+                    Source = DeviceTaskSourceEnumType.Manually,
+                    Priority = 0,
+                    TenantId = d.TenantId,
+                };
+            }).ToList());
+
+            tasks.AddRange(deleteDeviceCodes.Select(x =>
+            {
+                var d = devices.First(item => item.Code == x);
+                return new DeviceTaskEntity
+                {
+                    Type = DeviceTaskEnumType.Delete,
+                    DeviceType = d.Type,
+                    UserId = null,
+                    UserNo = gainfoNo,
+                    DeviceUniqueNo = d.UniqueNo,
+                    Status = DeviceTaskStatusEnumType.Wait,
+                    Version = 0,
+                    ResultMessage = null,
+                    CancellationId = 0,
+                    Source = DeviceTaskSourceEnumType.Manually,
+                    Priority = 0,
+                    TenantId = d.TenantId,
+                };
+            }).ToList());
+        }
+
+        await _dbContext.InsertAsync(tasks);
+        return new DevicePermissionAssignResponse
+        {
+            AddCount = addDeviceCodes.Count * gainfoNos.Count,
+            DeleteCount = deleteDeviceCodes.Count * gainfoNos.Count
+        };
+    }
+
+
+    public async Task<DevicePermissionAssignResponse> AssignDeviceGroupToTenantAsync(string currentTenantId, DevicePermissionSaveRequest request)
+    {
+        var groupData = await _dbContext.Queryable<DevicePermissionEntity>()
+            .Where(x => x.AssignType == AssignTypeEnumType.Tenant)
+            .Where(x => x.AssignValue == request.AssignValue)
+            .Where(x => x.UniqueType == request.UniqueType)
+            .Where(x => x.Type == request.Type)
+            .Where(x => x.TenantId == currentTenantId)
+            .ToListAsync();
+
+        var gainfoNos = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == request.AssignValue).Select(x => x.No).ToListAsync();
+
+        var beforeDeviceCodes = groupData.Select(x => x.UniqueValue).ToList();
+        var presentDeviceCodes = request.Codes.IsPresent() ? request.Codes : new List<Guid>();
+
+        var addDeviceCodes = presentDeviceCodes.Except(beforeDeviceCodes).ToList();
+        var deleteDeviceCodes = beforeDeviceCodes.Except(presentDeviceCodes).ToList();
+
+        await _dbContext.DeleteAsync(groupData);
+        //保存配置的权限
+        if (request.Codes.IsPresent())
+        {
+            var devicePermissions = request.Codes.Select(code => new DevicePermissionEntity
+            {
+                AssignType = request.AssignType,
+                AssignValue = request.AssignValue,
+                UniqueType = request.UniqueType,
+                UniqueValue = code,
+                Type = request.Type,
+                TenantId = currentTenantId
+            }).ToList();
+
+            await _dbContext.InsertAsync(devicePermissions);
+        }
+
+        var allDeviceCodes = addDeviceCodes.Concat(deleteDeviceCodes).ToList();
+        var devices = await _dbContext.Queryable<DeviceEntity>()
+            .Where(x => allDeviceCodes.Contains(x.Code))
+            .Select(x => new { x.Code, x.UniqueNo, x.Type, x.TenantId })
+            .ToListAsync();
+
+        var tasks = new List<DeviceTaskEntity>();
+        foreach (var gainfoNo in gainfoNos)
+        {
+            tasks.AddRange(addDeviceCodes.Select(x =>
+            {
+                var d = devices.First(item => item.Code == x);
+                return new DeviceTaskEntity
+                {
+                    Type = DeviceTaskEnumType.Add,
+                    DeviceType = d.Type,
+                    UserId = null,
+                    UserNo = gainfoNo,
+                    DeviceUniqueNo = d.UniqueNo,
+                    Status = DeviceTaskStatusEnumType.Wait,
+                    Version = 0,
+                    ResultMessage = null,
+                    CancellationId = 0,
+                    Source = DeviceTaskSourceEnumType.Manually,
+                    Priority = 0,
+                    TenantId = d.TenantId,
+                };
+            }).ToList());
+
+            tasks.AddRange(deleteDeviceCodes.Select(x =>
+            {
+                var d = devices.First(item => item.Code == x);
+                return new DeviceTaskEntity
+                {
+                    Type = DeviceTaskEnumType.Delete,
+                    DeviceType = d.Type,
+                    UserId = null,
+                    UserNo = gainfoNo,
+                    DeviceUniqueNo = d.UniqueNo,
+                    Status = DeviceTaskStatusEnumType.Wait,
+                    Version = 0,
+                    ResultMessage = null,
+                    CancellationId = 0,
+                    Source = DeviceTaskSourceEnumType.Manually,
+                    Priority = 0,
+                    TenantId = d.TenantId,
+                };
+            }).ToList());
+        }
+
+        await _dbContext.InsertAsync(tasks);
+        return new DevicePermissionAssignResponse
+        {
+            AddCount = addDeviceCodes.Count * gainfoNos.Count,
+            DeleteCount = deleteDeviceCodes.Count * gainfoNos.Count
+        };
+    }
+
     public async Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
     {
         var currentTenantId = _currentUser.GetStringTenantId();
@@ -640,16 +743,88 @@ public class DevicePermissionService : IDevicePermissionService
         });
 
         return page;
+    }
 
-        void DepartmentRecursionGetNext(string current, List<DepartmentEntity> data, List<string> result)
+    /// <inheritdoc />
+    public async Task ResetGainfoPageByDeviceAsync(DeviceGainfoReset request)
+    {
+        var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Code == request.Code).SingleAsync();
+        device.ThrowIfNull("设备不存在");
+        var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();
+
+        //当前设备的分组
+        var groups = await _dbContext.Queryable<DeviceGroupRelationshipEntity>()
+            .Where(x => x.DeviceCode == device.Code)
+            .Select(x => x.GroupCode)
+            .ToListAsync();
+
+        var permissions = await _dbContext.Queryable<DevicePermissionEntity>()
+            .Where(x => (x.UniqueType == DeviceAssignmentTypeEnumType.Device && x.UniqueValue == device.Code) || (x.UniqueType == DeviceAssignmentTypeEnumType.Group && groups.Contains(x.UniqueValue)))
+            .ToListAsync();
+
+        var gainfoNos = new List<string>();
+        foreach (var permission in permissions)
         {
-            var next = data.Where(x => x.PNo == current);
+            switch (permission.AssignType)
-            foreach (var item in next)
             {
-                result.Add(item.No);
+                case AssignTypeEnumType.User:
-                DepartmentRecursionGetNext(item.No, data, result);
+                    gainfoNos.Add(await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == permission.AssignValue).Select(x => x.No).SingleAsync());
+                    break;
+                case AssignTypeEnumType.Group:
+                {
+                    var code = Guid.Parse(permission.AssignValue);
+                    gainfoNos.AddRange(await _dbContext.Queryable<GainfoGroupEntity>().Where(x => x.Code == code)
+                        .LeftJoin<GainfoGroupRelationshipEntity>((a, b) => a.Code == b.GroupCode)
+                        .LeftJoin<GainfoEntity>((a, b, c) => b.UserNo == c.No)
+                        .Select((a, b, c) => c.No).ToListAsync());
+                }
+                    break;
+                case AssignTypeEnumType.Department:
+                {
+                    //递归向上获取 assignValue = department.No
+                    var arr = permission.AssignValue.Split(":");
+                    var tenantId = arr.First();
+                    var currentDepartmentNo = arr.Last();
+                    var departmentNos = new List<string> { currentDepartmentNo };
+                    DepartmentRecursionGetNext(currentDepartmentNo, departments, departmentNos);
+
+                    gainfoNos.AddRange(await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == tenantId && departmentNos.Contains(x.DepartmentNo)).Select(x => x.No).ToListAsync());
+                }
+                    break;
+                case AssignTypeEnumType.Tenant:
+                {
+                    gainfoNos.AddRange(await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == permission.AssignValue).Select(x => x.No).ToListAsync());
+                }
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
             }
         }
+
+        gainfoNos = gainfoNos.Distinct().ToList();
+
+        await _dbContext.InsertAsync(gainfoNos.Select(x => new DeviceTaskEntity
+        {
+            DeviceUniqueNo = device.UniqueNo,
+            Status = DeviceTaskStatusEnumType.Wait,
+            Type = DeviceTaskEnumType.Delete,
+            CancellationId = 0,
+            DeviceType = device.Type,
+            UserNo = x,
+            Version = 0,
+            TenantId = device.TenantId,
+            Source = DeviceTaskSourceEnumType.Manually
+        }).ToList());
+    }
+
+    void DepartmentRecursionGetNext(string current, List<DepartmentEntity> data, List<string> result)
+    {
+        var next = data.Where(x => x.PNo == current);
+        foreach (var item in next)
+        {
+            result.Add(item.No);
+            DepartmentRecursionGetNext(item.No, data, result);
+        }
     }
 
     public async Task GenerateDeviceTasksAsync(string userNo, DeviceTaskEnumType taskType, DeviceTaskSourceEnumType source)

Src/Dlhis.Basic/Organization/Controllers/GainfoPermissionsController.cs

@@ -4,7 +4,6 @@ using Dlhis.Basic.Organization.Response;
 using Dlhis.Basic.Organization.Services;
 using Dlhis.Basic.Places.Response;
 using Kurisu.AspNetCore.DataAccess.Dto;
-using Kurisu.AspNetCore.DataAccess.SqlSugar.Aop;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 

Src/Dlhis.External/Appointment/Services/Implements/AppointmentService.cs

@@ -70,6 +70,7 @@ public class AppointmentService : IAppointmentService
                 {
                     No = Guid.NewGuid().ToString(),
                     Code = await GetExternalCodeAsync(),
+                    Gender = GetGender(item.IdNo),
                     Type = GainfoUserTypeEnumType.External,
                     IdNo = item.IdNo,
                     Name = item.Name,
@@ -129,6 +130,24 @@ public class AppointmentService : IAppointmentService
         }
     }
 
+    private GenderEnumType GetGender(string idNo)
+    {
+        try
+        {
+            if (idNo.Length == 18)
+            {
+                return int.Parse(idNo.ToCharArray()[16].ToString()) % 2 == 0
+                    ? GenderEnumType.Female
+                    : GenderEnumType.Male;
+            }
+        }
+        catch (Exception e)
+        {
+        }
+
+        return GenderEnumType.Unknown;
+    }
+
     private async Task<string> GetExternalCodeAsync()
     {
         await using var handler = await _redisCache.LockAsync("gainfo:external:code-generate", expiry: TimeSpan.FromSeconds(3), retryInterval: TimeSpan.FromSeconds(1), retryCount: 3);