yuangb/jinko.yikatong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix 开启多线程

Browse Source
This commit is contained in:
liguoyang
2024-12-03 16:37:13 +08:00
parent 3c39f39f4b
commit c6a02cdca3
6 changed files with 343 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Src/Dlhis.Basic/Device/Controllers/DevicePermissionsController.cs
View File

@@ -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]

6
Src/Dlhis.Basic/Device/Request/DeviceGainfoReset.cs Normal file
View File

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

7
Src/Dlhis.Basic/Device/Services/IDevicePermissionService.cs
View File

@@ -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);
}

433
Src/Dlhis.Basic/Device/Services/Implements/DevicePermissionService.cs
View File

@@ -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>()
.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
};
return await AssignDeviceToTenantAsync(currentTenantId, isAll, deviceCodes, request);
}
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 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
{
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();
AssignType = request.AssignType,
AssignValue = request.AssignValue,
UniqueType = request.UniqueType,
UniqueValue = code,
Type = request.Type,
TenantId = currentTenantId
}).ToList();
await _dbContext.InsertAsync(devicePermissions);
}
});
}, null);
}
await _dbContext.InsertAsync(devicePermissions);
}
});
}, 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);
foreach (var item in next)
switch (permission.AssignType)
{
result.Add(item.No);
DepartmentRecursionGetNext(item.No, data, result);
case AssignTypeEnumType.User:
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)

1
Src/Dlhis.Basic/Organization/Controllers/GainfoPermissionsController.cs
View File

@@ -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;

19
Src/Dlhis.External/Appointment/Services/Implements/AppointmentService.cs
View File

@@ -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);