WMSPrjInstance/HH-0166_LuoYangDaYangCaiLiao.git

			@@ -4,6 +4,8 @@
			using HH.WCS.DaYang.util;
			using HH.WCS.DaYang.wms;
			using Newtonsoft.Json;
			using NLog.Fluent;
			using Opc.Ua;
			using SqlSugar;
			using System;
			using System.Collections.Concurrent;
			@@ -139,306 +141,75 @@
			return result;
			}

			#region 废弃老流程
			//internal static Result createtask(CreateTask model)
			//{
			// Result result = new Result { resultCode = 0, resultMsg = "创建成功" };
			// var db = new SqlHelper<object>().GetInstance();
			// string start = model.startBit;
			// string end = model.endBit;
			// string Type = "";
			// string cntrcode = "";
			// int startlayer = 1;

			// int endlayer = 1;
			// // string startarea = "";
			// //string endarea = "";
			// //1创建取托盘任务
			// if (model.TaskType == "1")
			// {
			// if (LocControl(start))
			// {
			// string startZone = "HJQ";
			// //找空托盘
			// var cntr = ContainerHelper.GetItemCntrRel(model.ItemCode).ToList();
			// if (cntr.Count > 0)
			// {
			// string[] cntrcodes = cntr.Select(a => a.S_CNTR_CODE).ToArray();
			// // 根据托盘找货位
			// var trayInfo = db.Queryable<LocCntrRel>().Where(a => cntrcodes.Contains(a.S_CNTR_CODE)).ToList();
			// if (trayInfo.Count() > 0)
			// {
			// //判断起点是否是指定库区的货位
			// foreach (var item in trayInfo)
			// {
			// var locations = db.Queryable<Location>().Where(a => a.S_CODE == item.S_LOC_CODE && a.S_AREA_CODE == startZone).First();
			// if (locations != null)
			// {
			// start = locations.S_CODE;
			// cntrcode = item.S_CNTR_CODE;
			// break;
			// }
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "根据托盘编码未找到所属货位编码";
			// return result;
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "找不到空托盘";
			// return result;
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "外侧货位有托盘";
			// return result;
			// }
			// }
			// // 2创建取物料任务
			// else if (model.TaskType == "2")
			// {
			// if (LocControl(start))
			// {
			// string startZone = "AGVZYQ";

			// //根据物料编码找托盘
			// var cntr = ContainerHelper.GetItemCntrRel(model.ItemCode).FirstOrDefault();
			// if (cntr != null)
			// {
			// //根据托盘找货位
			// var trayInfo = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == cntr.S_CNTR_CODE).ToList();
			// if (trayInfo.Count() > 0)
			// {
			// //判断起点是否是指定库区的货位
			// foreach (var item in trayInfo)
			// {
			// var locations = db.Queryable<Location>().Where(a => a.S_CODE == item.S_LOC_CODE && a.S_AREA_CODE == startZone).First();
			// if (locations != null)
			// {
			// start = locations.S_CODE;
			// cntrcode = cntr.S_CNTR_CODE;
			// //startlayer = locations.N_CURRENT_NUM == 1 ? 1 : 2;
			// // startlayer = locations.N_LAYER;
			// break;
			// }
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "根据物料托盘编码未找到所属货位编码";
			// return result;
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "根据物料编码未找到所属容器号";
			// return result;
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "外侧货位有托盘，不允许生成任务";
			// return result;
			// }

			// }
			// //3满拖入库
			// else if (model.TaskType == "3")
			// {

			// string endlloc = "JBW_01_01";


			// var locations = LocationHelper.GetLocList(endlloc).FirstOrDefault();
			// if (locations.S_LOCK_STATE != "无")
			// {
			// if (locations.N_CURRENT_NUM > 0)
			// {
			// result.resultCode = -1;
			// result.resultMsg = $"货位{endlloc}已有托盘，不允许生成任务";
			// return result;
			// }
			// else
			// {
			// end = endlloc;
			// }

			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = $"货位{endlloc}已有任务正在执行中，不允许生成任务";
			// return result;
			// }
			// //var locations = LocationHelper.GetLocListAny(startZone).OrderBy(a => a.N_ROW).ToList();
			// //var suo = locations.Find(a => a.S_LOCK_STATE != "无");
			// //if (suo != null)
			// //{
			// // var endloc = FindEndcolByLocList(locations, model.ItemCode);
			// // if (endloc != null)
			// // {
			// // end = endloc.S_CODE;
			// // }
			// //}
			// //else
			// //{
			// // result.resultCode = -1;
			// // result.resultMsg = $"库区{suo.S_AREA_CODE}已有任务正在执行中，不允许生成任务";
			// // return result;
			// //}



			// }
			// //4分拣出
			// else if (model.TaskType == "4")
			// {
			// string startZone = "HJQ";

			// //根据物料编码找托盘
			// var cntr = ContainerHelper.GetItemCntrRel(model.ItemCode).FirstOrDefault();
			// if (cntr != null)
			// {
			// //根据托盘找货位
			// var trayInfo = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == cntr.S_CNTR_CODE).ToList();
			// if (trayInfo.Count() > 0)
			// {
			// //判断起点是否是指定库区的货位
			// foreach (var item in trayInfo)
			// {
			// var locations = db.Queryable<Location>().Where(a => a.S_CODE == item.S_LOC_CODE && a.S_AREA_CODE == startZone).First();
			// if (locations != null)
			// {
			// start = locations.S_CODE;
			// cntrcode = cntr.S_CNTR_CODE;
			// break;
			// }
			// }

			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "根据物料托盘编码未找到所属货位编码";
			// return result;
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = "根据物料编码未找到所属容器号";
			// return result;
			// }
			// }
			// else
			// {
			// result.resultCode = -1;
			// result.resultMsg = $"任务类型有误，{model.TaskType}任务类型不是规定任务类型";
			// return result;
			// }
			// if (!string.IsNullOrEmpty(start) && !string.IsNullOrEmpty(end))
			// {
			// //创建wcs任务
			// var wcsTask = new WCSTask
			// {
			// S_CODE = WCSHelper.GenerateTaskNo(),
			// S_TYPE = Type,
			// S_START_LOC = start,
			// S_END_LOC = end,
			// N_CNTR_COUNT = 1,
			// N_SCHEDULE_TYPE = 1,
			// S_CNTR_CODE = cntrcode,
			// N_START_LAYER = startlayer,
			// N_END_LAYER = endlayer

			// };
			// LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			// if (WCSHelper.CreateTask(wcsTask))
			// {
			// LocationHelper.LockLoc(start, 2);
			// LocationHelper.LockLoc(end, 1);
			// LogHelper.Info("创建任务成功");
			// }
			// }

			// return result;
			//}
			#endregion

			private static object lockObj = new object();

			/// <summary>
			/// 创建任务
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			internal static Result createtask(CreateTaskModel model)
			internal static Result<Empty> createtask(CreateTaskModel model)
			{
			Result result = new Result { resultCode = 0, resultMsg = "创建成功" };
			Result<Empty> result = new Result<Empty> { Code = 0, Msg = "创建成功" };
			if (model == null)
			{
			result.resultCode = -1;
			result.resultMsg = "入参为空";
			result.Code = -1;
			result.Msg = "入参为空";
			return result;
			}
			var db = new SqlHelper<object>().GetInstance();
			string start = model.startBit;
			// string start = model.startBit;
			Location endloc = new Location();
			Location startloc = new Location();
			string Type = "";
			string cntrcode = "";
			lock (lockObj)
			{
			try
			{

			// 1 空托回库
			if (model.TaskType == "1")
			if (model.TaskType.Trim() == "1")
			{
			Type = "空托入库";

			#region 获取起点信息
			startloc = LocationHelper.GetLoc(model.startBit);
			if (endloc == null)
			if (startloc == null)
			{
			result.resultCode = -1;
			result.resultMsg = $"根据起点:{model.startBit}未找到货位信息";
			LogHelper.Info($"creattask:根据起点:{model.startBit}未找到货位信息");
			result.Code = -1;
			result.Msg = $"根据起点:{model.startBit}未找到货位信息";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			else
			{
			var cntr = LocationHelper.GetLocCntrRel(endloc.S_CODE).FirstOrDefault();
			if (cntr == null)
			if (startloc.N_LOCK_STATE != 0)
			{
			result.resultCode = -1;
			result.resultMsg = $"根据起点:{model.startBit}未找到绑定托盘";
			LogHelper.Info($"creattask:根据起点:{model.startBit}未找到绑定托盘");
			result.Code = -1;
			result.Msg = $"起点:{model.startBit}货位存在任务，该货位不允许再呼叫，请等待任务完成";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			else
			if (startloc.N_CURRENT_NUM == 0)
			{
			cntrcode = cntr.S_CNTR_CODE;
			result.Code = -1;
			result.Msg = $"起点:{model.startBit}货位不存在托盘，不允许下发任务";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			}

			#endregion

			#region 计算立库终点
			endloc = LocationHelper.InStorage(startloc);

			endloc = LocationHelper.InStorage("");
			if (endloc == null)
			{
			result.resultCode = -1;
			result.resultMsg = $"未计算到立库终点货位，请检查货位情况";
			LogHelper.Info($"creattask:未计算到立库终点货位，请检查货位情况");
			result.Code = -1;
			result.Msg = $"未计算到立库终点货位，请检查货位情况";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			#endregion
			@@ -446,15 +217,116 @@
			#region 创建作业
			if (startloc != null && endloc != null)
			{
			//获取托盘
			var Cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
			if (Cntr == null)
			{
			result.Code = -1;
			result.Msg = $"根据起点:{startloc.S_CODE}未找到托盘货位绑定关系";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			//创建作业
			var wcsTask = new WMSTask
			{
			S_CODE = WMSHelper.GenerateTaskNo(),
			S_TYPE = Type,
			N_TYPE = int.Parse(model.TaskType),
			S_START_LOC = start,
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = endloc.S_CODE,
			S_CNTR_CODE = cntrcode,
			S_CNTR_CODE = Cntr.S_CNTR_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_AREA = endloc.S_AREA_CODE,

			};
			LogHelper.Info("创建作业：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WMSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(startloc.S_CODE, 2);
			LocationHelper.LockLoc(endloc.S_CODE, 1);
			LogHelper.Info("创建作业成功");
			//空托回库成功，如果存在物料数据，删除
			var itemcntr = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == Cntr.S_CNTR_CODE).First();
			if (itemcntr != null) { db.Deleteable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == Cntr.S_CNTR_CODE).ExecuteCommand(); }
			LogHelper.Info("创建任务成功");
			}
			}
			#endregion

			}
			// 2 出库
			else if (model.TaskType.Trim() == "2")
			{
			Type = "出库";

			#region 获取终点信息
			endloc = LocationHelper.GetLoc(model.endBit);
			if (endloc == null)
			{
			result.Code = -1;
			result.Msg = $"根据终点:{model.startBit}未找到货位信息";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			else
			{
			if (endloc.N_LOCK_STATE != 0)
			{
			result.Code = -1;
			result.Msg = $"终点:{model.startBit}货位存在任务，该货位不允许再呼叫，请等待任务完成";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			if (endloc.N_CURRENT_NUM == 0)
			{
			result.Code = -1;
			result.Msg = $"起点:{model.startBit}货位不存在托盘，不允许下发任务";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			}
			#endregion

			#region 根据物料计算出库托盘，先进先出，优先出外侧
			//先计算内侧货位，判断是否有单组托盘
			var location = LocationHelper.GetLocByItemCodeOrderyTime("YCLLKQ", model.ItemCode);
			if (location != null)
			{
			startloc = location;
			}
			else
			{
			result.Code = -1;
			result.Msg = $"根据物料:{model.ItemCode}未找到库存托盘，或货位有锁，数量存在问题，请检查货位表";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}

			#endregion

			#region 创建作业
			if (startloc != null && endloc != null)
			{
			//获取托盘
			var Cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
			if (Cntr == null)
			{
			result.Code = -1;
			result.Msg = $"根据起点:{startloc.S_CODE}未找到托盘货位绑定关系";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}
			//创建作业
			var wcsTask = new WMSTask
			{
			S_CODE = WMSHelper.GenerateTaskNo(),
			S_TYPE = Type,
			N_TYPE = int.Parse(model.TaskType),
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = endloc.S_CODE,
			S_CNTR_CODE = Cntr.S_CNTR_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			@@ -474,20 +346,18 @@
			}
			else
			{
			result.resultCode = -1;
			result.resultMsg = $"任务类型有误，{model.TaskType}任务类型不是规定任务类型";
			LogHelper.Info($"creattask:任务类型有误，{model.TaskType}任务类型不是规定任务类型");
			result.Code = -1;
			result.Msg = $"任务类型有误，{model.TaskType}任务类型不是规定任务类型";
			LogHelper.Info($"creattask:{result.Msg}");
			return result;
			}



			return result;
			}
			catch (Exception ex)
			{
			result.resultCode = -1;
			result.resultMsg = $"{ex.ToString()}";
			result.Code = -1;
			result.Msg = $"{ex.ToString()}";
			return result;

			}
			@@ -496,22 +366,462 @@

			}

			internal static Result PutIn(PutInModel model)
			/// <summary>
			/// 设备信号反馈
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			internal static Result<Empty> NotifyDeviceSignal(NotifyDeviceSignalModel model)
			{
			Result result = new Result { resultCode = 0, resultMsg = "创建成功" };
			Result<Empty> result = new Result<Empty> { Code = 0, Msg = "创建成功" };
			if (model == null)
			{
			result.resultCode = -1;
			result.resultMsg = "入参为空";
			result.Code = -1;
			result.Msg = "入参为空";
			return result;
			}
			Location endloc = new Location();
			Location startloc = new Location();
			string cntrcode = model.CntrNo;
			string DiePanLoc = "CPDPJ-1-1";
			// string itemCode = "";
			var db = new SqlHelper<object>().GetInstance();

			if (model.DeviceNo == "1")//叠盘机
			{
			if (model.SignalType == 1)
			{
			//判断设备状态是否属于叠盘状态
			var DeviceStatu = db.Queryable<EquipmentStatus>().Where(a => a.DEVICENO == model.DeviceNo).First();
			if (DeviceStatu != null && DeviceStatu.STATUS == "1")
			{
			#region 获取起点信息，并判断空托是否叠满
			//根据起点获取绑定托盘数量
			//var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.Loc).ToList();
			//if (CntrLoc.Count < 4)
			//{
			// result.Code = -1;
			// result.Msg = $"根据货位:{model.Loc}获取托盘数量小于4";
			// LogHelper.Info($"EquipmentInfo:{result.Msg}");
			// return result;
			//}
			//else
			//{
			// //拼接托盘号
			// cntrcode = CntrLoc.Select(a => a.S_CNTR_CODE).ToString();
			//}
			cntrcode = model.CntrNo;
			//if (ContainerHelper.CheckEmpty(cntrcode))
			//{
			// result.Code = -1;
			// result.Msg = $"托盘:{cntrcode}已经绑定货位，叠盘机";
			// LogHelper.Info($"EquipmentInfo:{result.Msg}");
			// return result;
			//}
			var containern = db.Queryable<Container>().Where(a => a.S_CODE.Trim() == cntrcode).First();
			if (containern == null)
			{ ContainerHelper.AddCntr(cntrcode, "2"); }
			else
			{
			containern.S_SOURCE = "2";
			db.Updateable<Container>(containern).UpdateColumns(a => new { a.S_SOURCE }).ExecuteCommand();

			}

			startloc = LocationHelper.GetLoc(model.Loc);
			if (startloc == null)
			{
			result.Code = -1;
			result.Msg = $"根据起点:{model.Loc}未找到货位信息";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			#endregion

			#region 计算立库终点

			endloc = LocationHelper.InStorage("");
			if (endloc == null)
			{
			result.Code = -1;
			result.Msg = $"未计算到立库终点货位，请检查货位情况";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}

			#endregion

			#region 创建作业
			if (startloc != null && endloc != null)
			{
			var wcsTask = new WMSTask
			{
			S_CODE = WMSHelper.GenerateTaskNo(),
			S_TYPE = "叠盘机入库",
			N_TYPE = 3,
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = endloc.S_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,

			S_CNTR_CODE = cntrcode
			};
			LogHelper.Info("创建入平库作业：" + JsonConvert.SerializeObject(wcsTask));
			if (WMSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(startloc.S_CODE, 2);
			LocationHelper.LockLoc(endloc.S_CODE, 1);
			LogHelper.Info("创建作业成功");
			}
			}
			#endregion
			}
			else
			{
			result.Code = -1;
			result.Msg = $"当前叠盘机状态不属于叠盘状态，不允许空托入库";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			}
			else if (model.SignalType == 2)
			{ //判断设备状态是否属于叠盘状态
			var DeviceStatu = db.Queryable<EquipmentStatus>().Where(a => a.DEVICENO == model.DeviceNo).First();
			if (DeviceStatu != null && DeviceStatu.STATUS == "2")
			{
			#region 获取叠盘机托盘数量

			endloc = LocationHelper.GetLoc(DiePanLoc);
			if (endloc == null)
			{
			result.Code = -1;
			result.Msg = $"根据叠盘货位:{DiePanLoc}未找到货位信息";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			#endregion

			#region 计算数量
			if (endloc.N_CURRENT_NUM > 0 && endloc.N_CURRENT_NUM < 4)
			{
			startloc = LocationHelper.GetLocByItemCodeOrderyTime("YCLLKQ", null);

			}
			else
			{
			startloc = LocationHelper.GetLocByItemCodeOrderyTime("YCLLKQ", null, "2");
			if (startloc == null)
			{
			startloc = LocationHelper.GetLocByItemCodeOrderyTime("YCLLKQ", null);
			}
			}
			if (startloc == null)
			{
			result.Code = -1;
			result.Msg = $"未找到库存空托";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			else
			{
			var Cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).ToList();
			if (Cntr == null)
			{
			result.Code = -1;
			result.Msg = $"起点{startloc.S_CODE}，未找到托盘货位绑定关系，请检查货位数量";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			cntrcode = string.Join(",", Cntr.Select(a => a.S_CNTR_CODE));
			}

			#endregion

			#region 创建作业
			if (startloc != null && endloc != null)
			{
			var wcsTask = new WMSTask
			{
			S_CODE = WMSHelper.GenerateTaskNo(),
			S_TYPE = "叠盘机呼叫空托",
			N_TYPE = 3,
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = endloc.S_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,

			S_CNTR_CODE = cntrcode
			};
			LogHelper.Info("创建入平库作业：" + JsonConvert.SerializeObject(wcsTask));
			if (WMSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(startloc.S_CODE, 2);
			LocationHelper.LockLoc(endloc.S_CODE, 1);
			LogHelper.Info("创建作业成功");
			}
			}
			#endregion
			}
			else
			{
			result.Code = -1;
			result.Msg = $"当前叠盘机状态不属于拆托状态，不允许呼叫空托";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			}
			else
			{
			result.Code = -1;
			result.Msg = $"下发类型错误";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			}
			else //入库空
			{
			//入库口申请入库
			if (model.SignalType == 1)
			{
			#region 获取起点信息
			//根据托盘获取起点信息

			//var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE == model.Loc).First();
			//if (CntrLoc == null)
			//{
			// result.Code = -1;
			// result.Msg = $"根据起点:{model.Loc}未找到绑定托盘";
			// LogHelper.Info($"EquipmentInfo:{result.Msg}");
			// return result;
			//}
			startloc = LocationHelper.GetLoc(model.Loc);
			if (startloc == null)
			{
			result.Code = -1;
			result.Msg = $"根据起点:{model.Loc}未找到货位信息";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}

			#endregion

			#region 计算立库终点
			//获取托盘物料绑定关系
			var cntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE == model.CntrNo).First();
			if (cntrItem == null)
			{
			result.Code = -1;
			result.Msg = $"根据托盘:{model.CntrNo}未找到物料信息";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			endloc = LocationHelper.InStorage(cntrItem.S_ITEM_CODE);
			if (endloc == null)
			{
			result.Code = -1;
			result.Msg = $"未计算到立库终点货位，请检查货位情况";
			LogHelper.Info($"EquipmentInfo:未计算到立库终点货位，请检查货位情况");
			return result;
			}
			#endregion

			#region 创建作业
			if (startloc != null && endloc != null)
			{
			var wmsTask = new WMSTask
			{
			S_CODE = WMSHelper.GenerateTaskNo(),
			S_TYPE = "物料入库",
			N_TYPE = 3,
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = endloc.S_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,
			S_CNTR_CODE = model.CntrNo
			};
			LogHelper.Info("创建入平库作业：" + JsonConvert.SerializeObject(wmsTask));
			if (WMSHelper.CreateTask(wmsTask))
			{
			cntrItem.F_WEIGHT = float.Parse(model.Weight);
			var aaaaa = db.Updateable(cntrItem).UpdateColumns(a => new { a.F_WEIGHT }).ExecuteCommand();
			LocationHelper.LockLoc(startloc.S_CODE, 2);
			LocationHelper.LockLoc(endloc.S_CODE, 1);
			LogHelper.Info("创建作业成功");
			}
			}
			#endregion
			}
			//入库空申请叠盘
			else
			{
			//判断设备状态是否属于叠盘状态
			var DeviceStatu = db.Queryable<EquipmentStatus>().Where(a => a.DEVICENO == "1").First();
			if (DeviceStatu != null && DeviceStatu.STATUS == "1")
			{
			#region 获取起点信息
			//根据托盘获取起点信息
			//var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == cntrcode).First();
			//if (CntrLoc == null)
			//{
			// result.Code = -1;
			// result.Msg = $"根据托盘:{cntrcode}未找到绑定托盘";
			// LogHelper.Info($"EquipmentInfo:{result.Msg}");
			// return result;
			//}
			ContainerHelper.AddCntr(cntrcode, "1");
			startloc = LocationHelper.GetLoc(model.Loc);
			if (startloc == null)
			{
			result.Code = -1;
			result.Msg = $"根据起点:{model.Loc}未找到货位信息";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			var cntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE == model.CntrNo).First();
			if (cntrItem != null)
			{
			result.Code = -1;
			result.Msg = $"根据托盘:{model.CntrNo}找到物料信息,不允许叠盘入库";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			#endregion

			#region 获取终点信息

			//根据托盘获取起点信息
			endloc = db.Queryable<Location>().Where(a => a.S_CODE == DiePanLoc).First();
			if (endloc == null)
			{
			result.Code = -1;
			result.Msg = $"根据货位编码：{DiePanLoc}未找到叠盘货位";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			#endregion

			#region 创建作业
			if (startloc != null && endloc != null)
			{
			var wmsTask = new WMSTask
			{
			S_CODE = WMSHelper.GenerateTaskNo(),
			S_TYPE = "叠盘机空托入库",
			N_TYPE = 3,
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = endloc.S_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,
			S_CNTR_CODE = cntrcode
			};
			LogHelper.Info("创建入平库作业：" + JsonConvert.SerializeObject(wmsTask));
			if (WMSHelper.CreateTask(wmsTask))
			{
			LocationHelper.LockLoc(startloc.S_CODE, 2);
			LocationHelper.LockLoc(endloc.S_CODE, 1);
			LogHelper.Info("创建任务作业");
			}
			}

			#endregion
			}
			else
			{
			result.Code = -1;
			result.Msg = $"当前叠盘机状态不属于叠盘状态，不允许空托叠托";
			LogHelper.Info($"EquipmentInfo:{result.Msg}");
			return result;
			}
			}
			}


			return result;
			}

			internal static Result<ReseltApplyDestModel> ApplyDest(ApplyDestModel model)
			{
			Result<ReseltApplyDestModel> result = new Result<ReseltApplyDestModel> { Code = 0, Msg = "创建成功" };
			if (model == null)
			{
			result.Code = -1;
			result.Msg = "入参为空";
			return result;
			}
			var db = new SqlHelper<object>().GetInstance();
			string ItemCode = "";
			var task = WCSHelper.GetTask(model.TaskNo);
			if (task != null)
			{

			//根据任务托盘获取物料信息

			var cntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE == task.S_CNTR_CODE).First();
			if (cntrItem != null)
			{
			ItemCode = cntrItem.S_ITEM_CODE;
			}

			var endloc = LocationHelper.InStorage(ItemCode);
			if (endloc != null)
			{
			result.Data = new ReseltApplyDestModel() { Loc = endloc.S_CODE };
			}
			else
			{
			result.Code = -1;
			result.Msg = "当前没有可用终点可以分配";
			return result;
			}

			}
			else
			{
			result.Code = 1;
			result.Msg = "任务不存在";
			return result;
			}



			return result;
			}

			/// <summary>
			/// 获取托盘物料信息
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			internal static Result<Empty> GetCntrInfo(GetCntrInfoModel model)
			{
			Result<Empty> result = new Result<Empty> { Code = 0, Msg = "创建成功" };
			if (model == null)
			{
			result.Code = -1;
			result.Msg = "入参为空";
			return result;
			}

			var db = new SqlHelper<object>().GetInstance();
			string cntrCode = model.CntrNo;

			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE == cntrCode).ToList();
			if (CntrItem.Count > 0)
			{

			}

			return result;
			}

			/// <summary>
			/// 绑定托盘物料
			/// </summary>