707 lines
29 KiB
C#
707 lines
29 KiB
C#
using Dlhis.Basic.DataPermissions;
|
|
using Dlhis.Basic.Device.Dtos;
|
|
using Dlhis.Basic.Device.Request;
|
|
using Dlhis.Basic.Device.Response;
|
|
using Dlhis.Entity.Basic.Entity;
|
|
using Dlhis.Entity.Device.Entities;
|
|
using Dlhis.Entity.Device.Enums;
|
|
using Dlhis.Entity.Sys.Entities;
|
|
using Dlhis.Entity.Sys.Enums;
|
|
using Dlhis.Entity.Visitor.Entity;
|
|
using Dlhis.Sys.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.Scope;
|
|
using Kurisu.AspNetCore.Utils.Extensions;
|
|
using OfficeOpenXml;
|
|
using SqlSugar;
|
|
|
|
namespace Dlhis.Basic.Device.Services.Implements;
|
|
|
|
public class DevicePermissionService : IDevicePermissionService
|
|
{
|
|
private readonly IDbContext _dbContext;
|
|
private readonly IMyDataPermissionService _myDataPermissionService;
|
|
private readonly ITenantApi _tenantApi;
|
|
private readonly IParallelService _parallelService;
|
|
private readonly INamedResolver _namedResolver;
|
|
private readonly IDevicePermissionAnalyzeService _devicePermissionAnalyzeService;
|
|
private readonly ICurrentUser _currentUser;
|
|
|
|
public DevicePermissionService(IDbContext dbContext,
|
|
IMyDataPermissionService myDataPermissionService,
|
|
ITenantApi tenantApi,
|
|
IParallelService parallelService,
|
|
INamedResolver namedResolver,
|
|
IDevicePermissionAnalyzeService devicePermissionAnalyzeService,
|
|
ICurrentUser currentUser)
|
|
{
|
|
_dbContext = dbContext;
|
|
_myDataPermissionService = myDataPermissionService;
|
|
_tenantApi = tenantApi;
|
|
_parallelService = parallelService;
|
|
_namedResolver = namedResolver;
|
|
_devicePermissionAnalyzeService = devicePermissionAnalyzeService;
|
|
_currentUser = currentUser;
|
|
}
|
|
|
|
public async Task<DevicePermissionAssignResponse> AssignAsync(DevicePermissionSaveRequest request)
|
|
{
|
|
await _namedResolver.GetService<IPermissionAnalyzeService>(PermissionAnalyzeConstants.GetTypeName(request.AssignType)).AnalyzeAsync(request);
|
|
|
|
return null;
|
|
await CheckAssignTopDoorDeviceGroupAsync(request);
|
|
|
|
var currentTenantId = _currentUser.GetStringTenantId();
|
|
var role = _currentUser.GetRole();
|
|
var isAll = role is "admin" or "tenant-admin";
|
|
var deviceCodes = isAll ? new List<Guid>() : _myDataPermissionService.GetMyDeviceCodes();
|
|
|
|
_parallelService.Enable = true;
|
|
return await _devicePermissionAnalyzeService.GenerateDeviceTasksAsync(async () =>
|
|
{
|
|
request.AssignValue = request.AssignType == AssignTypeEnumType.Department ? request.TenantId + ":" + request.AssignValue : request.AssignValue;
|
|
|
|
await _dbContext.IgnoreAsync<ITenantId>(async () =>
|
|
{
|
|
//删除当前匹配的基地权限
|
|
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,
|
|
UniqueType = request.UniqueType,
|
|
UniqueValue = code,
|
|
Type = request.Type,
|
|
TenantId = currentTenantId
|
|
}).ToList();
|
|
|
|
await _dbContext.InsertAsync(devicePermissions);
|
|
}
|
|
});
|
|
}, null);
|
|
}
|
|
|
|
|
|
private async Task CheckAssignTopDoorDeviceGroupAsync(DevicePermissionSaveRequest request)
|
|
{
|
|
if (request.UniqueType == DeviceAssignmentTypeEnumType.Group)
|
|
{
|
|
await Scoped.Temp.Value.CreateAsync(async sp =>
|
|
{
|
|
var currentDb = sp.GetService<IDbContext>();
|
|
await currentDb.IgnoreAsync<ITenantId>(async () =>
|
|
{
|
|
var dgs = await currentDb.Queryable<DeviceGroupEntity>().Where(x => request.Codes.Contains(x.Code)).ToListAsync();
|
|
dgs.Any(x => x.TenantId.IsEmpty()).ThrowIfTrue("不可分配顶级分组节点");
|
|
});
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
public async Task<DevicePermissionAssignResponse> GenerateTasksAsync(List<Guid> addDeviceCodes, List<Guid> deleteDeviceCodes, List<string> gainfoNos)
|
|
{
|
|
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());
|
|
}
|
|
|
|
foreach (var items in tasks.Where(x => x.Type == DeviceTaskEnumType.Add).Chunk(500))
|
|
{
|
|
await _dbContext.InsertAsync(items.ToList());
|
|
}
|
|
|
|
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 addDeviceGroupCodes = presentDeviceCodes.Except(beforeDeviceCodes).ToList();
|
|
var deleteDeviceGroupCodes = 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 deviceGroups = await _dbContext.Queryable<DeviceGroupEntity>().ToListAsync();
|
|
|
|
var addDevices = await GetDevicesByGroupsAsync(deviceGroups, deviceGroups.Where(x => addDeviceGroupCodes.Contains(x.Code)).ToList());
|
|
var deleteDevices = await GetDevicesByGroupsAsync(deviceGroups, deviceGroups.Where(x => deleteDeviceGroupCodes.Contains(x.Code)).ToList());
|
|
|
|
var tasks = new List<DeviceTaskEntity>();
|
|
foreach (var gainfoNo in gainfoNos)
|
|
{
|
|
tasks.AddRange(addDevices.Select(x => new DeviceTaskEntity
|
|
{
|
|
Type = DeviceTaskEnumType.Add,
|
|
DeviceType = x.Type,
|
|
UserId = null,
|
|
UserNo = gainfoNo,
|
|
DeviceUniqueNo = x.UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Version = 0,
|
|
ResultMessage = null,
|
|
CancellationId = 0,
|
|
Source = DeviceTaskSourceEnumType.Manually,
|
|
Priority = 0,
|
|
TenantId = x.TenantId,
|
|
}).ToList());
|
|
|
|
tasks.AddRange(deleteDevices.Select(x => new DeviceTaskEntity
|
|
{
|
|
Type = DeviceTaskEnumType.Delete,
|
|
DeviceType = x.Type,
|
|
UserId = null,
|
|
UserNo = gainfoNo,
|
|
DeviceUniqueNo = x.UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Version = 0,
|
|
ResultMessage = null,
|
|
CancellationId = 0,
|
|
Source = DeviceTaskSourceEnumType.Manually,
|
|
Priority = 0,
|
|
TenantId = x.TenantId,
|
|
}).ToList());
|
|
}
|
|
|
|
foreach (var items in tasks.Where(x => x.Type == DeviceTaskEnumType.Add).Chunk(500))
|
|
{
|
|
await _dbContext.InsertAsync(items.ToList());
|
|
}
|
|
|
|
return new DevicePermissionAssignResponse
|
|
{
|
|
AddCount = addDevices.Count * gainfoNos.Count,
|
|
DeleteCount = deleteDevices.Count * gainfoNos.Count
|
|
};
|
|
}
|
|
|
|
private static void RecursionGetNextDeviceGroup(List<DeviceGroupEntity> allData, DeviceGroupEntity current, List<Guid> result)
|
|
{
|
|
var nextItems = allData.Where(x => x.PCode == current.Code).ToList();
|
|
foreach (var item in nextItems)
|
|
{
|
|
result.Add(item.Code);
|
|
RecursionGetNextDeviceGroup(allData, item, result);
|
|
}
|
|
}
|
|
|
|
private async Task<List<DeviceEntity>> GetDevicesByGroupsAsync(List<DeviceGroupEntity> allData, List<DeviceGroupEntity> groups)
|
|
{
|
|
var result = new List<Guid>();
|
|
foreach (var group in groups)
|
|
{
|
|
result.Add(group.Code);
|
|
RecursionGetNextDeviceGroup(allData, group, result);
|
|
}
|
|
|
|
var deviceCodes = await _dbContext.Queryable<DeviceGroupRelationshipEntity>()
|
|
.Where(x => result.Contains(x.GroupCode))
|
|
.Select(x => x.DeviceCode)
|
|
.ToListAsync();
|
|
|
|
return await _dbContext.Queryable<DeviceEntity>()
|
|
.Where(x => deviceCodes.Contains(x.Code))
|
|
.ToListAsync();
|
|
}
|
|
|
|
public async Task 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)
|
|
.Where(x => x.UniqueValue == request.UniqueValue)
|
|
.Where(x => x.AssignType == request.AssignType)
|
|
.Where(x => x.Type == request.Type)
|
|
.Where(x => x.TenantId == currentTenantId)
|
|
.ToListAsync();
|
|
|
|
var beforeNos = p.Select(x => x.AssignValue).ToList();
|
|
var presentNos = new List<string>();
|
|
if (request.Values.IsPresent())
|
|
{
|
|
presentNos = 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()
|
|
)
|
|
.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);
|
|
|
|
await _dbContext.DeleteAsync(p);
|
|
var devicePermissions = presentNos.Select(v => new DevicePermissionEntity
|
|
{
|
|
UniqueType = request.UniqueType,
|
|
UniqueValue = request.UniqueValue,
|
|
AssignType = request.AssignType,
|
|
AssignValue = v,
|
|
TenantId = currentTenantId,
|
|
Type = request.Type
|
|
}).ToList();
|
|
|
|
await _dbContext.InsertAsync(devicePermissions);
|
|
|
|
await _dbContext.InsertAsync(adds.Select(x => new DeviceTaskEntity
|
|
{
|
|
Type = DeviceTaskEnumType.Add,
|
|
DeviceType = device.Type,
|
|
UserId = null,
|
|
UserNo = x,
|
|
DeviceUniqueNo = device.UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Version = 0,
|
|
ResultMessage = null,
|
|
CancellationId = 0,
|
|
Source = DeviceTaskSourceEnumType.Manually,
|
|
Priority = 0,
|
|
TenantId = currentTenantId,
|
|
}).ToList());
|
|
|
|
await _dbContext.InsertAsync(deletes.Select(x => new DeviceTaskEntity
|
|
{
|
|
Type = DeviceTaskEnumType.Delete,
|
|
DeviceType = device.Type,
|
|
UserId = null,
|
|
UserNo = x,
|
|
DeviceUniqueNo = device.UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Version = 0,
|
|
ResultMessage = null,
|
|
CancellationId = 0,
|
|
Source = DeviceTaskSourceEnumType.Manually,
|
|
Priority = 0,
|
|
TenantId = currentTenantId
|
|
}).ToList());
|
|
|
|
// await GenerateDeviceTasksAsync(async () =>
|
|
// {
|
|
// await _dbContext.DeleteAsync(p);
|
|
//
|
|
// //保存配置的权限
|
|
// if (request.Values.IsPresent())
|
|
// {
|
|
// var nos = 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()
|
|
// )
|
|
// .Where(gainfo => request.Values.Contains(gainfo.Code) || request.Values.Contains(gainfo.No) || request.Values.Contains(gainfo.IdNo))
|
|
// .Select(gainfo => gainfo.No)
|
|
// .ToListAsync();
|
|
//
|
|
// //todo 临时注释
|
|
// //(gainfoNos.Count != request.Values.Count).ThrowIfTrue("存在非当前权限访问的人员,操作禁止!");
|
|
//
|
|
// var devicePermissions = nos.Select(v => new DevicePermissionEntity
|
|
// {
|
|
// UniqueType = request.UniqueType,
|
|
// UniqueValue = request.UniqueValue,
|
|
// AssignType = request.AssignType,
|
|
// AssignValue = v,
|
|
// TenantId = currentTenantId,
|
|
// Type = request.Type
|
|
// }).ToList();
|
|
//
|
|
// await _dbContext.InsertAsync(devicePermissions);
|
|
// }
|
|
// }, gainfoNos);
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task AssignToUniqueImportAsync(IFormFile file)
|
|
{
|
|
var deviceNo = Path.GetFileNameWithoutExtension(file.FileName);
|
|
|
|
var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.UniqueNo == deviceNo).SingleAsync();
|
|
device.ThrowIfNull("设备不存在");
|
|
|
|
ExcelPackage.LicenseContext = LicenseContext.NonCommercial;
|
|
using (var package = new ExcelPackage(file.OpenReadStream()))
|
|
{
|
|
ExcelWorksheet worksheet = package.Workbook.Worksheets[0];
|
|
int rowCount = worksheet.Dimension.Rows; // 获取行数
|
|
int colCount = worksheet.Dimension.Columns; // 获取列数
|
|
|
|
var list = new List<string>();
|
|
for (int i = 1; i < rowCount; i++)
|
|
{
|
|
var userCode = worksheet.Cells[i + 1, 2].GetCellValue<string>();
|
|
list.Add(userCode);
|
|
}
|
|
|
|
foreach (var items in list.Chunk(500))
|
|
{
|
|
var gainfoNos = await _dbContext.Queryable<GainfoEntity>().Where(x => items.Contains(x.Code)).Select(x => x.No).ToListAsync();
|
|
|
|
var permissions = gainfoNos.Select(x => new DevicePermissionEntity
|
|
{
|
|
AssignType = AssignTypeEnumType.User,
|
|
AssignValue = x,
|
|
UniqueType = DeviceAssignmentTypeEnumType.Device,
|
|
UniqueValue = device.Code,
|
|
Type = device.Type,
|
|
TenantId = device.TenantId,
|
|
IsDeleted = false
|
|
}).ToList();
|
|
|
|
await _dbContext.InsertAsync(permissions);
|
|
|
|
var tasks = permissions.Select(x => new DeviceTaskEntity
|
|
{
|
|
Type = DeviceTaskEnumType.Add,
|
|
DeviceType = x.Type,
|
|
UserId = null,
|
|
UserNo = x.AssignValue,
|
|
DeviceUniqueNo = device.UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Version = 0,
|
|
ResultMessage = null,
|
|
CancellationId = 0,
|
|
Source = DeviceTaskSourceEnumType.Manually,
|
|
Priority = 0,
|
|
TenantId = device.TenantId,
|
|
}).ToList();
|
|
|
|
await _dbContext.InsertAsync(tasks);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public async Task<Dictionary<string, List<UserTenantDeviceCodeDto>>> GetUserDevicePermissionsAsync(string code)
|
|
{
|
|
var userNo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == code).Select(x => x.No).SingleAsync();
|
|
return await _devicePermissionAnalyzeService.GetAssignDeviceCodesInternalAsync(new List<string> { userNo });
|
|
}
|
|
|
|
|
|
public async Task<Pagination<DeviceGainfoResponse>> GetGainfoPageByDeviceAsync(DeviceWithGainfoRequest request)
|
|
{
|
|
var device = await _dbContext.Queryable<DeviceEntity>().Where(x => x.UniqueNo == request.DeviceUniqueNo).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 ids = new List<long>();
|
|
foreach (var permission in permissions)
|
|
{
|
|
switch (permission.AssignType)
|
|
{
|
|
case AssignTypeEnumType.User:
|
|
ids.Add(await _dbContext.Queryable<GainfoEntity>().Where(x => x.No == permission.AssignValue).Select(x => x.Id).SingleAsync());
|
|
break;
|
|
case AssignTypeEnumType.Group:
|
|
{
|
|
var code = Guid.Parse(permission.AssignValue);
|
|
ids.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.Id).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);
|
|
|
|
ids.AddRange(await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == tenantId && departmentNos.Contains(x.DepartmentNo)).Select(x => x.Id).ToListAsync());
|
|
}
|
|
break;
|
|
case AssignTypeEnumType.Tenant:
|
|
{
|
|
ids.AddRange(await _dbContext.Queryable<GainfoEntity>().Where(x => x.Factory == permission.AssignValue).Select(x => x.Id).ToListAsync());
|
|
}
|
|
break;
|
|
default:
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
}
|
|
|
|
ids = ids.Distinct().ToList();
|
|
|
|
var page = await _dbContext.Queryable<GainfoEntity>()
|
|
.Where(x => ids.Contains(x.Id))
|
|
.WhereIF(request.Search.IsPresent(), x => x.Code == request.Search || x.Name.Contains(request.Search))
|
|
.Select<DeviceGainfoResponse>()
|
|
.ToPageListAsync(request);
|
|
|
|
var userNos = page.Data.Select(x => x.No).ToList();
|
|
|
|
var downStatus = await _dbContext.Queryable<DeviceTaskEntity>()
|
|
.Where(x => userNos.Contains(x.UserNo))
|
|
.Where(x => x.DeviceUniqueNo == device.UniqueNo)
|
|
.Where(x => x.Status == DeviceTaskStatusEnumType.Success)
|
|
.Select(x => new
|
|
{
|
|
num = SqlFunc.RowNumber(SqlFunc.Desc(x.ModifiedTime), x.UserNo),
|
|
x.UserNo,
|
|
x.Status,
|
|
x.ResultMessage,
|
|
x.ModifiedTime
|
|
}).MergeTable()
|
|
.Where(x => x.num == 1)
|
|
.ToListAsync();
|
|
|
|
var tenants = await _tenantApi.GetTenantsInternalAsync();
|
|
|
|
page.Data.ForEach(x =>
|
|
{
|
|
x.Workplace = tenants.FirstOrDefault(item => item.Code == x.Workplace)?.Name;
|
|
x.Factory = tenants.FirstOrDefault(item => item.Code == x.Factory)?.Name;
|
|
|
|
var d = downStatus.FirstOrDefault(item => item.UserNo == x.No);
|
|
if (d == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
x.Status = d.Status;
|
|
x.ResultMessage = d.ResultMessage;
|
|
x.ModifiedTime = d.ModifiedTime;
|
|
});
|
|
|
|
return page;
|
|
}
|
|
|
|
/// <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)
|
|
{
|
|
switch (permission.AssignType)
|
|
{
|
|
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)
|
|
{
|
|
var deviceCodes = await GetAssignDeviceCodesAsync(userNo);
|
|
if (!deviceCodes.Any()) return;
|
|
|
|
var devices = await _dbContext.Queryable<DeviceEntity>()
|
|
.Where(x => x.Enable)
|
|
.Where(x => deviceCodes.Contains(x.Code))
|
|
.ToListAsync();
|
|
|
|
var tasks = devices.Select(x => new DeviceTaskEntity
|
|
{
|
|
DeviceUniqueNo = x.UniqueNo,
|
|
Status = DeviceTaskStatusEnumType.Wait,
|
|
Type = taskType,
|
|
DeviceType = x.Type,
|
|
UserNo = userNo,
|
|
CancellationId = 0,
|
|
Priority = 0,
|
|
Version = 0,
|
|
TenantId = x.TenantId,
|
|
Source = source
|
|
}).ToList();
|
|
|
|
await _dbContext.InsertAsync(tasks);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取用户所有设备权限
|
|
/// </summary>
|
|
/// <param name="userCode"></param>
|
|
/// <returns></returns>
|
|
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 _devicePermissionAnalyzeService.GetAssignDeviceCodesInternalAsync(new List<string> { userNo });
|
|
return result.First().Value.SelectMany(x => x.Codes).ToList();
|
|
}
|
|
} |