413 lines
18 KiB
C#
413 lines
18 KiB
C#
using System.Collections.Concurrent;
|
|
using Dlhis.Basic.DataPermissions;
|
|
using Dlhis.Basic.Device.Dtos;
|
|
using Dlhis.Basic.Device.Request;
|
|
using Dlhis.Basic.Device.Response;
|
|
using Dlhis.Basic.Organization.Dto;
|
|
using Dlhis.Entity.Basic.Entity;
|
|
using Dlhis.Entity.Basic.Enums;
|
|
using Dlhis.Entity.Device.Entities;
|
|
using Dlhis.Entity.Device.Enums;
|
|
using Dlhis.Entity.Sys.Entities;
|
|
using Dlhis.Entity.Sys.Enums;
|
|
using Kurisu.AspNetCore.Authentication.Abstractions;
|
|
using Kurisu.AspNetCore.DataAccess.Entity;
|
|
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
|
|
namespace Dlhis.Basic.Device.Services.Implements;
|
|
|
|
public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
|
|
{
|
|
private readonly IDbContext _dbContext;
|
|
private readonly ICurrentUser _currentUser;
|
|
private readonly IMyDataPermissionService _myDataPermissionService;
|
|
|
|
public DevicePermissionAnalyzeService(IDbContext dbContext,
|
|
ICurrentUser currentUser,
|
|
IMyDataPermissionService myDataPermissionService)
|
|
{
|
|
_dbContext = dbContext;
|
|
_currentUser = currentUser;
|
|
_myDataPermissionService = myDataPermissionService;
|
|
}
|
|
|
|
|
|
public async Task<List<DevicePermissionEntity>> GetDevicePermissions(DevicePermissionSaveRequest request)
|
|
{
|
|
var currentTenantId = await GetCurrentFactoryAsync(request);
|
|
(bool enableDeviceFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
|
|
(bool enableDeviceGroupFilter, List<Guid> deviceGroupCodes) = _myDataPermissionService.GetMyDeviceGroupCodes();
|
|
|
|
return await _dbContext.Queryable<DevicePermissionEntity>().Where(x => x.AssignType == request.AssignType
|
|
&& x.AssignValue == request.GetActualAssignValue()
|
|
&& x.UniqueType == request.UniqueType
|
|
&& x.Type == request.Type
|
|
&& x.TenantId == currentTenantId)
|
|
.WhereIF(enableDeviceFilter && request.UniqueType == DeviceAssignmentTypeEnumType.Device, x => deviceCodes.Contains(x.UniqueValue))
|
|
.WhereIF(enableDeviceGroupFilter && request.UniqueType == DeviceAssignmentTypeEnumType.Group, x => deviceGroupCodes.Contains(x.UniqueValue))
|
|
.ToListAsync();
|
|
}
|
|
|
|
private async Task<string> GetCurrentFactoryAsync(DevicePermissionSaveRequest request)
|
|
{
|
|
var currentTenantId = _currentUser.GetStringTenantId();
|
|
|
|
var r = request.UniqueType switch
|
|
{
|
|
DeviceAssignmentTypeEnumType.Device => await _dbContext.Queryable<DeviceEntity>().Where(x => request.Codes.Contains(x.Code)).Where(x => x.TenantId != currentTenantId).AnyAsync(),
|
|
DeviceAssignmentTypeEnumType.Group => await _dbContext.Queryable<DeviceGroupEntity>().Where(x => request.Codes.Contains(x.Code)).Where(x => x.TenantId != currentTenantId).AnyAsync(),
|
|
_ => false
|
|
};
|
|
|
|
r.ThrowIfTrue("存在设备或者设备组不属于当前厂区,操作失败!");
|
|
|
|
return currentTenantId;
|
|
}
|
|
|
|
|
|
public async Task<DevicePermissionAssignResponse> GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos)
|
|
{
|
|
var before = await GetUserAssignDeviceCodesInTenantAsync(userNos);
|
|
|
|
//业务处理
|
|
_dbContext.Client.QueryFilter.Restore();
|
|
await func();
|
|
_dbContext.Client.QueryFilter.ClearAndBackup<ITenantId>();
|
|
|
|
var current = await GetUserAssignDeviceCodesInTenantAsync(userNos);
|
|
|
|
var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Enable).ToListAsync();
|
|
|
|
var waitAddTasks = new List<DeviceTaskEntity>();
|
|
var waitDeleteTasks = new List<DeviceTaskEntity>();
|
|
|
|
foreach (var userNo in userNos)
|
|
{
|
|
var beforeTenantDeviceCodes = before[userNo].ToList();
|
|
var currentTenantDeviceCodes = current[userNo].ToList();
|
|
|
|
var tenants = new HashSet<string>();
|
|
foreach (var item in beforeTenantDeviceCodes)
|
|
tenants.Add(item.Tenant);
|
|
foreach (var item in currentTenantDeviceCodes)
|
|
tenants.Add(item.Tenant);
|
|
|
|
foreach (var tenant in tenants)
|
|
{
|
|
var currentCodes = currentTenantDeviceCodes.FirstOrDefault(x => x.Tenant == tenant)?.Codes?.ToList() ?? new List<Guid>();
|
|
var beforeCodes = beforeTenantDeviceCodes.FirstOrDefault(x => x.Tenant == tenant)?.Codes?.ToList() ?? new List<Guid>();
|
|
|
|
//被删除
|
|
var deletedItems = beforeCodes.Where(x => !currentCodes.Contains(x)).ToList();
|
|
//新增
|
|
var addItems = currentCodes.Where(x => !beforeCodes.Contains(x)).ToList();
|
|
|
|
if (!deletedItems.Any() && !addItems.Any())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var deviceCodes = devices.Where(x => deletedItems.Contains(x.Code) || addItems.Contains(x.Code)).Select(x => x.Code).ToList();
|
|
deletedItems = deletedItems.Where(x => deviceCodes.Contains(x)).ToList();
|
|
addItems = addItems.Where(x => deviceCodes.Contains(x)).ToList();
|
|
|
|
//下发任务创建
|
|
deletedItems.ForEach(x => waitDeleteTasks.Add(new DeviceTaskEntity
|
|
{
|
|
DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Type = DeviceTaskEnumType.Delete,
|
|
CancellationId = 0,
|
|
DeviceType = devices.First(item => item.Code == x).Type,
|
|
UserNo = userNo,
|
|
Version = 0,
|
|
TenantId = tenant,
|
|
Source = DeviceTaskSourceEnumType.Manually
|
|
}));
|
|
|
|
addItems.ForEach(x => waitAddTasks.Add(new DeviceTaskEntity
|
|
{
|
|
DeviceUniqueNo = devices.First(item => item.Code == x).UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Type = DeviceTaskEnumType.Add,
|
|
DeviceType = devices.First(item => item.Code == x).Type,
|
|
UserNo = userNo,
|
|
Version = 0,
|
|
TenantId = tenant,
|
|
Source = DeviceTaskSourceEnumType.Manually
|
|
}));
|
|
}
|
|
}
|
|
|
|
await ChunkInsertAsync(waitAddTasks);
|
|
await ChunkInsertAsync(waitDeleteTasks);
|
|
|
|
return new DevicePermissionAssignResponse(waitAddTasks.Count, waitDeleteTasks.Count);
|
|
}
|
|
|
|
|
|
public async Task<Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
|
|
List<string> userNos,
|
|
DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
|
|
string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null)
|
|
{
|
|
var gainfos = await _dbContext.Queryable<GainfoEntity>().Where(x => userNos.Contains(x.No)).ToListAsync();
|
|
if (!gainfos.Any()) return new Dictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>();
|
|
|
|
var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => x.Enable).ToListAsync();
|
|
|
|
var enableFactoryPermissions = await _dbContext.Queryable<FactorySettingEntity>().ToListAsync();
|
|
|
|
var gainfoGroupRelationships = await _dbContext.Queryable<GainfoGroupRelationshipEntity>().Where(x => userNos.Contains(x.UserNo)).ToListAsync();
|
|
var gainfoGroups = await _dbContext.Queryable<GainfoGroupEntity>().ToListAsync();
|
|
|
|
var devicePermissions = await _dbContext.Queryable<DevicePermissionEntity>()
|
|
.Select<DevicePermissionDto>()
|
|
.ToListAsync();
|
|
|
|
var deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
|
|
var deviceRelationships = await _dbContext.Queryable<DeviceGroupRelationshipEntity>().ToListAsync();
|
|
var departments = await _dbContext.Queryable<DepartmentEntity>().ToListAsync();
|
|
|
|
var result = new ConcurrentDictionary<string, IEnumerable<TenantAssignTypeDeviceCode>>();
|
|
|
|
gainfos.ParallelForEach(gainfo =>
|
|
{
|
|
var internalIgnoreAssignTypes = new List<AssignTypeEnumType>();
|
|
|
|
if (ignoreAssignType.HasValue)
|
|
internalIgnoreAssignTypes.Add(ignoreAssignType.Value);
|
|
|
|
if (gainfo.Type == GainfoUserTypeEnumType.Outsource && (enableFactoryPermissions.FirstOrDefault(x => x.TenantId == gainfo.Factory)?.EnableOutsourceDown ?? true) == false)
|
|
{
|
|
internalIgnoreAssignTypes.Add(AssignTypeEnumType.Tenant);
|
|
}
|
|
|
|
var analyzePack = new AnalyzePackDto
|
|
{
|
|
UserNo = gainfo.No,
|
|
UserDepartment = gainfo.Factory + ":" + gainfo.DepartmentNo,
|
|
UserFactory = gainfo.Factory,
|
|
UserGainfoGroupCodes = gainfoGroupRelationships.Where(x => x.UserNo == gainfo.No).Select(x => x.GroupCode),
|
|
DeviceCodes = devices.WhereIf(gainfo.Type == GainfoUserTypeEnumType.Outsource, x => x.Type != DeviceTypeEnumType.Meal).Select(x => x.Code), //外包人员不允许餐饮
|
|
IgnoreAssignValue = ignoreAssignValue,
|
|
IgnoreAssignTypes = internalIgnoreAssignTypes,
|
|
IgnoreUniqueType = ignoreUniqueType
|
|
};
|
|
|
|
var codes = GetAssignDeviceCodesInternal(analyzePack,
|
|
gainfoGroups,
|
|
devicePermissions,
|
|
deviceGroups,
|
|
deviceRelationships,
|
|
departments);
|
|
|
|
result.TryAdd(gainfo.No, codes);
|
|
});
|
|
|
|
return result.ToDictionary(x => x.Key, x => x.Value);
|
|
}
|
|
|
|
|
|
private static IEnumerable<TenantAssignTypeDeviceCode> GetAssignDeviceCodesInternal(
|
|
AnalyzePackDto analyzePack,
|
|
List<GainfoGroupEntity> gainfoGroups,
|
|
List<DevicePermissionDto> devicePermissions,
|
|
List<DeviceGroupEntity> deviceGroups,
|
|
List<DeviceGroupRelationshipEntity> deviceGroupRelationships,
|
|
List<DepartmentEntity> departments)
|
|
{
|
|
var deviceDtos = new List<TenantAssignTypeDeviceCode>();
|
|
|
|
var uniqueTypes = new[] { DeviceAssignmentTypeEnumType.Device, DeviceAssignmentTypeEnumType.Group };
|
|
foreach (var assignType in new[] { AssignTypeEnumType.User, AssignTypeEnumType.Group, AssignTypeEnumType.Department, AssignTypeEnumType.Tenant })
|
|
{
|
|
if (analyzePack.IgnoreAssignTypes.Contains(assignType) && analyzePack.IgnoreAssignValue.IsEmpty())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var assignValues = assignType switch
|
|
{
|
|
AssignTypeEnumType.User => new[] { analyzePack.UserNo },
|
|
AssignTypeEnumType.Group => analyzePack.UserGainfoGroupCodes.Select(x => x.ToString()).ToArray(),
|
|
AssignTypeEnumType.Department => new[] { analyzePack.UserDepartment },
|
|
AssignTypeEnumType.Tenant => new[] { analyzePack.UserFactory },
|
|
AssignTypeEnumType.Role => throw new ArgumentOutOfRangeException(),
|
|
_ => throw new ArgumentOutOfRangeException()
|
|
};
|
|
|
|
|
|
var data = assignValues.SelectMany(x => uniqueTypes.Select(p => new { assignValue = x, uniqueType = p })).ToList();
|
|
var needRemove = data.Where(x => x.assignValue == analyzePack.IgnoreAssignValue && x.uniqueType == analyzePack.IgnoreUniqueType);
|
|
data = data.ExceptBy(needRemove, x => new { x.assignValue, x.uniqueType }).ToList();
|
|
|
|
foreach (var item in data)
|
|
{
|
|
deviceDtos.AddRange(GetCurrentAssignTypePermissions(devicePermissions, gainfoGroups, departments,
|
|
deviceGroups, deviceGroupRelationships,
|
|
item.uniqueType, assignType, item.assignValue));
|
|
}
|
|
}
|
|
|
|
return deviceDtos.GroupBy(x => x.Tenant).Select(x =>
|
|
{
|
|
var dto = new TenantAssignTypeDeviceCode
|
|
{
|
|
Tenant = x.Key,
|
|
AssignTypes = x.SelectMany(p => p.AssignTypes)
|
|
.GroupBy(p => new { p.AssignType, p.AssignValue, p.UniqueType })
|
|
.Select(p => new AssignTypeDeviceCode
|
|
{
|
|
AssignType = p.Key.AssignType,
|
|
AssignValue = p.Key.AssignValue,
|
|
UniqueType = p.Key.UniqueType,
|
|
Codes = p.SelectMany(xx => xx.Codes).ToList(),
|
|
OriginalCodes = p.Where(xx => xx.OriginalCodes.IsPresent()).SelectMany(xx => xx.OriginalCodes).ToList()
|
|
}).ToList()
|
|
};
|
|
|
|
return dto;
|
|
});
|
|
}
|
|
|
|
private static List<TenantAssignTypeDeviceCode> GetCurrentAssignTypePermissions(
|
|
List<DevicePermissionDto> devicePermissions,
|
|
List<GainfoGroupEntity> gainfoGroups,
|
|
List<DepartmentEntity> departments,
|
|
List<DeviceGroupEntity> deviceGroups,
|
|
List<DeviceGroupRelationshipEntity> deviceGroupRelationships,
|
|
DeviceAssignmentTypeEnumType uniqueType,
|
|
AssignTypeEnumType assignType,
|
|
string assignValue)
|
|
{
|
|
var assignValues = new List<string> { assignValue };
|
|
|
|
if (assignType == AssignTypeEnumType.Department)
|
|
{
|
|
// 2401:00001
|
|
//递归向上获取 assignValue = department.No
|
|
var arr = assignValue.Split(":");
|
|
var tenantId = arr[0];
|
|
var currentDepartmentNo = arr[1];
|
|
|
|
assignValues = RecursionHelper.HandlerDepartmentPreviousCodes(currentDepartmentNo, departments).Select(x => tenantId + ":" + x).ToList();
|
|
}
|
|
|
|
if (assignType == AssignTypeEnumType.Group)
|
|
{
|
|
assignValues = RecursionHelper.HandlerGainfoGroupPreviousCodes(Guid.Parse(assignValue), gainfoGroups).Select(x => x.ToString()).ToList();
|
|
}
|
|
|
|
|
|
var r = devicePermissions
|
|
.Where(x => x.UniqueType == uniqueType)
|
|
.Where(x => x.AssignType == assignType)
|
|
.Where(x => assignValues.Contains(x.AssignValue))
|
|
.GroupBy(x => x.TenantId)
|
|
.Select(x => new TenantAssignTypeDeviceCode
|
|
{
|
|
Tenant = x.Key,
|
|
AssignTypes = x.GroupBy(xx => new { xx.AssignType, xx.AssignValue }).Select(xx => new AssignTypeDeviceCode
|
|
{
|
|
AssignType = xx.Key.AssignType,
|
|
AssignValue = xx.Key.AssignValue,
|
|
UniqueType = uniqueType,
|
|
Codes = xx.Select(xxx => xxx.UniqueValue).ToList()
|
|
}).ToList()
|
|
})
|
|
.ToList();
|
|
|
|
if (uniqueType == DeviceAssignmentTypeEnumType.Group)
|
|
{
|
|
foreach (var groupItem in r)
|
|
{
|
|
foreach (var assignTypeDeviceCodeItem in groupItem.AssignTypes)
|
|
{
|
|
var nextItems = new List<Guid>();
|
|
foreach (var code in assignTypeDeviceCodeItem.Codes)
|
|
{
|
|
nextItems.AddRange(RecursionHelper.HandlerDeviceGroupNextCodes(code, deviceGroups));
|
|
}
|
|
|
|
nextItems = nextItems.Distinct().ToList();
|
|
assignTypeDeviceCodeItem.OriginalCodes = nextItems;
|
|
assignTypeDeviceCodeItem.Codes = deviceGroupRelationships.Where(x => nextItems.Contains(x.GroupCode)).Select(x => x.DeviceCode).ToList();
|
|
}
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
private async Task ChunkInsertAsync<T>(List<T> batch) where T : class, new()
|
|
{
|
|
foreach (var tasks in batch.Chunk(500))
|
|
{
|
|
await _dbContext.InsertAsync(tasks.ToList());
|
|
}
|
|
}
|
|
|
|
|
|
public async Task<Dictionary<string, IEnumerable<UserTenantDeviceCodeDto>>> GetUserAssignDeviceCodesInTenantAsync(
|
|
List<string> userNos,
|
|
DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
|
|
string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null)
|
|
{
|
|
var result = await GetUserAssignDeviceCodesWithTypeInTenantAsync(userNos, ignoreUniqueType, ignoreAssignValue, ignoreAssignType);
|
|
|
|
return result.ToDictionary(x => x.Key, x => x.Value.GroupBy(p => p.Tenant).Select(item =>
|
|
{
|
|
return new UserTenantDeviceCodeDto
|
|
{
|
|
Tenant = item.Key,
|
|
Codes = item.SelectMany(p => p.AssignTypes).SelectMany(p => p.Codes).Distinct().ToList(),
|
|
};
|
|
}));
|
|
}
|
|
|
|
|
|
public async Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request)
|
|
{
|
|
var currentAssignValue = request.AssignType == AssignTypeEnumType.Department ? request.TenantId + ":" + request.AssignValue : request.AssignValue;
|
|
|
|
(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();
|
|
}
|
|
|
|
public async Task<List<GainfoDto>> GetAssignmentUniqueAsync(DeviceGetAssignmentUniquesRequest request)
|
|
{
|
|
var nos = await _dbContext.Queryable<DevicePermissionEntity>()
|
|
.Where(x => x.UniqueType == request.UniqueType)
|
|
.Where(x => x.UniqueValue == request.UniqueValue)
|
|
.Where(x => x.AssignType == AssignTypeEnumType.User)
|
|
.Where(x => x.Type == request.Type)
|
|
.Select(x => x.AssignValue)
|
|
.ToListAsync();
|
|
|
|
return await _dbContext.Queryable<GainfoEntity>().Where(x => nos.Contains(x.No)).Select(x => new GainfoDto
|
|
{
|
|
Id = x.Id,
|
|
Code = x.Code,
|
|
Name = x.Name,
|
|
Workplace = x.Workplace,
|
|
Factory = x.Factory
|
|
}).ToListAsync();
|
|
}
|
|
|
|
public async Task<List<Guid>> GetAssignDeviceCodesAsync(string userCode)
|
|
{
|
|
var userNo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == userCode || x.No == userCode).Select(x => x.No).SingleAsync();
|
|
var result = await GetUserAssignDeviceCodesInTenantAsync(new List<string> { userNo });
|
|
return result.First().Value.SelectMany(x => x.Codes).ToList();
|
|
}
|
|
} |