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

refactor 优化,注释

Browse Source
This commit is contained in:
liguoyang
2025-01-10 16:19:49 +08:00
parent fe6667f602
commit 41c560e8c7
16 changed files with 172 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
Src/Dlhis.Basic.Api/Dto/PermissionUsersInfoDto.cs
View File

@@ -1,14 +0,0 @@
namespace Dlhis.Basic.Api.Dto;
public class PermissionUsersInfoDto
{
/// <summary>
/// 拥有权限的用户
/// </summary>
public List<string> UserNos { get; set; }
/// <summary>
/// 用户对应的 [ 厂区--设备Code ]
/// </summary>
public Dictionary<string, List<UserTenantDeviceCodeDto>> PermissionInfos { get; set; }
}

14
Src/Dlhis.Basic.Api/Dto/UserTenantDeviceCodeDto.cs
View File

@@ -1,14 +0,0 @@
namespace Dlhis.Basic.Api.Dto;
public class UserTenantDeviceCodeDto
{
/// <summary>
/// 租户
/// </summary>
public string Tenant { get; set; }
/// <summary>
/// 设备权限
/// </summary>
public List<Guid> Codes { get; set; }
}

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

@@ -1,5 +1,4 @@
using Dlhis.Basic.Device.Dtos;
using Dlhis.Basic.Device.Filters;
using Dlhis.Basic.Device.Request;
using Dlhis.Basic.Device.Response;
using Dlhis.Basic.Device.Services;
@@ -31,7 +30,6 @@ public class DevicePermissionsController : ControllerBase
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("assign")]
[AssignPermissionLimit]
[Transactional]
[CrossTenant]
public async Task<DevicePermissionAssignResponse> AssignAsync(DevicePermissionSaveRequest request)
@@ -44,7 +42,6 @@ public class DevicePermissionsController : ControllerBase
/// </summary>
/// <param name="request"></param>
[HttpPost("assign-unique")]
[AssignPermissionLimit]
[Transactional]
[CrossTenant]
public async Task<DevicePermissionAssignResponse> AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request)
@@ -52,14 +49,14 @@ public class DevicePermissionsController : ControllerBase
return await _devicePermissionService.AssignToUniqueAsync(request);
}
[AllowAnonymous]
[HttpPost("assign-unique-import")]
[Transactional]
[IgnoreTenant]
public async Task AssignToUniqueImportAsync(IFormFile file)
{
await _devicePermissionService.AssignToUniqueImportAsync(file);
}
// [AllowAnonymous]
// [HttpPost("assign-unique-import")]
// [Transactional]
// [IgnoreTenant]
// public async Task AssignToUniqueImportAsync(IFormFile file)
// {
// await _devicePermissionService.AssignToUniqueImportAsync(file);
// }
/// <summary>
/// 当前类型的权限分配

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

@@ -38,17 +38,4 @@ public class AssignTypeDeviceCode
public List<Guid> Codes { get; set; }
public List<Guid> OriginalCodes { get; set; }
}
public class UserTenantDeviceCodeDto
{
/// <summary>
/// 租户
/// </summary>
public string Tenant { get; set; }
/// <summary>
/// 设备权限
/// </summary>
public IEnumerable<Guid> Codes { get; set; }
}

22
Src/Dlhis.Basic/Device/Filters/AssignPermissionLimitAttribute.cs
View File

@@ -1,22 +0,0 @@
using Kurisu.AspNetCore.Authentication.Abstractions;
using Kurisu.AspNetCore.Cache;
using Kurisu.AspNetCore.Utils.Extensions;
using Microsoft.AspNetCore.Mvc.Filters;
namespace Dlhis.Basic.Device.Filters;
[AttributeUsage(AttributeTargets.Method)]
public class AssignPermissionLimitAttribute : Attribute, IAsyncActionFilter
{
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
// var currentUser = context.HttpContext.RequestServices.GetRequiredService<ICurrentUser>();
// var redisCache = context.HttpContext.RequestServices.GetRequiredService<RedisCache>();
//
// var currentTenantId = currentUser.GetStringTenantId();
//
// await using var handler = await redisCache.LockAsync($"permission:generate:{currentTenantId}", expiry: TimeSpan.FromMinutes(3));
// handler.Acquired.ThrowIfFalse("请勿频繁分配");
await next();
}
}

3
Src/Dlhis.Basic/Device/Request/DeviceGetAssignmentsRequest.cs
View File

@@ -56,11 +56,10 @@ public class DeviceGetAssignmentUniquesRequest
public DeviceAssignmentTypeEnumType UniqueType { get; set; }
/// <summary>
///
/// 权限值
/// </summary>
public Guid UniqueValue { get; set; }
/// <summary>
/// 设备类型
/// </summary>

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

@@ -1,6 +1,5 @@
using Dlhis.Basic.Device.Dtos;
using Dlhis.Basic.Device.Request;
using Dlhis.Basic.Device.Response;
using Dlhis.Basic.Organization.Dto;
using Dlhis.Entity.Sys.Entities;
using Dlhis.Entity.Sys.Enums;
@@ -12,22 +11,42 @@ namespace Dlhis.Basic.Device.Services;
/// </summary>
public interface IDevicePermissionAnalyzeService : IScopeDependency
{
/// <summary>
/// 获取存储的设备权限(原始数据)
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task<List<DevicePermissionEntity>> GetDevicePermissionsAsync(DevicePermissionSaveRequest request);
Task<DevicePermissionAssignResponse> GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos, string source);
/// <summary>
/// 获取设备权限codes(原始数据)
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request);
/// <summary>
/// 获取设备分配的人(按人员)
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task<List<GainfoDto>> GetAssignmentUniqueAsync(DeviceGetAssignmentUniquesRequest request);
Task<List<Guid>> GetAssignDeviceCodesAsync(string userNo);
Task<Dictionary<string, List<UserTenantDeviceCodeDto>>> GetUserAssignDeviceCodesInTenantAsync(
List<string> userNos,
DeviceAssignmentTypeEnumType? ignoreUniqueType = null,
string ignoreAssignValue = null, AssignTypeEnumType? ignoreAssignType = null);
/// <summary>
/// 获取人员所有权限codes
/// </summary>
/// <param name="userNo"></param>
/// <returns></returns>
Task<List<Guid>> GetUserPermissionDeviceCodesAsync(string userNo);
/// <summary>
/// 获取人员权限(人员--(厂区--分配方式--设备codes))
/// </summary>
/// <param name="userNos"></param>
/// <param name="ignoreUniqueType"></param>
/// <param name="ignoreAssignValue"></param>
/// <param name="ignoreAssignType"></param>
/// <returns></returns>
Task<Dictionary<string, List<TenantAssignTypeDeviceCode>>> GetUserAssignDeviceCodesWithTypeInTenantAsync(
List<string> userNos,
DeviceAssignmentTypeEnumType? ignoreUniqueType = null,

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

@@ -4,11 +4,29 @@ using Kurisu.AspNetCore.DataAccess.Dto;
namespace Dlhis.Basic.Device.Services;
/// <summary>
/// 例外人员权限分配
/// </summary>
public interface IDevicePermissionManuallyService : IScopeDependency
{
/// <summary>
/// 获取例外分配分页
/// </summary>
/// <param name="requestDto"></param>
/// <returns></returns>
Task<Pagination<DevicePermissionManuallyResponse>> GetPageAsync(PageDto requestDto);
/// <summary>
/// 添加例外
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task AddAsync(DevicePermissionManuallyAddRequest request);
/// <summary>
/// 删除例外
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task DeleteAsync(long id);
}

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

@@ -21,12 +21,8 @@ public interface IDevicePermissionService : IScopeDependency
/// <param name="request"></param>
/// <returns></returns>
Task<DevicePermissionAssignResponse> AssignToUniqueAsync(DevicePermissionsAssignToDeviceRequest request);
Task AssignToUniqueImportAsync(IFormFile file);
Task<Dictionary<string, IEnumerable<UserTenantDeviceCodeDto>>> GetUserDevicePermissionsAsync(string code);
//Task AssignToUniqueImportAsync(IFormFile file);
/// <summary>
/// 生成下发任务(主动生成)

30
Src/Dlhis.Basic/Device/Services/IDeviceTimePeriodService.cs
View File

@@ -5,15 +5,45 @@ using Kurisu.AspNetCore.DataAccess.Dto;
namespace Dlhis.Basic.Device.Services;
/// <summary>
/// 设备时段码服务
/// </summary>
public interface IDeviceTimePeriodService : IScopeDependency
{
/// <summary>
/// 时段码配置
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task<Pagination<DeviceTimePeriodPageResponse>> GetPageAsync(DeviceTimePeriodPageRequest request);
/// <summary>
/// 保存时段码
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task SaveAsync(DeviceTimePeriodSaveRequest request);
/// <summary>
/// 获取时段码配置
/// </summary>
/// <param name="assignType"></param>
/// <param name="value"></param>
/// <returns></returns>
Task<List<DeviceTimePeriodResponse>> GetListAsync(DeviceTimePeriodAssignEnumType assignType, Guid value);
/// <summary>
/// 删除时段码
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task DeleteCardTypeAsync(DeviceTimePeriodDeleteCardTypeRequest request);
/// <summary>
/// 生成时段码
/// </summary>
/// <param name="func"></param>
/// <param name="source"></param>
/// <returns></returns>
Task GenerateDeviceTimePeriodTasksAsync(Func<Task> func, string source);
}

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

@@ -2,7 +2,6 @@ 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;
@@ -11,7 +10,6 @@ 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;
@@ -34,8 +32,9 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
public async Task<List<DevicePermissionEntity>> GetDevicePermissionsAsync(DevicePermissionSaveRequest request)
{
var currentTenantId = await GetCurrentFactoryAsync(request);
var currentTenantId = await GetCurrentFactoryAsync(request.UniqueType, request.Codes);
//获取当前查询的配置
var setting = _dbContext.GetQueryableSetting();
var query = _dbContext.Queryable<DevicePermissionEntity>().Where(x => x.AssignType == request.AssignType
@@ -43,6 +42,8 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
&& x.UniqueType == request.UniqueType
&& x.Type == request.Type
&& x.TenantId == currentTenantId);
//根据数据权限进行过滤
if (setting.GetEnableDataPermission<DevicePermissionEntity>())
{
(bool enableDeviceFilter, List<Guid> deviceCodes) = _myDataPermissionService.GetMyDeviceCodes();
@@ -54,102 +55,32 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
}
return await query.ToListAsync();
}
private async Task<string> GetCurrentFactoryAsync(DevicePermissionSaveRequest request)
{
var currentTenantId = _currentUser.GetStringTenantId();
var r = request.UniqueType switch
//获取当前的操作人的基地
async Task<string> GetCurrentFactoryAsync(DeviceAssignmentTypeEnumType uniqueType, List<Guid> codes)
{
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
};
var internalCurrentTenantId = _currentUser.GetStringTenantId();
r.ThrowIfTrue("存在设备或者设备组不属于当前厂区,操作失败!");
return currentTenantId;
}
public async Task<DevicePermissionAssignResponse> GenerateDeviceTasksAsync(Func<Task> func, List<string> userNos, string source)
{
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 r = uniqueType switch
{
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>();
DeviceAssignmentTypeEnumType.Device => await _dbContext.Queryable<DeviceEntity>().Where(x => codes.Contains(x.Code)).Where(x => x.TenantId != internalCurrentTenantId).AnyAsync(),
DeviceAssignmentTypeEnumType.Group => await _dbContext.Queryable<DeviceGroupEntity>().Where(x => codes.Contains(x.Code)).Where(x => x.TenantId != internalCurrentTenantId).AnyAsync(),
_ => false
};
//被删除
var deletedItems = beforeCodes.Where(x => !currentCodes.Contains(x)).ToList();
//新增
var addItems = currentCodes.Where(x => !beforeCodes.Contains(x)).ToList();
r.ThrowIfTrue("存在设备或者设备组不属于当前厂区,操作失败!");
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,
DeviceType = devices.First(item => item.Code == x).Type,
UserNo = userNo,
Version = 0,
TenantId = tenant,
Source = source
}));
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 = source
}));
}
return internalCurrentTenantId;
}
}
await ChunkInsertAsync(waitAddTasks);
await ChunkInsertAsync(waitDeleteTasks);
return new DevicePermissionAssignResponse(waitAddTasks.Count, waitDeleteTasks.Count);
public async Task<List<Guid>> GetUserPermissionDeviceCodesAsync(string userNo)
{
var result = await GetUserAssignDeviceCodesWithTypeInTenantAsync(new List<string> { userNo });
return result.Count == 0
? new List<Guid>()
: result[userNo].SelectMany(x => x.AssignTypes.SelectMany(p => p.Codes)).Distinct().ToList();
}
@@ -344,33 +275,6 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
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, List<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(),
};
}).ToList());
}
public async Task<List<Guid>> GetAssignmentsAsync(DeviceGetAssignmentsRequest request)
{
var r = await GetDevicePermissionsAsync(new DevicePermissionSaveRequest
@@ -405,10 +309,4 @@ public class DevicePermissionAnalyzeService : IDevicePermissionAnalyzeService
Factory = x.Factory
}).ToListAsync();
}
public async Task<List<Guid>> GetAssignDeviceCodesAsync(string userNo)
{
var result = await GetUserAssignDeviceCodesInTenantAsync(new List<string> { userNo });
return result.First().Value.SelectMany(x => x.Codes).ToList();
}
}

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

@@ -156,81 +156,64 @@ public class DevicePermissionService : IDevicePermissionService
return new DevicePermissionAssignResponse(tasksToAdd.Count, tasksToDelete.Count);
}
/// <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,
Source = "人员分配到设备import",
Priority = 0,
TenantId = device.TenantId,
}).ToList();
await _dbContext.InsertAsync(tasks);
}
}
}
/// <inheritdoc />
public async Task<Dictionary<string, IEnumerable<UserTenantDeviceCodeDto>>> GetUserDevicePermissionsAsync(string code)
{
var userNo = await _dbContext.Queryable<GainfoEntity>().Where(x => x.Code == code).Select(x => x.No).SingleAsync();
var result = await _devicePermissionAnalyzeService.GetUserAssignDeviceCodesWithTypeInTenantAsync(new List<string> { userNo });
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(),
};
}));
}
// /// <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,
// Source = "人员分配到设备import",
// Priority = 0,
// TenantId = device.TenantId,
// }).ToList();
//
// await _dbContext.InsertAsync(tasks);
// }
// }
// }
public async Task<Pagination<DeviceGainfoResponse>> GetGainfoPageByDeviceAsync(DeviceWithGainfoRequest request)
{

3
Src/Dlhis.Basic/Device/Services/Implements/DeviceTimePeriodService.cs
View File

@@ -190,9 +190,10 @@ public class DeviceTimePeriodService : IDeviceTimePeriodService
DeviceUniqueNo = deviceUniqueNo,
Status = DeviceTaskStatusEnumType.Wait,
Version = 0,
ResultMessage = null,
Source = source,
Priority = 90,
TenantId = device.TenantId
TenantId = device.TenantId,
});
break;

4
Src/Dlhis.Basic/Organization/Controllers/GainfoGroupsController.cs
View File

@@ -1,5 +1,4 @@
using Dlhis.Basic.Device.Filters;
using Dlhis.Basic.Device.Response;
using Dlhis.Basic.Device.Response;
using Dlhis.Basic.Organization.Request;
using Dlhis.Basic.Organization.Response;
using Dlhis.Basic.Organization.Services;
@@ -75,7 +74,6 @@ public class GainfoGroupsController : ControllerBase
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("assign")]
[AssignPermissionLimit]
[Transactional]
[CrossTenant]
public async Task<DevicePermissionAssignResponse> AssignGainfosAsync(GainfoAssignRequest request)

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

@@ -169,7 +169,7 @@ public class GainfoPermissionService : IGainfoPermissionService
//获取人员的设备权限
if (deviceCodes.IsEmpty())
{
deviceCodes = await _devicePermissionAnalyzeService.GetAssignDeviceCodesAsync(gainfo!.No);
deviceCodes = await _devicePermissionAnalyzeService.GetUserPermissionDeviceCodesAsync(gainfo!.No);
}
var devices = await _dbContext.Queryable<DeviceEntity>().Where(x => deviceCodes.Contains(x.Code)).ToListAsync();

2
Src/Dlhis.Basic/Places/Controllers/BusinessPlacesController.cs
View File

@@ -1,5 +1,4 @@
using Dlhis.Basic.BusinessShift.Services;
using Dlhis.Basic.Device.Filters;
using Dlhis.Basic.Places.Request;
using Dlhis.Basic.Places.Response;
using Dlhis.Basic.Places.Services;
@@ -124,7 +123,6 @@ public class BusinessPlacesController : ControllerBase
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("device/assign")]
[AssignPermissionLimit]
[Transactional]
[CrossTenant]
public async Task Assign(DispositionDeviceRequest request)