优化时间段查询不出数据问题，PDA出库抽检出库任务卡控

huangxiaoqiang

5 天以前 74d731cd8ac6bd995fbda485ee3371300af29a74

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_StorageTaskServices/Task/Dt_TaskService.cs

@@ -1,7 +1,13 @@
using AngleSharp.Io;
using AngleSharp.Dom;
using AngleSharp.Io;
using Mapster;
using Masuit.Tools;
using Microsoft.AspNetCore.Mvc;
using Microsoft.IdentityModel.Tokens;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
using SqlSugar;
using System.ComponentModel.Design;
using System.Linq.Expressions;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Text;
@@ -19,6 +25,7 @@
using WIDESEA_StorageSocketServices;
using WIDESEA_StorageTaskRepository;
using WIDESEAWCS_BasicInfoRepository;
using WIDESEAWCS_BasicInfoService;
using WIDESEAWCS_Model.Models;

namespace WIDESEA_StorageTaskServices;
@@ -28,28 +35,516 @@
    private readonly LogFactory LogFactory = new LogFactory();
    private readonly IUnitOfWorkManage _unitOfWorkManage;
    private readonly IStockInfoRepository _stockInfoRepository;
    private readonly IDt_StationManagerRepository _stationManagerRepository;
    private readonly IDt_StationManagerService _stationManagerService;
    private readonly IDt_Task_HtyRepository _task_HtyRepository;
    private readonly IMapper _mapper;
    private readonly ILocationInfoRepository _locationRepository;
   
    private readonly IDt_HandAutomaticRepository _handAutomaticRepository;
    private readonly IDt_HostErrorMessageRepository _errorMessageRepository;

    public Dt_TaskService(IDt_TaskRepository BaseDal,
                                IUnitOfWorkManage unitOfWorkManage,
                                IStockInfoRepository stockInfoRepository,
                                IDt_Task_HtyRepository task_HtyRepository,
                                IMapper mapper,
                                ILocationInfoRepository locationRepository,
                                IStockInfoDetailRepository stockInfoDetailRepository) : base(BaseDal)
                                IStockInfoDetailRepository stockInfoDetailRepository,
                                IDt_StationManagerRepository stationManagerRepository,
                                IDt_HandAutomaticRepository handAutomaticRepository,
                                IDt_StationManagerService stationManagerService,
                                IDt_HostErrorMessageRepository errorMessageRepository) : base(BaseDal)
    {
        _unitOfWorkManage = unitOfWorkManage;
        _stockInfoRepository = stockInfoRepository;
        _task_HtyRepository = task_HtyRepository;
        _mapper = mapper;
        _locationRepository = locationRepository;
        _stationManagerRepository = stationManagerRepository;
        _handAutomaticRepository = handAutomaticRepository;
        _stationManagerService = stationManagerService;
        _errorMessageRepository = errorMessageRepository;
    }
    



    #region å¤–部接口方法
    public WebResponseContent InboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            //var HandAutomatic = _handAutomaticRepository.QueryFirst(x => true && x.HandAutomatic == "Automatic");
            //if (HandAutomatic != null)
            //{
            //    return content.Error("当前不是手动模式");
            //}
            var station = _stationManagerRepository.QueryFirst(x => x.HostName == taskDTO.SourceAddress && x.stationType == 1);
            if (station == null)
            {
                return content.Error("未找到入库站台信息");
            }
            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == taskDTO.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }
            var location = GetLocation();
            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = taskDTO.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                SourceAddress = station.stationName,
                TargetAddress = location.LocationCode,
                CurrentAddress = station.stationName,
                NextAddress = location.LocationCode,
                TaskType = (int)TaskInboundTypeEnum.Inbound,
                TaskState = (int)TaskInStatusEnum.InNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "32" ,
                d_floor = "1",
                d_involed1 = taskNew.SourceAddress,
                d_involed2 = InsertHyphenEveryTwoChars(taskNew.TargetAddress),
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            location.LocationStatus = (int)LocationEnum.Lock;
            _locationRepository.UpdateData(location);
            BaseDal.AddData(taskNew);
            var x = SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            LogFactory.GetLog("插入数据到AGV").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(x)}", "");
            LogFactory.GetLog("PDA").InfoFormat(true, $"InboundTask请求参数：{JsonConvert.SerializeObject(taskDTO)}{Environment.NewLine}", "");
            return content.OK("入库任务下发成功！");
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent SamplingInboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            //var HandAutomatic = _handAutomaticRepository.QueryFirst(x => true && x.HandAutomatic == "Automatic");
            //if (HandAutomatic != null)
            //{
            //    return content.Error("当前不是手动模式");
            //}
            var station = _stationManagerRepository.QueryFirst(x => x.HostName == taskDTO.SourceAddress && x.stationType == 1);
            if (station == null)
            {
                return content.Error("未找到入库站台信息");
            }
            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == taskDTO.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }
            var stock = _stockInfoRepository.QueryFirst(x => x.PalletCode == taskDTO.PalletCode);
            if (stock == null)
            {
                return content.Error("该托盘库存不存在");
            }
            var location = _locationRepository.QueryFirst(x => x.LocationCode == stock.LocationCode);
            
            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = taskDTO.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                SourceAddress = station.stationName,
                TargetAddress = stock.LocationCode,
                CurrentAddress = station.stationName,
                NextAddress = stock.LocationCode,
                TaskType = (int)TaskInboundTypeEnum.InQuality,
                TaskState = (int)TaskInStatusEnum.InNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "32",
                d_floor = "1",
                d_involed1 = taskNew.SourceAddress,
                d_involed2 = InsertHyphenEveryTwoChars(taskNew.TargetAddress),
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            location.LocationStatus = (int)LocationEnum.Lock;
            _locationRepository.UpdateData(location);
            BaseDal.AddData(taskNew);
            var x = SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            LogFactory.GetLog("插入数据到AGV").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(x)}", "");
            LogFactory.GetLog("PDA").InfoFormat(true, $"SamplingInboundTask请求参数：{JsonConvert.SerializeObject(taskDTO)}{Environment.NewLine}", "");
            return content.OK("抽检入库任务下发成功！");
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent OutboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            StationStatus stationOut = _stationManagerService.GetStationStatus("B001");
            if (stationOut == null)
            {
                return content.Error("获取出库站台信息失败，请重新出库");
            }
            Dt_StationManager station;
            if (stationOut.WorkstationO == "0")
            {
                var hasTaskOne = BaseDal.QueryFirst(x => x.TargetAddress == "B001::1");
                if (hasTaskOne == null)
                {
                    station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::1" && x.stationType == 2);
                }
                else
                {
                    if (stationOut.WorkstationT == "0")
                    {
                        var hasTaskTwo = BaseDal.QueryFirst(x => x.TargetAddress == "B001::2");
                        if (hasTaskTwo == null)
                        {
                            station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::2" && x.stationType == 2);
                        }
                        else
                        {
                            return content.Error("未找到可用站台，请查看站台是否存在任务");
                        }
                    }
                    else
                    {
                        return content.Error("出库站台状态不是空闲，请确认再下发出库任务");
                    }
                }
                
            }
            else if (stationOut.WorkstationT == "0")
            {
                var hasTaskOne = BaseDal.QueryFirst(x => x.TargetAddress == "B001::2");
                if (hasTaskOne == null)
                {
                    station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::2" && x.stationType == 2);
                }
                else
                {
                    return content.Error("未找到可用站台，请查看站台是否存在任务");
                }
            }
            else
            {
                return content.Error("出库站台状态不是空闲，请确认再下发出库任务");
            }
            //if (station == null)
            //{
            //    return content.Error("未找到出库站台信息");
            //}

            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == taskDTO.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }
            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = taskDTO.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                SourceAddress =  taskDTO.SourceAddress,
                TargetAddress = station.stationName,
                CurrentAddress = taskDTO.SourceAddress,
                NextAddress = station.stationName,
                TaskType = (int)TaskOutboundTypeEnum.Outbound,
                TaskState = (int)TaskOutStatusEnum.OutNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "64",
                d_floor = "1",
                d_involed1 = InsertHyphenEveryTwoChars(taskNew.SourceAddress),
                d_involed2 = taskNew.TargetAddress,
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            BaseDal.AddData(taskNew);
            var x = SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            LogFactory.GetLog("插入数据到AGV").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(x)}", "");
            LogFactory.GetLog("PDA").InfoFormat(true, $"OutboundTask请求参数：{JsonConvert.SerializeObject(taskDTO)}{Environment.NewLine}", "");
            return content.OK("出库任务下发成功！");
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent SamplingOutboundTask(TaskDTO taskDTO)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {

            StationStatus stationOut = _stationManagerService.GetStationStatus("B002");
            if (stationOut == null)
            {
                return content.Error("获取出库站台信息失败，请重新出库");
            }
            Dt_StationManager station;
            //if (stationOut.WorkstationO == "0")
            //{
            //    station = _stationManagerRepository.QueryFirst(x => x.stationName == "B002::1" && x.stationType == 1);
            //}
            //else if (stationOut.WorkstationT == "0")
            //{
            //    station = _stationManagerRepository.QueryFirst(x => x.stationName == "B002::2" && x.stationType == 1);
            //}
            //else
            //{
            //    return content.Error("出库站台状态不是空闲，请确认再下发出库任务");
            //}
            //if (station == null)
            //{
            //    return content.Error("未找到出库站台信息");
            //}
            if (stationOut.WorkstationO == "0")
            {
                var hasTaskOne = BaseDal.QueryFirst(x => x.TargetAddress == "B001::1");
                if (hasTaskOne == null)
                {
                    station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::1" && x.stationType == 2);
                }
                else
                {
                    if (stationOut.WorkstationT == "0")
                    {
                        var hasTaskTwo = BaseDal.QueryFirst(x => x.TargetAddress == "B001::2");
                        if (hasTaskTwo == null)
                        {
                            station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::2" && x.stationType == 2);
                        }
                        else
                        {
                            return content.Error("未找到可用站台，请查看站台是否存在任务");
                        }
                    }
                    else
                    {
                        return content.Error("出库站台状态不是空闲，请确认再下发出库任务");
                    }
                }

            }
            else if (stationOut.WorkstationT == "0")
            {
                var hasTaskOne = BaseDal.QueryFirst(x => x.TargetAddress == "B001::2");
                if (hasTaskOne == null)
                {
                    station = _stationManagerRepository.QueryFirst(x => x.stationName == "B001::2" && x.stationType == 2);
                }
                else
                {
                    return content.Error("未找到可用站台，请查看站台是否存在任务");
                }
            }
            else
            {
                return content.Error("出库站台状态不是空闲，请确认再下发出库任务");
            }

            var stock = _stockInfoRepository.QueryFirst(x => x.LocationCode == taskDTO.SourceAddress);
            if (stock == null)
            {
                return content.Error("该库位库存不存在");
            }
            Dt_Task task = BaseDal.QueryFirst(x => x.PalletCode == stock.PalletCode);
            if (task != null)
            {
                return content.Error("该托盘已存在任务");
            }

            var location = _locationRepository.QueryFirst(x => x.LocationCode == stock.LocationCode);
            if (location.LocationStatus != (int)LocationEnum.InStock)
            {
                return content.Error("该库位不是有货状态，请确认状态再下发任务！");
            }
            station.stationHasTask = "抽检出库";
            _stationManagerRepository.UpdateData(station);

            Dt_Task taskNew = new Dt_Task()
            {
                TaskNum = BaseDal.GetTaskNo().Result,
                PalletCode = stock.PalletCode,
                Dispatchertime = DateTime.Now,
                Grade = 1,
                SeqNo = Convert.ToInt32(0),
                CommandID = Convert.ToInt32(0),
                TargetAddress = station.stationName,
                SourceAddress = stock.LocationCode,
                NextAddress = station.stationName,
                CurrentAddress = stock.LocationCode,
                TaskType = (int)TaskOutboundTypeEnum.OutQuality,
                TaskState = (int)TaskOutStatusEnum.OutNew,
                Roadway = "PDA",
            };
            task_call task_Call = new task_call()
            {
                d_task_type = "128",
                d_floor = "1",
                d_involed1 = InsertHyphenEveryTwoChars(taskNew.SourceAddress),
                d_involed2 = taskNew.TargetAddress,
                d_involed5 = taskNew.TaskNum.ToString(),
            };
            BaseDal.AddData(taskNew);
            var x = SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            LogFactory.GetLog("插入数据到AGV").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(x)}", "");
            LogFactory.GetLog("PDA").InfoFormat(true, $"SamplingOutboundTask请求参数：{JsonConvert.SerializeObject(taskDTO)}{Environment.NewLine}", "");
            return content.OK("抽检出库任务下发成功！");
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }

    public string InsertHyphenEveryTwoChars(string input)
    {
        if (string.IsNullOrEmpty(input))
        {
            return input;
        }

        StringBuilder result = new StringBuilder();

        for (int i = 0; i < input.Length; i += 2)
        {
            // æ·»åŠ ä¸¤ä¸ªå­—符
            result.Append(input.Substring(i, 2));

            // å¦‚果不是最后两个字符，添加一个连字符
            if (i + 2 < input.Length)
            {
                result.Append('-');
            }
        }

        return result.ToString();
    }

    public DtLocationInfo GetLocation()
    {
        List<DtLocationInfo> locations = _locationRepository.QueryData(x => x.LocationStatus == (int)LocationEnum.Free);
        var location = locations.OrderBy(x => x.Row).ThenBy(x => x.Column).ThenBy(x => x.Layer).FirstOrDefault();
        if(location != null)
        {
            var task = BaseDal.QueryFirst(x => x.SourceAddress == location.LocationName || x.TargetAddress == location.LocationName);
            if(task != null)
            {
                GetLocation();
            }
        }
        return location;
    }

    public WebResponseContent TaskComplete(int? TaskNum)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            var task = BaseDal.QueryFirst(x => x.TaskNum == TaskNum);
            if (task != null)
            {
                switch (task.TaskType)
                {
                    case (int)TaskInboundTypeEnum.Inbound:
                        LogFactory.GetLog("任务完成").InfoFormat(true, "入库任务", "");
                        return CompleteInboundTask(task);

                    case (int)TaskOutboundTypeEnum.Outbound:

                        LogFactory.GetLog("任务完成").InfoFormat(true, "出库任务", "");
                        return CompleteOutboundTask(task);

                    case (int)TaskRelocationTypeEnum.Relocation:
                        return CompleteRelocationboundTask(task);

                    case (int)TaskOutboundTypeEnum.OutQuality:
                        return CompleteSamplingOutboundTask(task);

                    case (int)TaskInboundTypeEnum.InQuality:
                        return CompleteSamplingInboundTask(task);

                    default:
                        return content.Error("任务类型不存在");
                }
            }
            else
            {
                return content.Error("未找到任务");
            }
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }
    public WebResponseContent TaskStatus(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            if (task != null)
            {
                switch (task.TaskType)
                {
                    case (int)TaskInboundTypeEnum.Inbound:
                    case (int)TaskInboundTypeEnum.InQuality:
                        task.TaskState = (int)TaskInStatusEnum.AGV_InExecuting;
                        BaseDal.Update(task);
                        break;
                    case (int)TaskOutboundTypeEnum.Outbound:
                    case (int)TaskOutboundTypeEnum.OutQuality:
                    case (int)TaskStationTypeEnum.StationToStation:
                        task.TaskState = (int)TaskOutStatusEnum.AGV_OutExecuting;
                        BaseDal.Update(task);
                        break;
                    case (int)TaskRelocationTypeEnum.Relocation:
                        task.TaskState = (int)TaskRelocationStatusEnum.AGV_RelocationExecuting;
                        BaseDal.Update(task);
                        break;
                    case (int)TaskFireAlarmTypeEnum.FireAlarmOut:
                        task.TaskState = (int)TaskFireAlarmStatusEnum.AGV_FireAlarmExecuting;
                        BaseDal.Update(task);
                        break;

                    default:
                        return content.Error("任务类型不存在");
                }
                return content.OK();
            }
            else
            {
                return content.Error("未找到任务");
            }
        }
        catch (Exception ex)
        {
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent CompleteInboundTask(Dt_Task task)
    {
@@ -57,8 +552,9 @@
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = 215;
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            locationInf.LocationStatus = (int)LocationEnum.InStock;
            locationInf.LocationStatus = 2;
            var stock = new DtStockInfo()
            {
                PalletCode = task.PalletCode,
@@ -67,15 +563,43 @@
                Creater = "system",
                LocationId = locationInf.Id,
            };
            _stockInfoRepository.AddData(stock);
            SqlSugarHelper.DbWMS.Insertable(stock).ExecuteCommand();
            _locationRepository.UpdateData(locationInf);
            TaskMoveHty(task);
            _unitOfWorkManage.CommitTran();

            LogFactory.GetLog("入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();

            LogFactory.GetLog("入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent CompleteSamplingInboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = 215;
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            locationInf.LocationStatus = (int)LocationEnum.InStock;
            _locationRepository.UpdateData(locationInf);
            TaskMoveHty(task);
            _unitOfWorkManage.CommitTran();

            LogFactory.GetLog("抽检入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("抽检入库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }
@@ -86,26 +610,87 @@
        try
        {
            _unitOfWorkManage.BeginTran();
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            locationInf.LocationStatus = (int)LocationEnum.Free;
            var stock = _stockInfoRepository.QueryFirst(x=>x.PalletCode == task.PalletCode);
            task.TaskState = 135;

            DtStockInfo_Hty stockInfo_Hty = stock.Adapt<DtStockInfo_Hty>();
            stockInfo_Hty.ModifyDate = DateTime.Now;

            AddStockInfoHty(stockInfo_Hty);

            _stockInfoRepository.DeleteData(stock);
            _locationRepository.UpdateData(locationInf);
            AddStcokHty(task.PalletCode, task.SourceAddress);

            TaskMoveHty(task);

            _unitOfWorkManage.CommitTran();
            LogFactory.GetLog("出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent CompleteFireAlarmboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = (int)TaskFireAlarmStatusEnum.AGV_FireAlarmFinish;

            AddStcokHty(task.PalletCode,task.SourceAddress);

            TaskMoveHty(task);
            _unitOfWorkManage.CommitTran();
            LogFactory.GetLog("火警出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("火警出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public void AddStcokHty(string  PalletCode,string Location)
    {
        //var stock = _stockInfoRepository.QueryFirst(x => x.PalletCode == PalletCode); 
        var stock = SqlSugarHelper.DbWMS.Queryable<DtStockInfo>().Where(x => x.PalletCode == PalletCode).First();
        if (stock != null)
        {
            DtStockInfo_Hty stockInfo_Hty = stock.Adapt<DtStockInfo_Hty>();
            stockInfo_Hty.ModifyDate = DateTime.Now;

            AddStockInfoHty(stockInfo_Hty);

            //_stockInfoRepository.DeleteData(stock);
            SqlSugarHelper.DbWMS.Deleteable(stock).ExecuteCommand();
        }
        var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == Location);
        if (locationInf != null)
        {
            locationInf.LocationStatus = 0;
            _locationRepository.UpdateData(locationInf);
        }
    }

    public WebResponseContent CompleteSamplingOutboundTask(Dt_Task task)
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            _unitOfWorkManage.BeginTran();

            task.TaskState = 135;
            TaskMoveHty(task);

            _unitOfWorkManage.CommitTran();
            LogFactory.GetLog("抽检出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("抽检出库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }
@@ -116,10 +701,11 @@
        try
        {
            _unitOfWorkManage.BeginTran();
            task.TaskState = 315;
            var locationInf = _locationRepository.QueryFirst(x => x.LocationCode == task.TargetAddress);
            var location = _locationRepository.QueryFirst(x => x.LocationCode == task.SourceAddress);
            locationInf.LocationStatus = (int)LocationEnum.InStock;
            location.LocationStatus = (int)LocationEnum.Free;
            locationInf.LocationStatus = 2;
            location.LocationStatus = 0;

            var stock = _stockInfoRepository.QueryFirst(x => x.PalletCode == task.PalletCode);

@@ -132,12 +718,113 @@
            _locationRepository.UpdateData(location);
            TaskMoveHty(task);
            _unitOfWorkManage.CommitTran();
            LogFactory.GetLog("移库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(task)}", "");
            return content.OK();
        }
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("移库任务完成").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public void UpdateTask(string SourceAddress,string TargetAddress, string PalletCode)
    {
        var task = BaseDal.QueryFirst(x => x.PalletCode == PalletCode);
        if (task != null)
        {
            task.SourceAddress = SourceAddress;
            task.TargetAddress = TargetAddress;
            BaseDal.UpdateData(task);
            InsertAGVTask(task);
        }
    }
    private int InsertAGVTask(Dt_Task task)
    {
        var AgvTask = SqlSugarHelper.DbAGV.Queryable<task_call>().Where(x => x.d_involed5 == task.TaskNum.ToString()).First();
        if (AgvTask != null)
        {
            string SourceAddress = string.Empty;
            string TargetAddress = string.Empty;
            if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)
            {
                SourceAddress = task.SourceAddress;
                TargetAddress = InsertHyphenEveryTwoChars(task.TargetAddress);
            }
            else if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
            {
                SourceAddress = InsertHyphenEveryTwoChars(task.SourceAddress);
                TargetAddress = task.TargetAddress;
            }
            else if (task.TaskType == (int)TaskRelocationTypeEnum.Relocation)
            {
                TargetAddress = InsertHyphenEveryTwoChars(task.TargetAddress);
                SourceAddress = InsertHyphenEveryTwoChars(task.SourceAddress);
            }
            else if (task.TaskType == (int)TaskStationTypeEnum.StationToStation)
            {
                TargetAddress = task.TargetAddress;
                SourceAddress = task.SourceAddress;
            }
            else if (task.TaskType == (int)TaskFireAlarmTypeEnum.FireAlarmOut)
            {
                TargetAddress = task.TargetAddress;
                SourceAddress = task.SourceAddress;
            }

            AgvTask.d_involed1 = SourceAddress;
            AgvTask.d_involed2 = TargetAddress;
            var x = SqlSugarHelper.DbAGV.Updateable(AgvTask).ExecuteCommand();
            LogFactory.GetLog("插入数据到AGV").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(x)}", "");
            return x;
        }
        else
        {
            string SourceAddress = string.Empty;
            string TargetAddress = string.Empty;
            string AGVType = string.Empty;
            if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)
            {
                SourceAddress = task.SourceAddress;
                AGVType = "2";
                TargetAddress = InsertHyphenEveryTwoChars(task.TargetAddress);
            }
            else if (task.TaskType == (int)TaskOutboundTypeEnum.Outbound)
            {
                SourceAddress = InsertHyphenEveryTwoChars(task.SourceAddress);
                TargetAddress = task.TargetAddress;
                AGVType = "4";
            }
            else if (task.TaskType == (int)TaskRelocationTypeEnum.Relocation)
            {
                TargetAddress = InsertHyphenEveryTwoChars(task.TargetAddress);
                SourceAddress = InsertHyphenEveryTwoChars(task.SourceAddress);
                AGVType = "16";
            }
            else if (task.TaskType == (int)TaskStationTypeEnum.StationToStation)
            {
                TargetAddress = task.TargetAddress;
                SourceAddress = task.SourceAddress;
                AGVType = "8";
            }
            else if (task.TaskType == (int)TaskFireAlarmTypeEnum.FireAlarmOut)
            {
                TargetAddress = task.TargetAddress;
                SourceAddress = task.SourceAddress;
                AGVType = "1";
            }
            task_call task_Call = new task_call()
            {
                d_task_type = AGVType,
                d_floor = "1",
                d_involed1 = SourceAddress,
                d_involed2 = TargetAddress,
                d_involed5 = task.TaskNum.ToString(),
            };
            var x = SqlSugarHelper.DbAGV.Insertable(task_Call).ExecuteCommand();
            LogFactory.GetLog("插入数据到AGV").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(x)}", "");
            return x;
        }
    }
    public WebResponseContent TaskMoveHty(Dt_Task task)
@@ -147,12 +834,15 @@
        {
            _unitOfWorkManage.BeginTran();
            var taskHtyNG = CreateHistoricalTask(task);

            var taskNum = task.TaskNum.ToString();
            var isTaskHtyAdd = _task_HtyRepository.AddData(taskHtyNG) > 0;
            var isTaskDelete = Delete(task.TaskId);
            var AgvTask = SqlSugarHelper.DbAGV.Queryable<task_call>().Where(x => x.d_involed5 == task.TaskNum).First();
            if(AgvTask != null)
            var AgvTask = SqlSugarHelper.DbAGV.Queryable<task_call>().Where(x => x.d_involed5 == taskNum).First();
            if (AgvTask != null)
            {
                SqlSugarHelper.DbAGV.Deleteable(AgvTask).ExecuteCommand();
                var x=SqlSugarHelper.DbAGV.Deleteable(AgvTask).ExecuteCommand();
                LogFactory.GetLog("插入数据到AGV").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(x)}", "");
            }
            _unitOfWorkManage.CommitTran();
            return content.OK();
@@ -160,8 +850,103 @@
        catch (Exception ex)
        {
            _unitOfWorkManage.RollbackTran();
            LogFactory.GetLog("删除任务").InfoFormat(true, $"请求参数：{JsonConvert.SerializeObject(ex.Message)}", "");
            return content.Error(ex.Message);
        }
    }

    public WebResponseContent GetTaskInfo()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            Expression<Func<Dt_Task, bool>> expression = x => true;
            if (!App.User.IsSuperAdmin)
            {
                expression = x => x.Creater == App.User.UserName;
            }

            var task = BaseDal.QueryData(x => true).ToList();
            var newTask = task.OrderByDescending(x => x.CreateDate).Select(x => new
            {
                x.TaskNum,
                x.PalletCode,
                x.SourceAddress,
                x.TargetAddress,
                TaskType = new List<string> { GetTaskTypeDesc(x.TaskType) }[0], // æ¯ä¸ªä»»åŠ¡ç‹¬ç«‹ç”Ÿæˆ TaskType
                TaskState = new List<string> { GetTaskStateDesc(x.TaskState) }[0] // æ¯ä¸ªä»»åŠ¡ç‹¬ç«‹ç”Ÿæˆ TaskState
            }).ToList();

            content = WebResponseContent.Instance.OK(data: newTask);
        }
        catch (Exception ex)
        {
            content = WebResponseContent.Instance.Error(ex.Message);
        }
        return content;
    }

    public WebResponseContent GetHostError()
    {
        WebResponseContent content = new WebResponseContent();
        try
        {
            Expression<Func<Dt_Task, bool>> expression = x => true;
            if (!App.User.IsSuperAdmin)
            {
                expression = x => x.Creater == App.User.UserName;
            }

            var now = DateTime.Now;
            var startOfDay = new DateTime(now.Year, now.Month, now.Day);
            var newTask = _errorMessageRepository.QueryData(x =>x.CreateDate> startOfDay).OrderByDescending(x => x.CreateDate).Select(x => new
            {
                x.id,
                x.ErrorCode,
                x.ErrorMessage,
                x.Grade,
                x.CreateDate
            }).ToList();

            content = WebResponseContent.Instance.OK(data: newTask);
        }
        catch (Exception ex)
        {
            content = WebResponseContent.Instance.Error(ex.Message);
        }
        return content;
    }
    

    public string GetTaskTypeDesc(int taskType)
    {
        return taskType switch
        {
            (int)TaskInboundTypeEnum.Inbound => TaskInboundTypeEnum.Inbound.GetIntegralRuleTypeEnumDesc(),
            (int)TaskRelocationTypeEnum.Relocation => TaskRelocationTypeEnum.Relocation.GetIntegralRuleTypeEnumDesc(),
            (int)TaskStationTypeEnum.StationToStation => TaskStationTypeEnum.StationToStation.GetIntegralRuleTypeEnumDesc(),
            (int)TaskFireAlarmTypeEnum.FireAlarmOut => TaskFireAlarmTypeEnum.FireAlarmOut.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutboundTypeEnum.Outbound => TaskOutboundTypeEnum.Outbound.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutboundTypeEnum.OutQuality => TaskOutboundTypeEnum.OutQuality.GetIntegralRuleTypeEnumDesc(),
        };
    }
    public string GetTaskStateDesc(int? taskState)
    {
        return taskState switch
        {
            (int)TaskInStatusEnum.InNew => TaskInStatusEnum.InNew.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInStatusEnum.AGV_InExecuting => TaskInStatusEnum.AGV_InExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskInStatusEnum.AGV_InFinish => TaskInStatusEnum.AGV_InFinish.GetIntegralRuleTypeEnumDesc(),
            (int)TaskRelocationStatusEnum.RelocationNew => TaskRelocationStatusEnum.RelocationNew.GetIntegralRuleTypeEnumDesc(),
            (int)TaskRelocationStatusEnum.AGV_RelocationExecuting => TaskRelocationStatusEnum.AGV_RelocationExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskRelocationStatusEnum.AGV_RelocationFinish => TaskRelocationStatusEnum.AGV_RelocationFinish.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.OutNew => TaskOutStatusEnum.OutNew.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.AGV_OutExecuting => TaskOutStatusEnum.AGV_OutExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskOutStatusEnum.AGV_OutFinish => TaskOutStatusEnum.AGV_OutFinish.GetIntegralRuleTypeEnumDesc(),
            (int)TaskFireAlarmStatusEnum.FireAlarmNew => TaskFireAlarmStatusEnum.FireAlarmNew.GetIntegralRuleTypeEnumDesc(),
            (int)TaskFireAlarmStatusEnum.AGV_FireAlarmExecuting => TaskFireAlarmStatusEnum.AGV_FireAlarmExecuting.GetIntegralRuleTypeEnumDesc(),
            (int)TaskFireAlarmStatusEnum.FireAlarmFinish => TaskFireAlarmStatusEnum.FireAlarmFinish.GetIntegralRuleTypeEnumDesc(),
        };
    }

    #endregion å¤–部接口方法
@@ -196,9 +981,9 @@
    /// <returns>是否删除成功</returns>
    public bool Delete(int id)
    {
        return  BaseDal.Delete(id);
        return BaseDal.Delete(id);
    }
    private void  AddStockInfoHty(DtStockInfo_Hty dtStock)
    private void AddStockInfoHty(DtStockInfo_Hty dtStock)
    {
        var isStockAdd = SqlSugarHelper.DbWMS.InsertNav(dtStock).IncludesAllFirstLayer().ExecuteCommand();
        if (!isStockAdd)
@@ -207,5 +992,42 @@
        }
    }

    public override WebResponseContent DeleteData(object[] key)
    {
        WebResponseContent content = new WebResponseContent();
        // åˆ›å»ºåŽ†å²ä»»åŠ¡å®žä¾‹æ¨¡åž‹
        try
        {
            foreach (var item in key)
            {
                //var task = BaseDal.QueryFirst(x => x.TaskId == Convert.ToInt32(item));
                //var taskHty = task.Adapt<Dt_Task_Hty>();
                //taskHty.Creater = App.User.UserName != null ? App.User.UserName : "System";
                //_taskHtyRepository.AddData(taskHty);

                //return base.DeleteData(key);
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskId == Convert.ToInt32(item));
                if (task == null)
                {
                    return content.Error("未找到任务信息!");
                }
                var taskHtyNG = CreateHistoricalTask(task, true);

                // æ‰§è¡Œæ•°æ®åº“事务

                // æ·»åŠ åŽ†å²ä»»åŠ¡
                var isTaskHtyAdd = _task_HtyRepository.AddData(taskHtyNG) > 0;

                // åˆ é™¤ä»»åŠ¡æ•°æ®
                var isTaskDelete = BaseDal.Delete(task.TaskId);
            }
            return content.OK("删除成功!");
        }
        catch (Exception ex)
        {
            return content.Error("删除任务异常：" + ex.Message);
        }
    }

    #endregion private å†…部方法
}