印尼佳通优化

杨前锦

2025-07-07 c8f338feee0b6003d8f069b1d37fd9b90dd1b7f4

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/api/ApiHelper.cs

@@ -43,46 +43,27 @@
            Location endLoc = LocationHelper.GetLoc(model.endLocCode);
            if (endLoc == null)
            {
                WMSHelper.addAlarmRecord("流程异常", "低", $"WMS系统未查询到终点货位：{model.endLocCode}");
                throw new BusinessException($"WMS系统未查询到终点货位：{model.endLocCode},请检查终点货位编码是否正确");
                WMSHelper.addAlarmRecord("流程异常", "低", $"空工装出库，WMS系统未查询到终点货位：{model.endLocCode}");
                throw new BusinessException($"空工装出库，WMS系统未查询到终点货位：{model.endLocCode},请检查终点货位编码是否正确");
            }
            else 
            else if (endLoc.N_LOCK_STATE != 0) 
            {
                if (endLoc.C_ENABLE == "Y")
                {
                    if (endLoc.N_LOCK_STATE != 0)
                    {
                        var existTask = WCSHelper.GetTaskByStartOrEnd(model.endLocCode);
                        if (existTask != null)
                        {
                            WMSHelper.addAlarmRecord("流程异常", "低", $"终点货位：{model.endLocCode} 已有任务");
                            throw new BusinessException($"终点货位：{model.endLocCode} 已有任务");
                        }
                        else
                        {
                            LocationHelper.UnLockLoc(model.endLocCode);  // 没有任务就，自动解锁终点货位
                        }
                    }
                }
                else 
                {
                    WMSHelper.addAlarmRecord("流程异常", "低", $"终点货位：{model.endLocCode} 已禁用，请联系管理人员解除禁用");
                    throw new BusinessException($"终点货位：{model.endLocCode} 已禁用，请联系管理人员解除禁用");
                }
                WMSHelper.addAlarmRecord("流程异常", "低", $"空工装出库，终点货位：{model.endLocCode}处于锁定状态");
                throw new BusinessException($"空工装出库，终点货位：{model.endLocCode}处于锁定状态");
            }

            var transfeRelevance = WMSHelper.GetTransfeRelevance(model.endLocCode);  // 接驳货位关联属性
            if (transfeRelevance == null) 
            var areaCodes = Settings.getRelAreaCodes(endLoc.S_AREA_CODE);
            if (areaCodes.Count == 0) 
            {
                WMSHelper.addAlarmRecord("流程异常", "低", $"终点货位：{model.endLocCode},缺少配置属性，请联系管理人员进行配置属性");
                throw new BusinessException($"终点货位：{model.endLocCode},缺少配置属性，请联系管理人员进行配置属性");
                WMSHelper.addAlarmRecord("流程异常", "低", $"空工装出库，未配置库区:{endLoc.S_AREA_CODE}的关联关系");
                throw new BusinessException($"空工装出库，未配置库区:{endLoc.S_AREA_CODE}的关联关系");
            }

            Location startLoc = WMSHelper.getOutStockStartLoc(transfeRelevance.S_RELE_AREA, null);
            Location startLoc = WMSHelper.getOutStockStartLoc(areaCodes[0], null);
            if (startLoc == null)
            {
                WMSHelper.addAlarmRecord("流程异常", "低", $"未查询到空工装，立库可能缺少空工装");
                throw new BusinessException($"未查询到空工装，立库可能缺少空工装");
                WMSHelper.addAlarmRecord("流程异常", "低", $"空工装出库，库区:{areaCodes[0]}未查询到空工装");
                throw new BusinessException($"空工装出库，未查询到空工装，立库可能缺少空工装");
            }

            var locCntrRels = LocationHelper.GetLocCntr(startLoc.S_CODE);
@@ -98,7 +79,7 @@
                    S_END_LOC = endLoc.S_CODE,
                    S_END_AREA = endLoc.S_AREA_CODE,
                    S_TYPE = "空工装出库任务",
                    S_OP_DEF_NAME = "空工装出库缓存位",
                    S_OP_DEF_NAME = "空工装出库",
                    N_PRIORITY = 10,
                    T_START_TIME = DateTime.Now,
                };
@@ -144,10 +125,10 @@

        /// <summary>
        /// WCS读码请求流程
        /// 1.判断RFID 是否读取成功（托盘号是否为空）
        /// 2.查询关于RFID的预创建任务
        /// 3.如果读取成功，则激活预创建任务
        /// 4.如果读取不成功，查看异常区是否有空货位，有则创建搬运异常区任务，无则，记录异常激活预创建任务
        /// 业务场景：读码入库、读码出库
        /// 1.判断RFID是否存在WMS系统中，否，则默认为RFID无法识别
        /// 2.判断RFID是否与任务RFID是否一致
        /// 3.记录RFID异常信息
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
@@ -155,48 +136,27 @@
            ResponseResult responseResult = new ResponseResult();

            Location loc = LocationHelper.GetLoc(request.loc);
            if (loc == null) 
            if (loc != null)
            {
                WMSHelper.addAlarmRecord("流程异常", "中", $"读码位:{request.loc},没有在WMS系统中录入");
                throw new BusinessException($"读码位:{request.loc},没有在WMS系统中录入");
            }

            var locCntrRels = LocationHelper.GetLocCntr(request.loc);
            if (locCntrRels.Count > 0)
            {
                string taskCntrCode = locCntrRels[0].S_CNTR_CODE;
                // 2.查询关于RFID的预创建任务
                var cst = WCSHelper.GetPreCreatedTaskByCntr(taskCntrCode);
                var cst = WCSHelper.GetTask(request.taskNo);
                if (cst != null)
                {
                    bool errFlag = true;
                    // 1.判断RFID 是否读取成功（托盘号是否为空）
                    if (request.cntrNo != null)
                    var container = ContainerHelper.GetCntr(request.cntrNo);
                    if (container != null)
                    {
                        if (request.cntrNo == taskCntrCode)
                        if (cst.S_CNTR_CODE != request.cntrNo)
                        {
                            Container container = ContainerHelper.GetCntr(request.cntrNo);
                            if (container.N_E_STATE == 0)
                            {
                                errFlag = false;
                                WCSHelper.ActivatePreCreateTask(cst.S_OP_CODE);
                            }
                        }
                        else
                        {
                            ContainerHelper.UpdateCntrState(taskCntrCode, 1,"WCS反馈RFID与任务RFID不一致");
                            ContainerHelper.UpdateCntrState(cst.S_CNTR_CODE, 1);
                            WMSHelper.addRfidAnomalyRecord(cst.S_CNTR_CODE, 2, request.loc, cst.S_CODE);
                        }
                    }
                    else
                    else 
                    {
                        ContainerHelper.UpdateCntrState(taskCntrCode, 1,"WCS反馈RFID为null");
                        ContainerHelper.UpdateCntrState(cst.S_CNTR_CODE, 1);
                        WMSHelper.addRfidAnomalyRecord(cst.S_CNTR_CODE, 1, request.loc, cst.S_CODE);
                    }

                    // 方案1 4.激活预创建任务
                    if (errFlag) 
                    {
                        WCSHelper.ActivatePreCreateTask(cst.S_OP_CODE,1);
                    }
                    /*WCSHelper.ActivatePreCreateTask(cst.S_OP_CODE);*/

                    // 方案2 4.如果读取不成功，查看异常区是否有空货位  
                    /* var agvEndLoc = WMSHelper.GetTransfeRelevanceLoc(loc.S_AREA_CODE, "4");
@@ -233,15 +193,15 @@
                         WCSHelper.ActivatePreCreateTask(cst.S_OP_CODE);
                     }*/
                }
                else 
                else
                {
                    WMSHelper.addAlarmRecord("流程异常", "低", $"读码位:{request.loc}触发读码请求，读码位上容器:{taskCntrCode}没有预创建任务");
                    WMSHelper.addAlarmRecord("流程异常", "低", $"没有查询到读码的任务，任务号:{request.taskNo}");
                }
            }
            else 
            {
                WMSHelper.addAlarmRecord("流程异常", "中", $"读码位:{request.loc},没有查询到容器");
                throw new BusinessException($"读码位:{request.loc},没有查询到容器");
                WMSHelper.addAlarmRecord("流程异常", "中", $"读码位:{request.loc},没有在WMS系统中录入");
                throw new BusinessException($"读码位:{request.loc},没有在WMS系统中录入");
            }
            return responseResult;
        }
@@ -267,66 +227,58 @@
        /// <returns></returns>
        public static ResponseResult offLineProcess(OffLineRequest model) {
            ResponseResult responseResult = new ResponseResult();
            var existWmsTask = WMSHelper.GetWmsTaskByStart(model.loc);
            if (existWmsTask == null)

            var areaCodes = Settings.areaPropertyList.Select(a => a.areaCode).ToList();
            var isExistCntr = LocationHelper.checkAreaExistCntr(areaCodes,model.cntrNo);
            if (!isExistCntr)
            {
                // 判断满料接驳位对应的空工装缓存位状态（查询线体光电）
                var logicConfig = WMSHelper.getLogicConfigByJtCode(model.jtNo);
                if (logicConfig != null)
                // 查询起点货位是否存在已存在任务，防止任务重复发起
                var existWmsTask = WMSHelper.GetWmsTaskByStart(model.loc);
                if (existWmsTask == null)
                {
                    if (logicConfig.S_TASK_TYPE == "1" || logicConfig.S_TASK_TYPE == "2")
                    // 查询对应机台的物料下线配置信息
                    var logicConfig = WMSHelper.getLogicConfigByJtCode(model.jtNo);
                    if (logicConfig != null)
                    {
                        // 满料下线（直连）
                        LjMesTask mesTask = null;
                        if (model.cntrNo != null && model.cntrNo != "")
                        Container container = ContainerHelper.GetCntr(model.cntrNo);
                        if (container == null || !model.isNormal)
                        {
                            var container = ContainerHelper.GetCntr(model.cntrNo);
                            if (container == null)
                            {
                                ContainerHelper.AddCntr(model.cntrNo);
                                ContainerHelper.UpdateCntrState(model.cntrNo, 1, $"满料下线（直连）,WCS反馈的RFID:{model.cntrNo}在WMS系统中不存在");
                                WMSHelper.addAlarmRecord("流程异常", "中", $"满料下线（直连）,WCS反馈的RFID:{model.cntrNo}在WMS系统中不存在");
                            }
                            else
                            {
                                ContainerHelper.UpdateCntrState(model.cntrNo, 0, "");
                                mesTask = WMSHelper.getLjMesTaskByCntr(model.cntrNo);
                                if (mesTask == null)
                                {
                                    ContainerHelper.UpdateCntrState(model.cntrNo, 1, $"未查询到MES任务");
                                    WMSHelper.addAlarmRecord("流程异常", "低", $"满料下线（直连）,容器:{model.cntrNo}未查询到MES任务");
                                }
                            }
                        }
                        else 
                        {
                            model.cntrNo = ContainerHelper.GenerateCntrNo();
                            ContainerHelper.AddCntr(model.cntrNo);
                            ContainerHelper.UpdateCntrState(model.cntrNo, 1, $"WCS反馈的RFID:{model.cntrNo} 为空");
                            WMSHelper.addAlarmRecord("流程异常", "中", $"WCS反馈的RFID:{model.cntrNo} 为空");
                            ContainerHelper.UpdateCntrState(model.cntrNo, 1);
                            WMSHelper.addRfidAnomalyRecord(model.cntrNo, 1, model.loc, null);
                        }
                        triggerItemOffLineFlow(model.loc, model.cntrNo, logicConfig, mesTask);

                        // 根据物料下线配置信息，判断任务类型是直连下线还是非直连下线
                        if (logicConfig.S_TASK_TYPE == "1" || logicConfig.S_TASK_TYPE == "2")
                        {
                            triggerItemOffLineFlow(model.loc, model.cntrNo, logicConfig);
                        }
                        else
                        {
                            // 满料下线（非直连）
                            triggerItemOffLineFlow4(model.loc, model.cntrNo, logicConfig);
                        }
                    }
                    else
                    {
                        // 满料下线（非直连）
                        var mesTask = WMSHelper.getLjMesTaskByLoc(model.loc);
                        triggerItemOffLineFlow4(model.loc, logicConfig,mesTask);
                        WMSHelper.addAlarmRecord("流程异常", "高", $"机台号{model.jtNo},没有可用的逻辑线路,请联系管理人员");
                        throw new BusinessException($"机台号{model.jtNo},没有可用的逻辑线路，请联系管理人员");
                    }
                }
                else
                {
                    WMSHelper.addAlarmRecord("流程异常", "高", $"机台号{model.jtNo},没有可用的逻辑线路,请联系管理人员");
                    throw new BusinessException($"机台号{model.jtNo},没有可用的逻辑线路，请联系管理人员");
                    WMSHelper.addAlarmRecord("流程异常", "低", $"下线货位：{model.loc}已有任务，请勿重复下发任务");
                    throw new BusinessException($"下线货位：{model.loc}已有任务，请勿重复下发任务");
                }
            }
            else 
            {
                WMSHelper.addAlarmRecord("流程异常", "低", $"下线货位：{model.loc}已有任务，请勿重复下发任务");
                throw new BusinessException($"下线货位：{model.loc}已有任务，请勿重复下发任务");
                WMSHelper.addAlarmRecord("流程异常", "高", $"工装：{model.cntrNo}已入库，请勿重复入库");
                throw new BusinessException($"工装：{model.cntrNo}已入库，请勿重复入库");
            }
            return responseResult;
        }


        /// <summary>
        /// 满料下线（非直连）
@@ -337,52 +289,62 @@
        /// </summary>
        /// <param name="offLineLoc"></param>
        /// <param name="logicConfig"></param>
        /// <param name="cntrNo"></param>
        /// <returns></returns>
        public static bool triggerItemOffLineFlow4(string offLineLoc, LogicConfig logicConfig ,LjMesTask mesTask)
        public static bool triggerItemOffLineFlow4(string offLineLoc,string cntrNo, LogicConfig logicConfig ,LjMesTask mesTask = null)
        {
            bool result = true;
            try
            {
                if (mesTask == null) 
                {
                    mesTask = WMSHelper.getLjMesTaskByCntr(cntrNo);
                }
                
                if (mesTask != null)
                {
                    // 2.判断是否需要补空工装，需要，则创建空工装出库任务
                    // TODO 查询缓存位线体光电++++++
                    bool photoStatus = false;
                    var hcLoc = LocationHelper.GetLoc(logicConfig.S_LKBKHCLOC);
                    if (hcLoc != null)
                    {
                        var transfeRelevance = WMSHelper.GetTransfeRelevance(hcLoc.S_CODE);  // 缓存位关联属性
                        if (transfeRelevance != null)
                        if (hcLoc.N_CURRENT_NUM != 0 && hcLoc.N_LOCK_STATE == 0) 
                        {
                            photoStatus = true;
                            // 方案1，如果非直连的缓存位有光电信号，则查询设备状态判断是否需要补空工装
                            /*var deviceStatusDatas = WCSDispatch.getDeviceStatus(new List<string>() { transfeRelevance.S_DEVICE_NO });
                            if (deviceStatusDatas != null && deviceStatusDatas.Count > 0)
                            hcLoc = LocationHelper.GetEmptyLoc(hcLoc.S_AREA_CODE);
                        }

                        if (hcLoc != null) 
                        {
                            var bufferLocConfig = Settings.GetBufferLocConfig(hcLoc.S_CODE);  // 缓存位关联属性
                            if (bufferLocConfig != null || hcLoc.N_CURRENT_NUM == 0)
                            {
                                var deviceStatus = deviceStatusDatas[0];
                                if (deviceStatus.workStatus == 1 && deviceStatus.manualStatus == 0)
                                {
                                    photoStatus = deviceStatus.photoStatus == 1;
                                }
                                else
                                {
                                    WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{transfeRelevance.S_DEVICE_NO},设备当前处于不可用状态，请联系管理人员调整设备状态");
                                    throw new BusinessException($"设备号:{transfeRelevance.S_DEVICE_NO},设备当前处于不可用状态，请联系管理人员调整设备状态");
                                }
                                photoStatus = true;
                                // 方案1，如果非直连的缓存位有光电信号，则查询设备状态判断是否需要补空工装
                                /*   var deviceStatusDatas = WCSDispatch.getDeviceStatus(new List<string>() { bufferLocConfig.deviceNo });
                                   if (deviceStatusDatas != null && deviceStatusDatas.Count > 0)
                                   {
                                       var deviceStatus = deviceStatusDatas[0];
                                       if (deviceStatus.workStatus == 1 && deviceStatus.manualStatus == 0)
                                       {
                                           photoStatus = deviceStatus.photoStatus == 1;
                                       }
                                       else
                                       {
                                           WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{bufferLocConfig.deviceNo},设备当前处于不可用状态，请联系管理人员调整设备状态");
                                           throw new BusinessException($"设备号:{bufferLocConfig.deviceNo},设备当前处于不可用状态，请联系管理人员调整设备状态");
                                       }
                                   }
                                   else
                                   {
                                       WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{bufferLocConfig.deviceNo},查询设备状态失败，请联系工作人员查看设备是否正常");
                                       throw new BusinessException($"设备号:{bufferLocConfig.deviceNo},查询设备状态失败，请联系工作人员查看设备是否正常");
                                   }*/
                            }
                            else
                            {
                                WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{transfeRelevance.S_DEVICE_NO},查询设备状态失败，请联系工作人员查看设备是否正常");
                                throw new BusinessException($"设备号:{transfeRelevance.S_DEVICE_NO},查询设备状态失败，请联系工作人员查看设备是否正常");
                            }*/

                            // 方案2，如果非直连的缓存位没有光电信号，则根据货位状态进行判断，需要注意：人工取空工装需要解锁

                        }
                        else
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"缓存位:{logicConfig.S_LKBKHCLOC},没有配置属性信息，请联系管理人员配置");
                            throw new BusinessException($"缓存位:{logicConfig.S_LKBKHCLOC},没有配置属性信息，请联系管理人员配置");
                                WMSHelper.addAlarmRecord("流程异常", "高", $"缓存位:{logicConfig.S_LKBKHCLOC},没有配置属性信息，请联系管理人员配置");
                                throw new BusinessException($"缓存位:{logicConfig.S_LKBKHCLOC},没有配置属性信息，请联系管理人员配置");
                            }
                        }
                    }
                    else
@@ -401,13 +363,13 @@
                        kgzEndLoc = LocationHelper.GetLoc(logicConfig.S_LKBKHCLOC);
                        if (kgzStartLoc == null)
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                            throw new BusinessException($"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                            WMSHelper.addAlarmRecord("流程异常", "高", $"空工装出库站台:{logicConfig.S_LKKTJBLOC},没有在WMS系统中录入");
                            photoStatus = false;
                        }
                        if (kgzEndLoc == null)
                        {
                            WMSHelper.addAlarmRecord("流程异常", "中", $"空工装缓存位:{logicConfig.S_LKBKHCLOC},没有在WMS系统中录入");
                            throw new BusinessException($"空工装缓存位:{logicConfig.S_LKBKHCLOC},没有在WMS系统中录入");
                            photoStatus = false;
                        }

                        var locCntrRels = LocationHelper.GetLocCntr(kgzStartLoc.S_CODE);
@@ -417,8 +379,8 @@
                        }
                        else
                        {
                            WMSHelper.addAlarmRecord("流程异常", "中", $"空工装补充接驳位:{logicConfig.S_LKKTJBLOC},没有空工装");
                            throw new BusinessException($"空工装补充接驳位:{logicConfig.S_LKKTJBLOC},没有空工装");
                            kgzCntrCode = "虚拟容器";
                            WMSHelper.addAlarmRecord("流程异常", "低", $"空工装出库站台:{logicConfig.S_LKKTJBLOC},没有空工装");
                        }
                    }

@@ -440,7 +402,6 @@
                            S_OP_DEF_CODE = mesTask.ID.ToString(),
                            T_START_TIME = DateTime.Now,
                        };

                        if (WMSHelper.CreateWmsTask(wmsTask))
                        {
                            int priority = 10;
@@ -471,12 +432,12 @@
                                }
                            }

                            // 3.判断容器是否是异常工装，是，则创建异常工装入线边异常区任务；
                            // 否，则创建满料工装入库任务（如需要补空工装，则将任务状态改为预创建，等待补空工装任务完成后触发）
                            // 3.创建满料工装入库任务（如需要补空工装，则将任务状态改为预创建，等待补空工装任务完成后触发）
                            WCSTask wcsTask = new WCSTask()
                            {
                                S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                S_OP_CODE = wmsTask.S_CODE,
                                S_TYPE = "满料工装入库任务(非直连)",
                                S_CODE = WCSHelper.GenerateTaskNo(),
                                S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                S_START_LOC = startLoc.S_CODE,
@@ -487,25 +448,7 @@
                                N_PRIORITY = 99,
                                T_START_TIME = DateTime.Now,
                            };
                            Container container = ContainerHelper.GetCntr(cntrCode);
                            if (container.N_E_STATE == 0)
                            {
                                wcsTask.S_TYPE = "满料工装入库任务(非直连)";
                            }
                            else
                            {
                                Location ycgzLoc = null;
                                if (ycgzLoc != null)
                                {
                                    wcsTask.S_TYPE = "异常工装入库线边异常区";
                                    wcsTask.S_END_LOC = ycgzLoc.S_CODE;
                                    wcsTask.S_END_AREA = ycgzLoc.S_AREA_CODE;
                                }
                                else
                                {
                                    wcsTask.S_TYPE = "异常工装入库";
                                }
                            }

                            if (photoStatus)
                            {
                                wcsTask.N_B_STATE = -1;
@@ -517,14 +460,14 @@
                                // 起点、终点加锁
                                LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                                LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                                // 更新作业任务状态
                                wmsTask.N_B_STATE = 1;
                                WMSHelper.UpdateTaskState(wmsTask);

                                // 4.作业创建完成后，读取中间表，更新中间表状态
                                WMSHelper.readLjMesOffItemTask(wmsTask.S_CODE, mesTask.ID);
                            }

                            // 更新作业任务状态
                            wmsTask.N_B_STATE = 1;
                            WMSHelper.UpdateTaskState(wmsTask);

                            // 4.作业创建完成后，读取中间表，更新中间表状态
                            WMSHelper.readLjMesOffItemTask(wmsTask.S_CODE, mesTask.ID);
                        }
                    }
                    else
@@ -561,10 +504,10 @@
        /// 5.作业创建完成后，读取中间表，更新中间表状态
        /// </summary>
        /// <param name="offLineLoc">下线货位</param>
        /// <param name="cntrCode">下线容器编码</param>
        /// <param name="cntrNo">下线容器编码</param>
        /// <param name="logicConfig">逻辑配置</param>
        /// <returns></returns>
        public static bool triggerItemOffLineFlow(string offLineLoc, string cntrCode, LogicConfig logicConfig ,LjMesTask mesTask) {
        public static bool triggerItemOffLineFlow(string offLineLoc, string cntrNo, LogicConfig logicConfig ) {
            bool result = true;
            try
            {
@@ -573,14 +516,14 @@
                var hcLoc = LocationHelper.GetLoc(logicConfig.S_LKBKHCLOC);
                if (hcLoc != null)
                {
                    var transfeRelevance = WMSHelper.GetTransfeRelevance(hcLoc.S_CODE); // 缓存位关联属性
                    if (transfeRelevance != null)
                    var bufferLocConfig = Settings.GetBufferLocConfig(hcLoc.S_CODE);
                    if (bufferLocConfig != null)
                    {
                        // 测试代码
                        photoStatus = true;

                        // 业务代码，勿删
                        /*var deviceStatusDatas = WCSDispatch.getDeviceStatus(new List<string>() { transfeRelevance.S_DEVICE_NO });
                       /* // 业务代码，勿删
                        var deviceStatusDatas = WCSDispatch.getDeviceStatus(new List<string>() { bufferLocConfig.deviceNo });
                        if (deviceStatusDatas != null && deviceStatusDatas.Count > 0)
                        {
                            var deviceStatus = deviceStatusDatas[0];
@@ -588,17 +531,17 @@
                            {
                                photoStatus = deviceStatus.photoStatus == 1;
                            }
                            else 
                            else
                            {
                                WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{transfeRelevance.S_DEVICE_NO},设备当前处于不可用状态，请联系管理人员调整设备状态");
                                throw new BusinessException($"设备号:{transfeRelevance.S_DEVICE_NO},设备当前处于不可用状态，请联系管理人员调整设备状态");
                                WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{bufferLocConfig.deviceNo},设备当前处于不可用状态，请联系管理人员调整设备状态");
                                throw new BusinessException($"设备号:{bufferLocConfig.deviceNo},设备当前处于不可用状态，请联系管理人员调整设备状态");
                            }
                        }
                        else 
                        else
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{transfeRelevance.S_DEVICE_NO},查询设备状态失败，请联系工作人员查看设备是否正常");
                            throw new BusinessException($"设备号:{transfeRelevance.S_DEVICE_NO},查询设备状态失败，请联系工作人员查看设备是否正常");
                        }*/
                            WMSHelper.addAlarmRecord("流程异常", "高", $"设备号:{bufferLocConfig.deviceNo},查询设备状态失败，请联系工作人员查看设备是否正常");
                            throw new BusinessException($"设备号:{bufferLocConfig.deviceNo},查询设备状态失败，请联系工作人员查看设备是否正常");
                        }*/               
                    }
                    else
                    {
@@ -626,133 +569,130 @@
                    throw new BusinessException($"库内没有空余货位");
                }

                Container container = ContainerHelper.GetCntr(cntrCode);
                if (container != null)
                LjMesTask mesTask = WMSHelper.getLjMesTaskByCntr(cntrNo);
                // 1.创建满料下线作业
                var wmsTask = new WMSTask()
                {
                    // 1.创建满料下线作业
                    var wmsTask = new WMSTask()
                    S_CNTR_CODE = cntrNo,
                    S_CODE = WMSHelper.GenerateTaskNo(),
                    S_START_LOC = startLoc.S_CODE,
                    S_START_AREA = startLoc.S_AREA_CODE,
                    S_END_LOC = endLoc.S_CODE,
                    S_END_AREA = endLoc.S_AREA_CODE,
                    S_TYPE = "满料/异常工装入库任务(直连)",
                    S_OP_DEF_NAME = "满料/异常工装入库任务(直连)",
                    S_OP_DEF_CODE = mesTask != null ? mesTask.ID.ToString() : null,
                    T_START_TIME = DateTime.Now,
                };
                if (WMSHelper.CreateWmsTask(wmsTask))
                {
                    int priority = 10;
                    Dictionary<int, WCSTask> taskDic = new Dictionary<int, WCSTask>();

                    // 是否创建空工装出口任务
                    if (photoStatus || true )
                    {
                        S_CNTR_CODE = cntrCode,
                        S_CODE = WMSHelper.GenerateTaskNo(),
                        Location kgzStartLoc = WMSHelper.getOutStockStartLoc(logicConfig.S_AREA_CODE, null);
                        Location kgzEndLoc = LocationHelper.GetLoc(logicConfig.S_LKBKHCLOC);
                        if (kgzStartLoc == null)
                        {
                            WMSHelper.DeleteWmsTask(wmsTask.S_CODE);
                            WMSHelper.addAlarmRecord("流程异常", "高", $"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                            throw new BusinessException($"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                        }
                        if (kgzEndLoc == null)
                        {
                            WMSHelper.DeleteWmsTask(wmsTask.S_CODE);
                            WMSHelper.addAlarmRecord("流程异常", "中", $"空工装缓存位:{logicConfig.S_LKBKHCLOC},没有在WMS系统中录入");
                            throw new BusinessException($"空工装缓存位:{logicConfig.S_LKBKHCLOC},没有在WMS系统中录入");
                        }

                        var locCntrRels = LocationHelper.GetLocCntr(kgzStartLoc.S_CODE);
                        if (locCntrRels.Count > 0)
                        {
                            string kgzCntrCode = locCntrRels[0].S_CNTR_CODE;
                            // 如是胎侧直连模式，则提高空工装出库任务优先级
                            if (logicConfig.S_TASK_TYPE == "1")
                            {
                                priority = 99;
                            }
                            WCSTask kgzWcsTask = new WCSTask()
                            {
                                S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                S_OP_CODE = wmsTask.S_CODE,
                                S_CODE = WCSHelper.GenerateTaskNo(),
                                S_CNTR_CODE = kgzCntrCode,
                                S_TYPE = "空工装出库任务",
                                S_START_LOC = kgzStartLoc.S_CODE,
                                S_START_AREA = kgzStartLoc.S_AREA_CODE,
                                S_END_LOC = kgzEndLoc.S_CODE,
                                S_END_AREA = kgzEndLoc.S_AREA_CODE,
                                S_SCHEDULE_TYPE = "WCS",
                                N_PRIORITY = priority,
                                T_START_TIME = DateTime.Now,
                            };
                            taskDic.Add(priority, kgzWcsTask);
                        }
                        else
                        {
                            WMSHelper.DeleteWmsTask(wmsTask.S_CODE);
                            WMSHelper.addAlarmRecord("流程异常", "高", $"查询空工装货位错误，货位：{kgzStartLoc.S_CODE}没有空工装");
                            throw new BusinessException($"查询空工装货位错误，货位：{kgzStartLoc.S_CODE}没有空工装");
                        }
                    }

                    // 如是帘布直连模式则，提高满料入库优先级
                    if (logicConfig.S_TASK_TYPE == "2")
                    {
                        priority = 99;
                    }
                    else
                    {
                        priority = 10;
                    }

                    WCSTask wcsTask = new WCSTask()
                    {
                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                        S_OP_CODE = wmsTask.S_CODE,
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                        S_TYPE = wmsTask.S_TYPE,
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_LOC = endLoc.S_CODE,
                        S_END_AREA = endLoc.S_AREA_CODE,
                        S_TYPE = "满料/异常工装入库任务(直连)",
                        S_OP_DEF_NAME = "满料/异常工装入库任务(直连)",
                        S_OP_DEF_CODE = mesTask != null ? mesTask.ID.ToString() : null,
                        S_SCHEDULE_TYPE = "WCS",
                        N_PRIORITY = priority,
                        T_START_TIME = DateTime.Now,
                    };
                    if (WMSHelper.CreateWmsTask(wmsTask))
                    taskDic.Add(priority, wcsTask);

                    var tasks = taskDic.OrderByDescending(a => a.Key).Select(a => a.Value).ToList();
                    foreach (var task in tasks) 
                    {
                        int priority = 10;

                        // 是否创建空工装出口任务
                        if (photoStatus)
                        {
                            Location kgzStartLoc = WMSHelper.getOutStockStartLoc(logicConfig.S_AREA_CODE, null);
                            Location kgzEndLoc = LocationHelper.GetLoc(logicConfig.S_LKBKHCLOC);
                            if (kgzStartLoc == null)
                            {
                                WMSHelper.DeleteWmsTask(wmsTask.S_CODE);
                                WMSHelper.addAlarmRecord("流程异常", "高", $"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                                throw new BusinessException($"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                            }
                            if (kgzEndLoc == null)
                            {
                                WMSHelper.DeleteWmsTask(wmsTask.S_CODE);
                                WMSHelper.addAlarmRecord("流程异常", "中", $"空工装缓存位:{logicConfig.S_LKBKHCLOC},没有在WMS系统中录入");
                                throw new BusinessException($"空工装缓存位:{logicConfig.S_LKBKHCLOC},没有在WMS系统中录入");
                            }

                            var locCntrRels = LocationHelper.GetLocCntr(kgzStartLoc.S_CODE);
                            if (locCntrRels.Count > 0)
                            {
                                string kgzCntrCode = locCntrRels[0].S_CNTR_CODE;
                                // 如是胎侧直连模式，则提高空工装出库任务优先级
                                if (logicConfig.S_TASK_TYPE == "1")
                                {
                                    priority = 99;
                                }
                                WCSTask kgzWcsTask = new WCSTask()
                                {
                                    S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                    S_OP_CODE = wmsTask.S_CODE,
                                    S_CODE = WCSHelper.GenerateTaskNo(),
                                    S_CNTR_CODE = kgzCntrCode,
                                    S_TYPE = "空工装出库任务",
                                    S_START_LOC = kgzStartLoc.S_CODE,
                                    S_START_AREA = kgzStartLoc.S_AREA_CODE,
                                    S_END_LOC = kgzEndLoc.S_CODE,
                                    S_END_AREA = kgzEndLoc.S_AREA_CODE,
                                    S_SCHEDULE_TYPE = "WCS",
                                    N_PRIORITY = priority,
                                    T_START_TIME = DateTime.Now,
                                };

                                if (WCSHelper.CreateTask(kgzWcsTask))
                                {
                                    // 起点、终点加锁
                                    LocationHelper.LockLoc(kgzWcsTask.S_START_LOC, 2);
                                    LocationHelper.LockLoc(kgzWcsTask.S_END_LOC, 1);
                                }
                            }
                            else
                            {
                                WMSHelper.DeleteWmsTask(wmsTask.S_CODE);
                                WMSHelper.addAlarmRecord("流程异常", "高", $"查询空工装货位错误，货位：{kgzStartLoc.S_CODE}没有空工装");
                                throw new BusinessException($"查询空工装货位错误，货位：{kgzStartLoc.S_CODE}没有空工装");
                            }
                        }

                        // 如是帘布直连模式则，提高满料入库优先级
                        if (logicConfig.S_TASK_TYPE == "2")
                        {
                            priority = 99;
                        }
                        else 
                        {
                            priority = 10;
                        }

                        WCSTask wcsTask = new WCSTask()
                        {
                            S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                            S_OP_CODE = wmsTask.S_CODE,
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                            S_TYPE = wmsTask.S_TYPE,
                            S_START_LOC = startLoc.S_CODE,
                            S_START_AREA = startLoc.S_AREA_CODE,
                            S_END_LOC = endLoc.S_CODE,
                            S_END_AREA = endLoc.S_AREA_CODE,
                            S_SCHEDULE_TYPE = "WCS",
                            N_PRIORITY = priority,
                            T_START_TIME = DateTime.Now,
                        };

                        if (WCSHelper.CreateTask(wcsTask))
                        if (WCSHelper.CreateTask(task))
                        {
                            // 起点、终点加锁
                            LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                            LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);
                        }

                        // 更新作业任务状态
                        wmsTask.N_B_STATE = 1;
                        WMSHelper.UpdateTaskState(wmsTask);

                        // 5.作业创建完成后，读取中间表，更新中间表状态
                        if (mesTask != null)
                        {
                            WMSHelper.readLjMesOffItemTask(wmsTask.S_CODE, mesTask.ID);
                            LocationHelper.LockLoc(task.S_START_LOC, 2);
                            LocationHelper.LockLoc(task.S_END_LOC, 1);
                        }
                    }
                }
                else
                {
                    WMSHelper.addAlarmRecord("流程异常", "高", $"未查询到容器为:{cntrCode}的容器");
                    throw new BusinessException($"未查询到容器为:{cntrCode}的容器");

                    // 更新作业任务状态
                    wmsTask.N_B_STATE = 1;
                    WMSHelper.UpdateTaskState(wmsTask);

                    // 5.作业创建完成后，读取中间表，更新中间表状态
                    if (mesTask != null)
                    {
                        WMSHelper.readLjMesOffItemTask(wmsTask.S_CODE, mesTask.ID);
                    }
                    else 
                    {
                        ContainerHelper.UpdateCntrState(cntrNo, 1);
                        WMSHelper.addRfidAnomalyRecord(cntrNo, 3, offLineLoc, null);
                    }
                }
            }
            catch (BusinessException be) 
@@ -813,7 +753,7 @@
                    return responseResult;
                }

                middleLoc = WMSHelper.GetMinTaskTransfeLoc(startLoc.S_AREA_CODE, 2 , 2);
                middleLoc = WMSHelper.GetMinTaskTransfeLoc(startLoc.S_AREA_CODE, 2 );
                if (middleLoc == null) {
                    WMSHelper.addAlarmRecord("流程异常", "高", $"MES叫料任务{mesTask.ID},立库接驳位可能处于锁定或禁用状态，请查看");
                    responseResult.code = 1;
@@ -987,7 +927,6 @@
                                // 更新出库任务中间表状态
                                WMSHelper.updateLotOutTask(cst.S_CNTR_CODE, "2");
                            }

                        }
                    }
                }
@@ -1011,45 +950,27 @@
                if (mst != null && mst.N_B_STATE < 2) {

                    int emptyFlag = 0;  // 容器空满标识
                    Container cntr = ContainerHelper.GetCntr(cst.S_CNTR_CODE);
                    if (cntr != null && cntr.N_DETAIL_COUNT > 0) {
                    var cntrItemRels = ContainerHelper.GetCntrItemRel(cst.S_CNTR_CODE);
                    if (cntrItemRels.Count > 0) {
                        emptyFlag = 1;
                    }

                    // 1：堆垛机放货异常申请新终点
                    if (model.applyType == 1) {
                        // 报警：流程异常
                        WMSHelper.addAlarmRecord("流程异常", "低", $"堆垛机放货异常，异常货位：{cst.S_END_LOC}");
                        WMSHelper.addAlarmRecord("流程异常", "中", $"堆垛机放货异常，任务号：{cst.S_CODE}，异常货位：{cst.S_END_LOC}");

                        // 1.将异常货位上锁，并报警
                        LocationHelper.LockLoc(cst.S_END_LOC, 3);

                        // 2.查询新的入库终点
                        Location endLoc = WMSHelper.getInStockEndLoc(cst.S_END_AREA, emptyFlag);
                        Location endLoc = WMSHelper.getInStockEndLoc(cst.S_END_AREA, emptyFlag );
                        cst.S_END_LOC = endLoc.S_CODE;
                        WCSHelper.UpdateEndLoc(cst);

                        LocationHelper.LockLoc(endLoc.S_CODE, 1);
                        applyDest.destLoc = endLoc.S_CODE;
                    }
                    else if (model.applyType == 2)
                    {
                        if (cst.S_END_LOC == "虚拟库位")
                        {
                            var transfeRelevance = WMSHelper.GetTransfeRelevance(model.loc);  // 接驳位关联属性
                            if (transfeRelevance != null)
                            {
                                // 1.查询新的入库终点
                                Location endLoc = WMSHelper.getInStockEndLoc(transfeRelevance.S_RELE_AREA, emptyFlag);
                                cst.S_END_LOC = endLoc.S_CODE;
                                WCSHelper.UpdateEndLoc(cst);

                                LocationHelper.LockLoc(endLoc.S_CODE, 1);
                                applyDest.destLoc = endLoc.S_CODE;
                            }
                        }
                    }

                }
            }
            result.data = applyDest;
@@ -1059,7 +980,7 @@
        /// <summary>
        /// AGV申请终点
        /// 顺序 RFID验证 -> RFID与任务号验证 -> 物料合格状态验证 -> 虚拟终点
        /// 申请类型： 1.虚拟终点 2.RFID与任务不匹配 3.物料状态不合格
        /// 申请类型： 1.正常 2.异常
        /// 入库策略：先计算库区的容积率，再计算库区对应的入库站台的任务数，都取最小的
        /// 
        /// 1.确定任务是否在执行中
@@ -1115,7 +1036,8 @@
            {
                WMSHelper.addAlarmRecord("系统错误","高", $"AGV申请终点，WMS内部错误，错误原因：{ex.Message}", "AGV");
            }
            return null;
            LogHelper.Info($"变更AGV终点：{applyDest}", "AGV");
            return applyDest;
        }

        /// <summary>
@@ -1129,64 +1051,63 @@
        /// <returns></returns>
        public static string applyAgvDestXC(string applyType, WMSTask mst, WCSTask cst)
        {
            string destLoc = null;
            Location agvEndLoc = null;
            Location wmsEndLoc = null;
            Location endLoc = null;
            if (applyType == "1")
            {
                if (mst.S_TYPE == "余料/空工装入库")
                {
                    var mesTask = WMSHelper.GetLjMesTaskById(int.Parse(mst.S_OP_DEF_CODE));
                    if (mesTask.QTY != 0)
                    var bo = int.TryParse(mst.S_OP_DEF_CODE, out int mesId);
                    if (bo) 
                    {
                        var awaitTask = WMSHelper.GetAwaitWmsTaskByMaterialCode(mesTask.MATERIAL_CODE);
                        if (awaitTask != null)
                        var mesTask = WMSHelper.GetLjMesTaskById(mesId);
                        if (mesTask.QTY != 0)
                        {
                            // 取消任务
                            ApiHelper.cancelTask(awaitTask.S_CODE);
                            // 修改终点
                            agvEndLoc = LocationHelper.GetLoc(awaitTask.S_END_LOC);
                            wmsEndLoc = agvEndLoc;
                            mst.S_TYPE = "叫料出库任务";
                            var awaitTask = WMSHelper.GetAwaitWmsTaskByMaterialCode(mesTask.MATERIAL_CODE);
                            if (awaitTask != null)
                            {
                                // 取消任务
                                ApiHelper.cancelTask(awaitTask.S_CODE);
                                // 修改终点
                                endLoc = LocationHelper.GetLoc(awaitTask.S_END_LOC);
                                mst.S_TYPE = "叫料出库任务";
                            }
                        }
                    }
                }
            }

            if (agvEndLoc == null)
            if (endLoc == null)
            {
                string msg = "";
                if (applyType == "2" || applyType == "3" || applyType == "4")
                if (applyType == "2")
                {
                    cst.S_TYPE = cst.S_TYPE + "【异常】";
                    msg = "工装异常";
                }

                // TODO 反馈斜裁立库异常，请求斜裁入库终点
                agvEndLoc = null;

                string locCode = "XCCRKZTKQ-1-1";
                endLoc = LocationHelper.GetLoc(locCode);
            }

            if (agvEndLoc != null)
            if (endLoc != null)
            {
                destLoc = agvEndLoc.S_CODE;

                cst.S_END_LOC = agvEndLoc.S_CODE;
                cst.S_END_AREA = agvEndLoc.S_AREA_CODE;
                cst.S_END_LOC = endLoc.S_CODE;
                cst.S_END_AREA = endLoc.S_AREA_CODE;
                WCSHelper.UpdateEndLoc(cst);
            }

            if (wmsEndLoc != null)
            {
                mst.S_END_LOC = wmsEndLoc.S_CODE;
                mst.S_END_AREA = wmsEndLoc.S_AREA_CODE;
                mst.S_END_LOC = endLoc.S_CODE;
                mst.S_END_AREA = endLoc.S_AREA_CODE;
                WMSHelper.UpdateTaskEnd(mst);

                return endLoc.S_CODE;
            }
            return destLoc;
            return null;
        }

        /// <summary>
        /// AGV申请终点
        /// 场景：1.余料/空工装入库任务（成型机） 2.满料/空工装入库（机台） 3.满料/空工装出库异常 4.满料/空工装入库异常
        /// </summary>
        /// <param name="applyType">1.正常 2.RFID与任务RFID不匹配 3.物料状态不合格</param>
        /// <param name="loc"></param>
@@ -1238,7 +1159,7 @@
                        wmsEndLoc = WMSHelper.getInStockEndLoc(null, container.N_DETAIL_COUNT == 0 ? 0 : 1, container.N_TYPE);
                        if (wmsEndLoc != null)
                        {
                            agvEndLoc = WMSHelper.GetMinTaskTransfeLoc(wmsEndLoc.S_AREA_CODE, 1, 2);  // 1.立库接驳位 1.入库 2.非直连
                            agvEndLoc = WMSHelper.GetMinTaskTransfeLoc(wmsEndLoc.S_AREA_CODE, 1);  
                            if (agvEndLoc != null)
                            {
                                LogHelper.Info($"创建立库站台到立库的预创建任务，agv终点货位:{agvEndLoc.S_CODE},立库终点货位:{wmsEndLoc.S_CODE}", "AGV");
@@ -1268,7 +1189,7 @@
                            }
                            else
                            {
                                WMSHelper.addAlarmRecord("流程异常", "高", $"AGV申请终点失败，未查询到立库接驳位");
                                WMSHelper.addAlarmRecord("流程异常", "高", $"AGV申请终点失败，立库:{wmsEndLoc.S_AREA_CODE}未配置立库接驳位");
                                return null;
                            }
                        }
@@ -1314,7 +1235,7 @@
                        wmsEndLoc = WMSHelper.getInStockEndLoc(null, container.N_DETAIL_COUNT == 0 ? 0 : 1, container.N_TYPE);
                        if (wmsEndLoc != null)
                        {
                            agvEndLoc = WMSHelper.GetMinTaskTransfeLoc(wmsEndLoc.S_AREA_CODE, 1, 2);  // 1.立库接驳位 1.入库 2.非直连
                            agvEndLoc = WMSHelper.GetMinTaskTransfeLoc(wmsEndLoc.S_AREA_CODE, 1); 
                            if (agvEndLoc != null)
                            {
                                LogHelper.Info($"创建立库站台到立库的预创建任务，agv终点货位:{agvEndLoc.S_CODE},立库终点货位:{wmsEndLoc.S_CODE}", "AGV");
@@ -1325,7 +1246,7 @@
                                    S_OP_CODE = mst.S_CODE,
                                    S_CODE = WCSHelper.GenerateTaskNo(),
                                    S_CNTR_CODE = cst.S_CNTR_CODE,
                                    S_TYPE = cst.S_TYPE + "【异常】",
                                    S_TYPE = "异常工装入库",
                                    S_START_LOC = agvEndLoc.S_CODE,
                                    S_START_AREA = agvEndLoc.S_AREA_CODE,
                                    S_END_LOC = wmsEndLoc.S_CODE,
@@ -1333,6 +1254,7 @@
                                    S_SCHEDULE_TYPE = "WCS",
                                    N_PRIORITY = 10,
                                    N_B_STATE = -1,
                                    S_B_STATE = "预创建",
                                    T_START_TIME = DateTime.Now,
                                };
                                if (WCSHelper.CreateTask(wcsTask))
@@ -1361,19 +1283,14 @@
                        return null;
                    }
                }
            }

            // 重新发起新任务
            if (applyType != "1")
            {
                var mesTask = WMSHelper.GetLjMesTaskByAgvorderId(mst.S_CODE);
                if (mesTask != null) 
                if (mesTask != null)
                {
                    if (mst.S_TYPE.Contains("叫料出库任务"))
                    {
                        LogHelper.Info($"叫料出库任务异常，再次发起叫料出库任务", "AGV");
                        callMaterial(mesTask.MATERIAL_CODE, mesTask.POSITION_ID, mesTask.ID);
                        /*againCallMaterial(mst, mesTask.MATERIAL_CODE, mesTask.POSITION_ID, mesTask.ID);*/
                    }

                    // 满料下线（非直连）
@@ -1383,7 +1300,7 @@
                        var logicConfig = WMSHelper.getLogicConfigByJtCode(mesTask.EQP);
                        if (logicConfig != null)
                        {
                            triggerItemOffLineFlow4(mesTask.POSITION_ID, logicConfig, mesTask);
                            triggerItemOffLineFlow4(mesTask.POSITION_ID, mst.S_CNTR_CODE, logicConfig, mesTask);
                        }
                        else
                        {
@@ -1411,118 +1328,112 @@
        /// 成新机叫料
        /// </summary>
        /// <param name="materialCode"></param>
        /// <param name="endLocCode"></param>
        /// <param name="jtNo"></param>
        /// <param name="mesTaskId"></param>
        public static void callMaterial(string materialCode, string endLocCode, int mesTaskId)
        public static void callMaterial(string materialCode, string jtNo, int mesTaskId)
        {
            var oldWmsTask = WMSHelper.GetWmsTaskByEnd(endLocCode);
            if (oldWmsTask == null) {
                string cntrCode = "";
                Location endLoc = LocationHelper.GetLoc(endLocCode);
            string cntrCode = "";
            var mesTask = WMSHelper.GetLjMesTaskById(mesTaskId);

            if (mesTask != null)
            {
                Location endLoc = WMSHelper.getCallMaterialLocCode(jtNo);
                if (endLoc != null)
                {
                    Location middleLoc = null;
                    Location startLoc = WMSHelper.getOutStockStartLoc(null, materialCode);
                    if (startLoc == null)
                    {
                        var mesTask = WMSHelper.GetLjMesTaskById(mesTaskId);
                        if (mesTask != null)
                        {
                            mesTask.RECEIVE_MSG = "没有库存";
                            WMSHelper.updateLjMesTask(mesTask);
                        }
                        WMSHelper.addAlarmRecord("流程异常", "高", $"叫料失败，物料:{materialCode}没有库存");
                        return;
                    }
                    else 
                    if (startLoc != null)
                    {
                        var locCntrRels = LocationHelper.GetLocCntr(startLoc.S_CODE);
                        if (locCntrRels.Count > 0)
                        {
                            cntrCode = locCntrRels[0].S_CNTR_CODE;
                        }
                        else 
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"查询物料异常，货位:{startLoc.S_CODE}缺少容器信息");
                            return;
                        }
                    }

                    middleLoc = WMSHelper.GetTransfeRelevanceLoc(startLoc.S_AREA_CODE, 1 , 2);

                    if (middleLoc != null)
                    {
                        // 1.创建成新机叫料作业
                        var wmsTask = new WMSTask()
                        {
                            S_CNTR_CODE = cntrCode,
                            S_CODE = WMSHelper.GenerateTaskNo(),
                            S_START_LOC = startLoc.S_CODE,
                            S_START_AREA = startLoc.S_AREA_CODE,
                            S_END_LOC = endLoc.S_CODE,
                            S_END_AREA = endLoc.S_AREA_CODE,
                            S_TYPE = "叫料出库任务",
                            S_OP_DEF_CODE = mesTaskId.ToString(),
                            S_OP_DEF_NAME = "成型机叫料出库任务",
                            T_START_TIME = DateTime.Now,
                        };
                        if (WMSHelper.CreateWmsTask(wmsTask))
                        {
                            WCSTask wcsTask = new WCSTask()
                            middleLoc = WMSHelper.GetMinTaskTransfeLoc(startLoc.S_AREA_CODE, 2);
                            if (middleLoc != null)
                            {
                                S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                S_OP_CODE = wmsTask.S_CODE,
                                S_CODE = WCSHelper.GenerateTaskNo(),
                                S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                S_TYPE = wmsTask.S_TYPE + "-WCS",
                                S_START_LOC = startLoc.S_CODE,
                                S_START_AREA = startLoc.S_AREA_CODE,
                                S_END_LOC = middleLoc.S_CODE,
                                S_END_AREA = middleLoc.S_AREA_CODE,
                                S_SCHEDULE_TYPE = "WCS",
                                N_PRIORITY = 10,
                                T_START_TIME = DateTime.Now,
                            };
                                // 1.创建成新机叫料作业
                                var wmsTask = new WMSTask()
                                {
                                    S_CNTR_CODE = cntrCode,
                                    S_CODE = WMSHelper.GenerateTaskNo(),
                                    S_START_LOC = startLoc.S_CODE,
                                    S_START_AREA = startLoc.S_AREA_CODE,
                                    S_END_LOC = endLoc.S_CODE,
                                    S_END_AREA = endLoc.S_AREA_CODE,
                                    S_TYPE = "叫料出库任务",
                                    S_OP_DEF_CODE = mesTaskId.ToString(),
                                    S_OP_DEF_NAME = "成型机叫料出库任务",
                                    T_START_TIME = DateTime.Now,
                                };
                                if (WMSHelper.CreateWmsTask(wmsTask))
                                {
                                    WCSTask wcsTask = new WCSTask()
                                    {
                                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                        S_OP_CODE = wmsTask.S_CODE,
                                        S_CODE = WCSHelper.GenerateTaskNo(),
                                        S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                        S_TYPE = wmsTask.S_TYPE,
                                        S_START_LOC = startLoc.S_CODE,
                                        S_START_AREA = startLoc.S_AREA_CODE,
                                        S_END_LOC = middleLoc.S_CODE,
                                        S_END_AREA = middleLoc.S_AREA_CODE,
                                        S_SCHEDULE_TYPE = "WCS",
                                        N_PRIORITY = 10,
                                        T_START_TIME = DateTime.Now,
                                    };

                            if (WCSHelper.CreateTask(wcsTask))
                            {
                                // 起点、终点加锁
                                LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                                LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);
                                    if (WCSHelper.CreateTask(wcsTask))
                                    {
                                        // 起点、终点加锁
                                        LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                                        LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                                // 更新作业任务状态
                                wmsTask.N_B_STATE = 1;
                                WMSHelper.UpdateTaskState(wmsTask);
                                        // 更新作业任务状态
                                        wmsTask.N_B_STATE = 1;
                                        WMSHelper.UpdateTaskState(wmsTask);
                                    }

                                    // 预创建二段任务
                                    WCSTask twoWcsTask = new WCSTask()
                                    {
                                        S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                        S_OP_CODE = wmsTask.S_CODE,
                                        S_CODE = WCSHelper.GenerateTaskNo(),
                                        S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                        S_TYPE = wmsTask.S_TYPE,
                                        S_START_LOC = middleLoc.S_CODE,
                                        S_START_AREA = middleLoc.S_AREA_CODE,
                                        S_END_LOC = endLoc.S_CODE,
                                        S_END_AREA = endLoc.S_AREA_CODE,
                                        S_SCHEDULE_TYPE = "AGV",
                                        N_PRIORITY = 10,
                                        T_START_TIME = DateTime.Now,
                                        N_B_STATE = -1
                                    };
                                    WCSHelper.CreateTask(twoWcsTask);
                                    WMSHelper.readLjMesCallItemTask(wmsTask.S_CODE, mesTaskId);
                                }
                            }

                            // 预创建二段任务
                            WCSTask twoWcsTask = new WCSTask()
                            else
                            {
                                S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                S_OP_CODE = wmsTask.S_CODE,
                                S_CODE = WCSHelper.GenerateTaskNo(),
                                S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                S_TYPE = wmsTask.S_TYPE,
                                S_START_LOC = middleLoc.S_CODE,
                                S_START_AREA = middleLoc.S_AREA_CODE,
                                S_END_LOC = endLoc.S_CODE,
                                S_END_AREA = endLoc.S_AREA_CODE,
                                S_SCHEDULE_TYPE = "AGV",
                                N_PRIORITY = 10,
                                T_START_TIME = DateTime.Now,
                                N_B_STATE = -1
                            };
                            WCSHelper.CreateTask(twoWcsTask);

                            WMSHelper.readLjMesCallItemTask(wmsTask.S_CODE, mesTaskId);
                                WMSHelper.addAlarmRecord("流程异常", "高", $"成型机叫料失败，库区{startLoc.S_AREA_CODE}未查询到可用的接驳位");
                            }
                        }
                        else
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"成型机叫料失败，开始货位:{startLoc.S_CODE}异常，缺少容器信息");
                        }
                    }
                    else 
                    else
                    {
                        WMSHelper.addAlarmRecord("流程异常", "高", $"库区{startLoc.S_AREA_CODE}未查询到可用的接驳位");
                    }
                        mesTask.AWAIT_MSG = "库存不足";
                        WMSHelper.updateLjMesTask(mesTask);
                        WMSHelper.addAlarmRecord("流程异常", "高", $"成型机叫料失败，物料:{materialCode}库存不足");
                    }  
                }
            }
            
        }
        
        /// <summary>
@@ -1534,14 +1445,170 @@
        /// <param name="materialCode"></param>
        /// <param name="endLocCode"></param>
        /// <param name="mesTaskId"></param>
        public static void callMaterialHDK(string materialCode, string endLocCode, int mesTaskId)
        public static void callMaterialXC(string materialCode, string endLocCode, int mesTaskId)
        {
            // 1.查询环带库物料库存
            var mesTask = WMSHelper.GetLjMesTaskById(mesTaskId);
            if (mesTask != null) 
            {
                // 1.查询环带库物料库存最早入库时间
                DateTime inStockTimeXc = DateTime.MinValue;

            // 2.查询中转库库存，根据入库时间 进行先入先出
                // 2.查询中转库库存
                DateTime inStockTime = WMSHelper.getZZKInventoryInfo(materialCode);

            // 3.将MES任务写入环带库任务中间表
            WMSHelper.addLjXcTask(mesTaskId);
                // 3.根据先进先出计算出库的物料是环带库 还是中转库
                if (inStockTime >= inStockTimeXc)
                {
                    Location endLoc = WMSHelper.getCallMaterialLocCode(mesTask.EQP);
                    if (endLoc != null) 
                    {
                        // 4.创建斜裁-成新机叫料作业
                        var wmsTask = new WMSTask()
                        {
                            S_CODE = WMSHelper.GenerateTaskNo(),
                            S_CNTR_CODE = "",
                            S_START_LOC = "虚拟起点",
                            S_START_AREA = "虚拟库区",
                            S_END_LOC = endLoc.S_CODE,
                            S_END_AREA = endLoc.S_AREA_CODE,
                            S_TYPE = "叫料出库任务",
                            S_OP_DEF_CODE = mesTask.ID.ToString(),
                            S_OP_DEF_NAME = "成型机叫料出库任务(斜裁)",
                            T_START_TIME = DateTime.Now,
                            N_B_STATE = 0
                        };
                        if (WMSHelper.CreateWmsTask(wmsTask))
                        {
                            WCSTask wcsTask = new WCSTask()
                            {
                                S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                S_OP_CODE = wmsTask.S_CODE,
                                S_CODE = WCSHelper.GenerateTaskNo(),
                                S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                S_TYPE = wmsTask.S_TYPE,
                                S_START_LOC = wmsTask.S_START_LOC,
                                S_START_AREA = wmsTask.S_START_AREA,
                                S_END_LOC = endLoc.S_CODE,
                                S_END_AREA = endLoc.S_AREA_CODE,
                                S_SCHEDULE_TYPE = "AGV",
                                N_PRIORITY = 10,
                                T_START_TIME = DateTime.Now,
                                N_B_STATE = -1,
                                S_B_STATE = "预创建",
                            };

                            if (WCSHelper.CreateTask(wcsTask))
                            {
                                // 起点、终点加锁
                                LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                                LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                                // 5.将MES任务写入斜裁任务中间表
                                mesTask.AGVORDER_ID = wcsTask.S_CODE;
                                WMSHelper.addLjXcTask(mesTask);
                            }
                        }
                    }
                }
                else
                {
                    //中转库物料出库
                    Location startLoc = WMSHelper.getOutStockStartLoc(null, materialCode);
                    if (startLoc != null)
                    {
                        var locCntrRels = LocationHelper.GetLocCntr(startLoc.S_CODE);
                        if (locCntrRels != null && locCntrRels.Count > 0)
                        {
                            Location middleLoc = null;
                            Location endLoc = WMSHelper.getCallMaterialLocCode(mesTask.EQP);
                            if (endLoc != null)
                            {
                                middleLoc = WMSHelper.GetMinTaskTransfeLoc(startLoc.S_AREA_CODE, 2);
                                if (middleLoc != null)
                                {
                                    // 1.创建成新机叫料作业
                                    var wmsTask = new WMSTask()
                                    {
                                        S_CNTR_CODE = locCntrRels[0].S_CNTR_CODE,
                                        S_CODE = WMSHelper.GenerateTaskNo(),
                                        S_START_LOC = startLoc.S_CODE,
                                        S_START_AREA = startLoc.S_AREA_CODE,
                                        S_END_LOC = endLoc.S_CODE,
                                        S_END_AREA = endLoc.S_AREA_CODE,
                                        S_TYPE = "叫料出库任务",
                                        S_OP_DEF_CODE = mesTaskId.ToString(),
                                        S_OP_DEF_NAME = "成型机叫料出库任务",
                                        T_START_TIME = DateTime.Now,
                                    };
                                    if (WMSHelper.CreateWmsTask(wmsTask))
                                    {
                                        WCSTask wcsTask = new WCSTask()
                                        {
                                            S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                            S_OP_CODE = wmsTask.S_CODE,
                                            S_CODE = WCSHelper.GenerateTaskNo(),
                                            S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                            S_TYPE = wmsTask.S_TYPE,
                                            S_START_LOC = startLoc.S_CODE,
                                            S_START_AREA = startLoc.S_AREA_CODE,
                                            S_END_LOC = middleLoc.S_CODE,
                                            S_END_AREA = middleLoc.S_AREA_CODE,
                                            S_SCHEDULE_TYPE = "WCS",
                                            N_PRIORITY = 10,
                                            T_START_TIME = DateTime.Now,
                                        };

                                        if (WCSHelper.CreateTask(wcsTask))
                                        {
                                            // 起点、终点加锁
                                            LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                                            LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                                            // 更新作业任务状态
                                            wmsTask.N_B_STATE = 1;
                                            WMSHelper.UpdateTaskState(wmsTask);
                                        }

                                        // 预创建二段任务
                                        WCSTask twoWcsTask = new WCSTask()
                                        {
                                            S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                                            S_OP_CODE = wmsTask.S_CODE,
                                            S_CODE = WCSHelper.GenerateTaskNo(),
                                            S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                                            S_TYPE = wmsTask.S_TYPE,
                                            S_START_LOC = middleLoc.S_CODE,
                                            S_START_AREA = middleLoc.S_AREA_CODE,
                                            S_END_LOC = endLoc.S_CODE,
                                            S_END_AREA = endLoc.S_AREA_CODE,
                                            S_SCHEDULE_TYPE = "AGV",
                                            N_PRIORITY = 10,
                                            T_START_TIME = DateTime.Now,
                                            N_B_STATE = -1
                                        };
                                        WCSHelper.CreateTask(twoWcsTask);
                                        WMSHelper.readLjMesCallItemTask(wmsTask.S_CODE, mesTaskId);
                                    }
                                }
                                else
                                {
                                    WMSHelper.addAlarmRecord("流程异常", "高", $"成型机叫料失败，库区{startLoc.S_AREA_CODE}未查询到可用的接驳位");
                                }
                            }
                            else
                            {
                                WMSHelper.addAlarmRecord("流程异常", "高", $"成型机叫料失败，开始货位:{startLoc.S_CODE}异常，缺少容器信息");
                            }
                        }
                        else
                        {
                            mesTask.AWAIT_MSG = "库存不足";
                            WMSHelper.updateLjMesTask(mesTask);
                            WMSHelper.addAlarmRecord("流程异常", "高", $"成型机叫料失败，物料:{materialCode}库存不足");
                        }
                    }
                }
            }
        }

        /// <summary>
@@ -1552,12 +1619,12 @@
        /// 3.创建余料回库作业，创建agv搬运任务，虚拟终点
        /// </summary>
        /// <param name="locCode">成型机叫料终点</param>
        public static void returnMaterialOrEmptyTray(string locCode) 
        /// <param name="jtNo">成型机叫料终点</param>
        public static void returnMaterialOrEmptyTray(string locCode ,string jtNo) 
        {
            if (locCode != null)
            {
                // 2.查询mes任务中间表
                var mesTask = WMSHelper.getLjMesTaskByLoc(locCode);
                var mesTask = WMSHelper.getLjMesTaskByJtNo(jtNo);
                if (mesTask != null)
                {
                    createReturnTask(locCode, mesTask);
@@ -1587,7 +1654,7 @@
                S_START_AREA = startLoc.S_AREA_CODE,
                S_END_LOC = endLoc.S_CODE,
                S_END_AREA = endLoc.S_AREA_CODE,
                S_TYPE = "余料/空工装入库任务" + suffix,
                S_TYPE = "余料/空工装入库任务",
                S_OP_DEF_CODE = mesTask.ID.ToString(),
                S_OP_DEF_NAME = "余料/空工装入库" + suffix,
                T_START_TIME = DateTime.Now
@@ -1656,7 +1723,7 @@
                        S_OP_CODE = mst.S_CODE,
                        S_CODE = WCSHelper.GenerateTaskNo(),
                        S_CNTR_CODE = cst.S_CNTR_CODE,
                        S_TYPE = "不合格品回库",
                        S_TYPE = "不合格品入库任务",
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_LOC = agvEndLoc.S_CODE,
@@ -1680,7 +1747,7 @@
                wmsEndLoc = WMSHelper.getInStockEndLoc(null, container.N_DETAIL_COUNT == 0 ? 0 : 1, container.N_TYPE);
                if (wmsEndLoc != null)
                {
                    agvEndLoc = WMSHelper.GetMinTaskTransfeLoc(wmsEndLoc.S_AREA_CODE, 1, 2);  // 1.立库接驳位 1.入库 2.非直连
                    agvEndLoc = WMSHelper.GetMinTaskTransfeLoc(wmsEndLoc.S_AREA_CODE, 1); 
                    if (agvEndLoc != null)
                    {
                        // 预先生成入库站台-立库终点的搬运任务
@@ -1690,7 +1757,7 @@
                            S_OP_CODE = mst.S_CODE,
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_CNTR_CODE = cst.S_CNTR_CODE,
                            S_TYPE = "不合格品回库",
                            S_TYPE = "不合格品入库任务",
                            S_START_LOC = startLoc.S_CODE,
                            S_START_AREA = startLoc.S_AREA_CODE,
                            S_END_LOC = agvEndLoc.S_CODE,
@@ -1714,7 +1781,7 @@
                            S_OP_CODE = mst.S_CODE,
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_CNTR_CODE = cst.S_CNTR_CODE,
                            S_TYPE = "不合格品回库",
                            S_TYPE = "不合格品入库任务",
                            S_START_LOC = agvEndLoc.S_CODE,
                            S_START_AREA = agvEndLoc.S_AREA_CODE,
                            S_END_LOC = wmsEndLoc.S_CODE,
@@ -1734,10 +1801,11 @@
                    }
                }

                if (cst.S_TYPE == "叫料出库任务")
                var bo = int.TryParse(mst.S_OP_DEF_CODE, out int mesId);
                if (bo) 
                {
                    var mesTask = WMSHelper.GetLjMesTaskByAgvorderId(mst.S_CODE);
                    callMaterial( mesTask.MATERIAL_CODE, mesTask.POSITION_ID, mesTask.ID);
                    var mesTask = WMSHelper.GetLjMesTaskById(mesId);
                    callMaterial(mesTask.MATERIAL_CODE, mesTask.POSITION_ID, mesTask.ID);
                }
            }
            return result;
@@ -2033,7 +2101,7 @@
            {
                var transfeRelevance = WMSHelper.GetTransfeRelevance(model.locCode);  // 接驳位属性
                LogHelper.Info($"原站台属性：{JsonConvert.SerializeObject(transfeRelevance)}", "WMS");
                if (transfeRelevance != null && transfeRelevance.N_PROPERTY == 2)
                if (transfeRelevance != null)
                {
                    if (model.signalType == "1")
                    {
@@ -2085,10 +2153,88 @@
            return result;
        }

        /// <summary>
        /// 斜裁物料出库任务
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public static ResponseResult createXcItemOutStockTask(XcItemOutStockModel model)
        {
            ResponseResult responseResult = new ResponseResult();
            Location startLoc = LocationHelper.GetLoc(model.startLoc);
            if (startLoc == null)
            {
                WMSHelper.addAlarmRecord("流程异常", "高", $"成型机叫料出库(斜裁)，起点:{model.startLoc}在WMS系统中不存在");
                responseResult.code = 201;
                responseResult.msg = $"起点:{model.startLoc}在WMS系统中不存在";
                return responseResult;
            }
            Location endLoc = WMSHelper.getCallMaterialLocCode(model.eqNo);
            if (endLoc != null)
            {
                var wmsTask = WMSHelper.GetWmsTaskByCntr(model.palletId);
                if (wmsTask == null)
                {
                    ContainerHelper.AddCntr(model.palletId);

                    // 1.创建斜裁-成新机叫料作业
                    wmsTask = new WMSTask()
                    {
                        S_CNTR_CODE = model.palletId,
                        S_CODE = WMSHelper.GenerateTaskNo(),
                        S_START_LOC = startLoc.S_CODE,
                        S_START_AREA = startLoc.S_AREA_CODE,
                        S_END_LOC = endLoc.S_CODE,
                        S_END_AREA = endLoc.S_AREA_CODE,
                        S_TYPE = "叫料出库任务",
                        S_OP_DEF_CODE = model.reqId,
                        S_OP_DEF_NAME = "成型机叫料出库任务(斜裁)",
                        T_START_TIME = DateTime.Now,
                    };
                    if (WMSHelper.CreateWmsTask(wmsTask))
                    {
                        WCSTask wcsTask = new WCSTask()
                        {
                            S_OP_NAME = wmsTask.S_OP_DEF_NAME,
                            S_OP_CODE = wmsTask.S_CODE,
                            S_CODE = WCSHelper.GenerateTaskNo(),
                            S_CNTR_CODE = wmsTask.S_CNTR_CODE,
                            S_TYPE = wmsTask.S_TYPE,
                            S_START_LOC = startLoc.S_CODE,
                            S_START_AREA = startLoc.S_AREA_CODE,
                            S_END_LOC = endLoc.S_CODE,
                            S_END_AREA = endLoc.S_AREA_CODE,
                            S_SCHEDULE_TYPE = "AGV",
                            N_PRIORITY = 10,
                            T_START_TIME = DateTime.Now,
                        };

                        if (WCSHelper.CreateTask(wcsTask))
                        {
                            // 起点、终点加锁
                            LocationHelper.LockLoc(wcsTask.S_START_LOC, 2);
                            LocationHelper.LockLoc(wcsTask.S_END_LOC, 1);

                            // 更新作业任务状态
                            wmsTask.N_B_STATE = 1;
                            WMSHelper.UpdateTaskState(wmsTask);
                        }
                    }
                }
            }
            else 
            {
                responseResult.code = 201;
                responseResult.msg = $"成型机机台:{model.eqNo}没有空余的叫料货位";
            }
            return responseResult;
        }

        //----------------------------------------------------------------------------------------------------------------------------
        public class LocModel
        {
            public string locCode { get; set; }
            public string locCode { get; set; }  // 返料货位编号
            public string jtNo { get; set; } // 机台号
        }

        public class ApplyDest {
@@ -2194,6 +2340,7 @@
        {
            public string reqId { get; set; }
            public string reqTime { get; set; }
            public string taskNo { get; set; } // 托盘号
            public string loc { get; set; } // 货位 上料点、下料点、读码位、称重位（必填）
            public string cntrNo { get; set; } // 托盘号
            public int signalType { get; set; } //请求类型 1:下线请求 2：叫料请求 3：读码请求（必填）
@@ -2218,6 +2365,7 @@
            public string loc { get; set; } // 货位 上料点、下料点、读码位、称重位（必填）
            public string cntrNo { get; set; } // 托盘号
            public string jtNo { get; set; } // 机台号
            public bool isNormal { get; set; } //是否异常
        }

        /// <summary>
@@ -2227,6 +2375,7 @@
        {
            public string loc { get; set; } // 货位 上料点、下料点、读码位、称重位（必填）
            public string cntrNo { get; set; } // 托盘号
            public string taskNo { get; set; } // 任务号
        }

        public class AddTaskModel {