jinko.yikatong/Src/Dlhis.ScheduledTask/TaskAssignment/Services/Implements/DeviceTaskAssignmentService.cs

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 Dlhis.Sys.Api;
using Kurisu.AspNetCore.CustomClass;
using Kurisu.AspNetCore.DataAccess.Dto;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;
using SqlSugar;

namespace Dlhis.ScheduledTask.TaskAssignment.Services.Implements;

public class DeviceTaskAssignmentService : IDeviceTaskAssignmentService
{
    private readonly IDbContext _dbContext;
    private readonly ITenantApi _tenantApi;

    public DeviceTaskAssignmentService(IDbContext dbContext, ITenantApi tenantApi)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
    }

    public async Task<Pagination<DeviceTaskAssignmentResponse>> GetPageAsync(DeviceTaskAssignmentRequest request)
    {
        var page = await _dbContext.Queryable<DeviceTaskEntity>()
            .LeftJoin<DeviceEntity>((deviceTask, device) => deviceTask.DeviceUniqueNo == device.UniqueNo)
            .LeftJoin<GainfoEntity>((deviceTask, device, ga) => deviceTask.UserNo == ga.No)
            .LeftJoin<GainfoLeaveEntity>((deviceTask, device, ga, gaLeave) => deviceTask.UserNo == gaLeave.No)
            .LeftJoin<DeviceRegistryEntity>((deviceTask, device, ga, gaLeave, deviceRegistry) => deviceRegistry.DeviceUniqueNo == deviceTask.DeviceUniqueNo)
            .WhereIF(request.SearchDateTimePeriod.HasValue(), deviceTask => deviceTask.ModifiedTime >= request.SearchDateTimePeriod.Start
                                                                            && deviceTask.ModifiedTime <= request.SearchDateTimePeriod.End
            )
            .WhereIF(request.UserNo.IsPresent(), deviceTask => deviceTask.UserNo == request.UserNo)
            .Where(deviceTask => deviceTask.TenantId == request.Factory)
            .WhereIF(request.Type.HasValue, deviceTask => deviceTask.DeviceType == request.Type)
            .WhereIF(request.TaskTypes.IsPresent(), deviceTask => request.TaskTypes.Contains(deviceTask.Type))
            .WhereIF(request.Status.IsPresent(), deviceTask => request.Status.Contains(deviceTask.Status))
            .WhereIF(!request.Search.IsEmpty(), (deviceTask, device, ga) =>
                ga.Name == request.Search
                || ga.Code == request.Search
                || deviceTask.DeviceUniqueNo == request.Search
            )
            .WhereIF(request.IsOffline.HasValue && request.IsOffline.Value, (deviceTask, device, ga, gaLeave, deviceRegistry) =>
                device.HeartbeatInterval != 0 && SqlFunc.DateAdd(deviceRegistry.LastHeartbeatTime, device.HeartbeatInterval, DateType.Second) < DateTime.Now)
            .WhereIF(request.IsOffline.HasValue && !request.IsOffline.Value, (deviceTask, device, ga, gaLeave, deviceRegistry) =>
                device.HeartbeatInterval == 0 || SqlFunc.DateAdd(deviceRegistry.LastHeartbeatTime, device.HeartbeatInterval, DateType.Second) >= DateTime.Now)
            .OrderBy(deviceTask => deviceTask.ModifiedTime, OrderByType.Desc)
            .Select((deviceTask, device, ga, gaLeave, deviceRegistry) => new DeviceTaskAssignmentResponse
            {
                Id = deviceTask.Id,
                DeviceUniqueNo = deviceTask.DeviceUniqueNo,
                ResultMessage = deviceTask.ResultMessage,
                RetryCount = deviceTask.Version,
                Status = deviceTask.Status,
                UserNo = deviceTask.UserNo,
                UserName = SqlFunc.IsNull(ga.Name, gaLeave.Name),
                UserCode = SqlFunc.IsNull(ga.Code, gaLeave.Code),
                Type = deviceTask.Type,
                CreateTime = deviceTask.CreateTime,
                LastUpdateTime = deviceTask.ModifiedTime,
                TenantId = deviceTask.TenantId,
                LastHeartbeatTime = deviceRegistry.LastHeartbeatTime,
                HeartbeatInterval = device.HeartbeatInterval,
                DeployPlace = device.DeployPlace,
                CreateBy = deviceTask.CreatedBy
            })
            .ToPageListAsync(request);

        try
        {
            var tenants = await _tenantApi.GetTenantsInternalAsync();
            page.Data.ForEach(item => { item.TenantName = tenants.FirstOrDefault(x => x.Code == item.TenantId)?.Name; });
        }
        catch (Exception)
        {
            //ignore
        }

        return page;
    }

    public async Task ResetAsync(DeviceTaskResetRequest request)
    {
        var tasks = await _dbContext.Queryable<DeviceTaskEntity>()
            .Where(x => request.Ids.Contains(x.Id))
            .ToListAsync();

        //判断process任务时间
        if (!request.Force)
        {
            var now = DateTime.Now;
            tasks.Any(x => x.ModifiedTime.AddMinutes(10) < now && x.Status == DeviceTaskStatusEnumType.Process).ThrowIfTrue("请等待任务处理完成");
        }

        tasks.ForEach(x => x.Status = DeviceTaskStatusEnumType.Wait);

        //更新任务状态
        await _dbContext.UpdateAsync(tasks);
    }
}