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-12 16:30:43 +08:00
parent 5103c5adbb
commit 9f63d4f938
15 changed files with 258 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -39,7 +39,7 @@ public class DevicePermissionsController : ControllerBase
}
/// <summary>
/// 分配权限到设备/设备组/营业点
/// 分配权限到设备
/// </summary>
/// <param name="request"></param>
[HttpPost("assign-unique")]

27
Src/Dlhis.Basic/Device/Dtos/DevicePermissionSourceDto.cs Normal file
View File

@@ -0,0 +1,27 @@
using Dlhis.Entity.Sys.Enums;
namespace Dlhis.Basic.Device.Dtos;
public class DevicePermissionSourceDto
{
public string Factory { get; set; }
public IEnumerable<DevicePermissionSourceTypeDto> Types { get; set; }
}
public class DevicePermissionSourceTypeDto
{
/// <summary>
/// 分配类型
/// </summary>
public AssignTypeEnumType AssignType { get; init; }
/// <summary>
/// 分配值
/// </summary>
public string AssignValue { get; init; }
public DeviceAssignmentTypeEnumType UniqueType { get; set; }
public IEnumerable<Guid> Codes { get; set; }
}

1
Src/Dlhis.Basic/Device/Dtos/TenantAssignTypeDeviceCode.cs
View File

@@ -37,7 +37,6 @@ public class AssignTypeDeviceCode
/// </summary>
public List<Guid> Codes { get; set; }
public List<Guid> OriginalCodes { get; set; }
}

35
Src/Dlhis.Basic/Device/Request/DevicePermissionsAssignToDeviceRequest.cs
View File

@@ -1,45 +1,14 @@
using System.ComponentModel.DataAnnotations;
using Dlhis.Entity.Device.Enums;
using Dlhis.Entity.Sys.Enums;
namespace Dlhis.Basic.Device.Request;
namespace Dlhis.Basic.Device.Request;
public class DevicePermissionsAssignToDeviceRequest : IValidatableObject
public class DevicePermissionsAssignToDeviceRequest
{
/// <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; }
[EnumDataType(typeof(DeviceTypeEnumType))]
public DeviceTypeEnumType Type { get; set; }
/// <summary>
/// 只删除权限
/// </summary>
public bool IsDelete { get; set; }
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
if (AssignType != AssignTypeEnumType.User)
{
yield return new ValidationResult("仅支持导入档案人员", new[] { nameof(AssignType) });
}
}
}

20
Src/Dlhis.Basic/Device/Services/IDevicePermissionAnalyzeService.cs
View File

@@ -12,19 +12,25 @@ namespace Dlhis.Basic.Device.Services;
/// </summary>
public interface IDevicePermissionAnalyzeService : IScopeDependency
{
Task<List<DevicePermissionEntity>> GetDevicePermissions(DevicePermissionSaveRequest request);
Task<List<DevicePermissionEntity>> GetDevicePermissionsAsync(DevicePermissionSaveRequest request);
Task<DevicePermissionAssignResponse> GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos);
Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
List<string> userNos,
DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null
);
Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request);
Task<List<GainfoDto>> GetAssignmentUniqueAsync(DeviceGetAssignmentUniquesRequest request);
Task<List<Guid>> GetAssignDeviceCodesAsync(string userCode);
Task<Dictionary<string, IEnumerable<UserTenantDeviceCodeDto>>> GetUserAssignDeviceCodesInTenantAsync(
List<string> userNos,
DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null);
Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
List<string> userNos,
DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null
);
}

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

@@ -21,7 +21,7 @@ public interface IDevicePermissionService : IScopeDependency
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request);
Task<DevicePermissionAssignResponse> AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request);
Task AssignToUniqueImportAsync(IFormFile file);

2
Src/Dlhis.Basic/Device/Services/Implements/BasePermissionAnalyzeService.cs
View File

@@ -41,7 +41,7 @@ public abstract class BasePermissionAnalyzeService : IPermissionAnalyzeService
await CheckWhetherAssignToTopDeviceGroupAsync(request);
await CheckAssignedToTenantAsync(request);
var dps = await _devicePermissionAnalyzeService.GetDevicePermissions(request);
var dps = await _devicePermissionAnalyzeService.GetDevicePermissionsAsync(request);
try
{

18
Src/Dlhis.Basic/Device/Services/Implements/DeviceGroupService.cs
View File

@@ -106,6 +106,7 @@ public class DeviceGroupService : IDeviceGroupService
await CheckNoNextGroupAsync(group.Code);
await CheckGroupTypeMatchAsync(request, group);
await CheckAssignToTenantAsync(group.Code, request.DeviceCodes);
var relationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().Where(x => x.GroupCode == request.GroupCode).ToListAsync();
@@ -125,6 +126,23 @@ public class DeviceGroupService : IDeviceGroupService
return r;
}
private async Task CheckAssignToTenantAsync(Guid groupCode, List<Guid> deviceCodes)
{
if (await _dbContext.Queryable<DevicePermissionEntity>()
.Where(x => x.AssignType == AssignTypeEnumType.Tenant)
.Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Group)
.Where(x => x.UniqueValue == groupCode)
.AnyAsync())
{
(await _dbContext.Queryable<DevicePermissionEntity>()
.Where(x => x.AssignType != AssignTypeEnumType.Tenant)
.Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Device)
.Where(x => deviceCodes.Contains(x.UniqueValue))
.AnyAsync()).ThrowIfTrue("无法分配设备到该设备组:设备组已分配到厂区");
}
}
private async Task<DevicePermissionAssignResponse> PermissionResetAsync(Guid groupCode, List<Guid> beforeDeviceCodes, List<Guid> presentDeviceCodes)
{
var codesToAdd = presentDeviceCodes.Except(beforeDeviceCodes).ToList();

27
Src/Dlhis.Basic/Device/Services/Implements/DevicePermissionAnalyzeService.cs
View File

@@ -33,7 +33,7 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
}
public async Task<List<DevicePermissionEntity>> GetDevicePermissions(DevicePermissionSaveRequest request)
public async Task<List<DevicePermissionEntity>> GetDevicePermissionsAsync(DevicePermissionSaveRequest request)
{
var currentTenantId = await GetCurrentFactoryAsync(request);
(bool enableDeviceFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
@@ -196,7 +196,7 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
IgnoreUniqueType = ignoreUniqueType
};
var codes = GetAssignDeviceCodesInternal(analyzePack,
var codes = GetAssignDeviceCodesPermissions(analyzePack,
gainfoGroups,
devicePermissions,
deviceGroups,
@@ -210,7 +210,7 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
}
private static IEnumerable<TenantAssignTypeDeviceCode> GetAssignDeviceCodesInternal(
private static IEnumerable<TenantAssignTypeDeviceCode> GetAssignDeviceCodesPermissions(
AnalyzePackDto analyzePack,
List<GainfoGroupEntity> gainfoGroups,
List<DevicePermissionDto> devicePermissions,
@@ -366,18 +366,17 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
public async Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request)
{
var currentAssignValue = request.AssignType == AssignTypeEnumType.Department ? request.TenantId + ":" + request.AssignValue : request.AssignValue;
var r = await GetDevicePermissionsAsync(new DevicePermissionSaveRequest
{
AssignType = request.AssignType,
AssignValue = request.AssignValue,
UniqueType = request.UniqueType,
Codes = null,
TenantId = request.TenantId,
Type = request.Type
});
(bool enableFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
return await _dbContext.Queryable<DevicePermissionEntity>()
.Where(x => x.AssignType == request.AssignType)
.Where(x => x.AssignValue == currentAssignValue)
.Where(x => x.UniqueType == request.UniqueType)
.WhereIF(enableFilter && request.UniqueType == DeviceAssignmentTypeEnumType.Device, x => deviceCodes.Contains(x.UniqueValue))
.Where(x => x.Type == request.Type)
.Select(x => x.UniqueValue)
.ToListAsync();
return r.Select(x => x.UniqueValue).ToList();
}
public async Task<List<GainfoDto>> GetAssignmentUniqueAsync(DeviceGetAssignmentUniquesRequest request)

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

@@ -46,29 +46,30 @@ public class DevicePermissionService : IDevicePermissionService
.AnalyzeAsync(request);
}
public async Task AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
public async Task<DevicePermissionAssignResponse> AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
{
var currentTenantId = _currentUser.GetStringTenantId();
var today = DateTime.Today;
var factories = _currentUser.GetUserClaim("tenants").Split(",").ToList();
var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Code == request.UniqueValue).SingleAsync();
device.ThrowIfNull("设备不存在");
//删除当前匹配的基地权限
var p = await _dbContext.Queryable<DevicePermissionEntity>()
.Where(x => x.UniqueType == request.UniqueType)
//当前匹配的基地权限
var dps = await _dbContext.Queryable<DevicePermissionEntity>()
.Where(x => x.UniqueType == DeviceAssignmentTypeEnumType.Device)
.Where(x => x.UniqueValue == request.UniqueValue)
.Where(x => x.AssignType == request.AssignType)
.Where(x => x.Type == request.Type)
.Where(x => x.AssignType == AssignTypeEnumType.User)
.Where(x => x.Type == device.Type)
.Where(x => x.TenantId == currentTenantId)
.ToListAsync();
var beforeNos = p.Select(x => x.AssignValue).ToList();
var presentNos = new List<string>();
var beforeUserNos = dps.Select(x => x.AssignValue).ToList();
var presentUserNos = new List<string>();
if (request.Values.IsPresent())
{
presentNos = await _dbContext.Client.Queryable<GainfoEntity>()
var today = DateTime.Today;
var factories = _currentUser.GetUserClaim("tenants").Split(",").ToList();
presentUserNos = await _dbContext.Client.Queryable<GainfoEntity>()
.Where(gainfo => factories.Contains(gainfo.Factory) || SqlFunc.Subqueryable<BusinessTripEntity>()
.Where(x => factories.Contains(x.Destination) && SqlFunc.DateIsSame(x.BeginDate, today))
.Any()
@@ -76,59 +77,85 @@ public class DevicePermissionService : IDevicePermissionService
.Where(gainfo => request.Values.Contains(gainfo.Code) || request.Values.Contains(gainfo.No) || request.Values.Contains(gainfo.IdNo))
.Select(gainfo => gainfo.No)
.ToListAsync();
//gainfoNos = gainfoNos.Concat(nos).Distinct().ToList();
}
var adds = presentNos.Except(beforeNos);
var deletes = beforeNos.Except(presentNos);
var tasksToAdd = new List<DeviceTaskEntity>();
var tasksToDelete = new List<DeviceTaskEntity>();
await _dbContext.DeleteAsync(p);
var devicePermissions = presentNos.Select(v => new DevicePermissionEntity
try
{
UniqueType = request.UniqueType,
UniqueValue = request.UniqueValue,
AssignType = request.AssignType,
AssignValue = v,
TenantId = currentTenantId,
Type = request.Type
}).ToList();
var usersToAdd = presentUserNos.Except(beforeUserNos);
var usersToDelete = beforeUserNos.Except(presentUserNos).ToList();
await _dbContext.InsertAsync(devicePermissions);
var userTenantDeviceCodes = usersToDelete.IsPresent()
? await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(beforeUserNos.Union(presentUserNos).ToList())
: new Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>();
await _dbContext.InsertAsync(adds.Select(x => new DeviceTaskEntity
tasksToAdd.AddRange(usersToAdd.Select(userNo => new DeviceTaskEntity
{
Type = DeviceTaskEnumType.Add,
DeviceType = device.Type,
UserId = null,
UserNo = x,
UserNo = userNo,
DeviceUniqueNo = device.UniqueNo,
Status = DeviceTaskStatusEnumType.Wait,
Version = 0,
ResultMessage = null,
CancellationId = 0,
CancellationId = 20,
Source = DeviceTaskSourceEnumType.Manually,
Priority = 0,
TenantId = currentTenantId,
}).ToList());
}));
await _dbContext.InsertAsync(deletes.Select(x => new DeviceTaskEntity
foreach (var item in usersToDelete)
{
var permissions = userTenantDeviceCodes[item].ToList();
foreach (var permission in permissions)
{
permission.AssignTypes = permission.AssignTypes.Where(x => x.UniqueType != DeviceAssignmentTypeEnumType.Device).ToList();
}
var myDeviceCodes = permissions.SelectMany(x => x.AssignTypes.SelectMany(p => p.Codes)).Distinct().ToList();
if (myDeviceCodes.All(x => x != device.Code))
{
tasksToDelete.Add(new DeviceTaskEntity
{
Type = DeviceTaskEnumType.Delete,
DeviceType = device.Type,
UserId = null,
UserNo = x,
UserNo = item,
DeviceUniqueNo = device.UniqueNo,
Status = DeviceTaskStatusEnumType.Wait,
Version = 0,
ResultMessage = null,
CancellationId = 0,
CancellationId = 20,
Source = DeviceTaskSourceEnumType.Manually,
Priority = 0,
TenantId = currentTenantId
});
}
}
}
finally
{
await _dbContext.InsertAsync(tasksToAdd);
await _dbContext.InsertAsync(tasksToDelete);
await _dbContext.DeleteAsync(dps);
await _dbContext.InsertAsync(presentUserNos.Select(v => new DevicePermissionEntity
{
UniqueType = DeviceAssignmentTypeEnumType.Device,
UniqueValue = request.UniqueValue,
AssignType = AssignTypeEnumType.User,
AssignValue = v,
TenantId = currentTenantId,
Type = device.Type
}).ToList());
}
return new DevicePermissionAssignResponse(tasksToAdd.Count, tasksToDelete.Count);
}
/// <inheritdoc />
public async Task AssignToUniqueImportAsync(IFormFile file)
{

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

@@ -51,7 +51,7 @@ public class GainfoPermissionsController : ControllerBase
/// <param name="request"></param>
/// <returns></returns>
[HttpGet("assignDeviceCodes")]
public async Task<Pagination<DevicePageResponse>> GetAssignDeviceCodesAsync([FromQuery] DeviceAssRequest request)
public async Task<Pagination<GainfoDevicePermissionResponse>> GetAssignDeviceCodesAsync([FromQuery] DeviceAssRequest request)
{
return await _gainfoPermissions.GetAssignDeviceCodesAsync(request);
}

69
Src/Dlhis.Basic/Organization/Response/GainfoDevicePermissionResponse.cs Normal file
View File

@@ -0,0 +1,69 @@
using Dlhis.Basic.Device.Dtos;
using Dlhis.Entity.Device.Enums;
using Kurisu.AspNetCore.Utils.Extensions;
namespace Dlhis.Basic.Organization.Response;
public class GainfoDevicePermissionResponse
{
public long Id { get; set; }
/// <summary>
/// 设备code
/// </summary>
public Guid Code { get; set; }
/// <summary>
/// 设备码,IP/MAC/SNO
/// </summary>
public string UniqueNo { get; set; }
/// <summary>
/// 心跳间隔
/// </summary>
public int HeartbeatInterval { get; set; }
/// <summary>
/// 设备机功能类型
/// </summary>
public DeviceTypeEnumType Type { get; set; }
public string TypeDescription => Type.GetDescription();
/// <summary>
/// 是否启用
/// </summary>
public bool Enable { get; set; }
/// <summary>
/// 厂区
/// </summary>
public string Factory { get; set; }
/// <summary>
/// 最后心跳时间
/// </summary>
public DateTime? LastHeartbeatTime { get; set; }
/// <summary>
/// 是否在线
/// </summary>
public bool IsOnline
{
get
{
if (!LastHeartbeatTime.HasValue)
return false;
if (HeartbeatInterval <= 0)
return true;
return LastHeartbeatTime.Value.AddSeconds(HeartbeatInterval) >= DateTime.Now;
}
}
/// <summary>
/// 分配来源
/// </summary>
public DevicePermissionSourceDto Source { get; set; }
}

2
Src/Dlhis.Basic/Organization/Services/IGainfoPermissionService.cs
View File

@@ -13,7 +13,7 @@ public interface IGainfoPermissionService : IScopeDependency
Task<List<GetDevicesUnderGroupByUserNoResponse>> GetDevicesUnderGroupByUserNoAsync(string userNo, Guid deviceGroupCode);
Task<Pagination<DevicePageResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request);
Task<Pagination<GainfoDevicePermissionResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request);
Task<List<DeviceGroupTreeResponse>> GetAssignGroupAsync(string userNo);

1
Src/Dlhis.Basic/Organization/Services/Implements/GainfoGroupService.cs
View File

@@ -94,7 +94,6 @@ public class GainfoGroupService : IGainfoGroupService
.Where(x => x.GroupCode == request.GroupCode)
.ToListAsync();
var presentUserNos = await _dbContext.Queryable<GainfoEntity>()
.Where(x => request.UserNos.Contains(x.No) || request.UserNos.Contains(x.Code)) //NO和工号匹配
.Select(x => x.No)

45
Src/Dlhis.Basic/Organization/Services/Implements/GainfoPermissionService.cs
View File

@@ -1,4 +1,5 @@
using Dlhis.Basic.Device.Request;
using Dlhis.Basic.Device.Dtos;
using Dlhis.Basic.Device.Request;
using Dlhis.Basic.Device.Response;
using Dlhis.Basic.Device.Services;
using Dlhis.Basic.Organization.Request;
@@ -118,27 +119,39 @@ public class GainfoPermissionService : IGainfoPermissionService
}).ToList();
}
public async Task<Pagination<DevicePageResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request)
public async Task<Pagination<GainfoDevicePermissionResponse>> GetAssignDeviceCodesAsync(DeviceAssRequest request)
{
var ids = await _devicePermissionAnalyzeService.GetAssignDeviceCodesAsync(request.UserNo);
var result = await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(new List<string> { request.UserNo });
var permissions = result[request.UserNo].ToList();
var codes = permissions.SelectMany(x => x.AssignTypes.SelectMany(p => p.Codes)).Distinct().ToList();
var page = await _dbContext.Queryable<DeviceEntity>()
.LeftJoin<DeviceTemplateEntity>((d, dt) => d.TemplateCode == dt.Code)
.LeftJoin<DeviceRegistryEntity>((d, dt, dr) => d.UniqueNo == dr.DeviceUniqueNo)
.LeftJoin<BusinessPlaceEntity>((d, dt, dr, bp) => dr.BusinessPlaceCode == bp.Code)
.LeftJoin<DeviceRegistryEntity>((d, dr) => d.UniqueNo == dr.DeviceUniqueNo)
.WhereIF(request.DeviceType.HasValue, d => d.Type == request.DeviceType)
.Where(d => ids.Contains(d.Code))
.Select((d, dt, dr, bp) => new DevicePageResponse
{
FuncsStr = d.Funcs.ToString(),
Brand = dt.Brand,
Type = d.Type,
BusinessPlaceCode = bp.Code,
BusinessPlaceName = bp.Name,
LastHeartbeatTime = dr.LastHeartbeatTime
}, true)
.Where(d => codes.Contains(d.Code))
.Select((d, dr) => new GainfoDevicePermissionResponse { Factory = d.TenantId }, true)
.ToPageListAsync(request);
page.Data.ForEach(item =>
{
var permission = permissions.First(x => x.Tenant == item.Factory);
item.Source = new DevicePermissionSourceDto
{
Factory = item.Factory,
Types = permission.AssignTypes.Where(x => x.Codes.Any(p => p == item.Code)).Select(x => new DevicePermissionSourceTypeDto
{
AssignType = x.AssignType,
AssignValue = x.AssignValue,
UniqueType = x.UniqueType,
Codes = x.UniqueType == DeviceAssignmentTypeEnumType.Device
? x.Codes.Where(p => p == item.Code)
: x.Codes.Take(1)
})
};
});
return page;
}