'联调'

Admin

2026-01-20 aff4845905dd17fb2eca2780f46ab6294b3f9dc1

 ÏîÄ¿´úÂë/WMS/WIDESEA_WMSServer/WIDESEA_TaskInfoService/TaskService.cs

@@ -16,13 +16,26 @@
#endregion << ç‰ˆ æœ¬ æ³¨ é‡Š >>

using AutoMapper;
using Microsoft.Extensions.Logging;
using Org.BouncyCastle.Math.EC;
using SixLabors.ImageSharp;
using SqlSugar;
using System.ComponentModel;
using System.Net;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
using WIDESEA_Common.Log;
using WIDESEA_Common.OtherEnum;
using WIDESEA_Common.StockEnum;
using WIDESEA_Common.TaskEnum;
using WIDESEA_Core;
using WIDESEA_Core.BaseRepository;
using WIDESEA_Core.BaseServices;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.Task;
using WIDESEA_IBasicService;
using WIDESEA_IInboundService;
@@ -36,13 +49,14 @@
{
    public partial class TaskService : ServiceBase<Dt_Task, IRepository<Dt_Task>>, ITaskService
    {
        private readonly ILogger<TaskService> _logger;
        private readonly IMapper _mapper;
        private readonly IUnitOfWorkManage _unitOfWorkManage;
        private readonly IStockInfoService _stockInfoService;
        private readonly ILocationInfoService _locationInfoService;
        private readonly IWarehouseService _warehouseService;
        private readonly IRoadWayinfoService _roadWayinfoService;

        private Timer _timer;
        public IRepository<Dt_Task> Repository => BaseDal;

        private Dictionary<string, OrderByType> _taskOrderBy = new()
@@ -55,10 +69,31 @@

        public List<int> TaskOutboundTypes => typeof(TaskTypeEnum).GetEnumIndexList();

        public TaskService(IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage) : base(BaseDal)
        public TaskService(ILogger<TaskService> logger, IRepository<Dt_Task> BaseDal, IMapper mapper, IUnitOfWorkManage unitOfWorkManage, IStockInfoService stockInfoService, ILocationInfoService locationInfoService,
            IWarehouseService warehouseService, IRoadWayinfoService roadWayinfoService) : base(BaseDal)
        {
            _logger = logger;
            _mapper = mapper;
            _unitOfWorkManage = unitOfWorkManage;
            _stockInfoService = stockInfoService;
            _locationInfoService = locationInfoService;
            _warehouseService = warehouseService;
            _roadWayinfoService=roadWayinfoService;

        }
        public string MES_InReporttask = WIDESEA_Core.Helper.AppSettings.Configuration["MES_InReporttask"]; //入库反馈信息
        public string MES_OutReporttask = WIDESEA_Core.Helper.AppSettings.Configuration["MES_OutReporttask"];   //出库反馈信息
        public string MES_InventoryUpdateApply = WIDESEA_Core.Helper.AppSettings.Configuration["MES_InventoryUpdateApply"];   //储位异动申请
        public string MES_InventoryUpdateCallback = WIDESEA_Core.Helper.AppSettings.Configuration["MES_InventoryUpdateCallback"];   //储位异动申请
        public string MES_TaskErrorInfoCallback = WIDESEA_Core.Helper.AppSettings.Configuration["MES_TaskErrorInfoCallback"];   //任务异常上报
        public string WCS_SendConveyorTask = WIDESEA_Core.Helper.AppSettings.Configuration["WCS_SendConveyorTask"];   //输送线任务下发
        public string WCS_SendStackerTask = WIDESEA_Core.Helper.AppSettings.Configuration["WCS_SendStackerTask"];   //堆垛机任务下发


        public WebResponseContent CESTEXT()
        {
            WriteLog.Write_Log("接收MES入库任务下发", $"任务接收参数", "成功", $"参数：234jkljsldafjlasdf");
            return WebResponseContent.Instance.OK();
        }


@@ -69,11 +104,12 @@
        /// <returns></returns>
        public WebResponseContent TaskCompleted(WCSTaskDTO wCSTask)
        {
            WebResponseContent webResponse= new WebResponseContent();
            try
            {
                Dt_Task task = BaseDal.QueryFirst(x => x.TaskId == wCSTask.TaskNum && x.PalletCode == wCSTask.PalletCode);
                if (task == null)
                    return WebResponseContent.Instance.Error("未找到任务信息");
                    return webResponse.Error("未找到任务信息");

                switch ((TaskTypeEnum)task.TaskType)
                {
@@ -84,58 +120,291 @@
                    case TaskTypeEnum.Relocation:
                        return HandleRelocationTask(task, wCSTask.TaskType);
                    default:
                        return WebResponseContent.Instance.Error($"任务类型错误，任务号：{task.TaskId},托盘编号：{task.PalletCode},类型：{task.TaskType}");
                        return webResponse.Error($"任务类型错误，任务号：{task.TaskId},托盘编号：{task.PalletCode},类型：{task.TaskType}");
                }
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"WMS任务完成错误：{ex.Message}");
                return webResponse.Error($"WMS任务完成错误：{ex.Message}");
            }
        }

        private WebResponseContent HandleInboundTask(Dt_Task task, int wcsTaskType)
        {
            switch (wcsTaskType)
            WebResponseContent content = new WebResponseContent();
            try
            {
                case 1:
                    task.TaskStatus = (int)InTaskStatusEnum.PLC_InFinish;
                    BaseDal.UpdateData(task);
                    return WebResponseContent.Instance.OK($"已接收入库输送线完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                case 2:
                    task.TaskStatus = (int)InTaskStatusEnum.SC_OutFinish;
                    BaseDal.UpdateData(task);
                    return WebResponseContent.Instance.OK($"已接收入库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                default:
                    return WebResponseContent.Instance.Error($"WCS上报类型错误：{wcsTaskType}");
                switch (wcsTaskType)
                {
                    case 1:

                        if (string.IsNullOrEmpty(task.TargetAddress))
                        {
                            if(task.TaskStatus == (int)InTaskStatusEnum.PLC_InExecuting)
                            {
                                int loctype = 0;
                                if (task.Roadway == "1" || task.Roadway == "2")
                                {
                                    if (task.PalletType == "1") loctype = (int)LocationTypeEnum.SmallPallet;
                                    else if (task.PalletType == "2") loctype = (int)LocationTypeEnum.MediumPallet;
                                }
                                else
                                {
                                    loctype = (int)LocationTypeEnum.LargePallet;
                                }

                                //查找货位，更新任务
                                Dt_LocationInfo dt_Location = _locationInfoService.GetLocation(task.Roadway, loctype);
                                Dt_LocationInfo ShallowCargoHold = _locationInfoService.ShallowGetLocation(dt_Location.RoadwayNo, dt_Location.LocationType, dt_Location.Row, dt_Location.Layer, dt_Location.Column);
                                if (ShallowCargoHold == null) return content.Error($"未找到该货位信息,货位编号:{dt_Location.LocationCode}的浅货位");
                                if (ShallowCargoHold.LocationStatus != (int)LocationStatusEnum.Free) return content.Error($"任务号：{task.TaskId},托盘编号：{task.PalletCode},查找的货位浅货位有货，货位编号：{ShallowCargoHold.LocationCode}");

                                if (task.PalletCode[0] == 1 && (dt_Location.RoadwayNo == "1" || dt_Location.RoadwayNo == "2") && dt_Location.Column < 4)
                                {
                                    return content.Error($"条码为高托盘，但是查找的货位要入在低托盘下，故障,托盘条码：{task.PalletCode},货位编号:{dt_Location.LocationCode}");
                                }


                                Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(task.Roadway);

                                task.TargetAddress = dt_Location.LocationCode;
                                task.CurrentAddress = _Roadwayinfo.InSCStationCode;
                                task.NextAddress = dt_Location.LocationCode;
                                task.TaskStatus = (int)InTaskStatusEnum.PLC_InFinish;

                                dt_Location.LocationStatus = (int)LocationStatusEnum.Lock;

                                Dt_StockInfo dt_StockInfo = new Dt_StockInfo();
                                dt_StockInfo.PalletCode = task.PalletCode;
                                dt_StockInfo.PalletType = task.PalletType;
                                dt_StockInfo.WarehouseId = task.WarehouseId;
                                dt_StockInfo.LocationCode = dt_Location.LocationCode;
                                dt_StockInfo.StockStatus = (int)StockStatusEmun.入库中;
                                dt_StockInfo.Creater = "MWS";
                                dt_StockInfo.CreateDate = DateTime.Now;

                                _unitOfWorkManage.BeginTran();
                                _stockInfoService.AddData(dt_StockInfo);
                                _locationInfoService.UpdateData(dt_Location);
                                BaseDal.UpdateData(task);
                                _unitOfWorkManage.CommitTran();
                                return content.OK($"已接收入库输送线完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                return content.Error("上报失败，当前任务不是输送线执行中，WCS上报完成失败");
                            }

                            
                        }
                        else
                        {
                            //判断是否有该站台
                            if (task.TaskStatus == (int)InTaskStatusEnum.PLC_InExecuting)
                            {
                                string Resultplc = MesInTaskStatusEnum.Finish.GetDescription();
                                MES_parameter mES_PCLParameter = InStoreDocCallback(task.TaskNum, Resultplc, "操作成功", task.PalletCode, task.TargetAddress);
                                if (mES_PCLParameter.Result == "Y")
                                {
                                    task.TaskStatus = (int)InTaskStatusEnum.PLC_InFinish;
                                    _unitOfWorkManage.BeginTran();
                                    BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                                    _unitOfWorkManage.CommitTran();
                                    return content.OK($"输送线任务已反馈至上游，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                                }
                                else
                                {
                                    return content.Error("上传MES失败，原因：" + mES_PCLParameter.ResultMsg);
                                }
                            }
                            else
                            {
                                return content.Error($"上报失败，当前任务不是输送线执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }

                        }
                    case 2:
                        if (task.TaskStatus == (int)InTaskStatusEnum.SC_IntExecuting)
                        {
                            string Resultsc = MesInTaskStatusEnum.Finish.GetDescription();
                            //上报MES任务完成
                            MES_parameter mES_Parameter = InStoreDocCallback(task.TaskNum, Resultsc, "操作成功", task.PalletCode, task.TargetAddress);
                            if (mES_Parameter.Result == "Y")
                            {
                                Dt_StockInfo dt_Stockowc = _stockInfoService.Repository.QueryData(x => x.PalletCode == task.PalletCode).FirstOrDefault();
                                Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stockowc.LocationCode).FirstOrDefault();

                                dt_Stockowc.StockStatus = (int)StockStatusEmun.已入库;
                                dt_LocationInfo.LocationStatus = (int)LocationStatusEnum.InStock;
                                task.TaskStatus = (int)InTaskStatusEnum.InFinish;

                                _unitOfWorkManage.BeginTran();
                                _stockInfoService.UpdateData(dt_Stockowc);
                                _locationInfoService.UpdateData(dt_LocationInfo);
                                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                                _unitOfWorkManage.CommitTran();
                                return content.OK($"已接收入库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                return content.Error("上传MES失败，原因：" + mES_Parameter.ResultMsg);
                            }
                        }
                        else
                        {
                            return content.Error($"上报失败，当前任务不是堆垛机执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }
                            
                    default:
                        return content.Error($"WCS上报类型错误：{wcsTaskType}");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return content.Error($"WCS任务完成接口故障，原因：{ex.Message}");
            }
        }

        private WebResponseContent HandleOutboundTask(Dt_Task task, int wcsTaskType)
        {
            switch (wcsTaskType)
            WebResponseContent content = new WebResponseContent();
            try
            {
                case 1:
                    task.TaskStatus = (int)OutTaskStatusEnum.PLC_OutFinish;
                    BaseDal.UpdateData(task);
                    return WebResponseContent.Instance.OK($"已接收出库输送线完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                case 2:
                    task.TaskStatus = (int)OutTaskStatusEnum.SC_OutFinish;
                    BaseDal.UpdateData(task);
                    return WebResponseContent.Instance.OK($"已接收出库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                default:
                    return WebResponseContent.Instance.Error($"WCS上报类型错误：{wcsTaskType}");
                switch (wcsTaskType)
                {
                    case 1:
                        if(task.TaskStatus == (int)OutTaskStatusEnum.PLC_OutExecuting)
                        {
                            string Resultplc = MesOutTaskStatusEnum.Finish.GetDescription();
                            //上报MES任务完成
                            MES_parameter mES_Parameter = OutStoreDocCallback(task.TaskNum, Resultplc, "操作成功");
                            if (mES_Parameter.Result == "Y")
                            {
                                task.TaskStatus = (int)OutTaskStatusEnum.PLC_OutFinish;
                                BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                                return content.OK($"已接收出库输送线完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                return content.Error("上传MES失败，原因：" + mES_Parameter.ResultMsg);
                            }

                        }
                        else
                        {
                            return content.Error($"上报失败，WMS当前任务不是输送线执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }
                        
                    case 2:

                        if (task.TaskStatus == (int)OutTaskStatusEnum.SC_OutExecuting)
                        {
                            //获取对应PLC站台信息
                            Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(task.Roadway);
                            task.CurrentAddress = _Roadwayinfo.OutStationCode;
                            task.NextAddress = task.TargetAddress;
                            task.TaskStatus = (int)OutTaskStatusEnum.SC_OutFinish;

                            Dt_StockInfo dt_Stockowc = _stockInfoService.Repository.QueryData(x => x.PalletCode == task.PalletCode).FirstOrDefault();
                            Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stockowc.LocationCode).FirstOrDefault();
                            dt_LocationInfo.LocationStatus = (int)LocationStatusEnum.Free;

                            string Result = MesOutTaskStatusEnum.Outstore.GetDescription();
                            //调取上游系统反馈开始任务
                            MES_parameter mES_SCParameter = OutStoreDocCallback(task.TaskNum, Result, "操作成功");
                            if (mES_SCParameter.Result == "Y")
                            {
                                _unitOfWorkManage.BeginTran();
                                _stockInfoService.DeleteData(dt_Stockowc);
                                _locationInfoService.UpdateData(dt_LocationInfo);
                                BaseDal.UpdateData(task);
                                _unitOfWorkManage.CommitTran();
                                return content.OK($"已接收出库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                            }
                            else
                            {
                                return content.Error("上传MES失败，原因：" + mES_SCParameter.ResultMsg);
                            }
                        }
                        else
                        {
                            return content.Error($"上报失败，WMS当前任务不是堆垛机执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }
                        
                    default:
                        return content.Error($"WCS上报类型错误：{wcsTaskType}");
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return content.Error($"WCS任务完成接口故障，原因：{ex.Message}");
            }
        }

        private WebResponseContent HandleRelocationTask(Dt_Task task, int wcsTaskType)
        {
            if (wcsTaskType == 2)
            WebResponseContent responseContent = new WebResponseContent();
            try
            {
                task.TaskStatus = (int)RelocationTaskStatusEnum.RelocationFinish;
                BaseDal.UpdateData(task);
                return WebResponseContent.Instance.OK($"已接收移库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                if (wcsTaskType == 2)
                {
                    if(task.TaskStatus == (int)RelocationTaskStatusEnum.RelocationExecuting)
                    {
                        //上报MES任务完成
                        MES_parameter mES_Parameter = AbnormalStorageLocation(task.PalletCode, task.SourceAddress, task.TargetAddress);
                        if (mES_Parameter.Result == "Y")
                        {
                            Dt_LocationInfo OriginalLocation = _locationInfoService.Repository.QueryData(x => x.LocationCode == task.SourceAddress).FirstOrDefault();
                            Dt_LocationInfo NewLocation = _locationInfoService.Repository.QueryData(x => x.LocationCode == task.TargetAddress).FirstOrDefault();
                            Dt_StockInfo dt_StockInfo = _stockInfoService.Repository.QueryData(x => x.LocationCode == task.SourceAddress).FirstOrDefault();

                            List<Dt_LocationInfo> dt_Locations = new List<Dt_LocationInfo>();

                            OriginalLocation.LocationStatus = (int)LocationStatusEnum.Free;
                            NewLocation.LocationStatus = (int)LocationStatusEnum.InStock;
                            dt_StockInfo.LocationCode = NewLocation.LocationCode;
                            dt_StockInfo.StockStatus = (int)StockStatusEmun.已入库;
                            task.TaskStatus = (int)RelocationTaskStatusEnum.RelocationFinish;

                            dt_Locations.Add(OriginalLocation);
                            dt_Locations.Add(NewLocation);

                            _unitOfWorkManage.BeginTran();
                            _locationInfoService.UpdateData(dt_Locations);
                            _stockInfoService.UpdateData(dt_StockInfo);
                            BaseDal.DeleteAndMoveIntoHty(task, App.User.UserId == 0 ? OperateTypeEnum.自动完成 : OperateTypeEnum.人工完成);
                            _unitOfWorkManage.CommitTran();

                            return responseContent.OK($"已接收移库堆垛机完成信息，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                        }
                        else
                        {
                            return responseContent.Error("上传MES失败，原因：" + mES_Parameter.ResultMsg);
                        }
                    }
                    else
                    {
                        return responseContent.Error($"上报失败，WMS当前任务不是堆垛机执行中，WCS上报完成失败，任务号：{task.TaskId},托盘编号：{task.PalletCode}");
                    }
                    
                }
                else
                {
                    return responseContent.Error($"WCS上报类型错误：{wcsTaskType}");
                }
            }
            return WebResponseContent.Instance.Error($"WCS上报类型错误：{wcsTaskType}");
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return responseContent.Error($"WMS系统错误，原因：{ex.Message}");
            }
            
        }


        

    }
}