WMSPrjInstance/HH-0035_HeFeiLiaoTongAGV.git

			@@ -12,6 +12,7 @@
			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;
			@@ -34,6 +35,10 @@


			#region 佳通合肥接口业务


			public static object _lockCreateTask = new object();
			public static object _lockCreateItem = new object();
			/// <summary>
			/// 立库任务下发=》创建任务
			/// </summary>
			@@ -115,260 +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);
			return result;
			}
			}
			else
			{

			result.code = "1";
			result.msg = $"Putin==> 任务起点:{taskData.pickStation}找不到对应货位，请检查货位表";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("货位查找失败", result.msg, Source);
			}
			}
			else if (taskData.taskType == 2)//入库流程，直接使用起点货位和终点货位生成任务，起点需要有托盘
			{
			note = "入库";
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			Start = startloc.S_CODE;
			var CntrRel = LocationHelper.GetLocCntrRel(startloc.S_CODE).FirstOrDefault();
			if (CntrRel != null)
			{
			CntrCode = CntrRel.S_CNTR_CODE;
			}
			//else
			//{
			// result.code = "1";
			// result.msg = $"根据起点{Start},未找到托盘货位绑定关系";
			// 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 == 3)//移库流程，直接使用起点货位和终点货位生成任务，
			{
			note = "出库";
			//创建托盘物料绑定信息，并计算终点货位
			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 = $"Putin==> 任务起点:{taskData.pickStation}找不到对应货位，请检查货位表";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("货位查找失败", result.msg, Source);
			return result;
			}
			if (startArea.N_FLOOR == endArea.N_FLOOR)
			}
			else if (taskData.taskType == 2)//入库流程，直接使用起点货位和终点货位生成任务，起点需要有托盘
			{
			note = "入库";
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			//创建wcs任务
			var wcsTask = new WCSTask
			Start = startloc.S_CODE;
			var CntrRel = LocationHelper.GetLocCntrRel(startloc.S_CODE).OrderBy(a => a.T_CREATE).FirstOrDefault();
			if (CntrRel != null)
			{
			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
			if (CntrRel.S_CNTR_CODE != partData.rfid)
			{
			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("创建任务成功");
			result.code = "1";
			result.msg = $"根据起点：{Start}获取托盘:{CntrRel.S_CNTR_CODE}与下发托盘：{partData.rfid}不一致，请检查托盘码是否正确";
			AddErrorInfo("托盘码校检失败", result.msg, Source);
			return result;
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			CntrCode = CntrRel.S_CNTR_CODE;
			}

			}


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

			}
			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
			else if (taskData.taskType == 3)//移库流程，直接使用起点货位和终点货位生成任务，
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			}
			else if (taskData.taskType == 5)//移库流程，直接使用起点货位和终点货位生成任务，并绑定托盘
			{
			note = "出库";
			//创建托盘物料绑定信息，并计算终点货位
			if (CreateCntrIteminfo(partData, taskData))
			{
			note = "出库";
			//创建托盘物料绑定信息，并计算终点货位
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			@@ -394,197 +245,373 @@
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}

			}
			//暂存位回库
			else if (taskData.taskType == 6)//入库流程，直接使用起点货位和终点货位生成任务
			{
			note = "入库";
			//根据托盘号找货位
			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 = 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)
			{
			End = endloc.S_CODE;
			result.code = "1";
			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 = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			}
			else if (taskData.taskType == 5)//移库流程，直接使用起点货位和终点货位生成任务，并绑定托盘
			{
			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.dropStation}无可用货位";
			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 = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}

			}
			//暂存位回库
			else if (taskData.taskType == 6)//入库流程，直接使用起点货位和终点货位生成任务
			{
			note = "入库";
			//根据托盘号找货位
			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))
			{
			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 = $"根据终点库区：{taskData.dropStation},未找到对应货位";
			AddErrorInfo("查找库区失败", result.msg, Source);
			result.msg = "创建托盘物料信息失败";
			AddErrorInfo("创建托盘失败", result.msg, Source);
			return result;
			}
			}
			else
			else if (taskData.taskType == 8)//叠盘机空托回库
			{
			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 = "空托回库";//井松空托回库，需要与叠盘机安全交互
			startloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == taskData.pickStation).First();
			if (startloc != null)
			{
			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("创建任务成功");
			Start = startloc.S_CODE;
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			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;
			}
			@@ -702,6 +729,7 @@
			/// <returns></returns>
			internal static Result TrayItembind(TrayItembind model)
			{

			Result result = new Result() { code = "200", msg = "产出信息下发成功" };
			if (model == null)
			{
			@@ -710,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, model.ProductionTime, model.MaturityTime))
			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;
			}



			}
			@@ -847,13 +880,8 @@
			return result;
			}

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

			if (loc != null)
			{
			End = loc.S_CODE;
			@@ -974,7 +1002,6 @@
			string areacode = "";
			var db = new SqlHelper<object>().GetInstance();
			#endregion

			try
			{

			@@ -1062,55 +1089,60 @@
			#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);
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			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;
			@@ -1125,6 +1157,7 @@

			}

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

			try
			{
			#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)
			lock (_lockEmpty)
			{
			if (startloc.N_LAYER == 3)
			#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)
			{
			//叠盘货位计算叠盘货位
			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_LAYER == 3)
			{
			// 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)
			//叠盘货位计算叠盘货位
			// 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)
			{
			result.code = "1";
			result.msg = $"叠盘货位不可用";
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			// 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
			{
			endlayer = loc.N_CURRENT_NUM + 1;
			// 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 = $"Empty==> 任务起点:{Start}找不到对应货位，请检查货位表";
			LogHelper.Info($"{result.msg}");
			AddErrorInfo("查找货位失败", result.msg, Source);
			return result;
			}
			#endregion

			#region 创建任务
			if (startloc != null && loc != null)
			{
			if (startloc.N_LOCK_STATE != 0 && loc.N_LOCK_STATE != 0)
			{
			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 == "PB")
			{
			//找块胶堆叠区
			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 根据起点货位类型，获得回库库区
			//根据仓库计算库区
			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($"Putin==> {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 (startloc != null && loc != null)
			{
			if (startloc.N_LOCK_STATE != 0 && loc.N_LOCK_STATE != 0)
			{
			result.code = "1";
			result.msg = $"创建任务失败，起点货位状态{startloc.N_LOCK_STATE},起点货位状态：{loc.N_LOCK_STATE}";
			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 = 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(); }
			LogHelper.Info("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}
			#endregion
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			#endregion

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

			return result;
			}

			public static object _lockcallfixture = new object();

			/// <summary>
			/// 空工装呼叫
			@@ -1382,121 +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)
			{
			var whcode = Settings.wareLoc.Where(a => a.AreaCode == endloc.S_WH_CODE).FirstOrDefault();
			if (whcode != null)
			#region 根据仓库编码判断库区并计算出库货位
			var endloc = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == End).First();
			//根据仓库计算库区
			if (endloc != null)
			{
			areacode = whcode.PMK;
			}
			else
			{
			result.code = "1";
			result.msg = $"根据起点仓库编码：{endloc.S_WH_CODE}未找到对应配置文件";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}


			//计算出库托盘
			startloc = LocationHelper.GetLocByAreacode(areacode);
			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);
			return result;
			}
			#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 = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			#endregion
			}
			return result;
			#endregion


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

			}

			public static object _lockItemBack = new object();
			/// <summary>
			/// 余料返回
			/// </summary>
			@@ -1542,214 +1606,241 @@

			try
			{
			#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)
			lock (_lockItemBack)
			{
			var whcode = Settings.wareLoc.Where(a => a.AreaCode == startloc.S_WH_CODE).FirstOrDefault();
			if (whcode != null)
			#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)
			{
			//粉料直接回库，其他物料需要去对应的暂存区
			#region 根据物料判断回库库区
			if (model.PartNumber.StartsWith("4X"))
			if (CntrLoc.S_LOC_CODE != Start)
			{
			areacode = whcode.PMK;
			//loc = StorageCompute(itemcode, areacode);
			//if (loc == null)
			//{
			// loc = emptyRow(areacode);
			//}

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

			}
			#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)
			{
			//粉料直接回库，其他物料需要去对应的暂存区
			#region 根据物料判断回库库区
			if (model.PartNumber.StartsWith("4X"))
			{
			if (CntrLoc.S_LOC_CODE != Start)
			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.Rfid}绑定位置不是起点：{Start}";
			result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("托盘绑定位置不同", result.msg, Source);
			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

			if (model.PartNumber.StartsWith("3"))

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

			}
			else
			{

			result.code = "1";
			result.msg = $"创建任务失败，物料号{model.PartNumber}不属于规定物料";
			LogHelper.Info($"ItemBack：{result.msg}");
			AddErrorInfo("物料编码格式错误", result.msg, Source);
			result.msg = $"根据终点库区：{areacode},未找到对应货位";
			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);

			if (loc != null)
			{
			End = loc.S_CODE;
			}
			else
			{
			result.code = "1";
			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;
			}

			if (loc != null)
			}
			else
			{

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

			#endregion

			#region 创建任务
			if (!string.IsNullOrEmpty(Start) && !string.IsNullOrEmpty(End))
			{
			if (startloc.N_LOCK_STATE != 0)
			{
			End = loc.S_CODE;
			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

			};
			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 = $"库区:{areacode}无可用货位";
			AddErrorInfo("查找货位失败", result.msg, Source);
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			return result;
			}

			}
			else
			{

			result.code = "1";
			result.msg = $"根据起点仓库编码：{startloc.S_WH_CODE}未找到对应配置文件";
			LogHelper.Info($"Putin==> {result.msg}");
			AddErrorInfo("查找库区失败", result.msg, Source);
			return result;
			}

			}
			else
			{

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

			#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

			};
			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("创建任务成功");
			}
			else
			{
			result.code = "1";
			result.msg = $"任务创建失败";
			AddErrorInfo("任务创建失败", result.msg, Source);
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			#endregion
			}
			else
			{
			result.code = "1";
			result.msg = "创建任务失败，未找到对应的取货点或卸货点";
			return result;
			}
			#endregion




			return result;
			}
			@@ -1993,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";
			@@ -2011,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();


			@@ -2020,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)
			{
			@@ -2053,26 +2144,7 @@
			//根据任务数量判断送往哪个电梯（具体电梯流程根据现场电梯数量）
			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 = 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 = cntr.S_CNTR_CODE,
			N_END_LAYER = 1,
			Z_TYPE = 6
			};
			var wcsTask1 = new WCSTask
			{
			S_CODE = WCSHelper.GenerateTaskNo(),
			S_TYPE = "电梯2",
			@@ -2090,13 +2162,34 @@
			Z_TYPE = 6
			};

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

			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);
			LogHelper.Info("创建任务成功");

			}
			else
			{
			@@ -2120,7 +2213,7 @@
			{

			result.code = "1";
			result.msg = $"物料主数据创建失败错误信息：{ex}";
			result.msg = $"电梯搬运任务创建失败错误信息：{ex}";
			LogHelper.Error("点对点任务 Error：" + ex.ToString(), ex);
			return result;
			}
			@@ -2214,56 +2307,63 @@
			}
			string loc = model.LocationNum;
			var db = new SqlHelper<object>().GetInstance();
			try
			lock (_lockCreateItem)
			{
			var location = db.Queryable<Location>().Where(a => a.S_CODE.Trim() == loc).First();
			if (location != null)
			try
			{
			var loccntr = db.Queryable<LocCntrRel>().Where(a => a.S_LOC_CODE.Trim() == loc).First();

			if (loccntr != null)
			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();

			string cntrcode = loccntr.S_CNTR_CODE;
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
			if (CntrItem != null)
			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 托盘{cntrcode}无物料绑定关系");
			LogHelper.Info($"ClearLocCntr 货位{loc}无托盘货位绑定关系");
			}

			}
			else
			{
			LogHelper.Info($"ClearLocCntr 货位{loc}无托盘货位绑定关系");
			result.code = "1";
			result.msg = $"根据货位:{loc}找不到货位关系";
			AddErrorInfo("货位为空", result.msg, Source);
			return result;
			}
			}
			else
			catch (Exception ex)
			{
			LogHelper.Info($"ClearLocCntr Error：{ex}");
			db.Ado.CommitTran();
			result.code = "1";
			result.msg = $"根据货位:{loc}找不到货位关系";
			AddErrorInfo("货位为空", result.msg, Source);
			result.msg = $"Error：{ex}";
			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>
			/// 库位清空
			/// </summary>
			/// <param name="model"></param>
			@@ -2286,42 +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 });
			// 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)
			var CntrItem = db.Queryable<CntrItemDetail>().Where(a => a.S_CNTR_CODE.Trim() == cntrcode).First();
			if (CntrItem != null)
			{
			LogHelper.Info($"ClearLoc 库位清除成功");
			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($"ClearLoc 库位清除失败");
			result.code = "1";
			result.msg = "库位清除失败";
			AddErrorInfo("库位清除失败", result.msg, Source);
			return result;
			}
			LogHelper.Info($"库区清空=》托盘:{cntrcode}无物料数据");

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

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

			}

			}
			else
			{
			@@ -2353,14 +2459,14 @@
			DeviceInfoModel device = new DeviceInfoModel();

			List<DeviceInfos> deviceInfos = new List<DeviceInfos>();//叠盘机报错信息
			List<AgvInfos> agvInfos = new List<AgvInfos>();//agv报错信息
			// 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;
			// device.DeviceInfos = deviceInfos;
			//获取车辆报警信息
			var agvDeviceInfo = db.Queryable<HangChaAGV>().ToList();
			if (agvDeviceInfo.Count > 0)
			@@ -2372,10 +2478,10 @@
			foreach (var agv in agvDeviceInfo)
			{
			string agvErrorInfo = GetAgvAlarmSendCodeTwo(agv.agvErrCode, agv.errCode2, agv.faildCode);
			agvInfos.Add(new AgvInfos() { AgvNo = agv.agvNo, AgvInfo = agvErrorInfo });
			deviceInfos.Add(new DeviceInfos() { AgvNo = agv.agvNo, AgvInfo = agvErrorInfo });
			}
			}
			device.AgvInfos = agvInfos;
			device.DeviceInfos = deviceInfos;

			return device;
			}
			@@ -2439,6 +2545,8 @@
			#endregion

			#region 合肥佳通业务方法


			/// <summary>
			/// 托盘入库算法
			/// </summary>
			@@ -2448,7 +2556,8 @@
			internal static Location StorageCompute(string itemcode, string areacode)
			{
			var db = new SqlHelper<object>().GetInstance();
			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 ).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)
			@@ -2496,6 +2605,7 @@
			//}
			return result;
			}


			/// <summary>
			/// 根据物料计算托盘出库
			@@ -2611,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>
			/// 根据托盘编码，机台编码，工装类型计算机台线边区域
			@@ -2629,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&&a.S_LOCK_STATE=="无").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;
			@@ -2702,7 +2827,8 @@
			Location other = null;
			//当前排没有锁并且有空位置
			//先找满位，然后后面一层要么是空，要么不存在
			other = rowList.OrderBy(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)
			//{
			// //没有满位，那就找最小的空位