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 Dlhis.Sys.Api.Request;
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;
    private readonly IUserApi _userApi;
    private readonly ILogger<DeviceTaskAssignmentService> _logger;

    public DeviceTaskAssignmentService(IDbContext dbContext,
        ITenantApi tenantApi,
        IUserApi userApi,
        ILogger<DeviceTaskAssignmentService> logger)
    {
        _dbContext = dbContext;
        _tenantApi = tenantApi;
        _userApi = userApi;
        _logger = logger;
    }

    public async Task<Pagination<DeviceTaskAssignmentResponse>> GetPageAsync(DeviceTaskAssignmentRequest request)
    {
        var rows = 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, device) => 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, gaLeave) =>
                ga.Name == request.Search
                || ga.Code == request.Search
                || deviceTask.DeviceUniqueNo == request.Search
                || gaLeave.Code == 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)
            .Where((deviceTask, device) => device.Enable)
            .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,
                Source = deviceTask.Source
            })
            .ToPageListAsync(request.PageIndex, request.PageSize);

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

        try
        {
            var userIds = rows.Select(x => x.CreateBy).Distinct().ToList();
            var userInfos = await _userApi.GetUserByIdsAsync(new IdsRequest { Ids = userIds });
            rows.ForEach(item => item.Creator = userInfos.FirstOrDefault(x => x.Id == item.CreateBy)?.OperatorName);
        }
        catch (Exception e)
        {
            _logger.LogError("获取人员数据失败:{error}", e.Message);
        }

        return new Pagination<DeviceTaskAssignmentResponse>
        {
            PageIndex = request.PageIndex,
            PageSize = request.PageSize,
            Total = 0,
            Data = rows
        };
    }

    public async Task<Pagination<DeviceTaskAssignmentResponse>> GetPageWarningAsync(DeviceTaskAssignmentRequest request)
    {
        var limitTime = DateTime.Now.AddDays(-3);

        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)
            .Where(deviceTask => deviceTask.TenantId == request.Factory)
            .Where(deviceTask => deviceTask.DeviceType == request.Type)
            .Where(deviceTask => deviceTask.Status == DeviceTaskStatusEnumType.Process)
            .WhereIF(!request.Search.IsEmpty(), (deviceTask, device, ga) =>
                ga.Name == request.Search
                || ga.Code == request.Search
                || deviceTask.DeviceUniqueNo == request.Search
            )
            .Where(deviceTask => deviceTask.Version >= 10 || deviceTask.CreateTime < limitTime)
            .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,
                Source = deviceTask.Source
            })
            .ToPageListAsync(request);
        //.ToPageListAsync(request.PageIndex, request.PageSize);

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

        try
        {
            //var userIds = rows.Select(x => x.CreateBy).Distinct().ToList();
            var userIds = page.Data.Select(x => x.CreateBy).Distinct().ToList();
            var userInfos = await _userApi.GetUserByIdsAsync(new IdsRequest { Ids = userIds });
            page.Data.ForEach(item => item.Creator = userInfos.FirstOrDefault(x => x.Id == item.CreateBy)?.OperatorName);
        }
        catch (Exception e)
        {
            _logger.LogError("获取人员数据失败:{error}", e.Message);
        }

        // return new Pagination<DeviceTaskAssignmentResponse>
        // {
        //     PageIndex = request.PageIndex,
        //     PageSize = request.PageSize,
        //     Total = 0,
        //     Data = rows
        // };

        return page;
    }


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

        await _dbContext.Client.Deleteable<DeviceTaskEntity>()
            .Where(x => request.Ids.Contains(x.Id))
            .ExecuteCommandAsync();

        tasks.ForEach(x =>
        {
            x.Status = DeviceTaskStatusEnumType.Wait;
            x.Version = 0;
            x.Id = 0; // Reset Id to allow re-insertion
        });
        await _dbContext.InsertAsync(tasks);
    }
}