fix: 修复出入库冲突拦截，系统位置与实际位置的映射和修复

xiazhengtongxue

2026-03-19 bfcd7f5b405e431a5c07fe3fa77d74c892d4e66b

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

@@ -1,4 +1,5 @@
using MailKit.Search;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using OfficeOpenXml.FormulaParsing.Excel.Functions.DateTime;
@@ -9,6 +10,7 @@
using System.Linq;
using System.Reflection;
using System.Reflection.Metadata;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Common.LocationEnum;
@@ -21,6 +23,8 @@
using WIDESEA_Core.Helper;
using WIDESEA_DTO.Inbound;
using WIDESEA_DTO.Task;
using WIDESEA_IStockService;
using WIDESEA_ITaskInfoService;
using WIDESEA_Model.Models;
using static WIDESEA_ITaskInfoService.ITaskService;

@@ -28,10 +32,11 @@
{
    public partial class TaskService
    {
        public static List<string> InStationareaList = new List<string>() { "1113", "1114", "1115", "1116", "1117", "1118", "1119", "1120", "1121", "1122" ,"1123"};
        //入库，空盘回库
        public ApiResponse AddInStoreDoc(MES_InTask mES_In)
        {
            WriteLog.GetLog("接收MES入库任务下发").Write($"参数：{mES_In.ToJson()}", $"任务接收参数");
            WriteLog.Write_Log("MES_接收入库任务下发", $"任务接收参数", "接收参数", $"参数：{mES_In.ToJson()}");
            ApiResponse apiResponse = new ApiResponse();
            try
            {
@@ -45,20 +50,51 @@
                if (string.IsNullOrWhiteSpace(mES_In.endPosition)) return apiResponse.Error("目标位置不能为空");
                if (string.IsNullOrWhiteSpace(mES_In.containerType)) return apiResponse.Error("载具类型不能为空");  //载具类型，布料-1，松布卷-2，成品-1

                Dt_Task setask = BaseDal.QueryData(x => x.PalletCode == mES_In.containerNo).FirstOrDefault();
                if (setask != null) return apiResponse.Error($"WMS已有当前任务，不可重复下发，托盘编号：{mES_In.containerNo}");

                // åˆ¤æ–­ä¸‹å‘的托盘编号是否库存托盘编号有重复
                if (_stockInfoService.IsContainerNoExist(mES_In.containerNo)) return apiResponse.Error($"当前库位已有该托盘编号，托盘编号：{mES_In.containerNo}");
                Dt_Warehouse dt_Warehouse = _warehouseService.QueryWarehouse(mES_In.warehouseNo);
                if (dt_Warehouse == null) return apiResponse.Error($"WMS未能查询道对应仓库，仓库编码：{mES_In.warehouseNo}");
                int LocationType = 1;
                if (dt_Warehouse.WarehouseType == (int)WarehouseEnum.YMYL)
                string Roadway = "0";

                string SourceAddress = mES_In.startPosition;
                string TargetAddress = "";
                string CurrentAddress = mES_In.startPosition;
                string NextAddress = "";
                int WarehouseId = dt_Warehouse.WarehouseId;


                if (dt_Warehouse.WarehouseCode == mES_In.endPosition)
                {
                    if (mES_In.containerType == "2") LocationType = 2;
                    if (dt_Warehouse.WarehouseType == (int)WarehouseEnum.YMYL)
                    {
                        if (mES_In.containerType == "2") LocationType = 2;
                    }
                    else if (dt_Warehouse.WarehouseType == (int)WarehouseEnum.YMCP)
                    {
                        LocationType = 3;
                    }
                    Roadway = _locationInfoService.AccessingTunnel(dt_Warehouse.WarehouseId, LocationType);
                    if (Roadway == "0") return apiResponse.Error($"WMS未能查询道对应巷道编号，仓库编码：{mES_In.warehouseNo}");
                    //获取对应PLC站台信息
                    Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(Roadway);
                    NextAddress = _Roadwayinfo.InStationCode;
                }

                string Roadway = _locationInfoService.AccessingTunnel(dt_Warehouse.WarehouseId, LocationType);
                if (Roadway == "") return apiResponse.Error($"WMS未能查询道对应巷道编号，仓库编码：{mES_In.warehouseNo}");

                //获取对应PLC站台信息
                Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(Roadway);

                else
                {
                    if (dt_Warehouse.WarehouseType == (int)WarehouseEnum.YMYL)
                    {
                        Roadway="1";
                    }
                    else if (dt_Warehouse.WarehouseType == (int)WarehouseEnum.YMCP)
                    {
                        Roadway = "2";
                    }
                    TargetAddress = mES_In.endPosition;
                    NextAddress = mES_In.endPosition;
                }

                Dt_Task task = new Dt_Task();
                task.TaskNum = mES_In.transNo;
@@ -67,35 +103,57 @@
                task.Roadway = Roadway;
                task.TaskType = (int)TaskTypeEnum.Inbound;
                task.TaskStatus = (int)InTaskStatusEnum.InNew;
                task.SourceAddress = mES_In.startPosition;
                task.TargetAddress = "";
                task.CurrentAddress = mES_In.startPosition;
                task.NextAddress = _Roadwayinfo.InStationCode;
                task.WarehouseId = dt_Warehouse.WarehouseId;
                task.SourceAddress = SourceAddress;
                task.TargetAddress = TargetAddress;
                task.CurrentAddress = CurrentAddress;
                task.NextAddress = NextAddress;
                task.WarehouseId = WarehouseId;
                task.OrderNo = mES_In.transDate.ToString();
                task.Grade = 1;
                task.Creater = "MES";
                task.CreateDate = DateTime.Now;

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

                _unitOfWorkManage.BeginTran();
                BaseDal.AddData(task);
                _stockInfoService.Repository.AddData(dt_StockInfo);
                _unitOfWorkManage.CommitTran();
                WriteLog.GetLog("接收MES入库任务下发").Write($"参数：{mES_In.containerNo}", $"入库任务添加成功");
                return apiResponse.OK();
                //创建任务后，判断是否是产线回库的任务
                if (!InStationareaList.Contains(task.SourceAddress))
                {
                    WriteLog.Write_Log("MES_接收入库任务下发", $"反馈信息", "成功", $"任务添加成功，托盘条码：{task.PalletCode}");
                    return apiResponse.OK();
                }
                else
                {
                    WCSginseng result = PLC_IssueTasks(
                        taskid, // ä¸æ˜¯task.Taskid
                        task.WarehouseId,
                        task.TaskNum,
                        task.PalletCode,
                        int.Parse(task.PalletType),
                        task.CurrentAddress,
                        task.NextAddress,
                        "");
                    if (result.IsSuccess)
                    {
                        Dt_Task deltaskin = BaseDal.QueryData(x => x.TaskId == taskid).FirstOrDefault();
                        deltaskin.TaskStatus = (int)InTaskStatusEnum.PLC_InExecuting;
                        string Result = MesInTaskStatusEnum.Start.GetDescription();
                        BaseDal.UpdateData(deltaskin);
                        //调取上游系统反馈开始任务
                        InStoreDocCallback(task.TaskNum, Result, "操作成功", task.PalletCode, "");
                        return apiResponse.OK();
                    }
                    else
                    {
                        Dt_Task deltask= BaseDal.QueryData(x => x.TaskId == taskid).FirstOrDefault();
                        BaseDal.DeleteData(deltask);
                        return apiResponse.Error($"下发任务失败，下发WCS失败，原因：{result.Message}");
                    }
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                WriteLog.GetLog("接收MES入库任务下发").Write($"原因：{ex.Message}", $"入库任务添加");
                WriteLog.Write_Log("MES_接收入库任务下发", $"反馈信息", "失败", $"任务添加失败，托盘条码：{mES_In.containerNo},系统出错原因：{ex.Message}");
                return apiResponse.Error($"WMS任务添加错误，原因：{ex.Message}");
            }

@@ -105,7 +163,8 @@
        //出库任务
        public ApiResponse AddOutStoreDoc(MES_InTask mES_In)
        {
            WriteLog.GetLog("接收MES出库任务下发").Write($"参数：{mES_In.ToJson()}", $"任务接收参数");
            WriteLog.Write_Log("MES_接收MES出库任务下发", $"任务接收参数", "接收参数", $"参数：{mES_In.ToJson()}");

            ApiResponse apiResponse = new ApiResponse();
            try
            {
@@ -117,48 +176,103 @@
                if (string.IsNullOrWhiteSpace(mES_In.containerNo)) return apiResponse.Error("托盘码不能为空");
                if (string.IsNullOrWhiteSpace(mES_In.endPosition)) return apiResponse.Error("目标位置不能为空");


                Dt_StockInfo dt_Stock=_stockInfoService.Repository.QueryData(x=>x.PalletCode== mES_In.containerNo && x.StockStatus== (int)StockStatusEmun.已入库).FirstOrDefault();
                // å½“前任务mES_In.endPosition目标位置1113 - 1122
                var restrictedPositions = new List<string> { "1113", "1114", "1115", "1116", "1117", "1118", "1119", "1120", "1121", "1122", "1123" };
                bool isRestrictedPosition = restrictedPositions.Contains(mES_In.endPosition);
                if (isRestrictedPosition)
                {
                    bool hasExistingTask = BaseDal.QueryData(x => x.TargetAddress == mES_In.endPosition).Any();
                    if (hasExistingTask)
                    {
                        // ç›®æ ‡ä½ç½®åœ¨1113-1122范围内的处理逻辑
                        return apiResponse.Error($"当前有去目标位置{mES_In.endPosition}的任务，请重新操作");
                    }
                }
                Dt_StockInfo dt_Stock=_stockInfoService.Repository.QueryData(x=>x.PalletCode== mES_In.containerNo).FirstOrDefault();
                if (dt_Stock == null) return apiResponse.Error($"WMS未能查找道该托盘条码的库存货位信息，条码：{mES_In.containerNo}");

                Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stock.LocationCode && x.LocationStatus== (int)LocationStatusEnum.InStock).FirstOrDefault();
                if (dt_LocationInfo == null) return apiResponse.Error($"WMS未能查找道该托盘条码的库存货位信息，条码：{mES_In.containerNo}，未找到货位号：{dt_Stock.LocationCode}");
                if(dt_Stock.StockStatus == (int)StockStatusEmun.已入库)
                {
                    Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stock.LocationCode && x.LocationStatus == (int)LocationStatusEnum.InStock).FirstOrDefault();
                    if (dt_LocationInfo == null) return apiResponse.Error($"WMS未能查找道该托盘条码的库存货位信息，条码：{mES_In.containerNo}，未找到货位号：{dt_Stock.LocationCode}");

                Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(dt_LocationInfo.RoadwayNo);
                    Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(dt_LocationInfo.RoadwayNo);

                Dt_Task task = new Dt_Task();
                task.TaskNum = mES_In.transNo;
                task.PalletCode = dt_Stock.PalletCode;
                task.PalletType = dt_Stock.PalletType;
                task.Roadway = dt_LocationInfo.RoadwayNo;
                task.TaskType = (int)TaskTypeEnum.Outbound;
                task.TaskStatus = (int)OutTaskStatusEnum.OutNew;
                task.SourceAddress = dt_LocationInfo.LocationCode;
                task.TargetAddress = mES_In.endPosition;
                task.CurrentAddress = dt_LocationInfo.LocationCode;
                task.NextAddress = _Roadwayinfo.OutSCStationCode;
                task.WarehouseId = dt_LocationInfo.WarehouseId;
                task.OrderNo = mES_In.transDate.ToString();
                task.Grade = 1;
                task.Creater = "MES";
                task.CreateDate = DateTime.Now;
                    Dt_Task setask = BaseDal.QueryData(x => x.PalletCode == mES_In.containerNo).FirstOrDefault();
                    if (setask != null) return apiResponse.Error($"WMS已有当前任务，不可重复下发，托盘编号：{mES_In.containerNo}");

                dt_Stock.StockStatus = (int)StockStatusEmun.出库中;
                dt_LocationInfo.LocationStatus = (int)LocationStatusEnum.Lock;
                    Dt_Task task = new Dt_Task();
                    task.TaskNum = mES_In.transNo;
                    task.PalletCode = dt_Stock.PalletCode;
                    task.PalletType = dt_Stock.PalletType;
                    task.Roadway = dt_LocationInfo.RoadwayNo;
                    task.TaskType = (int)TaskTypeEnum.Outbound;
                    task.TaskStatus = (int)OutTaskStatusEnum.OutNew;
                    task.SourceAddress = dt_LocationInfo.LocationCode;
                    task.TargetAddress = mES_In.endPosition;
                    task.CurrentAddress = dt_LocationInfo.LocationCode;
                    task.NextAddress = _Roadwayinfo.OutSCStationCode;
                    task.WarehouseId = dt_LocationInfo.WarehouseId;
                    task.OrderNo = mES_In.transDate.ToString();
                    task.Grade = 1;
                    task.Creater = "MES";
                    task.CreateDate = DateTime.Now;

                _unitOfWorkManage.BeginTran();
                BaseDal.AddData(task);
                _stockInfoService.Repository.UpdateData(dt_Stock);
                _locationInfoService.Repository.UpdateData(dt_LocationInfo);
                _unitOfWorkManage.CommitTran();
                    dt_Stock.StockStatus = (int)StockStatusEmun.出库中;
                    dt_LocationInfo.LocationStatus = (int)LocationStatusEnum.Lock;

                WriteLog.GetLog("接收MES出库任务下发").Write($"添加成功，托盘条码：{dt_Stock.PalletCode}", $"出库任务添加");
                return apiResponse.OK();
                    _unitOfWorkManage.BeginTran();
                    BaseDal.AddData(task);
                    _stockInfoService.Repository.UpdateData(dt_Stock);
                    _locationInfoService.Repository.UpdateData(dt_LocationInfo);
                    _unitOfWorkManage.CommitTran();


                    WriteLog.Write_Log("MES_接收MES出库任务下发", $"出库任务添加", "成功", $"添加成功，托盘条码：{dt_Stock.PalletCode}");
                    return apiResponse.OK();
                }else if(dt_Stock.StockStatus == (int)StockStatusEmun.移库锁定)
                {
                    Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stock.LocationCode && x.LocationStatus == (int)LocationStatusEnum.Lock).FirstOrDefault();
                    if (dt_LocationInfo == null) return apiResponse.Error($"WMS未能查找道该托盘条码的库存货位信息，条码：{mES_In.containerNo}，未找到货位号：{dt_Stock.LocationCode}");

                    Dt_roadwayinfo _Roadwayinfo = _roadWayinfoService.QbtainPlatform(dt_LocationInfo.RoadwayNo);

                    Dt_Task task = new Dt_Task();
                    task.TaskNum = mES_In.transNo;
                    task.PalletCode = dt_Stock.PalletCode;
                    task.PalletType = dt_Stock.PalletType;
                    task.Roadway = dt_LocationInfo.RoadwayNo;
                    task.TaskType = (int)TaskTypeEnum.Outbound;
                    task.TaskStatus = (int)OutTaskStatusEnum.OutWait;
                    task.SourceAddress = dt_LocationInfo.LocationCode;
                    task.TargetAddress = mES_In.endPosition;
                    task.CurrentAddress = dt_LocationInfo.LocationCode;
                    task.NextAddress = _Roadwayinfo.OutSCStationCode;
                    task.WarehouseId = dt_LocationInfo.WarehouseId;
                    task.OrderNo = mES_In.transDate.ToString();
                    task.Grade = 1;
                    task.Creater = "MES";
                    task.CreateDate = DateTime.Now;

                    _unitOfWorkManage.BeginTran();
                    BaseDal.AddData(task);
                    _unitOfWorkManage.CommitTran();
                    WriteLog.Write_Log("MES_接收MES出库任务下发", $"出库任务添加", "成功", $"添加成功，托盘条码：{dt_Stock.PalletCode}");
                    return apiResponse.OK();

                }
                else
                {
                    WriteLog.Write_Log("MES_接收MES出库任务下发", $"出库任务添加", $"失败,托盘条码：{dt_Stock.PalletCode}", $"库存状态错误，请查看WMS系统库存,库存状态：{dt_Stock.StockStatus}");
                    return apiResponse.Error("库存状态错误，请查看WMS系统库存");
                }

                
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                WriteLog.GetLog("接收MES出库任务下发").Write($"原因：{ex.Message}", $"出库任务添加");
                WriteLog.Write_Log("MES_接收MES出库任务下发", $"出库任务添加", "失败", $"任务添加失败，托盘条码：{mES_In.containerNo},系统出错原因：{ex.Message}");
                return apiResponse.Error($"WMS任务添加错误，原因：{ex.Message}");
            }
        }
@@ -166,11 +280,13 @@
        //储位查询接口
        public ApiResponse GetLocationByContainer(MES_InTask mES_In)
        {
            WriteLog.Write_Log("MES_储位查询接口", $"储位查询接口", "参数", $"托盘条码：{mES_In.ToJson()}");

            ApiResponse apiResponse = new ApiResponse();
            try
            {
                if (string.IsNullOrWhiteSpace(mES_In.containerNo)) return apiResponse.Error("托盘码不能为空");
                Dt_StockInfo dt_Stock = _stockInfoService.Repository.QueryData(x => x.PalletCode == mES_In.containerNo).FirstOrDefault();
                Dt_StockInfo dt_Stock = _stockInfoService.Repository.QueryData(x => x.PalletCode == mES_In.containerNo &&x.StockStatus==(int)StockStatusEmun.已入库).FirstOrDefault();
                if (dt_Stock == null) return apiResponse.Error($"WMS未能查找道该托盘条码的库存货位信息，条码：{mES_In.containerNo}");
                Dt_LocationInfo dt_LocationInfo = _locationInfoService.Repository.QueryData(x => x.LocationCode == dt_Stock.LocationCode).FirstOrDefault();
                if (dt_LocationInfo == null) return apiResponse.Error($"WMS未能查找道该托盘条码的库存货位信息，条码：{mES_In.containerNo}，未找到货位号：{dt_Stock.LocationCode}");
@@ -195,7 +311,7 @@
            }
            catch (Exception ex)
            {
                WriteLog.GetLog("储位查询接口").Write($"原因：{ex.Message}", $"储位查询查询失败");
                WriteLog.Write_Log("MES_储位查询接口", $"储位查询接口", "查询失败", $"托盘条码：{mES_In.ToJson()}");
                return apiResponse.Error($"WMS储位查询错误，原因：{ex.Message}");
            }
            
@@ -204,6 +320,7 @@
        //任务查询接口
        public ApiResponse GetTaskInfo(MES_InTask mES_In)
        {
            WriteLog.Write_Log("MES_任务查询接口", $"任务查询接口", "参数", $"接收的参数：{mES_In.ToJson()}");
            ApiResponse apiResponse = new ApiResponse();
            try
            {
@@ -230,7 +347,7 @@
            }
            catch (Exception ex)
            {
                WriteLog.GetLog("任务查询接口").Write($"原因：{ex.Message}", $"任务查询失败");
                WriteLog.Write_Log("MES_任务查询接口", $"任务查询接口", "失败", $"条码：{mES_In.transNo}，原因：{ex.Message}");
                return apiResponse.Error($"WMS任务查询接口错误，原因：{ex.Message}");
            }
        }
@@ -243,23 +360,177 @@
            {
                if (string.IsNullOrWhiteSpace(mES_In.transNo)) return apiResponse.Error("单据编号不能为空");
                Dt_Task dt_Task = BaseDal.QueryData(x => x.TaskNum == mES_In.transNo).FirstOrDefault();
                if (dt_Task == null) return apiResponse.Error($"WMS未能查找道对应单据任务，条码：{mES_In.transNo}");
                if(dt_Task.TaskStatus== (int)InTaskStatusEnum.InNew || dt_Task.TaskStatus == (int)OutTaskStatusEnum.OutNew)
                if (dt_Task == null) {
                    WriteLog.Write_Log("MES_任务取消接口", $"任务取消接口", "成功", $"单据编号：{mES_In.transNo}，注意！！WMS未能查找道对应单据任务");
                    return apiResponse.OK();
                    //return apiResponse.Error($"WMS未能查找道对应单据任务，条码：{mES_In.transNo}");
                } 
                if(dt_Task.TaskStatus== (int)InTaskStatusEnum.InNew)
                {
                    BaseDal.DeleteData(dt_Task);
                    return apiResponse.OK();
                }else if(dt_Task.TaskStatus == (int)OutTaskStatusEnum.OutNew)
                {
                    Dt_StockInfo dt_StockInfo = _stockInfoService.Repository.QueryData(x => x.PalletCode == dt_Task.PalletCode).FirstOrDefault();
                    Dt_LocationInfo dt_LocationInfo= _locationInfoService.Repository.QueryData(x=>x.LocationCode== dt_StockInfo.LocationCode).FirstOrDefault();
                    dt_StockInfo.StockStatus = (int)StockStatusEmun.已入库;
                    dt_LocationInfo.LocationStatus = (int)LocationStatusEnum.InStock;

                    _stockInfoService.Repository.UpdateData(dt_StockInfo);
                    _locationInfoService.Repository.UpdateData(dt_LocationInfo);
                    BaseDal.DeleteData(dt_Task);
                    WriteLog.Write_Log("MES_任务取消接口", $"任务取消接口", "成功", $"单据编号：{mES_In.transNo}");
                    return apiResponse.OK();
                }
                else
                {
                    WriteLog.Write_Log("MES_任务取消接口", $"任务取消接口", "失败", $"单据编号：{mES_In.transNo},任务已经在执行中，不可取消");
                    return apiResponse.Error("任务已经在执行中，不可取消");
                }
                
            }
            catch (Exception ex)
            {
                WriteLog.GetLog("任务取消接口").Write($"原因：{ex.Message}", $"任务取消失败");
                WriteLog.Write_Log("MES_任务取消接口", $"任务取消接口", "失败", $"单据编号：{mES_In.transNo}，原因：{ex.Message}");
                return apiResponse.Error($"WMS任务取消接口错误，原因：{ex.Message}");
            }
        }

        //入库任务反馈接口
        public MES_parameter InStoreDocCallback(string TransNo, string Result, string ResultMsg, string ContainerNo, string LocationCode)
        {
            MES_parameter mES_Parame= new MES_parameter();
            try
            {
                MesInResultResponse mesInResult = new MesInResultResponse();
                mesInResult.TransNo = TransNo;
                mesInResult.Result = Result;
                mesInResult.ResultMsg = ResultMsg;
                mesInResult.ContainerNo = ContainerNo;
                mesInResult.LocationCode = LocationCode;
                mES_Parame = HttpHelper.Post<MES_parameter>(MES_InReporttask, mesInResult, "入库任务汇报");

                WriteLog.Write_Log("MES_入库任务反馈接口", $"入库任务反馈接口", "成功", $"订单编号：{TransNo}，执行结果：{Result}，执行结果描述：{ResultMsg}，托盘条码：{ContainerNo}，库位编号：{LocationCode}，上传的参数：{mesInResult.ToJson()}，回传的参数：{mES_Parame.ToJson()}");
                return mES_Parame;
            }
            catch (Exception ex)
            {
                mES_Parame.Result = "N";
                mES_Parame.ResultMsg= $"入库：WMS系统上传失败,原因：{ex.Message}";
                WriteLog.Write_Log("MES_入库任务反馈接口", $"入库任务反馈接口", "失败", $"订单编号：{TransNo}，执行结果：{Result}，执行结果描述：{ResultMsg}，托盘条码：{ContainerNo}，库位编号：{LocationCode}，上传失败，原因:{ex.Message}");
                return mES_Parame;
            }

        }
        //出库任务反馈接口
        public MES_parameter OutStoreDocCallback(string TransNo,string Result,string ResultMsg)
        {
            MES_parameter mES_Parame = new MES_parameter();
            try
            {
                MesOutResultResponse mesInResult = new MesOutResultResponse();
                mesInResult.TransNo = TransNo;
                mesInResult.Result = Result;
                mesInResult.ResultMsg = ResultMsg;
                mES_Parame = HttpHelper.Post<MES_parameter>(MES_OutReporttask, mesInResult, "出库任务汇报");
                WriteLog.Write_Log("MES_出库任务反馈接口", $"出库任务反馈接口", "成功", $"订单编号：{TransNo}，执行结果：{Result}，执行结果描述：{ResultMsg}，上传的参数：{mesInResult.ToJson()}，回传的参数：{mES_Parame.ToJson()}");
                return mES_Parame;
            }
            catch (Exception ex)
            {
                mES_Parame.Result = "N";
                mES_Parame.ResultMsg = $"出库：WMS系统上传失败,原因：{ex.Message}";
                WriteLog.Write_Log("MES_出库任务反馈接口", $"出库任务反馈接口", "失败", $"订单编号：{TransNo}，执行结果：{Result}，执行结果描述：{ResultMsg}，上传失败，原因:{ex.Message}");
                return mES_Parame;
            }
        }

        /// <summary>
        /// å‚¨ä½å¼‚动申请
        /// </summary>
        /// <param name="ContainerNo">托盘条码</param>
        /// <param name="OriginalLocationCode">原储位</param>
        /// <param name="NewLocationCode">新储位</param>
        /// <returns></returns>
        public MES_parameter ApplicationChangeStorageLocation(string ContainerNo,string OriginalLocationCode,string NewLocationCode)
        {
            MES_parameter mES_Parame = new MES_parameter();
            try
            {
                MES_Storagelocation Storagelocation = new MES_Storagelocation();
                Storagelocation.ContainerNo = ContainerNo;
                Storagelocation.OriginalLocationCode = OriginalLocationCode;
                Storagelocation.NewLocationCode = NewLocationCode;
                mES_Parame = HttpHelper.Post<MES_parameter>(MES_InventoryUpdateApply, Storagelocation, "储位异动申请");
                WriteLog.Write_Log("MES_储位异动申请", $"储位异动申请", "成功", $"托盘条码：{ContainerNo}，原库位：{OriginalLocationCode}，新库位：{NewLocationCode}，上传的参数：{Storagelocation.ToJson()}，回传的参数：{mES_Parame.ToJson()}");
                return mES_Parame;
            }
            catch (Exception ex)
            {
                mES_Parame.Result = "N";
                mES_Parame.ResultMsg = $"储位异动申请：WMS系统调取失败,原因：{ex.Message}";
                WriteLog.Write_Log("MES_储位异动申请", $"储位异动申请", "失败", $"托盘条码：{ContainerNo}，原库位：{OriginalLocationCode}，新库位：{NewLocationCode}，上传失败，原因:{ex.Message}");
                return mES_Parame;
            }
        }

        /// <summary>
        /// å‚¨ä½å¼‚动
        /// </summary>
        /// <param name="ContainerNo">托盘条码</param>
        /// <param name="OriginalLocationCode">原储位</param>
        /// <param name="NewLocationCode">新储位</param>
        /// <returns></returns>
        public MES_parameter AbnormalStorageLocation(string ContainerNo, string OriginalLocationCode, string NewLocationCode)
        {
            MES_parameter mES_Parame = new MES_parameter();
            try
            {
                MES_Storagelocation Storagelocation = new MES_Storagelocation();
                Storagelocation.ContainerNo = ContainerNo;
                Storagelocation.OriginalLocationCode = OriginalLocationCode;
                Storagelocation.NewLocationCode = NewLocationCode;
                mES_Parame = HttpHelper.Post<MES_parameter>(MES_InventoryUpdateCallback, Storagelocation, "储位异动");
                WriteLog.Write_Log("MES_储位异动上传", $"储位异动上传", "成功", $"托盘条码：{ContainerNo}，原库位：{OriginalLocationCode}，新库位：{NewLocationCode}，上传的参数：{Storagelocation.ToJson()}，回传的参数：{mES_Parame.ToJson()}");
                return mES_Parame;
            }
            catch (Exception ex)
            {
                mES_Parame.Result = "N";
                mES_Parame.ResultMsg = $"储位异动：WMS系统调取失败,原因：{ex.Message}";
                WriteLog.Write_Log("MES_储位异动上传", $"储位异动上传", "失败", $"托盘条码：{ContainerNo}，原库位：{OriginalLocationCode}，新库位：{NewLocationCode}，上传失败，原因:{ex.Message}");
                return mES_Parame;
            }
        }
        /// <summary>
        /// ä»»åŠ¡å¼‚常
        /// </summary>
        /// <param name="TransNo">单据编号</param>
        /// <param name="EquipmentType">设备类型</param>
        /// <param name="EquipmentNumber">设备编码</param>
        /// <param name="ErrorInfo">异常报文</param>MES_TaskErrorInfoCallback
        /// <returns></returns>
        public MES_parameter ToMES_TaskException(string TransNo,string EquipmentType,string EquipmentNumber,string ErrorInfo)
        {
            MES_parameter mES_Parame = new MES_parameter();
            try
            {
                MES_TaskException Storagelocation = new MES_TaskException();
                Storagelocation.TransNo = TransNo;
                Storagelocation.EquipmentType = EquipmentType;
                Storagelocation.EquipmentNumber = EquipmentNumber;
                Storagelocation.ErrorInfo = ErrorInfo;
                mES_Parame = HttpHelper.Post<MES_parameter>(MES_TaskErrorInfoCallback, Storagelocation, "任务异常");
                WriteLog.Write_Log("MES_任务异常", $"任务异常", "成功", $"单据编号：{TransNo}，设备类型：{EquipmentType}，设备编码：{EquipmentNumber}，异常报文{ErrorInfo}，，上传的参数：{Storagelocation.ToJson()}，回传的参数：{mES_Parame.ToJson()}");
                return mES_Parame;
            }
            catch (Exception ex)
            {
                mES_Parame.Result = "N";
                mES_Parame.ResultMsg = $"任务异常：WMS系统调取失败,原因：{ex.Message}";
                WriteLog.Write_Log("MES_任务异常", $"任务异常", "失败", $"单据编号：{TransNo}，设备类型：{EquipmentType}，设备编码：{EquipmentNumber}，异常报文{ErrorInfo}，上传失败，原因:{ex.Message}");
                return mES_Parame;
            }
        }
    }
}