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-01-14 19:59:38 +08:00
parent 79bc32c959
commit 64c15ad305
9 changed files with 306 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Src/Dlhis.Canteen/Order/Services/Implements/OrderService.cs
View File

@@ -182,6 +182,7 @@ public class OrderService : IOrderService
await _dbContext.Updateable<CanteenOrderEntity>()
.SetColumns(x => x.OrderStatus == CanteenOrderStatusEnumType.Failure)
.SetColumns(x => x.Result == ex.Message)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(x => x.Id == orderId)
.ExecuteCommandAsync();
@@ -190,6 +191,7 @@ public class OrderService : IOrderService
await _dbContext.Updateable<CanteenOrderEntity>()
.SetColumns(x => x.OrderStatus == CanteenOrderStatusEnumType.Successful)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(x => x.Id == orderId)
.ExecuteCommandAsync();
}

5
Src/Dlhis.Entity/Device/Entities/DeviceTask.cs
View File

@@ -33,11 +33,6 @@ public class DeviceTaskEntity : SugarBaseEntity, ITenantId, IVersion
/// </summary>
public string DeviceUniqueNo { get; set; }
/// <summary>
/// 重试次数
/// </summary>
public int RetryCount { get; set; }
/// <summary>
/// 任务下发状态
/// </summary>

54
Src/Dlhis.ScheduledTask/TaskAssignment/Controllers/AssignmentsController.cs Normal file
View File

@@ -0,0 +1,54 @@
using Dlhis.ScheduledTask.TaskAssignment.Request;
using Dlhis.ScheduledTask.TaskAssignment.Response;
using Dlhis.ScheduledTask.TaskAssignment.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace Dlhis.ScheduledTask.TaskAssignment.Controllers;
/// <summary>
/// 任务分配
/// </summary>
[Authorize]
[Route("api/[controller]")]
[ApiController]
public class AssignmentsController : ControllerBase
{
private readonly IAssignmentService _assignmentService;
public AssignmentsController(IAssignmentService assignmentService)
{
_assignmentService = assignmentService;
}
/// <summary>
/// 获取设备任务(按设备)
/// </summary>
/// <returns></returns>
[HttpGet("devicetasks")]
public async Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksGetAsync([FromQuery] DeviceTaskGetRequest request)
{
return await _assignmentService.DeviceGetTasksAsync(request);
}
/// <summary>
/// 获取设备任务(按设备)
/// </summary>
/// <returns></returns>
[HttpPost("devicetasks")]
public async Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksPostAsync(DeviceTaskGetRequest request)
{
return await _assignmentService.DeviceGetTasksAsync(request);
}
/// <summary>
/// 更新任务状态
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
[HttpPost("taskstatus")]
public async Task UpdateDeviceTaskStatusAsync(UpdateDeviceTaskStatusRequest request)
{
await _assignmentService.UpdateDeviceTaskStatusAsync(request);
}
}

10
Src/Dlhis.ScheduledTask/TaskAssignment/Controllers/DeviceTaskAssignmentsController.cs
View File

@@ -32,14 +32,4 @@ public class DeviceTaskAssignmentsController : ControllerBase
{
return await _deviceTaskAssignmentService.GetPageAsync(request);
}
/// <summary>
/// 获取设备任务(按设备)
/// </summary>
/// <returns></returns>
[HttpGet("device-tasks")]
public async Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksAsync([FromQuery] DeviceTaskGetRequest request)
{
return await _deviceTaskAssignmentService.DeviceGetTasksAsync(request);
}
}

19
Src/Dlhis.ScheduledTask/TaskAssignment/Request/UpdateDeviceTaskStatusRequest.cs Normal file
View File

@@ -0,0 +1,19 @@
namespace Dlhis.ScheduledTask.TaskAssignment.Request;
public class UpdateDeviceTaskStatusRequest
{
/// <summary>
/// 任务id
/// </summary>
public long TaskId { get; set; }
/// <summary>
/// 是否执行成功
/// </summary>
public bool IsSuccess { get; set; }
/// <summary>
/// 处理结果描述
/// </summary>
public string ResultMessage { get; set; }
}

22
Src/Dlhis.ScheduledTask/TaskAssignment/Services/IAssignmentService.cs Normal file
View File

@@ -0,0 +1,22 @@
using Dlhis.ScheduledTask.TaskAssignment.Request;
using Dlhis.ScheduledTask.TaskAssignment.Response;
namespace Dlhis.ScheduledTask.TaskAssignment.Services;
public interface IAssignmentService : IScopeDependency
{
/// <summary>
/// 设备获取任务
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksAsync(DeviceTaskGetRequest request);
/// <summary>
/// 更新设备任务状态
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task UpdateDeviceTaskStatusAsync(UpdateDeviceTaskStatusRequest request);
}

7
Src/Dlhis.ScheduledTask/TaskAssignment/Services/IDeviceTaskAssignmentService.cs
View File

@@ -7,11 +7,4 @@ namespace Dlhis.ScheduledTask.TaskAssignment.Services;
public interface IDeviceTaskAssignmentService : IScopeDependency
{
Task<Pagination<DeviceTaskAssignmentResponse>> GetPageAsync(DeviceTaskAssignmentRequest request);
/// <summary>
/// 设备获取任务
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksAsync(DeviceTaskGetRequest request);
}

206
Src/Dlhis.ScheduledTask/TaskAssignment/Services/Implements/AssignmentService.cs Normal file
View File

@@ -0,0 +1,206 @@
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using System.Linq.Expressions;
using Dlhis.ScheduledTask.TaskAssignment.Request;
using Dlhis.ScheduledTask.TaskAssignment.Response;
using Kurisu.AspNetCore.Scope;
using Kurisu.AspNetCore.UnifyResultAndValidation;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.SqlSugar.Services;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.Extensions.Options;
using SqlSugar;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Attributes;
namespace Dlhis.ScheduledTask.TaskAssignment.Services.Implements;
[IgnoreTenant]
public class AssignmentService : IAssignmentService
{
private readonly IDbContext _dbContext;
private readonly ILogger<AssignmentService> _logger;
public AssignmentService(IDbContext dbContext, ILogger<AssignmentService> logger)
{
_dbContext = dbContext;
_logger = logger;
}
public async Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksAsync(DeviceTaskGetRequest request)
{
var data = await ContinueUpdateAsync(async () =>
{
var page = await _dbContext.Queryable<DeviceTaskEntity>()
.LeftJoin<DeviceEntity>((deviceTask, deivce) => deviceTask.DeviceUniqueNo == deivce.UniqueNo)
.LeftJoin<DeviceTemplateEntity>((deviceTask, deivce, deivceTamplate) => deivceTamplate.Code == deivce.TemplateCode)
.LeftJoin<GainfoEntity>((deviceTask, deivce, deivceTamplate, ga) => deviceTask.UserNo == ga.No)
.LeftJoin<DepartmentEntity>((deviceTask, deivce, deivceTamplate, ga, department) => department.No == ga.DepartmentNo)
.WhereIF(request.Brand.IsPresent(), (deviceTask, deivce, deivceTamplate) => deivceTamplate.Brand == request.Brand)
.WhereIF(request.DeviceUniqueNo.IsPresent(), (deviceTask, deivce) => deviceTask.DeviceUniqueNo == request.DeviceUniqueNo)
.Where(deviceTask => deviceTask.Status == DeviceTaskStatusEnumType.Wait)
.OrderBy(deviceTask => deviceTask.CreateTime)
.Select((deviceTask, deivce, deivceTamplate, ga, department) => new
{
deviceTask.Id,
deviceTask.Type,
deviceTask.DeviceUniqueNo,
DeviceConnectionInfo = deivce.ConnectionInfo,
deivce.Brand,
deviceTask.UserNo,
deviceTask.UserCode,
UserName = ga.Name,
ga.DepartmentNo,
DepartmentName = department.Name,
ga.CardNo,
deviceTask.Version
})
.ToPageListAsync(request);
if (!page.Data.Any())
{
return page.Data;
}
var taskIdVs = page.Data.Select(x => new { x.Id, x.Version }).ToList();
Expression<Func<DeviceTaskEntity, bool>> where = LinqExpressionExtension.False<DeviceTaskEntity>();
taskIdVs.ForEach(p =>
{
where = where.Or(x => x.Id == p.Id && x.Version == p.Version && x.Status != DeviceTaskStatusEnumType.Success);
});
await _dbContext.Client.Ado.BeginTranAsync();
try
{
var effecet = await _dbContext.Updateable<DeviceTaskEntity>()
.SetColumns(x => x.Version == x.Version + 1)
.SetColumns(x => x.Status == DeviceTaskStatusEnumType.Process)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(where)
.ExecuteCommandAsync();
if (taskIdVs.Count != effecet)
{
throw new VersionExceptions("更新错误");
}
await _dbContext.Client.Ado.CommitTranAsync();
}
catch
{
await _dbContext.Client.Ado.RollbackTranAsync();
throw;
}
return page.Data;
}, 5);
if (!data.Any())
{
return new List<DeviceTaskToDeviceByDeviceResponse>();
}
return Scoped.Request.Value.Create((sp) =>
{
var faceUrlOptions = sp.GetService<IOptions<FaceUrlOptions>>().Value;
var dataProtectionProvider = sp.GetService<IDataProtectionProvider>();
var timeLimitedDataProtector = dataProtectionProvider
.CreateProtector("down:face")
.ToTimeLimitedDataProtector();
return data.GroupBy(x => new { x.Brand, x.DeviceUniqueNo, x.DeviceConnectionInfo })
.Select(x =>
{
var b = x.Key.Brand;
var d = x.Key.DeviceUniqueNo;
var dc = x.Key.DeviceConnectionInfo;
return new DeviceTaskToDeviceByDeviceResponse
{
Brand = b,
DeviceUniqueNo = d,
DeviceConnectionInfo = dc,
Tasks = x.AsEnumerable().Select(item =>
{
var key = $"face:{item.UserCode}";
var token = timeLimitedDataProtector.Protect(key, TimeSpan.FromSeconds(faceUrlOptions.Limit));
return new TaskCombineUserDimensionDto
{
TaskId = item.Id,
Type = item.Type,
UserInfo = new UserToDeviceResponse
{
UserNo = item.UserNo,
UserCode = item.UserCode,
UserName = item.UserName,
DepartmentNo = item.DepartmentNo,
DepartmentName = item.DepartmentName,
CardNo = item.CardNo,
Face = faceUrlOptions.Url + token
}
};
}).ToList()
};
}).ToList();
});
}
public async Task UpdateDeviceTaskStatusAsync(UpdateDeviceTaskStatusRequest request)
{
for (int i = 0; i < 5; i++)
{
var deviceTask = await _dbContext.Queryable<DeviceTaskEntity>().Where(x => x.Id == request.TaskId).SingleAsync();
deviceTask.ThrowIfNull("设备任务不存在");
(deviceTask.Status != DeviceTaskStatusEnumType.Process)
.ThrowIfTrue($"任务状态[{deviceTask.Status.GetDescription()}]有误");
var status = request.IsSuccess ? DeviceTaskStatusEnumType.Success : DeviceTaskStatusEnumType.Error;
var effect = await _dbContext.Updateable<DeviceTaskEntity>()
.SetColumns(x => x.Status == status)
.SetColumns(x => x.ResultMessage == request.ResultMessage)
.SetColumns(x => x.Version == x.Version + 1)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(x => x.Id == request.TaskId && x.Version == deviceTask.Version)
.ExecuteCommandAsync();
if (effect == 0)
{
continue;
}
return;
}
throw new UserFriendlyException("操作失败,请重试");
}
//*********************************************************** help methods *********************************************************************
private async Task<T> ContinueUpdateAsync<T>(Func<Task<T>> func, int retry)
{
for (int i = 0; i < retry; i++)
{
try
{
return await func();
}
catch (Exception ex) when (ex is VersionExceptions)
{
_logger.LogWarning(ex, ex.Message);
}
catch (Exception)
{
throw;
}
}
throw new UserFriendlyException("操作失败,请重试");
}
}

148
Src/Dlhis.ScheduledTask/TaskAssignment/Services/Implements/DeviceTaskAssignmentService.cs
View File

@@ -1,30 +1,20 @@
using System.Linq.Expressions;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Basic.Entity;
using Dlhis.Entity.Device.Entities;
using Dlhis.Entity.Device.Enums;
using Dlhis.ScheduledTask.TaskAssignment.Request;
using Dlhis.ScheduledTask.TaskAssignment.Response;
using Kurisu.AspNetCore.Scope;
using Kurisu.AspNetCore.UnifyResultAndValidation;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Microsoft.AspNetCore.DataProtection;
using Microsoft.Extensions.Options;
using SqlSugar;
namespace Dlhis.ScheduledTask.TaskAssignment.Services.Implements;
public class DeviceTaskAssignmentService : IDeviceTaskAssignmentService
{
private readonly IDbContext _dbContext;
private readonly ILogger<DeviceTaskAssignmentService> _logger;
public DeviceTaskAssignmentService(IDbContext dbContext, ILogger<DeviceTaskAssignmentService> logger)
public DeviceTaskAssignmentService(IDbContext dbContext)
{
_dbContext = dbContext;
_logger = logger;
}
public async Task<Pagination<DeviceTaskAssignmentResponse>> GetPageAsync(DeviceTaskAssignmentRequest request)
@@ -35,7 +25,7 @@ public class DeviceTaskAssignmentService : IDeviceTaskAssignmentService
{
DeviceUniqueNo = deviceTask.DeviceUniqueNo,
ResultMessage = deviceTask.ResultMessage,
RetryCount = deviceTask.RetryCount,
RetryCount = deviceTask.Version,
Status = deviceTask.Status,
UserNo = deviceTask.UserNo,
UserName = ga.Name,
@@ -48,136 +38,4 @@ public class DeviceTaskAssignmentService : IDeviceTaskAssignmentService
return page;
}
public async Task<List<DeviceTaskToDeviceByDeviceResponse>> DeviceGetTasksAsync(DeviceTaskGetRequest request)
{
var data = await ContinueUpdateAsync(async () =>
{
var page = await _dbContext.Queryable<DeviceTaskEntity>()
.LeftJoin<DeviceEntity>((deviceTask, deivce) => deviceTask.DeviceUniqueNo == deivce.UniqueNo)
.LeftJoin<DeviceTemplateEntity>((deviceTask, deivce, deivceTamplate) => deivceTamplate.Code == deivce.TemplateCode)
.LeftJoin<GainfoEntity>((deviceTask, deivce, deivceTamplate, ga) => deviceTask.UserNo == ga.No)
.LeftJoin<DepartmentEntity>((deviceTask, deivce, deivceTamplate, ga, department) => department.No == ga.DepartmentNo)
.WhereIF(request.Brand.IsPresent(), (deviceTask, deivce, deivceTamplate) => deivceTamplate.Brand == request.Brand)
.WhereIF(request.DeviceUniqueNo.IsPresent(), (deviceTask, deivce) => deviceTask.DeviceUniqueNo == request.DeviceUniqueNo)
.Where(deviceTask => deviceTask.Status != DeviceTaskStatusEnumType.Success)
.OrderBy(deviceTask => deviceTask.CreateTime)
.Select((deviceTask, deivce, deivceTamplate, ga, department) => new
{
deviceTask.Id,
deviceTask.Type,
deviceTask.DeviceUniqueNo,
DeviceConnectionInfo = deivce.ConnectionInfo,
deivce.Brand,
deviceTask.UserNo,
deviceTask.UserCode,
UserName = ga.Name,
ga.DepartmentNo,
DepartmentName = department.Name,
ga.CardNo,
deviceTask.Version
})
.ToPageListAsync(request);
var taskIdVs = page.Data.Select(x => new { x.Id, x.Version }).ToList();
Expression<Func<DeviceTaskEntity, bool>> where = LinqExpressionExtension.False<DeviceTaskEntity>();
taskIdVs.ForEach(p =>
{
where = where.Or(x => x.Id == p.Id && x.Version == p.Version && x.Status != DeviceTaskStatusEnumType.Success);
});
await _dbContext.Client.Ado.BeginTranAsync();
try
{
var effecet = await _dbContext.Updateable<DeviceTaskEntity>()
.SetColumns(x => x.Version == x.Version + 1)
.SetColumns(x => x.Status == DeviceTaskStatusEnumType.Process)
.SetColumns(x => x.ModifiedTime == DateTime.Now)
.Where(where)
.ExecuteCommandAsync();
if (taskIdVs.Count != effecet)
{
throw new VersionExceptions("更新错误");
}
await _dbContext.Client.Ado.CommitTranAsync();
}
catch
{
await _dbContext.Client.Ado.RollbackTranAsync();
throw;
}
return page.Data;
}, 5);
return Scoped.Request.Value.Create((sp) =>
{
var faceUrlOptions = sp.GetService<IOptions<FaceUrlOptions>>().Value;
var dataProtectionProvider = sp.GetService<IDataProtectionProvider>();
var timeLimitedDataProtector = dataProtectionProvider
.CreateProtector("down:face")
.ToTimeLimitedDataProtector();
return data.GroupBy(x => new { x.Brand, x.DeviceUniqueNo, x.DeviceConnectionInfo })
.Select(x =>
{
var b = x.Key.Brand;
var d = x.Key.DeviceUniqueNo;
var dc = x.Key.DeviceConnectionInfo;
return new DeviceTaskToDeviceByDeviceResponse
{
Brand = b,
DeviceUniqueNo = d,
DeviceConnectionInfo = dc,
Tasks = x.AsEnumerable().Select(item =>
{
var key = $"face:{item.UserCode}";
var token = timeLimitedDataProtector.Protect(key, TimeSpan.FromSeconds(faceUrlOptions.Limit));
return new TaskCombineUserDimensionDto
{
TaskId = item.Id,
Type = item.Type,
UserInfo = new UserToDeviceResponse
{
UserNo = item.UserNo,
UserCode = item.UserCode,
UserName = item.UserName,
DepartmentNo = item.DepartmentNo,
DepartmentName = item.DepartmentName,
CardNo = item.CardNo,
Face = faceUrlOptions.Url + token
}
};
}).ToList()
};
}).ToList();
});
}
private async Task<T> ContinueUpdateAsync<T>(Func<Task<T>> func, int retry)
{
for (int i = 0; i < retry; i++)
{
try
{
return await func();
}
catch (Exception ex) when (ex is VersionExceptions)
{
_logger.LogWarning(ex, ex.Message);
}
catch (Exception)
{
throw;
}
}
throw new UserFriendlyException("操作失败,请重试");
}
}