WMSPrjInstance/HH-0035_HeFeiLiaoTongAGV.git

			@@ -11,8 +11,12 @@
			using System;
			using System.Collections.Generic;
			using System.Linq;
			using System.Reflection.Emit;
			using System.Runtime.CompilerServices;
			using System.ServiceModel;
			using System.Threading;
			using System.Threading.Tasks;
			using System.Web.UI.WebControls;
			using static HH.WCS.JiaTong.api.ApiModel;
			using static HH.WCS.JiaTong.api.OtherModel;
			using static HH.WCS.JiaTong.LISTA.process.HttpModel;
			@@ -31,6 +35,10 @@


			#region 佳通合肥接口业务


			public static object _lockCreateTask = new object();
			public static object _lockCreateItem = new object();
			/// <summary>
			/// 立库任务下发=》创建任务
			/// </summary>
			@@ -80,7 +88,7 @@
			// AddErrorInfo("寻找出库区失败", result.msg);
			// return result;
			//}


			int n_type = 0; //任务来源 1.密炼立库 3.预备库 ,4.原材料库
			string Source = "";
			switch (taskData.source)
			@@ -112,242 +120,106 @@

			Location endloc = new Location();
			Location startloc = new Location();

			if (taskData.taskType == 1) //出库流程，通过物料机台计算线边货位
			lock (_lockCreateTask)
			{
			note = "出库";
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			if (taskData.taskType == 1) //出库流程，通过物料机台计算线边货位
			{
			//创建托盘物料绑定信息，并计算终点货位
			Start = taskData.pickStation;
			if (CreateCntrIteminfo(partData, taskData))
			note = "出库";
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			endloc = Computeloc(CntrCode, taskData.dropStation, taskData.carrierType);
			if (endloc != null)
			//创建托盘物料绑定信息，并计算终点货位
			Start = taskData.pickStation;
			if (CreateCntrIteminfo(partData, taskData))
			{
			End = endloc.S_CODE;
			endloc = Computeloc(CntrCode, taskData.dropStation, taskData.carrierType);
			if (endloc != null)
			{
			End = endloc.S_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"机台编码:{taskData.dropStation}，未找到可用货位";
			AddErrorInfo("寻找出库货位失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = $"机台编码:{taskData.dropStation}，未找到可用货位";
			AddErrorInfo("寻找出库货位失败", result.msg, Source);
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}
			}
			else
			{

			result.code = "1";
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			result.msg = $"Putin==> 任务起点:{taskData.pickStation}找不到对应货位，请检查货位表";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			else
			else if (taskData.taskType == 2)//入库流程，直接使用起点货位和终点货位生成任务，起点需要有托盘
			{

			result.code = "1";
			result.msg = $"Putin==> 任务起点:{taskData.pickStation}找不到对应货位，请检查货位表";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("货位查找失败", result.msg, Source);
			}
			}
			else if (taskData.taskType == 2)//入库流程，直接使用起点货位和终点货位生成任务，起点需要有托盘
			{
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			var CntrRel = LocationHelper.GetLocCntrRel(startloc.S_CODE).FirstOrDefault();
			if (CntrRel != null)
			note = "入库";
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = startloc.S_CODE;
			CntrCode = CntrRel.S_CNTR_CODE;
			var CntrRel = LocationHelper.GetLocCntrRel(startloc.S_CODE).OrderBy(a => a.T_CREATE).FirstOrDefault();
			if (CntrRel != null)
			{
			if (CntrRel.S_CNTR_CODE != partData.rfid)
			{
			result.code = "1";
			result.msg = $"根据起点：{Start}获取托盘:{CntrRel.S_CNTR_CODE}与下发托盘：{partData.rfid}不一致，请检查托盘码是否正确";
			AddErrorInfo("托盘码校检失败", result.msg, Source);
			return result;
			}
			else
			{
			CntrCode = CntrRel.S_CNTR_CODE;
			}

			}
			//else
			//{
			// result.code = "1";
			// result.msg = $"根据起点{Start},未找到托盘货位绑定关系";
			// AddErrorInfo("托盘查找失败", result.msg, Source);
			// return result;
			//}

			}
			else
			{
			result.code = "1";
			result.msg = $"根据起点{Start},未找到托盘货位绑定关系";
			AddErrorInfo("托盘查找失败", result.msg, Source);
			return result;
			}

			}
			//判断是否是空托回库
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == CntrCode).First();
			if (CntrItem == null)
			{
			note = "空托回库";//井松空托回库，需要与叠盘机安全交互
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点{End},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			else if (taskData.taskType == 3)//移库流程，直接使用起点货位和终点货位生成任务，
			{
			//创建托盘物料绑定信息，并计算终点货位

			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = taskData.pickStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据起点{taskData.pickStation},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点{taskData.dropStation},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			else if (taskData.taskType == 4)//原材料库需要判断是否需要分配电梯任务,创建分档任务
			{
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = taskData.pickStation;
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}

			//判断楼层是否相等，如果不相同需要生成分段任务进行电梯调用
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE).First();
			var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE).First();
			if (startArea == null \|\| endArea == null)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点:{startloc.S_AREA_CODE},终点：{endloc.S_AREA_CODE}未找到对应库区";
			result.msg = $"根据起点{taskData.pickStation},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			if (startArea.N_FLOOR == endArea.N_FLOOR)
			{
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = startArea.S_NAME + "->" + endArea.S_NAME,
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = Start,
			S_END_LOC = End,
			N_CNTR_COUNT = 1,
			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,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			S_WMS_NO = taskData.wmsTaskNo,
			Z_TYPE = n_type
			};
			LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WCSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(Start, 2);

			LogHelper.Info("创建任务成功");
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else if (startArea.N_FLOOR != endArea.N_FLOOR)
			else
			{
			//楼层电梯分配
			var endloc1 = Settings.elevatorLoc.Find(a => a.Floor == startArea.N_FLOOR);
			var startloc1 = Settings.elevatorLoc.Find(a => a.Floor == endArea.N_FLOOR);

			//创建wcs分段任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "电梯1",
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = Start,
			S_END_LOC = endloc1.Location[0],
			N_CNTR_COUNT = 1,
			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,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			S_WMS_NO = taskData.wmsTaskNo,
			Z_TYPE = n_type
			};
			var wcsTask1 = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "电梯2",
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = startloc1.Location[0],
			S_END_LOC = End,
			N_CNTR_COUNT = 1,
			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,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			S_WMS_NO = taskData.wmsTaskNo,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = n_type


			};

			LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WCSHelper.CreateTask(wcsTask) && WCSHelper.CreateTask(wcsTask1))
			{

			LocationHelper.LockLoc(endloc.S_CODE, 1);
			LogHelper.Info("创建任务成功");
			}
			result.code = "1";
			result.msg = $"根据终点{End},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			else
			else if (taskData.taskType == 3)//移库流程，直接使用起点货位和终点货位生成任务，
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			}
			else if (taskData.taskType == 5)//移库流程，直接使用起点货位和终点货位生成任务，并绑定托盘
			{
			//创建托盘物料绑定信息，并计算终点货位
			if (CreateCntrIteminfo(partData, taskData))
			{
			note = "出库";
			//创建托盘物料绑定信息，并计算终点货位
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			@@ -373,188 +245,373 @@
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}

			}
			//暂存位回库
			else if (taskData.taskType == 6)//入库流程，直接使用起点货位和终点货位生成任务
			{
			//根据托盘号找货位
			var CntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == partData.rfid).First();
			if (CntrRel != null)
			{
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == CntrRel.S_LOC_CODE).First();
			if (startloc != null)
			{
			Start = startloc.S_CODE;
			CntrCode = CntrRel.S_CNTR_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据托盘{partData.rfid},未找到托盘货位绑定关系";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点{End},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			//点对库区
			else if (taskData.taskType == 7)//异常位
			{
			note = "异常库区入库";
			//创建托盘物料绑定信息，并计算终点货位
			if (CreateCntrIteminfo(partData, taskData))
			else if (taskData.taskType == 4)//原材料库需要判断是否需要分配电梯任务,创建分档任务
			{
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = taskData.pickStation;
			}
			var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == taskData.dropStation).ToList();
			if (EndLocs.Count > 0)
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			endloc = EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
			if (endloc != null)
			{
			End = endloc.S_CODE;
			}
			else
			End = taskData.dropStation;
			}

			//判断楼层是否相等，如果不相同需要生成分段任务进行电梯调用
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE).First();
			var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE).First();
			if (startArea == null \|\| endArea == null)
			{
			result.code = "1";
			result.msg = $"终点库区：{taskData.dropStation}无可用货位";
			AddErrorInfo("查找库区失败", result.msg, Source);
			result.msg = $"创建任务失败，起点:{startloc.S_AREA_CODE},终点：{endloc.S_AREA_CODE}未找到对应库区";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			if (startArea.N_FLOOR == endArea.N_FLOOR)
			{
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = startArea.S_NAME + "->" + endArea.S_NAME,
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = Start,
			S_END_LOC = End,
			N_CNTR_COUNT = 1,
			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,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			S_WMS_NO = taskData.wmsTaskNo,
			Z_TYPE = n_type,


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

			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}
			else if (startArea.N_FLOOR != endArea.N_FLOOR)
			{
			//楼层电梯分配
			var elevatorLoc = LocationHelper.GetElevatorLoc();

			if (elevatorLoc != null)
			{ //创建wcs分段任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "电梯1",
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = Start,
			S_END_LOC = elevatorLoc.S_CODE,
			N_CNTR_COUNT = 1,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = elevatorLoc.S_WH_CODE,
			S_END_AREA = elevatorLoc.S_AREA_CODE,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			S_WMS_NO = taskData.wmsTaskNo,
			Z_TYPE = n_type,
			S_MES_NO = taskData.mesTaskNo
			};
			var wcsTask1 = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "电梯2",
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = elevatorLoc.S_CODE,
			S_END_LOC = End,
			N_CNTR_COUNT = 1,
			S_START_WH = elevatorLoc.S_WH_CODE,
			S_START_AREA = elevatorLoc.S_AREA_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			S_WMS_NO = taskData.wmsTaskNo,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = n_type,
			S_MES_NO = taskData.mesTaskNo

			};
			LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WCSHelper.CreateTask(wcsTask) && WCSHelper.CreateTask(wcsTask1))
			{

			// LocationHelper.LockLoc(Start, 1);
			//LocationHelper.LockLoc(End, 2);
			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}



			}
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点库区：{taskData.dropStation},未找到对应货位";
			AddErrorInfo("查找库区失败", result.msg, Source);
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			}
			else
			else if (taskData.taskType == 5)//移库流程，直接使用起点货位和终点货位生成任务，并绑定托盘
			{
			result.code = "1";
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}
			}
			else if (taskData.taskType == 8)//叠盘机空托回库
			{
			note = "空托回库";//井松空托回库，需要与叠盘机安全交互
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = startloc.S_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据起点:{taskData.pickStation},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点:{End},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			LogHelper.Info($"Createtask==> 任务类型有误");
			result.code = "1";
			result.msg = "任务类型：{taskData.taskType}不在规定范围内";
			AddErrorInfo("任务类型错误", result.msg, Source);
			}
			if (taskData.taskType != 4)
			{
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			if (startloc.N_LOCK_STATE != 0)
			note = "出库";
			//创建托盘物料绑定信息，并计算终点货位
			if (CreateCntrIteminfo(partData, taskData))
			{
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = taskData.pickStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据起点{taskData.pickStation},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点{taskData.dropStation},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg);
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}
			var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE.Trim()).First();
			var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE.Trim()).First();
			if (startArea == null \|\| endArea == null)
			{
			LogHelper.Info($"起点：{JsonConvert.SerializeObject(startArea)}");
			LogHelper.Info($"终点：{JsonConvert.SerializeObject(endArea)}");
			result.code = "1";
			result.msg = $"创建任务失败，起点:{startloc.S_AREA_CODE},终点{endloc.S_AREA_CODE}未找到对应库区";
			AddErrorInfo("库区查找失败", result.msg);
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = startArea.S_NAME + "->" + endArea.S_NAME,
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = Start,
			S_END_LOC = End,
			N_CNTR_COUNT = 1,
			S_START_WH = startloc.S_WH_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			Z_TYPE = n_type,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			S_WMS_NO = taskData.wmsTaskNo,
			S_NOTE = note

			};
			LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WCSHelper.CreateTask(wcsTask))
			}
			//暂存位回库
			else if (taskData.taskType == 6)//入库流程，直接使用起点货位和终点货位生成任务
			{
			note = "入库";
			//根据托盘号找货位
			var CntrRel = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE == partData.rfid).First();
			if (CntrRel != null)
			{
			LocationHelper.LockLoc(Start, 2);
			LocationHelper.LockLoc(End, 1);
			LogHelper.Info("创建任务成功");
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == CntrRel.S_LOC_CODE).First();
			if (startloc != null)
			{
			Start = startloc.S_CODE;
			CntrCode = CntrRel.S_CNTR_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据托盘{partData.rfid},未找到托盘货位绑定关系";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点{End},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			//点对库区
			else if (taskData.taskType == 7)//异常位
			{
			note = "异常库区入库";
			//创建托盘物料绑定信息，并计算终点货位
			if (CreateCntrIteminfo(partData, taskData))
			{
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = taskData.pickStation;
			}
			var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == taskData.dropStation).ToList();
			if (EndLocs.Count > 0)
			{
			endloc = EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
			if (endloc != null)
			{
			End = endloc.S_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"终点库区：{taskData.dropStation}无可用货位";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}

			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点库区：{taskData.dropStation},未找到对应货位";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}
			}
			else if (taskData.taskType == 8)//叠盘机空托回库
			{
			note = "空托回库";//井松空托回库，需要与叠盘机安全交互
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = startloc.S_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据起点:{taskData.pickStation},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.dropStation).First();
			if (endloc != null)
			{
			End = taskData.dropStation;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点:{End},找不到对应货位，请检查货位表";
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			LogHelper.Info($"Createtask==> 任务类型有误");
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			result.msg = "任务类型：{taskData.taskType}不在规定范围内";
			AddErrorInfo("任务类型错误", result.msg, Source);
			}
			if (taskData.taskType != 4)
			{
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			if (startloc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg);
			return result;
			}
			var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE.Trim()).First();
			var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE.Trim()).First();
			if (startArea == null \|\| endArea == null)
			{
			LogHelper.Info($"起点：{JsonConvert.SerializeObject(startArea)}");
			LogHelper.Info($"终点：{JsonConvert.SerializeObject(endArea)}");
			result.code = "1";
			result.msg = $"创建任务失败，起点:{startloc.S_AREA_CODE},终点{endloc.S_AREA_CODE}未找到对应库区";
			AddErrorInfo("库区查找失败", result.msg);
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = startArea.S_NAME + "->" + endArea.S_NAME,
			S_EQ_NO = taskData.taskNum,
			S_START_LOC = Start,
			S_END_LOC = End,
			N_CNTR_COUNT = 1,
			S_START_WH = startloc.S_WH_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_PRIORITY = taskData.priority,
			Z_TYPE = n_type,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			S_WMS_NO = taskData.wmsTaskNo,
			S_NOTE = note,
			S_MES_NO = taskData.mesTaskNo

			};
			LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WCSHelper.CreateTask(wcsTask))
			{
			// LocationHelper.LockLoc(Start, 2);
			//LocationHelper.LockLoc(End, 1);
			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			}
			}


			return result;
			}
			@@ -672,6 +729,7 @@
			/// <returns></returns>
			internal static Result TrayItembind(TrayItembind model)
			{

			Result result = new Result() { code = "200", msg = "产出信息下发成功" };
			if (model == null)
			{
			@@ -680,29 +738,34 @@
			AddErrorInfo("参数为空", result.msg);
			return result;
			}
			try
			lock (_lockCreateItem)
			{
			//创建托盘数据绑定关系
			if (ContainerHelper.CreateCntrItem(model.Rfid, model.PartNumber, model.PartDesc, model.LotNumber, model.Weight, model.Qty))
			try
			{
			//创建成功流程
			}
			else
			{
			result.code = "1";
			result.msg = "产出信息下发失败，托盘物料绑定关系创建失败";
			AddErrorInfo("创建绑定关系失败", result.msg, "Mes");

			//创建托盘数据绑定关系
			if (ContainerHelper.CreateCntrItem(model.Rfid, model.PartNumber, model.PartDesc, model.LotNumber, model.Weight, model.Qty, model.ProductionTime, model.MaturityTime))
			{
			//创建成功流程
			}
			else
			{
			result.code = "1";
			result.msg = "产出信息下发失败，托盘物料绑定关系创建失败";
			AddErrorInfo("创建绑定关系失败", result.msg, "Mes");
			return result;
			}
			return result;
			}
			return result;
			catch (Exception ex)
			{
			result.code = "1";
			result.msg = ex.ToString();
			LogHelper.Error("TrayItembind Error：" + ex.ToString(), ex);
			return result;
			}
			}
			catch (Exception ex)
			{
			result.code = "1";
			result.msg = ex.ToString();
			LogHelper.Error("TrayItembind Error：" + ex.ToString(), ex);
			return result;
			}



			}
			@@ -736,6 +799,18 @@
			string areacode = "";
			try
			{

			#region 入库检查托盘物料表有无数据
			var cntritem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (cntritem == null)
			{
			result.code = "1";
			result.msg = $"创建任务失败，托盘:{model.Rfid}无绑定物料数据";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("托盘绑定物料数据为空", result.msg, Source);
			return result;
			}
			#endregion

			#region 判断托盘绑定货位是否和下发绑定起点相同,如果没绑定托盘则绑定托盘
			var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			@@ -791,23 +866,22 @@
			if (startloc != null)
			{
			//根据仓库计算库区
			if (startloc.S_WH_CODE == "101")
			var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
			if (whcode != null)
			{
			areacode = "PMGQ";
			areacode = whcode.PMK;
			}
			else
			{
			areacode = "PK2";
			result.code = "1";
			result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			areacode = "FLPK";

			//判断有无相同物料排
			loc = StorageCompute(itemcode, areacode);
			if (loc == null)
			{
			//无相同物料排找空排
			loc = emptyRow(areacode);
			}

			if (loc != null)
			{
			End = loc.S_CODE;
			@@ -819,6 +893,7 @@
			result.msg = $"库区:{areacode}无可用货位";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			}
			else
			@@ -828,6 +903,7 @@
			result.msg = $"任务起点:{Start}找不到对应货位，请检查货位表";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			#endregion

			@@ -863,9 +939,16 @@
			LogHelper.Info("创建入平库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(Start, 2);
			LocationHelper.LockLoc(End, 1);
			//LocationHelper.LockLoc(Start, 2);
			//LocationHelper.LockLoc(End, 1);
			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}
			else
			@@ -885,7 +968,6 @@
			LogHelper.Error("Putin Error：" + ex.ToString(), ex);
			return result;
			}

			}

			/// <summary>
			@@ -920,53 +1002,55 @@
			string areacode = "";
			var db = new SqlHelper<object>().GetInstance();
			#endregion

			try
			{

			#region 根据物料编码规则计算出库库区
			//粉料从平库出库，其他物料需要从暂存区出库
			if (model.PartNumber.StartsWith("4X"))
			var locJt = db.Queryable<Location>().Where(a => a.S_AREA_CODE == model.WorkCenter).First();
			if (locJt == null)
			{
			areacode = "FLPK";
			cntrType = "PM";
			result.code = "1";
			result.msg = $"根据机台编码：{model.WorkCenter}未找到对应货位";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			else
			//根据仓库计算库区
			var whcode = Settings.wareLoc.Where(a => a.AreaCode == locJt.S_WH_CODE).FirstOrDefault();
			if (whcode != null)
			{

			if (model.PartNumber.StartsWith("3"))
			if (model.PartNumber.StartsWith("4X"))
			{
			cntrType = "RC";
			areacode = "KJZCW";
			areacode = whcode.PMK;
			cntrType = "PM";
			}
			else
			{
			if (model.PartNumber.StartsWith("3"))
			{
			cntrType = "RC";
			areacode = whcode.ZCW;
			}
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("物料编码格式错误", result.msg, Source);
			return result;
			result.code = "1";
			result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("物料编码格式错误", result.msg, Source);
			return result;
			}
			}
			}
			//根据物料获取对应库区
			// var iteminfo = db.Queryable<TN_Material>().Where(a => a.S_ITEM_CODE.Trim() == itemcode).First();
			//if (iteminfo != null)
			//{
			// areacode = iteminfo.S_WH_CODE;
			//}
			//areacode = computeArea(itemcode);
			//if (string.IsNullOrEmpty(areacode))
			//{
			// LogHelper.Info($"PutOut==> 根据物料编码:{itemcode}找不到对应库区，请检查配置文件");
			// result.code = "1";
			// result.msg = $"根据物料编码:{itemcode}找不到对应库区，物料表配置";
			// AddErrorInfo("查找库区失败", result.msg);
			//}
			//if (itemcode == "测试1")
			//{
			// areacode = "PMJP";
			//}
			else
			{
			result.code = "1";
			result.msg = $"根据终点库区仓库编码：{locJt.S_WH_CODE}未找到对应配置文件";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			#endregion

			#region 根据物料编码计算出库货位，送往线边位置
			@@ -984,6 +1068,14 @@
			{
			End = Endloc.S_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"Computeloc==》根据机台编码：{model.WorkCenter},工装类型：{cntrType} 未找到空货位数据，请检查货位表";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			@@ -992,52 +1084,65 @@
			result.msg = $"任务物料:{itemcode}找不到对应库存";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			#endregion

			#region 任务创建
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			if (string.IsNullOrEmpty(Start))
			{
			if (loc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg, Source);
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "出平库",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = Start,
			S_END_LOC = End,
			S_START_WH = loc.S_WH_CODE,
			S_START_AREA = loc.S_AREA_CODE,
			S_END_WH = Endloc.S_WH_CODE,
			S_END_AREA = Endloc.S_AREA_CODE,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = n_type
			};
			LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			LogHelper.Info("创建任务成功");
			LocationHelper.LockLoc(Start, 2);
			LocationHelper.LockLoc(End, 1);
			}
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点";
			return result;
			}
			if (string.IsNullOrEmpty(End))
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的卸货点";
			return result;
			}
			if (loc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg, Source);
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "出平库",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = Start,
			S_END_LOC = End,
			S_START_WH = loc.S_WH_CODE,
			S_START_AREA = loc.S_AREA_CODE,
			S_END_WH = Endloc.S_WH_CODE,
			S_END_AREA = Endloc.S_AREA_CODE,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = CntrCode,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = n_type

			};
			LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			LogHelper.Info("创建任务成功");
			//LocationHelper.LockLoc(Start, 2);
			//LocationHelper.LockLoc(End, 1);
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}

			#endregion

			return result;
			@@ -1052,6 +1157,7 @@

			}

			public static object _lockEmpty = new object();
			/// <summary>
			/// 空工装回库
			/// </summary>
			@@ -1082,205 +1188,218 @@

			try
			{
			#region 判断托盘绑定货位是否和下发绑定起点相同
			var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (CntrLoc != null)
			lock (_lockEmpty)
			{
			if (CntrLoc.S_LOC_CODE != Start)
			#region 判断托盘绑定货位是否和下发绑定起点相同
			//var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			//if (CntrLoc != null)
			//{
			// if (CntrLoc.S_LOC_CODE != Start)
			// {
			// LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}");
			// result.code = "1";
			// result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
			// AddErrorInfo("托盘绑定位置不同", result.msg);
			// return result;
			// }
			//}
			//else
			//{
			// LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}未找到绑定货位");
			// result.code = "1";
			// result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
			// AddErrorInfo("查找托盘货位失败", result.msg);
			// return result;
			//}
			#endregion

			#region 根据货位楼层判断，3楼去往叠盘位其他的回库
			var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
			if (startloc != null)
			{
			LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}");
			if (startloc.N_LAYER == 3)
			{
			//叠盘货位计算叠盘货位
			// var dploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "叠盘" && a.N_LAYER == startloc.N_LAYER && a.S_WH_CODE.Trim() == startloc.S_WH_CODE && a.C_ENABLE == "Y").ToList();
			var dploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "叠盘" && a.N_LAYER == startloc.N_LAYER && a.S_WH_CODE.Trim() == startloc.S_WH_CODE ).ToList();
			if (dploc.Count > 0)
			{
			// LogHelper.Info($"获取叠盘货位:{JsonConvert.SerializeObject(dploc)}");
			loc = dploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
			if (loc == null)
			{
			LogHelper.Info($"三楼货位叠盘位，都已经有锁或者已经叠满，请检查货位状态");
			result.code = "1";
			result.msg = $"叠盘货位不可用，终点库区没有可用货位，请检查锁状态和数量";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			else
			{
			endlayer = loc.N_CURRENT_NUM + 1;
			}
			}
			else
			{
			// LogHelper.Info($"根据货位楼层：{startloc.N_LAYER}，仓库编码：{startloc.S_WH_CODE}，货位备注：叠盘，未找到叠盘货位");
			result.code = "1";
			result.msg = $"叠盘货位不可用，未找到可叠盘货位";
			LogHelper.Info($"根据货位备注：叠盘，货位楼层:{startloc.N_LAYER},货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			}
			else if (startloc.S_NOTE == "PB")
			{
			//找块胶堆叠区
			// var KjDploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "片胶堆叠位" && a.S_WH_CODE.Trim() == startloc.S_WH_CODE && a.C_ENABLE == "Y").ToList();
			var KjDploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "片胶堆叠位" && a.S_WH_CODE.Trim() == startloc.S_WH_CODE).ToList();
			if (KjDploc.Count > 0)
			{
			loc = KjDploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
			if (loc == null)
			{
			LogHelper.Info($"片胶堆叠位，都已经有锁或者已经叠满，请检查货位状态");
			result.code = "1";
			result.msg = $"叠盘货位不可用，终点库区没有可用货位，请检查锁状态和数量";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			else
			{
			endlayer = loc.N_CURRENT_NUM + 1;
			}
			}
			else
			{
			LogHelper.Info($"根据货位备注：片胶堆叠位,货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
			result.code = "1";
			result.msg = $"叠盘货位不可用";
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			#region 根据起点货位类型，获得回库库区
			//根据仓库计算库区
			var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
			if (whcode != null)
			{
			if (string.IsNullOrEmpty(startloc.S_NOTE))
			{
			areacode = whcode.PMK;
			}
			}
			else
			{
			result.code = "1";
			result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
			LogHelper.Info($" {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			#endregion

			//回库货位计算库区货位
			loc = StorageCompute(itemcode, areacode);
			if (loc == null)
			{
			loc = emptyRow(areacode);
			if (loc == null)
			{
			result.code = "1";
			result.msg = $"库区：{areacode}没有可用货位";
			LogHelper.Info($" {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			// LogHelper.Info($"库区：{areacode}没有可用货位");
			}
			}
			//else
			//{

			// result.code = "1";
			// result.msg = $"库区:{areacode}无可用货位";
			// LogHelper.Info($"{result.msg}");
			// AddErrorInfo("查找货位失败", result.msg, Source);
			// return result;
			//}
			}

			}
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
			AddErrorInfo("托盘绑定位置不同", result.msg);
			result.msg = $"Empty==> 任务起点:{Start}找不到对应货位，请检查货位表";
			LogHelper.Info($"{result.msg}");
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			LogHelper.Info($"ItemBack：创建任务失败，托盘:{model.Rfid}未找到绑定货位");
			result.code = "1";
			result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
			AddErrorInfo("查找托盘货位失败", result.msg);
			return result;
			}
			#endregion
			#endregion

			#region 根据货位楼层判断，3楼去往叠盘位其他的回库
			var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
			if (startloc != null)
			{
			if (startloc.N_LAYER == 3)
			#region 创建任务
			if (startloc != null && loc != null)
			{
			//叠盘货位计算叠盘货位
			var dploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "叠盘" && a.N_LAYER == startloc.N_LAYER && a.S_WH_CODE.Trim() == startloc.S_WH_CODE).ToList();
			if (dploc.Count > 0)
			if (startloc.N_LOCK_STATE != 0 && loc.N_LOCK_STATE != 0)
			{
			// LogHelper.Info($"获取叠盘货位:{JsonConvert.SerializeObject(dploc)}");
			loc = dploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
			if (loc == null)
			{
			result.code = "1";
			result.msg = $"叠盘货位不可用";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			else
			{
			endlayer = loc.N_CURRENT_NUM + 1;
			}
			}
			else
			{

			result.code = "1";
			result.msg = $"叠盘货位不可用";
			LogHelper.Info($"根据货位备注：叠盘，货位楼层:{startloc.N_LAYER},货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
			AddErrorInfo("查找货位失败", result.msg, Source);
			result.msg = $"创建任务失败，起点货位状态{startloc.N_LOCK_STATE},起点货位状态：{loc.N_LOCK_STATE}";
			AddErrorInfo("货位有锁", result.msg);
			return result;
			}
			}
			else if (startloc.S_NOTE == "PM")
			{
			//找块胶堆叠区
			var KjDploc = db.Queryable<Location>().Where(a => a.S_NOTE.Trim() == "片胶堆叠位" && a.S_WH_CODE.Trim() == startloc.S_WH_CODE).ToList();
			if (KjDploc.Count > 0)
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			loc = KjDploc.FindAll(a => a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM < 6).OrderByDescending(a => a.N_CURRENT_NUM).FirstOrDefault();
			if (loc == null)
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "空工装回库",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = loc.S_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = loc.S_WH_CODE,
			S_END_AREA = loc.S_AREA_CODE,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = model.Rfid,
			N_START_LAYER = 1,
			N_END_LAYER = endlayer,
			Z_TYPE = 5
			};
			LogHelper.Info("创建空托回库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			//LocationHelper.LockLoc(startloc.S_CODE, 2);
			//LocationHelper.LockLoc(loc.S_CODE, 1);
			// 空托回库判断托盘有无绑定物料信息如果有则删除
			var itemcntr = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (itemcntr != null) { db.Deleteable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).ExecuteCommand(); }
			var container = db.Queryable<Container>().Where(a => a.S_CODE.Trim() == model.Rfid).First();
			if (container == null)
			{
			result.code = "1";
			result.msg = $"叠盘货位不可用";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			container = new Container { S_CODE = model.Rfid };
			db.Insertable<Container>(container).ExecuteCommand();
			}
			else
			{
			endlayer = loc.N_CURRENT_NUM + 1;
			}
			LogHelper.Info("创建任务成功");
			}
			else
			{
			LogHelper.Info($"根据货位备注：片胶堆叠位,货位仓库:{startloc.S_WH_CODE}，找不到叠盘货位");
			result.code = "1";
			result.msg = $"叠盘货位不可用";
			AddErrorInfo("查找货位失败", result.msg, Source);
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			#region 根据托盘找呼叫空托任务，并获得出库库区
			msts = WCSHelper.GetTaskBycntrcode(model.Rfid.Trim());
			if (msts.Count() > 0)
			{
			msts.RemoveAll(a => string.IsNullOrEmpty(a.S_CNTR_CODE));
			mst = msts.OrderByDescending(a => a.T_CREATE).FirstOrDefault();
			}
			if (mst != null)
			{
			LogHelper.Info($"找到出库任务：{JsonConvert.SerializeObject(mst)}");
			areacode = mst.S_START_AREA;
			}
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，根据托盘编码{model.Rfid}未找到托盘出库任务";
			LogHelper.Info($"{result.msg}");
			AddErrorInfo("查找任务失败", result.msg, Source);
			return result;
			}
			if (string.IsNullOrEmpty(areacode))
			{

			result.code = "1";
			result.msg = $"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空";
			LogHelper.Info($"{result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			#endregion

			//回库货位计算库区货位
			loc = StorageCompute(itemcode, areacode);
			if (loc == null)
			{
			loc = emptyRow(areacode);
			if (loc == null)
			{
			LogHelper.Info($"库区：{areacode}没有空排");
			}
			}
			else
			{

			result.code = "1";
			result.msg = $"库区:{areacode}无可用货位";
			LogHelper.Info($"{result.msg}");
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			}

			}
			else
			{

			result.code = "1";
			result.msg = $"Empty==> 任务起点:{Start}找不到对应货位，请检查货位表";
			LogHelper.Info($"{result.msg}");
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			#endregion

			#region 创建任务
			if (!string.IsNullOrEmpty(Start) && loc != null)
			{
			if (startloc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg);
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "空工装回库",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = Start,
			S_END_LOC = loc.S_CODE,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = loc.S_WH_CODE,
			S_END_AREA = loc.S_AREA_CODE,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = model.Rfid,
			N_START_LAYER = 1,
			N_END_LAYER = endlayer,
			Z_TYPE = 5
			};
			LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(Start, 2);
			LocationHelper.LockLoc(loc.S_CODE, 1);
			// 空托回库判断托盘有无绑定物料信息如果有则删除
			var itemcntr = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (itemcntr != null) { db.Deleteable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).ExecuteCommand(); }
			LogHelper.Info("创建任务成功");
			}
			#endregion
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			#endregion

			}
			catch (Exception ex)
			{
			@@ -1292,6 +1411,8 @@

			return result;
			}

			public static object _lockcallfixture = new object();

			/// <summary>
			/// 空工装呼叫
			@@ -1314,108 +1435,131 @@
			#region 变量
			string Start = "";
			string End = model.TargetLocation;
			string itemcode = "";

			string areacode = "";
			string cntrcode = "";
			Location startloc = new Location();
			// startloc = LocationHelper.GetLocByAreacode(areacode, model.CarrierType);
			#endregion

			try
			{
			#region 根据仓库编码判断库区并计算出库货位
			var endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == End).First();
			if (endloc != null)
			lock (_lockcallfixture)
			{
			if (endloc.S_WH_CODE == "101")
			#region 根据仓库编码判断库区并计算出库货位
			var endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == End).First();
			//根据仓库计算库区
			if (endloc != null)
			{
			// itemcode = "TP";
			areacode = "PMGQ";
			}
			else
			{
			//itemcode = "TP";
			areacode = "PK2";
			}
			areacode = "FLPK";
			//计算出库托盘
			startloc = airlift(areacode, itemcode);
			if (startloc != null)
			{
			var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
			if (cntr != null)
			var whcode = Settings.wareLoc.Where(a => a.AreaCode == endloc.S_WH_CODE).FirstOrDefault();
			if (whcode != null)
			{
			Start = cntr.S_LOC_CODE;
			cntrcode = cntr.S_CNTR_CODE;
			areacode = whcode.PMK;
			}
			else
			{
			result.code = "1";
			result.msg = $"创建空工装呼叫任务==>根据货位{endloc.S_CODE}未找到托盘货位绑定关系";
			result.msg = $"根据起点仓库编码：{endloc.S_WH_CODE}未找到对应配置文件";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}

			//计算出库托盘
			startloc = LocationHelper.GetLocByAreacode(areacode, model.CarrierType);
			if (startloc != null)
			{
			var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
			if (cntr != null)
			{
			Start = cntr.S_LOC_CODE;
			cntrcode = cntr.S_CNTR_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"创建空工装呼叫任务==>根据货位{endloc.S_CODE}未找到托盘货位绑定关系";
			LogHelper.Info($"callfixture:{result.msg}");
			AddErrorInfo("查找托盘失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = $"创建空工装呼叫任务==>根据库区：{areacode}，托盘类型：{model.CarrierType}找不到对应空托";
			LogHelper.Info($"callfixture:{result.msg}");
			AddErrorInfo("查找托盘失败", result.msg, Source);
			return result;
			}

			}

			}
			else
			{

			result.code = "1";
			result.msg = $"任务起点:{End}找不到对应货位，请检查货位表";
			LogHelper.Info($"callfixture:{result.msg}");
			AddErrorInfo("查找货位失败", result.msg, Source);

			}
			#endregion

			#region 创建任务
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			if (startloc.N_LOCK_STATE != 0)
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg);
			result.msg = $"任务起点:{End}找不到对应货位，请检查货位表";
			LogHelper.Info($"callfixture:{result.msg}");
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "空工装呼叫",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = Start,
			S_END_LOC = End,
			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,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = cntrcode,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = 5
			#endregion

			};
			LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			#region 创建任务
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			LocationHelper.LockLoc(Start, 2);
			LocationHelper.LockLoc(End, 1);
			LogHelper.Info("创建任务成功");
			if (startloc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg);
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "空工装呼叫",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = Start,
			S_END_LOC = End,
			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,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = cntrcode,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = 5,
			S_NOTE = "粉料"
			};
			LogHelper.Info("创建呼叫空托任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			//LocationHelper.LockLoc(Start, 2);
			//LocationHelper.LockLoc(End, 1);
			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			return result;
			#endregion
			}
			return result;
			#endregion


			}
			catch (Exception ex)
			@@ -1430,6 +1574,7 @@

			}

			public static object _lockItemBack = new object();
			/// <summary>
			/// 余料返回
			/// </summary>
			@@ -1461,93 +1606,122 @@

			try
			{
			#region 判断托盘绑定货位是否和下发绑定起点相同
			var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (CntrLoc != null)
			lock (_lockItemBack)
			{
			if (CntrLoc.S_LOC_CODE != Start)
			#region 余料返回根据托盘找出库任务
			//余料返回根据托盘找出库任务
			//msts = WCSHelper.GetTaskBycntrcode(model.Rfid);
			//if (msts.Count() > 0)
			//{
			// msts.RemoveAll(a => string.IsNullOrEmpty(a.S_CNTR_CODE));
			// mst = msts.OrderByDescending(a => a.T_CREATE).FirstOrDefault();
			//}
			//if (mst != null)
			//{
			// areacode = mst.S_START_AREA;
			//}
			//else
			//{
			// result.code = "1";
			// result.msg = $"创建任务失败，根据托盘编码{model.Rfid}未找到托盘出库任务";
			// AddErrorInfo("查找任务失败", result.msg);
			// return result;
			//}
			//if (string.IsNullOrEmpty(areacode))
			//{
			// LogHelper.Info($"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空");
			// result.code = "1";
			// result.msg = $"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空";
			// AddErrorInfo("查找库区失败", result.msg);
			// return result;
			//}
			#endregion

			#region 判断托盘绑定货位是否和下发绑定起点相同
			var CntrLoc = db.Queryable<LocCntrRel>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (CntrLoc != null)
			{

			result.code = "1";
			result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("托盘绑定位置不同", result.msg, Source);
			return result;
			}
			}
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，托盘:{model.Rfid}未找到绑定货位";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("查找托盘货位失败", result.msg, Source);
			return result;
			}
			#endregion

			#region 余料返回根据托盘找出库任务
			//余料返回根据托盘找出库任务
			//msts = WCSHelper.GetTaskBycntrcode(model.Rfid);
			//if (msts.Count() > 0)
			//{
			// msts.RemoveAll(a => string.IsNullOrEmpty(a.S_CNTR_CODE));
			// mst = msts.OrderByDescending(a => a.T_CREATE).FirstOrDefault();
			//}
			//if (mst != null)
			//{
			// areacode = mst.S_START_AREA;
			//}
			//else
			//{
			// result.code = "1";
			// result.msg = $"创建任务失败，根据托盘编码{model.Rfid}未找到托盘出库任务";
			// AddErrorInfo("查找任务失败", result.msg);
			// return result;
			//}
			//if (string.IsNullOrEmpty(areacode))
			//{
			// LogHelper.Info($"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空");
			// result.code = "1";
			// result.msg = $"创建任务失败，根据托盘编码{model.Rfid}找到出库任务{mst.S_CODE}的起点库区为空";
			// AddErrorInfo("查找库区失败", result.msg);
			// return result;
			//}
			#endregion

			#region 根据物料编码判断回库还是回到对应暂存区
			var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
			if (startloc != null)
			{
			//粉料直接回库，其他物料需要去对应的暂存区
			if (model.PartNumber.StartsWith("4X"))
			{
			areacode = "FLPK";
			loc = StorageCompute(itemcode, areacode);
			if (loc == null)
			if (CntrLoc.S_LOC_CODE != Start)
			{
			loc = emptyRow(areacode);

			result.code = "1";
			result.msg = $"创建任务失败，托盘:{model.Rfid}绑定位置不是起点：{Start}";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("托盘绑定位置不同", result.msg, Source);
			return result;
			}
			}
			else
			{
			if (model.PartNumber.StartsWith("3"))
			if (db.Insertable(new LocCntrRel() { S_CNTR_CODE = model.Rfid, S_LOC_CODE = Start }).ExecuteCommand() <= 0)
			{
			areacode = "KJYLZCW";
			}
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
			result.msg = $"创建任务失败，托盘:{model.Rfid}绑定货位{Start}失败";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("物料编码格式错误", result.msg, Source);
			AddErrorInfo("托盘绑定货位失败", result.msg, Source);
			return result;
			}
			var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == areacode).ToList();
			if (EndLocs.Count > 0)

			}
			#endregion

			#region 根据物料编码判断回库还是回到对应暂存区
			var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == Start).First();
			if (startloc != null)
			{
			var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
			if (whcode != null)
			{
			loc = EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
			//粉料直接回库，其他物料需要去对应的暂存区
			#region 根据物料判断回库库区
			if (model.PartNumber.StartsWith("4X"))
			{
			areacode = whcode.PMK;
			//loc = StorageCompute(itemcode, areacode);
			//if (loc == null)
			//{
			// loc = emptyRow(areacode);
			//}
			}
			else
			{


			if (model.PartNumber.StartsWith("3"))
			{
			areacode = whcode.ZCW;
			}
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("物料编码格式错误", result.msg, Source);
			return result;
			}


			}
			#endregion


			var EndLocs = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == areacode).ToList();
			//查找货位库区
			if (EndLocs.Count > 0)
			{
			//loc = EndLocs.Find(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0);
			loc = FindEndcolByLocList(EndLocs);

			}
			else
			{
			result.code = "1";
			result.msg = $"根据终点库区：{areacode},未找到对应货位";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}

			if (loc != null)
			{
			End = loc.S_CODE;
			@@ -1555,105 +1729,118 @@
			else
			{
			result.code = "1";
			result.msg = $"终点库区：{areacode}无可用货位";
			AddErrorInfo("查找库区失败", result.msg, Source);
			result.msg = $"库区:{areacode}无可用货位";
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}

			}
			else
			{

			result.code = "1";
			result.msg = $"根据终点库区：{areacode},未找到对应货位";
			result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}
			//loc = StorageCompute(itemcode, areacode);
			//if (loc == null)
			//{
			// loc = emptyRow(areacode);
			//}
			}
			if (loc != null)
			{
			End = loc.S_CODE;

			}
			else
			{

			result.code = "1";
			result.msg = $"库区:{areacode}无可用货位";
			result.msg = $"货位:{Start}找不到对应货位";
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			}
			else
			{

			result.code = "1";
			result.msg = $"货位:{Start}找不到对应货位";
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			#endregion

			#endregion
			#region 创建任务
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			if (startloc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg);
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "余料返回",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = Start,
			S_END_LOC = End,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = loc.S_WH_CODE,
			S_END_AREA = loc.S_AREA_CODE,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = model.Rfid,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = 5

			#region 创建任务
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			if (startloc.N_LOCK_STATE != 0)
			};
			LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			//LocationHelper.LockLoc(Start, 2);
			//LocationHelper.LockLoc(End, 1);
			//创建任务成功更新余料信息
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (CntrItem != null)
			{
			CntrItem.F_WEIGHT = model.LotList[0].Weight.ToString();
			CntrItem.S_BS_TYPE = "余料";
			CntrItem.F_QTY = float.Parse(model.LotList[0].qty);
			CntrItem.S_ITEM_STATE = model.LotList[0].QualityStatus;

			db.Updateable(CntrItem).UpdateColumns(a => new { a.F_WEIGHT, a.S_BS_TYPE }).ExecuteCommand();
			}
			else
			{
			var cir = new CntrItemDetail
			{
			S_CNTR_CODE = model.Rfid,
			S_ITEM_CODE = itemcode,
			S_ITEM_NAME = model.PartNumber,
			S_ITEM_SPEC = model.PartDesc,
			F_QTY = float.Parse(model.LotList[0].qty),
			S_BS_TYPE = "余料",
			F_WEIGHT = model.LotList[0].Weight.ToString(),
			S_ITEM_STATE = model.LotList[0].QualityStatus,
			D_EXP_DATE = model.LotList[0].MaturityTime,
			D_PRD_DATE = model.LotList[0].ProductionTime
			};
			db.Insertable<CntrItemDetail>(cir).ExecuteCommand();
			}
			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{Start}有锁";
			AddErrorInfo("货位有锁", result.msg);
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			//创建wcs任务
			var wcsTask = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "余料返回",
			S_EQ_NO = model.TaskNumber,
			S_START_LOC = Start,
			S_END_LOC = End,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_END_WH = loc.S_WH_CODE,
			S_END_AREA = loc.S_AREA_CODE,
			N_CNTR_COUNT = 1,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = model.Rfid,
			N_START_LAYER = 1,
			N_END_LAYER = 1,
			Z_TYPE = 5

			};
			LogHelper.Info("创建出平库任务：" + JsonConvert.SerializeObject(wcsTask));
			if (WCSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(Start, 2);
			LocationHelper.LockLoc(End, 1);
			//创建任务成功更新余料信息
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == model.Rfid).First();
			if (CntrItem != null)
			{
			CntrItem.F_WEIGHT = model.LotList[0].Weight.ToString();
			CntrItem.S_BS_TYPE = "余料";
			CntrItem.F_QTY = float.Parse(model.LotList[0].qty);
			CntrItem.S_ITEM_STATE = model.LotList[0].QualityStatus;

			db.Updateable(CntrItem).UpdateColumns(a => new { a.F_WEIGHT, a.S_BS_TYPE }).ExecuteCommand();
			}
			LogHelper.Info("创建任务成功");
			}
			#endregion
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			#endregion




			return result;
			}
			@@ -1760,10 +1947,11 @@
			itemInfo.REMARK1 = model.StewingTime;
			itemInfo.REMARK2 = model.OverdueTime;
			itemInfo.S_MP_TYPE = model.Unit;
			if (db.Insertable<TN_Material>(itemInfo).ExecuteCommand()>0)
			if (db.Insertable<TN_Material>(itemInfo).ExecuteCommand() > 0)
			{
			LogHelper.Info($"add:物料编码:{model.PartNumber}的物料主数据已同步");
			} ;
			}
			;
			return result;
			}
			catch (Exception ex)
			@@ -1857,9 +2045,16 @@
			LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WCSHelper.CreateTask(wcsTask))
			{
			LocationHelper.LockLoc(Start, 2);
			LocationHelper.LockLoc(End, 1);
			//LocationHelper.LockLoc(Start, 2);
			//LocationHelper.LockLoc(End, 1);
			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			}
			else
			@@ -1889,11 +2084,11 @@
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			internal static Result CreatelevatorTask(Elevator model)
			internal static Result CreatelevatorTask(ElevatorModel model)
			{
			Result result = new Result() { code = "200", msg = "点对点任务创建成功" };
			string Source = "MES";
			if (model == null)
			Result result = new Result() { code = "200", msg = "电梯搬运任务创建成功" };
			string Source = "WMS";
			if (model.Data == null)
			{
			result.code = "1";
			result.msg = "参数为null";
			@@ -1907,6 +2102,7 @@

			var startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == model.Data.start_loc_code).First();

			// var endloc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == model.Data.end_loc_code && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y").First();
			var endloc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == model.Data.end_loc_code && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0).First();


			@@ -1916,11 +2112,10 @@
			if (startloc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点{startloc.S_CODE}有锁";
			result.msg = $"创建任务失败，起点{startloc.S_CODE}有锁，电梯有其他任务，请等待电梯任务完成";
			AddErrorInfo("货位有锁", result.msg, Source);
			return result;
			}

			var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == startloc.S_CODE).First();
			if (cntr == null)
			{
			@@ -1935,48 +2130,30 @@
			// var startArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == startloc.S_AREA_CODE).First();
			//var endArea = db.Queryable<Area>().Where(a => a.S_CODE.Trim() == endloc.S_AREA_CODE).First();

			string dtcode = "DT-01";
			//楼层电梯分配
			var Diantiloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == dtcode).First();
			if (Diantiloc == null)
			{
			result.code = "1";
			result.msg = $"创建任务失败，根据货位编码:{dtcode}未找到电梯货位";
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			//string dtcode = "DT-01";
			////楼层电梯分配
			//var Diantiloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == dtcode).First();
			//if (Diantiloc == null)
			//{
			// result.code = "1";
			// result.msg = $"创建任务失败，根据货位编码:{dtcode}未找到电梯货位";
			// AddErrorInfo("查找货位失败", result.msg, Source);
			// return result;
			//}

			//根据电梯数量判断送往哪个电梯（具体电梯流程根据现场电梯数量）
			//根据任务数量判断送往哪个电梯（具体电梯流程根据现场电梯数量）
			var elevatorLoc = LocationHelper.GetElevatorLoc();

			//创建wcs分段任务
			var wcsTask = new WCSTask
			{

			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "电梯1",
			S_EQ_NO = model.Data.task_no,
			S_START_LOC = startloc.S_CODE,
			S_END_LOC = Diantiloc.S_CODE,
			N_CNTR_COUNT = 1,
			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,
			N_SCHEDULE_TYPE = 1,
			S_CNTR_CODE = cntr.S_CNTR_CODE,
			N_END_LAYER = 1,
			Z_TYPE = 6
			};
			var wcsTask1 = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "电梯2",
			S_EQ_NO = model.Data.task_no,
			S_START_LOC = Diantiloc.S_CODE,
			S_START_LOC = elevatorLoc.S_CODE,
			S_END_LOC = endloc.S_CODE,
			N_CNTR_COUNT = 1,
			S_START_WH = startloc.S_WH_CODE,
			S_START_AREA = startloc.S_AREA_CODE,
			S_START_WH = elevatorLoc.S_WH_CODE,
			S_START_AREA = elevatorLoc.S_AREA_CODE,
			S_END_WH = endloc.S_WH_CODE,
			S_END_AREA = endloc.S_AREA_CODE,
			N_SCHEDULE_TYPE = 1,
			@@ -1985,13 +2162,41 @@
			Z_TYPE = 6
			};

			LogHelper.Info("创建任务：" + JsonConvert.SerializeObject(wcsTask), "CreateTask");
			if (WCSHelper.CreateTask(wcsTask) && WCSHelper.CreateTask(wcsTask1))
			{

			LocationHelper.LockLoc(startloc.S_CODE, 2);
			LocationHelper.LockLoc(endloc.S_CODE, 1);
			if (WCSHelper.CreateTask(wcsTask))
			{
			LogHelper.Info("创建任务成功");
			var device = Settings.deviceInfos.Where(a => a.TN_Location == startloc.S_CODE).FirstOrDefault();
			var loc = LocationHelper.GetLocByLoc(endloc.S_CODE);
			if (device == null)
			{
			LogHelper.Info($"根据任务起点:{startloc.S_CODE},未找到对应电梯配置文件");
			}
			if (loc == null)
			{
			LogHelper.Info($"根据任务起点:{endloc.S_CODE},未找到对应货位");
			}
			if (device != null && loc != null)
			{
			int value = 0;
			if (loc.N_LAYER == 1) value = 1;
			else if (loc.N_LAYER == 2) value = 3;
			else if (loc.N_LAYER == 3) value = 5;

			ModbusHelper.WriteSingleRegister(40089, value, device.address, 1024);
			ModbusHelper.WriteSingleRegister(40102, 1, device.address, 1024);
			}

			//LocationHelper.LockLoc(startloc.S_CODE, 2);
			//LocationHelper.LockLoc(endloc.S_CODE, 1);

			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}

			}
			@@ -2008,7 +2213,7 @@
			{

			result.code = "1";
			result.msg = $"物料主数据创建失败错误信息：{ex}";
			result.msg = $"电梯搬运任务创建失败错误信息：{ex}";
			LogHelper.Error("点对点任务 Error：" + ex.ToString(), ex);
			return result;
			}
			@@ -2084,7 +2289,80 @@
			return result;
			}

			/// <summary>
			/// 库位清空
			/// </summary>
			/// <param name="model"></param>
			/// <returns></returns>
			internal static Result ClearLocCntr(ClearTask model)
			{
			Result result = new Result() { code = "200", msg = "库位清除成功" };
			string Source = "MES";
			if (model == null)
			{
			result.code = "1";
			result.msg = "参数为null";
			AddErrorInfo("参数为空", result.msg, Source);
			return result;
			}
			string loc = model.LocationNum;
			var db = new SqlHelper<object>().GetInstance();
			lock (_lockCreateItem)
			{
			try
			{
			var location = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == loc).First();
			if (location != null)
			{
			var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).First();

			if (loccntr != null)
			{
			string cntrcode = loccntr.S_CNTR_CODE;
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
			if (CntrItem != null)
			{
			//清除托盘物料绑定关系
			db.Deleteable<CntrItemDetail>().Where(it => it.S_CNTR_CODE.Trim() == CntrItem.S_CNTR_CODE).ExecuteCommand();
			}
			else
			{
			LogHelper.Info($"ClearLocCntr 托盘{cntrcode}无物料绑定关系");
			}
			if (LocationHelper.UnBindingLoc(loc, new List<string>() { cntrcode }))
			{
			LogHelper.Info($"清除托盘货位关系成功");
			}

			}
			else
			{
			LogHelper.Info($"ClearLocCntr 货位{loc}无托盘货位绑定关系");
			}
			}
			else
			{
			result.code = "1";
			result.msg = $"根据货位:{loc}找不到货位关系";
			AddErrorInfo("货位为空", result.msg, Source);
			return result;
			}
			}
			catch (Exception ex)
			{
			LogHelper.Info($"ClearLocCntr Error：{ex}");
			db.Ado.CommitTran();
			result.code = "1";
			result.msg = $"Error：{ex}";
			return result;

			}
			}



			return result;
			}
			/// <summary>
			/// 库位清空
			/// </summary>
			@@ -2108,31 +2386,48 @@
			var location = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == loc).First();
			if (location != null)
			{
			var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).First();

			if (loccntr != null)
			var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).ToList();
			if (loccntr.Count > 0)
			{

			string cntrcode = loccntr.S_CNTR_CODE;
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
			if (CntrItem != null)
			foreach (var item in loccntr)
			{
			string cntrcode = item.S_CNTR_CODE;
			LocationHelper.UnBindingLoc(loc, new List<string>() { cntrcode });
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
			if (CntrItem != null)
			{
			db.Deleteable<Container>().Where(it => it.S_CODE == item.S_CNTR_CODE).ExecuteCommand();
			// db.Deleteable<LocCntrRel>().Where(it => it.S_LOC_CODE.Trim() == loc).ExecuteCommand();
			if (db.Deleteable<CntrItemDetail>().Where(it => it.S_CNTR_CODE == cntrcode).ExecuteCommand() > 0)
			{
			LogHelper.Info($"ClearLoc 库位清除成功");
			}
			else
			{
			LogHelper.Info($"ClearLoc 库位清除失败");
			result.code = "1";
			result.msg = "库位清除失败";
			AddErrorInfo("库位清除失败", result.msg, Source);
			return result;
			}
			}
			else
			{
			LogHelper.Info($"库区清空=》托盘:{cntrcode}无物料数据");

			LocationHelper.UnBindingLoc(loc, new List<string>() { "cntrcode" });
			// db.Deleteable<LocCntrRel>().Where(it => it.S_LOC_CODE.Trim() == loc).ExecuteCommand();
			db.Deleteable<CntrItemDetail>().Where(it => it.S_CNTR_CODE.Trim() == cntrcode).ExecuteCommand();

			}
			else
			{
			LogHelper.Info($"ClearLoc 托盘{cntrcode}无物料绑定关系");
			}
			}

			}
			else
			{
			LogHelper.Info($"ClearLoc 货位{loc}无托盘货位绑定关系");
			result.code = "1";
			result.msg = $" ClearLoc 货位{loc}无托盘货位绑定关系";
			AddErrorInfo("库位清除失败", result.msg, Source);
			return result;

			}

			}
			else
			{
			@@ -2154,10 +2449,104 @@

			return result;
			}
			/// <summary>
			/// 设备状态上报
			/// </summary>
			/// <returns></returns>
			internal static DeviceInfoModel Device()
			{
			var db = new SqlHelper<HangChaAGV>().GetInstance();
			DeviceInfoModel device = new DeviceInfoModel();

			List<DeviceInfos> deviceInfos = new List<DeviceInfos>();//叠盘机报错信息
			// List<AgvInfos> agvInfos = new List<AgvInfos>();//agv报错信息

			//获取内存中叠盘机的报错信息
			foreach (var dpjInfo in DeviceProcess.DpjInfoDirectory)
			{
			deviceInfos.Add(new DeviceInfos() { Device = dpjInfo.Value.DeviceName, DeviceInfo = dpjInfo.Value.ErrorInfo });
			}
			// device.DeviceInfos = deviceInfos;
			//获取车辆报警信息
			var agvDeviceInfo = db.Queryable<HangChaAGV>().ToList();
			if (agvDeviceInfo.Count > 0)
			{
			device.AgvQty = agvDeviceInfo.Count;
			device.AgvErrorQty = agvDeviceInfo.FindAll(a => a.agvErrCode != "0" \|\| a.agvErrCode != "0" \|\| a.faildCode != "0").Count;
			device.AgvChargeQty = agvDeviceInfo.FindAll(a => a.agvErrCode == "1").Count;
			device.AgvRunQty = agvDeviceInfo.FindAll(a => a.agvErrCode == "1").Count;
			foreach (var agv in agvDeviceInfo)
			{
			string agvErrorInfo = GetAgvAlarmSendCodeTwo(agv.agvErrCode, agv.errCode2, agv.faildCode);
			deviceInfos.Add(new DeviceInfos() { AgvNo = agv.agvNo, AgvInfo = agvErrorInfo });
			}
			}
			device.DeviceInfos = deviceInfos;

			return device;
			}

			/// <summary>
			/// agv小车故障码处理
			/// </summary>
			/// <param name="errCode1">错误码1</param>
			/// <param name="errCode2">错误码2</param>
			/// <param name="faildCode">错误码3</param>
			/// <returns></returns>
			private static string GetAgvAlarmSendCodeTwo(string errCode1, string errCode2, string faildCode)
			{
			string result = "";
			//将报警信息整合
			string binSW1 = Convert.ToString(int.Parse(errCode1), 2).PadLeft(22, '0');
			string binSW2 = Convert.ToString(int.Parse(errCode1), 2).PadLeft(20, '0');
			string binFc = Convert.ToString(int.Parse(errCode1), 2).PadLeft(16, '0');
			var arr1 = binSW1.ToArray();
			var arr2 = binSW2.ToArray();
			var arr3 = binFc.ToArray();

			for (int i = 0; i <= arr1.Length; i++)
			{
			if (arr1[i] == '1')
			{
			var ErrorInfo = Settings.agvErrorCode1.Where(a => a.ErrorCode == i).FirstOrDefault();
			if (ErrorInfo != null)
			{
			result = result + "," + $"{ErrorInfo.ErrorInfo}";
			}

			}
			}
			for (int i = 0; i <= arr2.Length; i++)
			{
			if (arr1[i] == '1')
			{
			var ErrorInfo = Settings.agvErrorCode2.Where(a => a.ErrorCode == i).FirstOrDefault();
			if (ErrorInfo != null)
			{
			result = result + "," + $"{ErrorInfo.ErrorInfo}";
			}

			}
			}
			for (int i = 0; i <= arr3.Length; i++)
			{
			if (arr1[i] == '1')
			{
			var ErrorInfo = Settings.agvFaildCode.Where(a => a.ErrorCode == i).FirstOrDefault();
			if (ErrorInfo != null)
			{
			result = result + "," + $"{ErrorInfo.ErrorInfo}";
			}

			}
			}
			return result;
			}
			#endregion

			#region 合肥佳通业务方法


			/// <summary>
			/// 托盘入库算法
			/// </summary>
			@@ -2167,53 +2556,56 @@
			internal static Location StorageCompute(string itemcode, string areacode)
			{
			var db = new SqlHelper<object>().GetInstance();
			Location result = null;
			//查询所有有托盘的排
			var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE.Trim() == areacode).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
			if (list.Count > 0)
			{
			for (int i = 0; i < list.Count; i++)
			{
			LogHelper.Info($"有托盘排号{list[i].N_ROW}，物料编码{itemcode},库区{areacode}");
			//判断托盘物料是否相同物料信息相同
			var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == list[i].S_CODE).First();
			if (cntr != null)
			{
			if (string.IsNullOrEmpty(itemcode))//空托入库
			{
			var iteminfo = ContainerHelper.GetCntrItemRel(cntr.S_CNTR_CODE).FirstOrDefault();
			if (iteminfo == null)
			{
			//物料相同入货位后一位货位
			result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE.Trim() == areacode && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL).First();
			}
			}
			else//满拖入库
			{
			var iteminfo = ContainerHelper.GetCntrItemRel(cntr.S_CNTR_CODE).FirstOrDefault();
			if (iteminfo != null)
			{
			if (iteminfo.S_ITEM_CODE == itemcode)
			{
			//物料相同入货位后一位货位
			result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE.Trim() == areacode && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL).First();
			// Location result = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM == 0 && a.S_AREA_CODE.Trim() == areacode && a.N_LOCK_STATE == 0 ).First();
			Location result = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM == 0 && a.S_AREA_CODE.Trim() == areacode && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y").First();
			//查询所有有托盘的排没锁的排
			// var list = db.Queryable<Location>().Where(a => a.N_CURRENT_NUM > 0 && a.S_AREA_CODE.Trim() == areacode && a.N_LOCK_STATE == 0).OrderByDescending(a => a.N_COL).Take(1).PartitionBy(a => a.N_ROW).ToList();
			// if (list.Count > 0)
			//{
			// for (int i = 0; i < list.Count; i++)
			// {
			// LogHelper.Info($"有托盘排号{list[i].N_ROW}，物料编码{itemcode},库区{areacode}");
			// //查询货位绑定托盘
			// var cntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == list[i].S_CODE).First();
			// if (cntr != null)
			// {
			// //查询托盘物料信息
			// var iteminfo = ContainerHelper.GetCntrItemRel(cntr.S_CNTR_CODE).FirstOrDefault();

			}
			}
			}
			if (result != null)
			{
			return result;
			}
			}
			else
			{
			LogHelper.Info($"根据货物编码{list[i].S_CODE}未找到托盘货位绑定关系");
			}
			}
			}
			// if (string.IsNullOrEmpty(itemcode))//空托入库
			// {
			// if (iteminfo == null)
			// {
			// //物料相同入货位后一位货位
			// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE.Trim() == areacode && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL && a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM == 0).First();
			// }
			// }
			// else//满拖入库
			// {
			// if (iteminfo != null)
			// {
			// if (iteminfo.S_ITEM_CODE == itemcode)
			// {
			// //物料相同入货位后一位货位
			// result = db.Queryable<Location>().OrderBy(a => a.N_COL).Where(a => a.S_AREA_CODE.Trim() == areacode && a.N_ROW == list[i].N_ROW && a.N_COL > list[i].N_COL && a.N_LOCK_STATE == 0 && a.N_CURRENT_NUM == 0).First();

			// }
			// }
			// }
			// if (result != null)
			// {
			// return result;
			// }
			// }
			// else
			// {
			// LogHelper.Info($"根据货物编码{list[i].S_CODE}未找到托盘货位绑定关系");
			// }
			// }
			//}
			return result;
			}


			/// <summary>
			/// 根据物料计算托盘出库
			@@ -2281,7 +2673,12 @@
			#endregion
			var loc = LocationHelper.GetLocByItemCode(areacode, itemcode, level);
			LogHelper.Info($"airlift=>根据库区编码:{areacode}，物料编码:{itemcode},物料等级计算出有托盘货位{JsonConvert.SerializeObject(loc)}");
			result = FindStartcolByLoclist(loc);
			// result = FindStartcolByLoclist(loc);
			if (loc.Count > 0)
			{
			result = loc.OrderByDescending(a => a.N_COL).First();
			}

			LogHelper.Info($"airlift=>可用货位为：{JsonConvert.SerializeObject(result)}");
			return result;
			}
			@@ -2324,6 +2721,21 @@
			}

			}

			//internal static bool CreateCntrLoc(taskData taskData)
			//{
			// if ( taskData == null)
			// {
			// LogHelper.Info($"CreateCntrIteminfo==> 立库任务下发参数有空，创建物料托盘绑定关系失败");
			// return false;
			// }
			// else
			// {
			// LocationHelper.BindingLoc(taskData.pickStation,new List<string>() { taskData.rfid });

			// }

			//}
			private static object _lockLocation = new object();
			/// <summary>
			/// 根据托盘编码，机台编码，工装类型计算机台线边区域
			@@ -2342,7 +2754,7 @@

			lock (_lockLocation)
			{
			var loc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == jtcode.Trim() && a.S_NOTE == cntrType && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0).First();
			var loc = db.Queryable<Location>().Where(a => a.S_AREA_CODE.Trim() == jtcode.Trim() && a.S_NOTE == cntrType && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.S_LOCK_STATE == "无").First();
			if (loc != null)
			{
			End = loc;
			@@ -2399,7 +2811,7 @@
			/// </summary>
			/// <param name="locations"></param>
			/// <returns></returns>
			internal static Location FindEndcolByLocList(List<Location> locations, string itemcode)
			internal static Location FindEndcolByLocList(List<Location> locations)
			{
			try
			{
			@@ -2415,7 +2827,8 @@
			Location other = null;
			//当前排没有锁并且有空位置
			//先找满位，然后后面一层要么是空，要么不存在
			other = rowList.OrderByDescending(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 0).FirstOrDefault();
			/// other = rowList.OrderBy(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y").FirstOrDefault();
			other = rowList.OrderBy(a => a.N_COL).Where(a => a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 ).FirstOrDefault();
			//if (full == null)
			//{
			// //没有满位，那就找最小的空位
			@@ -2492,9 +2905,9 @@
			}

			}


			#endregion



			internal static CodeInfo GetCodeInfo(string code, string org)
			{