WMSPrjInstance/HH-0115_HangYang.git

			@@ -12,12 +12,15 @@
			using Swashbuckle.Swagger;
			using System;
			using System.Collections.Generic;
			using System.Diagnostics;
			using System.Linq;
			using System.Reflection;
			using System.Security.Cryptography;
			using System.Text;
			using System.Threading.Tasks;
			using static HH.WCS.HangYang.api.OtherModel.Putaway_Order_In;
			using static HH.WCS.HangYang.LISTA.process.HttpModel;
			using static HH.WCS.HangYang.util.Settings;
			using static HH.WCS.HangYang.wms.WMSHelper;
			using static System.Runtime.CompilerServices.RuntimeHelpers;

			@@ -45,7 +48,7 @@
			{

			LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
			LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList(),mst.S_NOTE);
			LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList(), mst.S_NOTE);
			}

			}
			@@ -84,7 +87,7 @@
			internal static bool Intercept(WCSTask mst)
			{
			var result = false;


			return result;
			}

			@@ -371,9 +374,9 @@
			}

			/// <summary>
			/// 入库单新增
			/// 杭氧物料主数据新增接口
			/// </summary>
			/// <param name="model">入库单</param>
			/// <param name="model">物料主数据</param>
			/// <returns></returns>
			public static Result GetMaterialData(List<MES_Material> model)
			{
			@@ -382,44 +385,25 @@
			{
			if (model == null)
			{
			result.errMsg = "入库单不可为空值！";
			result.errMsg = "物料主数据不可为空值！";
			return result;
			}
			var materialList = new List<TN_Material>();

			//foreach (var item in model.InOrderDetail)
			//{
			// var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
			// if (itemType == null)
			// {
			// result.errMsg = $"未查询到物料{item.S_ITEM_CODE}的物料属性！";
			// return result;
			// }
			// item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
			//}

			//var groupedInOrders = model.InOrderDetail
			// .GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
			// .Select((group, index) => new InOrder
			// {
			// S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
			// S_BS_NO = model.S_BS_NO,
			// S_OP_TYPE = model.S_OP_TYPE,
			// S_BS_TYPE = model.S_BS_TYPE,
			// S_NOTE = model.S_NOTE,
			// InOrderDetail = group.Select(detail =>
			// {
			// // 修改 group 中的 S_IO_NO 字段为 S_NO 的值
			// detail.S_IO_NO = $"{model.S_BS_NO}_{index + 1}";
			// detail.S_BS_NO = model.S_BS_NO;
			// return detail;
			// }).ToList() // 分组后的明细
			// })
			// .ToList();
			//var res = WMSHelper.CreateOrderIn(groupedInOrders);
			//if (res)
			//{
			// result.success = true;
			//}
			foreach (var item in model)
			{
			materialList.Add(new TN_Material
			{
			S_ITEM_CODE = item.S_ITEM_CODE,
			S_ITEM_NAME = item.S_ITEM_NAME,
			S_ITEM_TYPE = item.S_AREA_CODE,
			S_ITEM_SPEC = item.S_MATERIAL_SPEC,
			S_MATERIAL = item.S_MATERIAL,
			S_UOM = item.S_UOM,
			C_CLEAN = item.C_CLEAN,
			});
			}
			WMSHelper.CreateMaterialData(materialList);
			return result;
			}
			catch (Exception ex)
			@@ -430,7 +414,7 @@
			var frame = st.GetFrame(0); // 获取第一个堆栈帧
			if (frame != null)
			{
			LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
			LogHelper.Error($"GetMaterialData物料主数据新增出现错误！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			@@ -441,7 +425,7 @@
			}

			/// <summary>
			/// 入库单新增
			/// 入库单新增以及修改
			/// </summary>
			/// <param name="model">入库单</param>
			/// <returns></returns>
			@@ -515,13 +499,13 @@
			}

			/// <summary>
			/// 出库单新增
			/// 出库单新增以及修改
			/// </summary>
			/// <param name="model">入库单</param>
			/// <param name="model">出库单</param>
			/// <returns></returns>
			public static Result GetOutboundOrder(OutOrder model)
			{
			Result result = new Result() { success = false, };
			Result result = new Result() { success = false };
			try
			{
			if (model == null \|\| !model.OutOrderDetail.Any())
			@@ -530,6 +514,7 @@
			return result;
			}

			// 第一步：设置物料属性信息
			foreach (var item in model.OutOrderDetail)
			{
			var itemType = WMSHelper.GetItemType(item.S_ITEM_CODE);
			@@ -539,31 +524,79 @@
			return result;
			}
			item.S_EXT_ATTR1 = itemType.S_ITEM_TYPE;
			item.S_ITEM_NAME = itemType.S_ITEM_NAME;
			item.S_ITEM_NAME = itemType.S_ITEM_NAME;
			item.C_CLEAN = itemType.C_CLEAN;
			}

			var groupedInOrders = model.OutOrderDetail
			.GroupBy(detail => detail.S_EXT_ATTR1) // 按物料属性分组
			.Select((group, index) => new OutOrder
			{
			S_NO = $"{model.S_BS_NO}_{index + 1}", // 拼接来源单号
			S_BS_NO = model.S_BS_NO,
			S_OP_TYPE = model.S_OP_TYPE,
			S_NOTE = model.S_NOTE,
			S_BS_TYPE = "ERP",
			S_FACTORY = "HY001",
			S_WH_CODE = "CK001",
			S_AREA_CODE = group.Key.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
			OutOrderDetail = group.Select(detail =>
			{
			// 修改 group 中的 S_IO_NO 字段为 S_NO 的值
			detail.S_OO_NO = $"{model.S_BS_NO}_{index + 1}";
			detail.S_BS_NO = model.S_BS_NO;
			return detail;
			}).ToList() // 分组后的明细
			})
			.ToList();
			var res = WMSHelper.CreateOrderOut(groupedInOrders);
			// 第二步：先按物料属性分组，再按是否清洗分组
			var groupedOrders = model.OutOrderDetail
			.GroupBy(detail => new
			{
			MaterialType = detail.S_EXT_ATTR1,
			IsClean = detail.C_CLEAN
			}) // 按物料属性和是否清洗双重分组
			.Select((group, index) => new OutOrder
			{
			S_NO = $"{model.S_BS_NO}_{index + 1}",
			S_BS_NO = model.S_BS_NO,
			S_OP_TYPE = model.S_OP_TYPE,
			S_OUT_TO = model.S_OUT_TO,
			S_NOTE = model.S_NOTE,
			S_BS_TYPE = "ERP",
			S_FACTORY = "HY001",
			S_WH_CODE = "CK001",
			S_AREA_CODE = group.Key.MaterialType.Equals("料箱库") ? "LXLKQ" : "TPLKQ",
			C_CLEAN = group.Key.IsClean, // 添加是否清洗标记
			OutOrderDetail = group.Select(detail =>
			{
			detail.S_OO_NO = $"{model.S_BS_NO}_{index + 1}";
			detail.S_BS_NO = model.S_BS_NO;
			return detail;
			}).ToList()
			})
			.ToList();

			// 第三步：调用创建出库单方法
			var res = WMSHelper.CreateOrderOut(groupedOrders);
			if (res)
			{
			result.success = true;
			}
			return result;
			}
			catch (Exception ex)
			{
			result.success = false;
			result.errMsg = ex.Message;
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0);
			if (frame != null)
			{
			LogHelper.Error($"GetOutboundOrder出库单新增出现错误！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}
			return result;
			}
			}

			/// <summary>
			/// 入库单取消
			/// </summary>
			/// <param name="model">入库单</param>
			/// <returns></returns>
			public static Result CancelInboundOrder(InOrder model)
			{
			Result result = new Result() { success = false, };
			try
			{
			if (model == null \|\| !model.InOrderDetail.Any())
			{
			result.errMsg = "入库单取消不可为空值！";
			return result;
			}
			var res = WMSHelper.CancelOrderIn(model);
			if (res)
			{
			result.success = true;
			@@ -578,328 +611,1323 @@
			var frame = st.GetFrame(0); // 获取第一个堆栈帧
			if (frame != null)
			{
			LogHelper.Error($"GetInboundOrder入库单新增出现错误！！", ex);
			LogHelper.Error($"CancelInboundOrder入库单取消出现错误！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}
			return result;
			}

			}

			/// <summary>
			/// 出库单取消
			/// </summary>
			/// <param name="model">出库单</param>
			/// <returns></returns>
			public static Result CancelOutboundOrder(OutOrder model)
			{
			Result result = new Result() { success = false };
			try
			{
			if (model == null \|\| !model.OutOrderDetail.Any())
			{
			result.errMsg = "出库单不可为空值！";
			return result;
			}
			var res = WMSHelper.CancelOrderOut(model);
			if (res)
			{
			result.success = true;
			}
			return result;
			}
			catch (Exception ex)
			{
			result.success = false;
			result.errMsg = ex.Message;
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0);
			if (frame != null)
			{
			LogHelper.Error($"CancelOutboundOrder出库单取消出现错误！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}
			return result;
			}
			}


			///// <summary>
			///// 获取作业创建入库任务
			///// </summary>
			///// <param name="mst"></param>
			///// <returns></returns>
			//internal static bool CreateInTask(WMSTask mst)
			//{
			// try
			// {
			// var result = false;
			// var taskState = mst.S_B_STATE.Trim();
			// if (taskState == "等待")
			// {
			// if (!string.IsNullOrEmpty(mst.S_START_LOC))
			// {
			// //杭氧所有库区
			// var reservoirs = Settings.ReservoirAreas.ToList();
			// if (!reservoirs.Any() \|\| reservoirs == null)
			// {
			// LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
			// return false;
			// }
			// if (mst.S_TYPE == "托盘转运")
			// {
			// var lxAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault().areaCode);
			// if (lxAnyLoc.Any())
			// {
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxAnyLoc.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// }
			// else
			// {
			// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			// if (rkAnyLoc.Any())
			// {
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// //标记为合托
			// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
			// }
			// else
			// {
			// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			// return false;
			// }
			// }
			// }
			// if (mst.S_TYPE == "托盘入库")
			// {
			// //1.查询下下库里面是否有要合托的托盘
			// var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
			// if (locMerge != null)
			// {
			// //（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
			// var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
			// if (anyLoc.Any())
			// {

			// foreach (var item in anyLoc)
			// {
			// //生成一条出库的任务
			// var relevancys = Settings.Relevancys.Where(s => s.InLoc == item.S_CODE).FirstOrDefault();
			// if (relevancys == null)
			// {
			// LogHelper.Info($"Settings未查询到合托入库位{item.S_CODE}对应的出库位！", "杭氧");
			// continue;
			// }
			// //生成到合托区的任务
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, item.S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
			// return false;
			// }
			// res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
			// return false;
			// }
			// //（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
			// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
			// WMSHelper.UpdateStatus(mst, 1);
			// break;
			// }


			// }
			// else
			// {
			// //（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
			// //生成到入库缓存区的任务
			// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			// if (rkAnyLoc.Any())
			// {
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// //标记为合托
			// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
			// }
			// else
			// {
			// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			// return false;
			// }
			// }

			// }
			// else
			// {
			// //2.如果没有要合托的托盘
			// var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			// if (area == null)
			// {
			// LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			// return false;
			// }
			// //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			// if (anyLoc.Any())
			// {
			// //生成到接驳位的任务
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// }
			// else
			// {
			// //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
			// //生成到入库缓存区的任务
			// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			// if (rkAnyLoc.Any())
			// {
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// //标记为不合托
			// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			// }
			// else
			// {
			// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			// return false;
			// }

			// }

			// }
			// }
			// if (mst.S_TYPE == "合托回库")
			// {
			// var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
			// if (trayLst.Any())
			// {
			// //满托回库
			// var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			// if (area == null)
			// {
			// LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			// return false;
			// }
			// //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			// if (anyLoc.Any())
			// {
			// //生成到接驳位的任务
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// }
			// else
			// {
			// //(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
			// //生成到入库缓存区的任务
			// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			// if (rkAnyLoc.Any())
			// {
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// //标记为不合托
			// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			// }
			// else
			// {
			// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			// return false;
			// }

			// }
			// }
			// else
			// {
			// //空托回库
			// var area = reservoirs.Where(s => s.areaName == "人机接驳位-空托位").FirstOrDefault();
			// if (area == null)
			// {
			// LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			// return false;
			// }
			// //(2.1)先查询人机接驳位-空托位是否为空，如果为空直接生成到入库的任务
			// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			// if (anyLoc.Any())
			// {
			// //生成到接驳位的任务
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "人机接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// }
			// else
			// {
			// //生成到入库缓存区的任务
			// var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			// if (rkAnyLoc.Any())
			// {
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			// return false;
			// }
			// //标记为不合托
			// ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			// WMSHelper.UpdateStatus(mst, 1);

			// }
			// else
			// {
			// LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			// return false;
			// }
			// }
			// }
			// }
			// if (mst.S_TYPE == "料箱出库")
			// {

			// //满托回库
			// var area = reservoirs.Where(s => s.areaName == "料箱码盘区").FirstOrDefault();
			// if (area == null)
			// {
			// LogHelper.Info("Settings出现错误未查询到料箱码盘区！", "杭氧");
			// return false;
			// }
			// //(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			// var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			// if (anyLoc.Any())
			// {
			// //生成到接驳位的任务
			// var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "料箱出库", mst.S_CNTR_CODE, mst.S_CODE);
			// if (!res)
			// {
			// LogHelper.Info("料箱出库任务创建失败！", "杭氧");
			// return false;
			// }
			// WMSHelper.UpdateStatus(mst, 1);
			// }
			// else
			// {
			// LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
			// }
			// }
			// }
			// }
			// else { result = true; }
			// return result;
			// }
			// catch (Exception ex)
			// {
			// var st = new System.Diagnostics.StackTrace(ex, true);
			// var frame = st.GetFrame(0); // 获取第一个堆栈帧
			// if (frame != null)
			// {
			// LogHelper.Error($"CreateInTask获取作业创建入库任务出现错误！！", ex);
			// LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			// LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			// LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			// }
			// return false;
			// }

			//}

			#region 等待作业

			/// <summary>
			/// 获取作业创建入库任务
			/// </summary>
			/// <param name="mst"></param>
			/// <returns></returns>
			internal static bool CreateInTask(WMSTask mst)
			internal static async Task<bool> CreateInTask(WMSTask mst)
			{
			try
			{
			var result = false;
			var taskState = mst.S_B_STATE.Trim();
			if (taskState == "等待")
			if (mst.S_B_STATE.Trim() != "等待") return true;
			//if (string.IsNullOrEmpty(mst.S_START_LOC)) return false;

			var reservoirs = Settings.ReservoirAreas?.ToList();
			if (reservoirs == null \|\| !reservoirs.Any())
			{
			if (!string.IsNullOrEmpty(mst.S_START_LOC))
			LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
			return false;
			}

			switch (mst.S_TYPE)
			{
			case "托盘转运":
			return HandlePalletTransport(mst, reservoirs);
			case "托盘入库":
			return HandlePalletStorage(mst, reservoirs);
			case "合托回库":
			return HandleMergeReturn(mst, reservoirs);
			case "分拣回库":
			return await SortingReturn(mst, reservoirs);
			case "解绑回库":
			return await UnbindReturn(mst, reservoirs);
			case "空托回库":
			return await EmptyPalletReturn(mst, reservoirs);
			case "空托出库":
			return EmptyPalletOutbound(mst);
			case "料箱出库":
			return HandleBoxOutbound(mst, reservoirs);
			case "发货暂存":
			return PreShipmentStage(mst);
			case "发货清洗":
			return PreShipmentStage(mst);
			case "发货装配":
			return PreShipmentStage(mst);
			default:
			return true;
			}
			}
			catch (Exception ex)
			{
			LogErrorDetails(ex);
			return false;
			}
			}

			/// <summary>
			/// 托盘转运
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static bool HandlePalletTransport(WMSTask mst, List<ReservoirArea> reservoirs)
			{
			var res = true;
			var lxArea = reservoirs.FirstOrDefault(s => s.areaName == "料箱入库缓存位");
			if (lxArea != null)
			{
			var lxLocations = LocationHelper.GetLocAreaList(lxArea.areaCode);
			if (lxLocations.Any())
			{
			res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxLocations.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			//杭氧所有库区
			var reservoirs = Settings.ReservoirAreas.ToList();
			if (!reservoirs.Any() \|\| reservoirs == null)
			LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			}

			var rkArea = reservoirs.FirstOrDefault(s => s.areaName == "入库缓存区");
			if (rkArea == null) return false;

			var rkLocations = LocationHelper.GetLocAreaList(rkArea.areaCode);
			if (!rkLocations.Any())
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}

			res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkLocations.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
			return true;
			}

			/// <summary>
			/// 托盘入库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static bool HandlePalletStorage(WMSTask mst, List<ReservoirArea> reservoirs)
			{
			var result = true;
			var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
			if (locMerge != null)
			{
			//（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
			var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
			if (anyLoc.Any())
			{
			foreach (var item in anyLoc)
			{
			//生成一条出库的任务
			var relevancys = Settings.Relevancys.Where(s => s.InLoc == item.S_CODE).FirstOrDefault();
			if (relevancys == null)
			{
			LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
			LogHelper.Info($"Settings未查询到合托入库位{item.S_CODE}对应的出库位！", "杭氧");
			continue;
			}
			//生成到合托区的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, item.S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
			return false;
			}
			if (mst.S_TYPE == "托盘转运")
			res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			var lxAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "料箱入库缓存位").FirstOrDefault().areaCode);
			if (lxAnyLoc.Any())
			{

			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, lxAnyLoc.FirstOrDefault().S_CODE, "料箱缓存位入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("料箱缓存位入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "料箱码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "料箱合托");
			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}
			}
			LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
			return false;
			}
			if (mst.S_TYPE == "托盘入库")
			{
			//1.查询下下库里面是否有要合托的托盘
			var locMerge = WMSHelper.GetLocMerge(mst.S_CNTR_CODE);
			if (locMerge != null)
			{
			//（1.1）如果有要合托的托盘就去判断一下合托工位是否为空
			var anyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "合托区").FirstOrDefault().areaCode);
			if (anyLoc.Any())
			{

			//生成一条出库的任务
			var relevancys = Settings.Relevancys.Where(s => s.InLoc == anyLoc.FirstOrDefault().S_CODE).FirstOrDefault();
			if (relevancys == null)
			{
			LogHelper.Info("Settings出现错误未查询到合托入库位对应的出库位！", "杭氧");
			return false;
			}
			//生成到合托区的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘合托入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘合托入库任务创建失败！", "杭氧");
			return false;
			}
			res = TaskProcess.HYCreateTransport(locMerge.S_LOC_CODE, relevancys.OutLoc, "码盘合托出库", locMerge.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘合托出库任务创建失败！", "杭氧");
			return false;
			}
			//（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");

			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			//（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}
			}

			}
			else
			{
			//2.如果没有要合托的托盘
			var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			//(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为不合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}

			}

			}
			}
			if (mst.S_TYPE == "合托回库")
			{
			var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
			if (trayLst.Any())
			{
			//满托回库
			var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			//(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为不合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}

			}
			}
			else
			{
			//空托回库
			var area = reservoirs.Where(s => s.areaName == "人机接驳位-空托位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询人机接驳位-空托位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "人机接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			//标记为不合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			WMSHelper.UpdateStatus(mst, 1);

			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}
			}
			}
			}
			if (mst.S_TYPE == "料箱出库")
			{

			//满托回库
			var area = reservoirs.Where(s => s.areaName == "料箱码盘区").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到料箱码盘区！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "料箱出库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("料箱出库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
			}
			}
			//（1.2）如果合托工位为空就直接合托到合托工位里面，同时生成一个出库任务把被合托的托盘出出来（标记为要合托）
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
			WMSHelper.UpdateStatus(mst, 1);
			break;
			}
			}
			else { result = true; }
			else
			{
			//（1.3）如果合托工位不为空就去入库缓存区（标记为要合托）
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "合托");
			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}
			}

			}
			else
			{
			//2.如果没有要合托的托盘
			var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			//(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为不合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}

			}

			}
			return result;
			}

			/// <summary>
			/// 合托回库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static bool HandleMergeReturn(WMSTask mst, List<ReservoirArea> reservoirs)
			{
			var trayLst = ContainerHelper.GetCntrItemRel(mst.S_CNTR_CODE);
			if (trayLst.Any())
			{
			//满托回库
			var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			//(2.2)如果入库接驳位不为空，则生成到入库缓存区的任务（标记为不合托）
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			//标记为不合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}

			}
			}
			else
			{
			//空托回库
			var area = reservoirs.Where(s => s.areaName == "人机接驳位-空托位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询人机接驳位-空托位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "人机接驳入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			//生成到入库缓存区的任务
			var rkAnyLoc = LocationHelper.GetLocAreaList(reservoirs.Where(s => s.areaName == "入库缓存区").FirstOrDefault().areaCode);
			if (rkAnyLoc.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, rkAnyLoc.FirstOrDefault().S_CODE, "码盘缓存入库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘缓存入库任务创建失败！", "杭氧");
			return false;
			}
			//标记为不合托
			ContainerHelper.UpdateCntrAbouts(mst.S_CNTR_CODE, "不合托");
			WMSHelper.UpdateStatus(mst, 1);

			}
			else
			{
			LogHelper.Info("入库缓存区没有空货位！", "杭氧");
			return false;
			}
			}
			}
			return true;
			}

			/// <summary>
			/// 分拣回库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static async Task<bool> SortingReturn(WMSTask mst, List<ReservoirArea> reservoirs)
			{
			var trayLst = ContainerHelper.GetCntr(mst.S_CNTR_CODE);
			if (trayLst != null && trayLst.S_TYPE.Equals("托盘"))
			{
			//托盘分拣回库
			var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "托盘分拣回库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("托盘分拣回库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			}
			else
			{
			//料箱回库
			var inbound = new Inbound()
			{
			areaCode = "LXLKQ"
			};
			var wh = new Warehouse(inbound);
			var stored = await wh.StoreItemAsync();
			if (stored == null)
			{
			LogHelper.Info($"未查询到{inbound.areaCode}可用货位！", "杭氧");
			return false;
			}

			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, stored.loationCode, "料箱分拣回库" , mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("料箱分拣回库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			return true;
			}

			/// <summary>
			/// 解绑回库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static async Task<bool> UnbindReturn(WMSTask mst, List<ReservoirArea> reservoirs)
			{
			var trayLst = ContainerHelper.GetCntr(mst.S_CNTR_CODE);
			if (trayLst != null && trayLst.S_TYPE.Equals("托盘"))
			{
			//托盘分拣回库
			var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "托盘解绑回库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("托盘解绑回库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			}
			else
			{
			//料箱回库
			var inbound = new Inbound()
			{
			areaCode = "LXLKQ"
			};
			var wh = new Warehouse(inbound);
			var stored = await wh.StoreItemAsync();
			if (stored == null)
			{
			LogHelper.Info($"未查询到{inbound.areaCode}可用货位！", "杭氧");
			return false;
			}

			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, stored.loationCode, "料箱解绑回库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("料箱解绑回库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			return true;
			}

			/// <summary>
			/// 空托回库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static async Task<bool> EmptyPalletReturn(WMSTask mst, List<ReservoirArea> reservoirs)
			{
			var trayLst = ContainerHelper.GetCntr(mst.S_CNTR_CODE);
			if (trayLst != null && trayLst.S_TYPE.Equals("托盘"))
			{
			//托盘空托回库
			var area = reservoirs.Where(s => s.areaName == "入库接驳位").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到入库接驳位！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "托盘空托回库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("托盘空托回库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			}
			else
			{
			//料箱空托回库
			var inbound = new Inbound()
			{
			areaCode = "LXLKQ"
			};
			var wh = new Warehouse(inbound);
			var stored = await wh.StoreItemAsync();
			if (stored == null)
			{
			LogHelper.Info($"未查询到{inbound.areaCode}可用货位！", "杭氧");
			return false;
			}

			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, stored.loationCode, "料箱空托回库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("料箱空托回库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			return true;
			}

			/// <summary>
			/// 空托出库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static bool EmptyPalletOutbound(WMSTask mst)
			{
			var result = true;
			var scheduler = new EmptyPalletOutboundScheduler(mst.S_START_AREA);

			var outbound = new Outbound
			{
			endArea = mst.S_END_AREA,
			endBit = mst.S_END_LOC,
			requiredCount = 1,
			taskType = "空托出库"
			};
			// 请求出库
			var tasks = scheduler.GenerateEmptyPalletTasks(outbound);

			foreach (var item in tasks)
			{
			// 创建出库任务
			var res = TaskProcess.HYCreateTransport(item.S_START_LOC, item.S_END_LOC, item.S_TYPE, item.S_CNTR_CODE, mst.S_CODE);
			mst.S_START_LOC = item.S_START_LOC;
			mst.S_CNTR_CODE = item.S_CNTR_CODE;
			//修改空托出库起点和托盘码
			UpdateTask(mst,1);
			if (!res)
			{
			LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
			return false;
			}
			}
			return result;
			}

			/// <summary>
			/// 料箱出库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static bool HandleBoxOutbound(WMSTask mst, List<ReservoirArea> reservoirs)
			{
			var result = true;
			var area = reservoirs.Where(s => s.areaName == "料箱码盘区").FirstOrDefault();
			if (area == null)
			{
			LogHelper.Info("Settings出现错误未查询到料箱码盘区！", "杭氧");
			return false;
			}
			//(2.1)先查询入库接驳位是否为空，如果为空直接生成到入库的任务
			var anyLoc = LocationHelper.GetLocAreaList(area.areaCode);
			if (anyLoc.Any())
			{
			//生成到接驳位的任务
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, anyLoc.FirstOrDefault().S_CODE, "料箱出库", mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info("料箱出库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			else
			{
			LogHelper.Info("料箱码盘区未有可用货位！", "杭氧");
			}
			return result;
			}

			/// <summary>
			/// 发货暂存 \|\| 发货清洗 \|\| 发货装配 (暂时使用一个方法处理)
			/// </summary>
			/// <param name="mst"></param>
			/// <returns></returns>
			private static bool PreShipmentStage(WMSTask mst)
			{
			var locList = LocationHelper.GetLocAreaList(mst.S_END_AREA);
			if (locList.Any())
			{
			var res = TaskProcess.HYCreateTransport(mst.S_START_LOC, locList.FirstOrDefault().S_CODE, mst.S_TYPE, mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info($"{mst.S_TYPE}入库任务创建失败！", "杭氧");
			return false;
			}
			WMSHelper.UpdateStatus(mst, 1);
			}
			return true;
			}

			/// <summary>
			/// 发货清洗
			/// </summary>
			/// <param name="mst"></param>
			/// <returns></returns>
			private static bool OutboundCleaning(WMSTask mst)
			{
			return true;
			}

			/// <summary>
			/// 发货装配
			/// </summary>
			/// <param name="mst"></param>
			/// <returns></returns>
			private static bool OutboundAssembly(WMSTask mst)
			{
			return true;
			}
			#endregion

			#region 执行作业

			/// <summary>
			/// 获取执行的作业创建任务
			/// </summary>
			/// <param name="mst"></param>
			/// <returns></returns>
			internal static bool exeCreateInTask(WMSTask mst)
			{
			try
			{
			if (mst.S_B_STATE.Trim() != "执行") return true;
			if (string.IsNullOrEmpty(mst.S_START_LOC)) return false;

			var reservoirs = Settings.ReservoirAreas?.ToList();
			if (reservoirs == null \|\| !reservoirs.Any())
			{
			LogHelper.Info("Settings出现错误未查询到杭氧的库区！", "杭氧");
			return false;
			}

			switch (mst.S_TYPE)
			{
			case "配盘出库":
			return PalletOutbound(mst);
			default:
			return true;
			}
			}
			catch (Exception ex)
			{
			LogErrorDetails(ex);
			return false;
			}
			}

			/// <summary>
			/// 配盘出库
			/// </summary>
			/// <param name="mst"></param>
			/// <param name="reservoirs"></param>
			/// <returns></returns>
			private static bool PalletOutbound(WMSTask mst)
			{
			var relevancys = Settings.OutRelevancys.Where(s => s.conLoc == mst.S_END_LOC).FirstOrDefault();
			if (relevancys == null)
			{
			LogHelper.Info($"Settings未查询到集货位{mst.S_END_LOC}对应的分拣位！", "杭氧");
			return false;
			}
			var locList = LocationHelper.GetLocListEmptyFree(relevancys.sorLoc.ToList());
			if (locList.Any())
			{
			var startLoc = WMSHelper.GetCntrLoc(mst.S_CNTR_CODE);
			if (startLoc != null)
			{
			// 创建出库任务
			var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, locList.FirstOrDefault().S_CODE, mst.S_TYPE, mst.S_CNTR_CODE, mst.S_CODE);
			if (!res)
			{
			LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
			return false;
			}
			}

			}

			return true;
			}

			#endregion

			#region WCS调用接口

			/// <summary>
			/// WCS调用设备信号反馈
			/// </summary>
			/// <param name="model">请求参数</param>
			/// <returns></returns>
			public static async Task<WcsResult> notifyDeviceSignal(List<WcsModel> model)
			{
			WcsResult result = new WcsResult() { code = 1, };
			try
			{
			foreach (var item in model)
			{
			if (string.IsNullOrEmpty(item.cntrNo))
			{
			result.msg = "托盘号为空！";
			return result;
			}
			var list = WMSHelper.GetWmsTaskList("等待", item.cntrNo);
			if (list == null)
			{
			list = WMSHelper.GetWmsTaskList("执行", item.cntrNo);
			if (list != null && list.S_TYPE.Contains("回库"))
			{
			list.S_END_AREA = "TPLKQ";
			}
			}
			if (list == null)
			{
			result.msg = "未查询到在等待中的作业！";
			return result;
			}

			var inbound = new Inbound()
			{
			areaCode = list.S_END_AREA
			};
			var wh = new Warehouse(inbound);
			var stored = await wh.StoreItemAsync();
			if (stored == null)
			{
			result.msg = "立库区未查询到可用货位！";
			return result;
			}

			var startLoc = ContainerHelper.GetCntrLoc(list.S_CNTR_CODE);
			if (startLoc == null)
			{
			result.msg = $"未查询到托盘{list.S_CNTR_CODE}所在的货位！";
			return result;
			}
			var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, stored.loationCode, list.S_B_STATE == "等待" ? "料箱入库" : "托盘入库", list.S_CNTR_CODE, list.S_CODE);
			if (!res)
			{
			result.msg = "入库任务创建失败！";
			return result;
			}
			WMSHelper.UpdateTaskStatus(list.S_CODE, 1);
			ContainerHelper.UpdateCntrAbouts(list.S_CNTR_CODE, "");
			}
			result.code = 0;
			return result;
			}
			catch (Exception ex)
			{
			result.code = 2;
			result.msg = ex.Message;
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0); // 获取第一个堆栈帧
			if (frame != null)
			{
			LogHelper.Error($"CreateInTask获取作业创建入库任务出现错误！！", ex);
			LogHelper.Error($"notifyDeviceSignal设备信号反馈出现错误！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}
			return false;
			return result;
			}
			}

			/// <summary>
			/// WCS调用任务状态反馈
			/// </summary>
			/// <param name="model">请求参数</param>
			/// <returns></returns>
			public static async Task<WcsResult> notifyTaskStatus(WcsTaskModel model)
			{
			WcsResult result = new WcsResult() { code = 1, };
			try
			{
			if (model == null)
			{
			result.msg = "请求参数为空";
			return result;
			}

			var task = WCSHelper.GetTask(model.taskNo);
			if (task == null)
			{
			result.msg = "未查询到任务号";
			return result;
			}

			// 状态与操作的映射字典
			var stateActions = new Dictionary<int, Action>
			{
			[1] = () => WCSHelper.Begin(task),
			[2] = () => HandleTaskCompletion(task),
			[3] = () => WCSHelper.UpdateStatus(task, "开始取货"),
			[4] = () => HandlePickCompletion(task),
			[5] = () => WCSHelper.UpdateStatus(task, "开始卸货"),
			[6] = () => HandleUnloadCompletion(task),
			[7] = () => HandleTaskFailure(task),
			[8] = () => HandleTaskCompletion(task)
			};
			result.code = 0;
			return result;
			}
			catch (Exception ex)
			{
			result.code = 2;
			result.msg = ex.Message;
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0); // 获取第一个堆栈帧
			if (frame != null)
			{
			LogHelper.Error($"notifyTaskStatus任务状态反馈出现错误！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}
			return result;
			}
			}

			// 处理任务完成逻辑
			private static void HandleTaskCompletion(WCSTask task)
			{
			WCSHelper.End(task);

			// 根据任务类型处理不同的完成逻辑
			if (Settings.CompleteTasks.taskType.Contains(task.S_TYPE))
			{
			WMSHelper.UpdateWmsTask(task, 2);
			WMSHelper.UpdateDistributionCntrState(2, 3, task.S_CNTR_CODE);
			}

			if (new List<string> { "料箱入库", "托盘入库" }.Contains(task.S_TYPE))
			{
			ContainerHelper.UpdateCntrItem(task.S_CNTR_CODE);
			}

			// 处理区域变更
			HandleAreaChange(task);
			}

			// 处理取货完成逻辑
			private static void HandlePickCompletion(WCSTask task)
			{
			WCSHelper.UpdateStatus(task, "取货完成");
			TaskProcess.OperateStatus(task, 4);
			}

			// 处理卸货完成逻辑
			private static void HandleUnloadCompletion(WCSTask task)
			{
			WCSHelper.UpdateStatus(task, "卸货完成");
			TaskProcess.OperateStatus(task, 6);
			}

			// 处理任务失败逻辑
			private static void HandleTaskFailure(WCSTask task)
			{
			TaskProcess.OperateStatus(task, 7);
			WCSHelper.Fail(task);
			}

			// 处理区域变更逻辑
			private static void HandleAreaChange(WCSTask task)
			{
			var areas = new List<string> { "TPLKQ", "LXLKQ" };
			var area = new List<string> { "配盘出库", "配盘缓存" };

			if (areas.Contains(task.S_START_AREA) && !area.Contains(task.S_TYPE))
			{
			WMSHelper.DeleteChange(task);
			}

			if (areas.Contains(task.S_END_AREA))
			{
			WMSHelper.AddChange(task);
			}
			}

			/// <summary>
			/// WCS调用申请终点
			/// </summary>
			/// <param name="model">请求参数</param>
			/// <returns></returns>
			public static async Task<WcsResult> applyDest(WcsTaskEnd model)
			{
			WcsResult result = new WcsResult() { code = 1, };
			try
			{
			if (model == null)
			{
			result.msg = "请求参数为空";
			return result;
			}

			var task = WCSHelper.GetTask(model.taskNo);
			if (task == null)
			{
			result.msg = "未查询到任务号";
			return result;
			}

			result.code = 0;
			result.data.Add(new DataModel { taskNo = task.S_CODE, cntrCode = task.S_CNTR_CODE, end = task.S_END_LOC });
			return result;
			}
			catch (Exception ex)
			{
			result.code = 2;
			result.msg = ex.Message;
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0); // 获取第一个堆栈帧
			if (frame != null)
			{
			LogHelper.Error($"applyDest申请终点出现错误！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}
			return result;
			}
			}
			#endregion




			/// <summary>
			/// 错误日志记录
			/// </summary>
			/// <param name="ex">错误信息</param>
			private static void LogErrorDetails(Exception ex)
			{
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0);
			if (frame == null) return;

			var errorDetails = new StringBuilder()
			.AppendLine($"错误信息: {ex.Message}")
			.AppendLine($"文件名: {frame.GetFileName()}")
			.AppendLine($"行号: {frame.GetFileLineNumber()}")
			.AppendLine($"列号: {frame.GetFileColumnNumber()}")
			.ToString();

			LogHelper.Error("CreateInTask获取作业创建入库任务出现错误！" + errorDetails, ex);
			}

			/// <summary>
			@@ -950,7 +1978,7 @@
			{
			return false;
			}


			//生成一条出库的任务
			var relevancys = Settings.Relevancys.Where(s => s.InLoc == anyLoc.FirstOrDefault().S_CODE).FirstOrDefault();
			if (relevancys == null)
			@@ -979,7 +2007,7 @@
			return false;
			}
			}


			//不合托逻辑
			var noCntrAbouts = ContainerHelper.GetCntrAbouts(rkAnyLoc.areaCode, "不合托").FirstOrDefault();
			if (noCntrAbouts != null)
			@@ -999,7 +2027,7 @@
			}
			//2.2如果入库接驳位为空创建码盘接驳入库的任务
			//生成到接驳位的任务
			res = TaskProcess.HYCreateTransport(noCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", noCntrAbouts.S_CNTR_CODE,list.S_CODE);
			res = TaskProcess.HYCreateTransport(noCntrAbouts.S_LOC_CODE, anyLoc.FirstOrDefault().S_CODE, "码盘接驳入库", noCntrAbouts.S_CNTR_CODE, list.S_CODE);
			if (!res)
			{
			LogHelper.Info("码盘接驳入库任务创建失败！", "杭氧");
			@@ -1066,136 +2094,212 @@
			}

			/// <summary>
			/// WCS调用设备信号反馈
			/// 根据配盘单生成出库任务
			/// </summary>
			/// <param name="model">请求参数</param>
			/// <param name="distributionCntrs">配盘单</param>
			/// <returns></returns>
			public static async Task<Result> notifyDeviceSignal(List<Wcsmodel> model)
			internal static bool GenerateFromPicking(List<DistributionCntr> distributionCntrs)
			{
			Result result = new Result() { success = false, };
			try
			{
			foreach (var item in model)
			{
			if (string.IsNullOrEmpty(item.cntrNo))
			{
			result.errMsg = "托盘号为空！";
			return result;
			}
			var list = WMSHelper.GetWmsTaskList("等待", item.cntrNo);
			if (list == null)
			{
			list = WMSHelper.GetWmsTaskList("执行", item.cntrNo);
			}
			if (list == null)
			{
			result.errMsg = "未查询到在等待中的作业！";
			return result;
			}
			// 1. 初始化调度器和出库任务列表
			var scheduler = new DoubleDeepOutboundScheduler(distributionCntrs);
			var outboundTasks = CreateOutboundTasks(distributionCntrs);

			var inbound = new Inbound()
			{
			areaCode = list.S_END_AREA
			};
			var wh = new Warehouse(inbound);
			var stored = await wh.StoreItemAsync();
			if (stored == null)
			{
			result.errMsg = "立库区未查询到可用货位！";
			return result;
			}
			// 2. 计算货位生成任务数据
			var tasks = scheduler.GenerateOutboundTasks(outboundTasks);
			if (!tasks.Any()) return false;

			var startLoc = ContainerHelper.GetCntrLoc(list.S_CNTR_CODE);
			if (startLoc == null)
			{
			result.errMsg = $"未查询到托盘{list.S_CNTR_CODE}所在的货位！";
			return result;
			}
			var res = TaskProcess.HYCreateTransport(startLoc.S_LOC_CODE, stored.loationCode, list.S_B_STATE == "等待" ? "料箱入库" : "托盘入库", list.S_CNTR_CODE, list.S_CODE);
			if (!res)
			{
			result.errMsg = "入库任务创建失败！";
			return result;
			}
			WMSHelper.UpdateTaskStatus(list.S_CODE, 1);
			ContainerHelper.UpdateCntrAbouts(list.S_CNTR_CODE, "");
			}

			// 3. 创建WMS作业
			var mainTask = CreateMainWmsTask(tasks.Where(s=>s.S_TYPE == "配盘出库").First());
			if (!WMSHelper.CreateWmsTask(mainTask)) return false;

			result.success = true;
			return result;
			// 4. 生成WMS主任务
			return ProcessAllTransportTasks(tasks, mainTask.S_CODE);
			}
			catch (Exception ex)
			{
			result.success = false;
			result.errMsg = ex.Message;
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0); // 获取第一个堆栈帧
			if (frame != null)
			{
			LogHelper.Error($"notifyDeviceSignalWCS调用设备信号反馈出现错误！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}
			return result;
			LogErrorWithStackTrace("根据配盘单生成出库任务失败", ex);
			return false;
			}
			}

			/// <summary>
			/// 根据配盘单生成出库任务
			/// </summary>
			/// <param name="distributionCntr">配盘单</param>
			/// <returns></returns>
			internal static bool GenerateFromPicking(List<DistributionCntr> distributionCntr)
			{
			try
			{
			// 创建调度器
			var scheduler = new DoubleDeepOutboundScheduler(distributionCntr);
			// --------------------- 辅助方法 ---------------------

			var listOut = new List<Outbound>();
			foreach (var item in distributionCntr)
			{
			listOut.Add(new Outbound
			{
			locCode = item.S_LOC_CODE,
			areaCode = item.S_AREA_CODE,
			endArea = item.S_EXIT_AREA_CODE,
			endBit = item.S_EXIT_LOC_CODE,
			trayCode = item.S_CNTR_CODE,
			taskType = "配盘出库"
			});
			}
			// 请求出库
			var tasks = scheduler.GenerateOutboundTasks(listOut);
			foreach (var item in tasks)
			{
			// 创建出库任务
			var res = TaskProcess.HYCreateTransport(item.S_START_LOC, item.S_END_LOC, item.S_TYPE, item.S_CNTR_CODE, item.S_OP_CODE);
			UpdateDistributionCntrState("作业中", item.S_CNTR_CODE);
			if (!res)
			{
			LogHelper.Info($"根据配盘单生成出库任务创建出库任务失败！！");
			return false;
			}
			}
			return true;
			}
			catch (Exception ex)
			private static List<Outbound> CreateOutboundTasks(List<DistributionCntr> distributionCntrs)
			{
			return distributionCntrs.Select(item => new Outbound
			{
			var st = new System.Diagnostics.StackTrace(ex, true);
			var frame = st.GetFrame(0); // 获取第一个堆栈帧
			if (frame != null)
			locCode = item.S_LOC_CODE,
			areaCode = item.S_AREA_CODE,
			endArea = item.S_EXIT_AREA_CODE,
			endBit = item.S_EXIT_LOC_CODE,
			trayCode = item.S_CNTR_CODE,
			taskType = "配盘出库"
			}).ToList();
			}

			private static WMSTask CreateMainWmsTask(WCSTask firstTask)
			{
			return new WMSTask
			{
			S_CNTR_CODE = firstTask.S_CNTR_CODE,
			S_CODE = WMSHelper.GenerateTaskNo(),
			S_START_LOC = firstTask.S_START_LOC,
			S_START_AREA = firstTask.S_START_AREA,
			S_END_LOC = firstTask.S_END_LOC,
			S_END_AREA = firstTask.S_END_AREA,
			S_START_WH = "CK001",
			S_END_WH = "CK001",
			N_B_STATE = 1,
			S_B_STATE = "执行",
			N_TYPE = 2,
			S_TYPE = "配盘出库"
			};
			}

			private static bool ProcessAllTransportTasks(List<WCSTask> tasks, string wmsTaskCode)
			{
			foreach (var task in tasks.OrderBy(t => t.N_PRIORITY))
			{
			if (IsLxLkqOrRelocationTask(task))
			{
			LogHelper.Error($"根据配盘单生成出库任务！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			if (!ProcessLxLkqTransportTask(task, wmsTaskCode))
			return false;
			}
			else
			{
			if (!ProcessNormalTransportTask(task, wmsTaskCode))
			return false;
			}
			}
			return true;
			}

			private static bool IsLxLkqOrRelocationTask(WCSTask task)
			{
			return task.S_START_AREA == "LXLKQ" \|\| task.S_TYPE == "深位移库";
			}

			/// <summary>
			/// 生成LXLKQ \|\| 深位移库的配盘任务
			/// </summary>
			/// <param name="task"></param>
			/// <param name="wmsTaskCode"></param>
			/// <returns></returns>
			private static bool ProcessLxLkqTransportTask(WCSTask task, string wmsTaskCode)
			{
			bool success = false;
			if (task.S_TYPE == "深位移库")
			{
			success = TaskProcess.HYCreateTransport(
			task.S_START_LOC,
			task.S_END_LOC,
			task.S_TYPE,
			task.S_CNTR_CODE,
			wmsTaskCode,
			task.N_PRIORITY);
			return success;
			}
			var relevancy = Settings.OutRelevancys.FirstOrDefault(s => s.conLoc == task.S_END_LOC);
			if (relevancy == null)
			{
			LogHelper.Info($"Settings未查询到集货位{task.S_END_LOC}对应的分拣位！", "杭氧");
			return false;
			}


			// 尝试使用分拣位
			var emptyLoc = LocationHelper.GetLocListEmptyFree(relevancy.sorLoc.ToList()).FirstOrDefault();
			if (emptyLoc != null)
			{
			success = TaskProcess.HYCreateTransport(
			task.S_START_LOC,
			emptyLoc.S_CODE,
			task.S_TYPE,
			task.S_CNTR_CODE,
			wmsTaskCode,
			task.N_PRIORITY);
			if (success && task.S_TYPE != "深位移库")
			{
			UpdateDistributionCntrState(1, 2, task.S_CNTR_CODE);
			}
			}
			return success;
			}

			/// <summary>
			/// 生成TPLKQ的配盘任务
			/// </summary>
			/// <param name="task"></param>
			/// <param name="wmsTaskCode"></param>
			/// <returns></returns>
			private static bool ProcessNormalTransportTask(WCSTask task, string wmsTaskCode)
			{
			var relevancy = Settings.OutRelevancys.FirstOrDefault(s => s.conLoc == task.S_END_LOC);
			if (relevancy == null)
			{
			LogHelper.Info($"Settings未查询到集货位{task.S_END_LOC}对应的分拣位！", "杭氧");
			return false;
			}

			// 尝试使用分拣位
			var emptyLoc = LocationHelper.GetLocListEmptyFree(relevancy.sorLoc.ToList()).FirstOrDefault();
			if (emptyLoc != null)
			{
			return CreateAndLogTransport(
			task.S_START_LOC,
			emptyLoc.S_CODE,
			task.S_TYPE,
			task.S_CNTR_CODE,
			wmsTaskCode,
			task.N_PRIORITY);
			}

			// 尝试使用拣选缓存区
			var reservoir = Settings.ReservoirAreas.FirstOrDefault(s => s.areaName == "拣选缓存区");
			if (reservoir == null) return false;

			var lxLocation = LocationHelper.GetLocAreaList(reservoir.areaCode).FirstOrDefault();
			if (lxLocation == null) return false;

			return CreateAndLogTransport(
			task.S_START_LOC,
			lxLocation.S_CODE,
			"配盘缓存",
			task.S_CNTR_CODE,
			wmsTaskCode,
			task.N_PRIORITY);
			}

			private static bool CreateAndLogTransport(string startLoc, string endLoc, string taskType,
			string cntrCode, string wmsTaskCode, int priority)
			{
			var success = TaskProcess.HYCreateTransport(
			startLoc, endLoc, taskType, cntrCode, wmsTaskCode, priority);

			if (success)
			{
			UpdateDistributionCntrState(1, 2, cntrCode);
			}
			else
			{
			LogHelper.Info("根据配盘单生成出库任务创建出库任务失败！！");
			}

			return success;
			}

			private static void LogErrorWithStackTrace(string message, Exception ex)
			{
			var st = new StackTrace(ex, true);
			var frame = st.GetFrame(0);
			if (frame == null) return;

			LogHelper.Error($"{message}{ex.Message}！！", ex);
			LogHelper.Error($"文件名: {frame.GetFileName()}", ex);
			LogHelper.Error($"行号: {frame.GetFileLineNumber()}", ex);
			LogHelper.Error($"列号: {frame.GetFileColumnNumber()}", ex);
			}

			#endregion