印尼佳通-硫化流程出入库流程开发

杨前锦

2025-06-11 e0d89637030791ce1e7dd46ca5fdec9979977960

印尼佳通-硫化流程出入库流程开发

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

@@ -43,22 +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 if (endLoc.N_LOCK_STATE != 0) 
            {
                WMSHelper.addAlarmRecord("流程异常", "低", $"空工装出库，终点货位：{model.endLocCode}处于锁定状态");
                throw new BusinessException($"空工装出库，终点货位：{model.endLocCode}处于锁定状态");
            }

            var areaCodes = Settings.getRelAreaCodes(endLoc.S_AREA_CODE);
            if (areaCodes.Count == 0) 
            {
                WMSHelper.addAlarmRecord("流程异常", "低", $"未配置库区:{endLoc.S_AREA_CODE}的关联关系");
                throw new BusinessException($"未配置库区:{endLoc.S_AREA_CODE}的关联关系");
                WMSHelper.addAlarmRecord("流程异常", "低", $"空工装出库，未配置库区:{endLoc.S_AREA_CODE}的关联关系");
                throw new BusinessException($"空工装出库，未配置库区:{endLoc.S_AREA_CODE}的关联关系");
            }

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

            var locCntrRels = LocationHelper.GetLocCntr(startLoc.S_CODE);
@@ -139,7 +144,7 @@
                    var container = ContainerHelper.GetCntr(request.cntrNo);
                    if (container != null)
                    {
                        if (cst.S_CNTR_CODE == request.cntrNo)
                        if (cst.S_CNTR_CODE != request.cntrNo)
                        {
                            ContainerHelper.UpdateCntrState(cst.S_CNTR_CODE, 1);
                            WMSHelper.addRfidAnomalyRecord(cst.S_CNTR_CODE, 2, request.loc, cst.S_CODE);
@@ -150,6 +155,8 @@
                        ContainerHelper.UpdateCntrState(cst.S_CNTR_CODE, 1);
                        WMSHelper.addRfidAnomalyRecord(cst.S_CNTR_CODE, 1, request.loc, cst.S_CODE);
                    }

                    /*WCSHelper.ActivatePreCreateTask(cst.S_OP_CODE);*/

                    // 方案2 4.如果读取不成功，查看异常区是否有空货位  
                    /* var agvEndLoc = WMSHelper.GetTransfeRelevanceLoc(loc.S_AREA_CODE, "4");
@@ -229,39 +236,23 @@
                var logicConfig = WMSHelper.getLogicConfigByJtCode(model.jtNo);
                if (logicConfig != null)
                {
                    Container container = ContainerHelper.GetCntr(model.cntrNo);
                    if (container == null || !model.isNormal)
                    {
                        ContainerHelper.AddCntr(model.cntrNo);
                        ContainerHelper.UpdateCntrState(model.cntrNo, 1);
                        WMSHelper.addRfidAnomalyRecord(model.cntrNo, 1, model.loc, null);
                    }

                    // 根据物料下线配置信息，判断任务类型是直连下线还是非直连下线
                    if (logicConfig.S_TASK_TYPE == "1" || logicConfig.S_TASK_TYPE == "2")
                    {
                        // 直连下线，需要判断校验RFID
                        LjMesTask mesTask = null;
                        var container = ContainerHelper.GetCntr(model.cntrNo);
                        if (container != null)
                        {
                            mesTask = WMSHelper.getLjMesTaskByCntr(model.cntrNo);
                            if (mesTask == null)
                            {
                                ContainerHelper.UpdateCntrState(model.cntrNo, 1);
                                WMSHelper.addRfidAnomalyRecord(model.cntrNo, 3, model.loc, null);
                            }
                        }
                        else 
                        {
                            model.isNormal = false;
                        }

                        if (!model.isNormal) 
                        {
                            ContainerHelper.AddCntr(model.cntrNo);
                            ContainerHelper.UpdateCntrState(model.cntrNo, 1);
                            WMSHelper.addRfidAnomalyRecord(model.cntrNo, 1, model.loc, null);
                        }
                        triggerItemOffLineFlow(model.loc, model.cntrNo, logicConfig, mesTask);
                        triggerItemOffLineFlow(model.loc, model.cntrNo, logicConfig);
                    }
                    else
                    {
                        // 满料下线（非直连）
                        var mesTask = WMSHelper.getLjMesTaskByLoc(model.loc);
                        triggerItemOffLineFlow4(model.loc, logicConfig,mesTask);
                        triggerItemOffLineFlow4(model.loc, model.cntrNo, logicConfig);
                    }
                }
                else
@@ -278,6 +269,7 @@
            return responseResult;
        }


        /// <summary>
        /// 满料下线（非直连）
        /// 1.创建满料下线作业
@@ -287,52 +279,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
@@ -352,12 +354,12 @@
                        if (kgzStartLoc == null)
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                            throw new BusinessException($"库区:{logicConfig.S_AREA_CODE},没有可用的空工装");
                            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);
@@ -367,8 +369,8 @@
                        }
                        else
                        {
                            WMSHelper.addAlarmRecord("流程异常", "中", $"空工装补充接驳位:{logicConfig.S_LKKTJBLOC},没有空工装");
                            throw new BusinessException($"空工装补充接驳位:{logicConfig.S_LKKTJBLOC},没有空工装");
                            WMSHelper.addAlarmRecord("流程异常", "中", $"空工装出库站台:{logicConfig.S_LKKTJBLOC},没有空工装");
                            photoStatus = false;
                        }
                    }

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

                        if (WMSHelper.CreateWmsTask(wmsTask))
                        {
                            int priority = 10;
@@ -421,12 +422,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,
@@ -437,25 +438,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;
@@ -467,14 +450,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
@@ -511,10 +494,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
            {
@@ -523,14 +506,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];
@@ -538,16 +521,16 @@
                            {
                                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
@@ -576,133 +559,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) 
@@ -1137,6 +1117,7 @@

        /// <summary>
        /// AGV申请终点
        /// 场景：1.余料/空工装入库任务（成型机） 2.满料/空工装入库（机台） 3.满料/空工装出库异常 4.满料/空工装入库异常
        /// </summary>
        /// <param name="applyType">1.正常 2.RFID与任务RFID不匹配 3.物料状态不合格</param>
        /// <param name="loc"></param>
@@ -1283,6 +1264,7 @@
                                    S_SCHEDULE_TYPE = "WCS",
                                    N_PRIORITY = 10,
                                    N_B_STATE = -1,
                                    S_B_STATE = "预创建",
                                    T_START_TIME = DateTime.Now,
                                };
                                if (WCSHelper.CreateTask(wcsTask))
@@ -1313,36 +1295,6 @@
                }
            }

            // 重新发起新任务
            if (applyType != "1")
            {
                var mesTask = WMSHelper.GetLjMesTaskByAgvorderId(mst.S_CODE);
                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);*/
                    }

                    // 满料下线（非直连）
                    if (mst.S_TYPE.Contains("满料/异常工装入库任务") && cst.S_TYPE.Contains("空工装出库任务"))
                    {
                        LogHelper.Info($"满料/异常工装入库任务异常，再次发起满料/异常工装入库任务", "AGV");
                        var logicConfig = WMSHelper.getLogicConfigByJtCode(mesTask.EQP);
                        if (logicConfig != null)
                        {
                            triggerItemOffLineFlow4(mesTask.POSITION_ID, logicConfig, mesTask);
                        }
                        else
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"MES任务{mesTask.ID},机台号：{mesTask.EQP},未查询到逻辑线路", "AGV");
                        }
                    }
                }
            }

            if (agvEndLoc != null && wmsEndLoc != null)
            {
                destLoc = agvEndLoc.S_CODE;
@@ -1354,6 +1306,35 @@
                mst.S_END_AREA = wmsEndLoc.S_AREA_CODE;
                WMSHelper.UpdateTaskEnd(mst);
            }

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

                    // 满料下线（非直连）
                    if (mst.S_TYPE.Contains("满料/异常工装入库任务") && cst.S_TYPE.Contains("空工装出库任务"))
                    {
                        LogHelper.Info($"满料/异常工装入库任务异常，再次发起满料/异常工装入库任务", "AGV");
                        var logicConfig = WMSHelper.getLogicConfigByJtCode(mesTask.EQP);
                        if (logicConfig != null)
                        {
                            triggerItemOffLineFlow4(mesTask.POSITION_ID, mst.S_CNTR_CODE, logicConfig ,mesTask);
                        }
                        else
                        {
                            WMSHelper.addAlarmRecord("流程异常", "高", $"MES任务{mesTask.ID},机台号：{mesTask.EQP},未查询到逻辑线路", "AGV");
                        }
                    }
                }
            }
            return destLoc;
        }


 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/config/config.json

@@ -5,76 +5,86 @@
  "SqlServer1": "Data Source=192.168.1.198\\sql2008;Initial Catalog=OIMobox;User ID=sa;Password=sa@2015",
  "OracleServer": "Data Source=(DESCRIPTION=(ADDRESS_LIST=(ADDRESS=(PROTOCOL=TCP)(HOST=192.168.1.144)(PORT=1521)))(CONNECT_DATA=(SERVER=DEDICATED)(SID=jiatong)));User Id=system;Password=Hh123321;",
  "ApiPort": 8901,
  "FacCode": "0000",
  "FacCode": "FJJT",
  "WHCode": "W001",

  // 接驳区、缓存区、机台下线区、成型机叫料区 对应的立库库区
  "AreaRelevance": [
    {
      "areaCode": "",
      "relAreaCode": [ "" ]
      "areaCode": "TCZLKGZHCKQ",
      "relAreaCode": [ "TCZLCK" ]
    },
    {
      "areaCode": "",
      "relAreaCode": [ "" ]
      "areaCode": "TMZLKGZHCKQ",
      "relAreaCode": [ "TMZLCK" ]
    }
  ],


  // 直连缓存位配置
  "BufferLocConfig": [
    {
      "locCode": "TCZLKGZHCKQ1-1",
      "deviceNo": "1"
    },
    {
      "locCode": "TCZLKGZHCKQ2-1",
      "deviceNo": "2"
    }
  ],

  // cntrType 1.胎面；2.胎侧；3.内衬；4.帘布；5.环带；6.冠带；7.钢包
  // type 1.直连 2.非直连
  "AreaProperty": [
    {
      "areaCode": "TMLKQ",
      "areaName": "胎面库一（直连）",
      "areaCode": "TMZLCK",
      "areaName": "胎面库（直连）",
      "cntrType": [ 1 ],
      "type": 1
    },
    {
      "areaCode": "TMLKQ2",
      "areaName": "胎面库二（非直连）",
      "areaCode": "TMFZLCK",
      "areaName": "胎面库（非直连）",
      "cntrType": [ 1 ],
      "type": 2
    },
    {
      "areaCode": "TCLKQ",
      "areaName": "胎侧库一（直连）",
      "areaCode": "TCZLCK",
      "areaName": "胎侧库（直连）",
      "cntrType": [ 2 ],
      "type": 1
    },
    {
      "areaCode": "TCLKQ2",
      "areaName": "胎侧库二（非直连）",
      "areaCode": "TCFZLCK",
      "areaName": "胎侧库（非直连）",
      "cntrType": [ 2 ],
      "type": 2
    },
    {
      "areaCode": "NCLKQ",
      "areaCode": "NCFZLCK",
      "areaName": "内衬库（非直连）",
      "cntrType": [ 3 ],
      "type": 2
    },
    {
      "areaCode": "LBLKQ",
      "areaCode": "LBFZLCK",
      "areaName": "帘布库（直连）",
      "cntrType": [ 4 ],
      "type": 1
    },
    {
      "areaCode": "LBLKQ",
      "areaCode": "LBFZLCK",
      "areaName": "环带库",
      "cntrType": [ 5, 6 ],
      "type": 2
    },
    {
      "areaCode": "GBLKQ",
      "areaCode": "GBFZLCK",
      "areaName": "钢包库(非直连)",
      "cntrType": [ 7 ],
      "type": 2
    },
    {
      "areaCode": "ZZKQ",
      "areaCode": "ZZFZLCK",
      "areaName": "中转库(非直连)",
      "cntrType": [ 7 ],
      "type": 2
@@ -82,14 +92,15 @@
  ],


  "DeviceInfo": [
  "CarDeviceInfo": [
    {
      "address": "127.0.0.11",
      "deviceName": "产线1",
      "deviceName": "1号车",
      "deviceNo": 1,
      "enable": 0
    }
  ],

  "linePlcInfo": [
    {
      "deviceNo": "1",

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/core/Monitor.cs

@@ -200,7 +200,6 @@
                        if (startLoc != null)
                        {
                            var locCntrRels = LocationHelper.GetLocCntr(startLoc.S_CODE);
                            // 1.创建斜裁-成新机叫料作业
                            wmsTask = new WMSTask()
                            {
                                S_CNTR_CODE = locCntrRels[0].S_CNTR_CODE,
@@ -209,7 +208,7 @@
                                S_START_AREA = startLoc.S_AREA_CODE,
                                S_END_LOC = jbLoc.S_CODE,
                                S_END_AREA = jbLoc.S_AREA_CODE,
                                S_TYPE = "空工装出库",
                                S_TYPE = "空工装自动出库任务",
                                S_OP_DEF_NAME = "自动补充空工装到接驳位",
                                T_START_TIME = DateTime.Now,
                            };

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/core/WCSCore.cs

@@ -62,6 +62,7 @@
                                        break;
                                    case 4:
                                        WCSHelper.UpdateStatus(cst, "取货完成");
                                        LocationHelper.UnLockLoc(cst.S_START_LOC);
                                        TaskProcess.OperateStatus(cst, 4);
                                        break;
                                    case 5:
@@ -69,6 +70,7 @@
                                        break;
                                    case 6:
                                        WCSHelper.UpdateStatus(cst, "卸货完成");
                                        LocationHelper.UnLockLoc(cst.S_END_LOC);
                                        TaskProcess.OperateStatus(cst, 6);
                                        break;
                                    #endregion
@@ -84,11 +86,13 @@
                            else if (model.State == 1012)
                            {
                                LogHelper.Info("开始进行RFID扫描", "AGV");
                                ContainerHelper.UpdateCntrState(cst.S_CNTR_CODE, 1);
                                WMSHelper.addRfidAnomalyRecord(cst.S_CNTR_CODE, 2, cst.S_START_LOC, null);
                                // 查询扫描的RFID
                                // 发送 00 04 71 02到扫码器 ，接受返回数据并解析
                                byte[] bytes = new byte[] {00,04,71,02};
                                var plc = Settings.deviceInfos.Where(a => a.deviceNo == model.ForkliftNo && a.enable == 1).FirstOrDefault();
                                TcpServer.TcpServerSend(plc.address, bytes);
                                /*  byte[] bytes = new byte[] { 00, 04, 71, 02 };
                                  var plc = Settings.carDeviceInfos.Where(a => a.deviceNo == model.ForkliftNo && a.enable == 1).FirstOrDefault();
                                  TcpServer.TcpServerSend(plc.address, bytes);*/
                            }
                            else if (model.State == 1002)
                            {
@@ -116,7 +120,7 @@
                                        param = $"{model.No};{cst.S_START_LOC};{cst.S_END_LOC};4;512;0;1"
                                    };
                                    NDCApi.ChangeOrderParam(paramModel);
                                    LogHelper.Info($"获取AGV终点：{agvEndLoc}", "AGV");
                                    LogHelper.Info($"变更AGV终点：{agvEndLoc}", "AGV");
                                }
                                else
                                {
@@ -150,7 +154,11 @@

                                // 检测是否是读码位，非读码位，可以激活预创建任务
                                var transfe = WMSHelper.GetTransfeRelevance(cst.S_END_LOC);  // 接驳位属性
                                if ((transfe == null || transfe.N_READ_LOC == 0))
                                if (transfe != null && transfe.N_READ_LOC == 1) 
                                {
                                    WCSHelper.ActivatePreCreateTask(mst.S_CODE);
                                }
                                else if ( transfe.N_READ_LOC == 0)
                                {
                                    if (cst.S_TYPE.Contains("【异常】"))
                                    {
@@ -176,9 +184,7 @@
                                    // 如果作业名称为成型机叫料出库任务，则触发余料/空托搬运任务
                                    string locCode = WMSHelper.getReturnMaterialLocCode(mst.S_END_LOC);
                                    ApiHelper.returnMaterialOrEmptyTray(locCode);
                                }

                                
                                }   
                            }
                        }
                        else

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/models/AlarmRecord.cs

@@ -15,5 +15,6 @@
        public string S_ALARM_LEVEL { get; set; } // 报警级别  低、中、高
        public string S_ALARM_MSG { get; set; } // 报警信息
        public string S_FILE_NAME { get; set; } // 文件名
        public int N_IS_READ { get; set; } // 文件名
    }
}

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/models/CntrItemRel.cs

@@ -22,7 +22,7 @@
        public string S_BATCH_NO { get; set; }   // 批次条码
    
        public float F_QTY { get; set; }  // 数量
        public string S_UOM { get; set; } = "";  // 规格
        public string S_UOM { get; set; } = "个";  // 规格
        public string S_CNTR_CODE { get; set; }
        /// <summary>
        /// 分配量,被其它

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/models/Container.cs

@@ -10,31 +10,16 @@

        public string S_CODE { get; set; }
        public string S_TYPE { get; set; }  // 1.胎面;2.胎侧;3.内衬;4.帘布;5.环带;6.冠带;7.钢包
        public string S_SPEC { get; set; }
        public float F_WEIGHT { get; set; }
        public int N_LENGTH { get; set; }
        public int N_WIDTH { get; set; }
        public int N_HEIGHT { get; set; }
        public string C_IS_VIRTUAL { get; set; } = "N";
        public int N_TYPE { get; set; }
        public string C_ENABLE { get; set; } = "Y";
        public string S_STATE_PRE { get; set; }
        public int N_REVIEW_RESULT { get; set; }

        public int N_DETAIL_COUNT { get; set; }
        public int N_B_STATE { get; set; }
        public string S_LOCK_OP_CODE { get; set; }
        public string S_LOCK_STATE { get; set; }
        public int N_LOCK_STATE { get; set; }
        /// <summary>
        /// 码盘时候标记
        /// </summary>
        public string S_SRC { get; internal set; }
        public string S_DEST { get; internal set; }

        // --------------------福建佳通-----------------
        public int N_E_STATE { get; set; } = 0;  // 托盘异常状态  0.默认 1.WCS读码异常 2.AGV读码器读码异常 3.未查询到RFID的MES任务 4.RFID与任务RFID不一致 5.托盘物料不合格
        public string S_ERR_DESC { get; internal set; } // 异常描述


        /// <summary>

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/models/TransfeRelevance.cs

@@ -15,7 +15,7 @@
    {
        public string S_LOC_CODE { get; set; } // 货位编码
        public int N_PROPERTY { get; set; } // 货位属性 (1.直连 2.非直连)
        public int N_ACT_TYPE { get; set; } // 货位类型 1.入库接驳位 2.出库接驳位
        public int N_TYPE { get; set; } // 货位类型 1.入库接驳位 2.出库接驳位
        public string S_RELE_AREA { get; set; } // 所属库区
        public string S_DEVICE_NO { get; set; } // 设备号         用途：用于查询线体光电，判断缓存位是否为空
        public int N_IS_MANUAL { get; set; } // 是否为人工 (0.非人工 2.人工)   用途：切换人工站台

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/process/DeviceProcess.cs

@@ -16,7 +16,7 @@
    {
        internal static void Analysis(string data, string ip) {
            if (data.Length == 8) {
                var plc = Settings.deviceInfos.Where(a => a.address == ip && a.enable == 1).FirstOrDefault();
                var plc = Settings.carDeviceInfos.Where(a => a.address == ip && a.enable == 1).FirstOrDefault();
                if (plc != null) {
                    WCSTask cst = WCSHelper.GetTaskByEq(plc.deviceNo);
                    if (cst != null) 

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/process/TaskProcess.cs

@@ -28,13 +28,6 @@
            else {
                Console.WriteLine($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，终点绑定容器{mst.S_CNTR_CODE}");
                LogHelper.Info($"任务{mst.S_CODE} 货位{mst.S_END_LOC}卸货完成，起点解绑容器{mst.S_CNTR_CODE}");
                // 终点为直连缓存位，不绑定
                var loc = WMSHelper.GetTransfeRelevance(mst.S_END_LOC); 
                if (loc != null && loc.N_PROPERTY == 1)
                {
                    LocationHelper.UnLockLoc(mst.S_END_LOC);
                    return;
                }
                LocationHelper.BindingLoc(mst.S_END_LOC, mst.S_CNTR_CODE.Split(',').ToList());
            }
        }

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/util/Settings.cs

@@ -12,11 +12,13 @@
        public static string SqlServer { get; set; }
        public static string SqlServer1 { get; set; }
        public static string OracleServer { get; set; }
        public static List<deviceInfo> deviceInfos { get; set; }
        public static List<CarDeviceInfo> carDeviceInfos { get; set; }
        public static List<LinePlcInfo> linePlcInfo { get; set; }
        public static List<PlcValue> plcValue { get; set; }
        public static List<AreaProperty> areaPropertyList { get; set; }
        public static List<AreaRelevance> areaRelevanceList { get; set; }

        public static List<BufferLocConfig> bufferLocConfigList { get; set; }
        public static int port { get; set; }
        public static string WHCode { get; set; }
        public static string FacCode { get; set; }
@@ -61,8 +63,8 @@
                            if (keyValue.Name == "ApiPort") {
                                port = int.Parse(keyValue.Value.ToString());
                            }
                            if (keyValue.Name == "DeviceInfo") {
                                deviceInfos = JsonConvert.DeserializeObject<List<deviceInfo>>(keyValue.Value.ToString());
                            if (keyValue.Name == "CarDeviceInfo") {
                                carDeviceInfos = JsonConvert.DeserializeObject<List<CarDeviceInfo>>(keyValue.Value.ToString());
                            }
                            if (keyValue.Name == "linePlcInfo") {
                                linePlcInfo = JsonConvert.DeserializeObject<List<LinePlcInfo>>(keyValue.Value.ToString());
@@ -77,6 +79,10 @@
                            if (keyValue.Name == "AreaRelevance")
                            {
                                areaRelevanceList = JsonConvert.DeserializeObject<List<AreaRelevance>>(keyValue.Value.ToString());
                            }
                            if (keyValue.Name == "BufferLocConfig")
                            {
                                bufferLocConfigList = JsonConvert.DeserializeObject<List<BufferLocConfig>>(keyValue.Value.ToString());
                            }
                        }
                    }
@@ -113,6 +119,22 @@
            return areaCodes;
        }

        /// <summary>
        /// 获取直连缓存位配置
        /// </summary>
        /// <param name="locCode"></param>
        /// <returns></returns>
        public static BufferLocConfig GetBufferLocConfig(string locCode) 
        {
           return bufferLocConfigList.Where(a => a.locCode == locCode).FirstOrDefault();
        }

        public class BufferLocConfig 
        {
            public string locCode { get; set; }
            public string deviceNo { get; set; }
        }

        public class AreaRelevance
        {
            public string areaCode { get; set; }
@@ -126,7 +148,8 @@
            public List<int> cntrType { get; set; }  // 容器类型 1.胎面；2.胎侧；3.内衬；4.帘布；5.环带；6.冠带；7.钢包
        }

        public class deviceInfo {
        public class CarDeviceInfo
        {
            public string address { get; set; }
            public string deviceName { get; set; }
            public string deviceNo { get; set; }

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/wms/ContainerHelper.cs

@@ -18,20 +18,7 @@
            var date = DateTime.Now.ToString("yyMMdd");
            return $"TP{date}{id.ToString().PadLeft(4, '0')}";
        }
        /// <summary>
        /// 根据容器类型、目的地、状态查询容器
        /// </summary>
        /// <param name="dest"></param>
        /// <param name="cntrType"></param>
        /// <param name="state"></param>
        /// <returns></returns>
        internal static List<Container> GetCntrListByPurpose(string dest, string cntrType, int state) {
            //1.0 查货位容器表
            var db = new SqlHelper<object>().GetInstance();
            var list = db.Queryable<Container>().Where(a => a.S_DEST == dest && a.S_TYPE == cntrType && a.N_B_STATE == state).ToList();
            return list;

        }
        
        /// <summary>
        /// TN_ContainerHelper.test("4L天然水箱装6入", 50, "335ml东方树叶15入", 30);
        /// </summary>
@@ -199,7 +186,7 @@
                var count = db.Queryable<CntrItemRel>().Count(a => a.S_CNTR_CODE == cntr.S_CODE);
                cntr.N_DETAIL_COUNT = count;
                cntr.C_ENABLE = "N";//码盘后将托盘设置为不可用状态，入库后变成可用
                db.Updateable(cntr).UpdateColumns(it => new { it.N_DETAIL_COUNT, it.C_ENABLE, it.S_SRC }).ExecuteCommand();
                db.Updateable(cntr).UpdateColumns(it => new { it.N_DETAIL_COUNT, it.C_ENABLE}).ExecuteCommand();

                db.CommitTran();
                res = true;
@@ -212,64 +199,9 @@
            return res;
        }

        /// <summary>
        /// 物料信息绑定到满容器上
        /// </summary>
        /// <param name="cntrCode"></param>
        /// <param name="itemCode"></param>
        /// <param name="batchNo"></param>
        /// <param name="qty"></param>
        /// <param name="purpose">容器用途，用于哪个线边还是目的点</param>
        /// <returns></returns>
        internal static bool BindCntrItemSingle(Container cntr, string itemCode, string batchNo, float qty) {
            var res = false;
            var db = new SqlHelper<object>().GetInstance();
            try {
                db.BeginTran();
                db.Updateable(cntr).UpdateColumns(it => new { it.S_DEST }).ExecuteCommand();
                //1.将原有容器物料信息删除
                db.Deleteable<CntrItemRel>().Where(it => it.S_CNTR_CODE == cntr.S_CODE.Trim()).ExecuteCommand();
                //2.插入新的容器物料信息（容器号不变）
                var cir = new CntrItemRel { S_CNTR_CODE = cntr.S_CODE.Trim(), S_BATCH_NO = batchNo, F_QTY = qty, S_ITEM_CODE = itemCode };
                db.Insertable<CntrItemRel>(cir).ExecuteCommand();

                db.CommitTran();
                res = true;
            }
            catch (Exception ex) {
                db.RollbackTran();
            }

            return res;
        }
        /// <summary>
        /// 根据容器来源和状态获取托盘
        /// </summary>
        /// <param name="src"></param>
        /// <param name="state"></param>
        /// <returns></returns>
        internal static List<Container> GetCntr(string dest, int state, string cntrType = "") {
            var db = new SqlHelper<object>().GetInstance();
            if (cntrType == "") {
                return db.Queryable<Container>().Where(a => a.S_DEST == dest && a.N_B_STATE == state).ToList();
            }
            else {
                return db.Queryable<Container>().Where(a => a.S_DEST == dest && a.N_B_STATE == state && a.S_TYPE == cntrType).ToList();
            }
        }
        internal static bool UpdateCntr(List<string> cntrs, string dest, int state) {
            var res = false;
            var db = new SqlHelper<object>().GetInstance();
            var models = db.Queryable<Container>().Where(a => cntrs.Contains(a.S_CODE)).ToList();
            if (models.Count > 0) {
                models.ForEach(a => {
                    a.S_DEST = dest; a.N_B_STATE = state;
                    db.Updateable(a).UpdateColumns(it => new { it.S_DEST, it.N_B_STATE }).ExecuteCommand();
                });
                res = true;
            }
            return res;
        }
        
       
        

        internal static bool UpdateCntr(Container container)
        {
@@ -277,36 +209,8 @@
            return db.Updateable(container).ExecuteCommand()>0;
        }

        internal static bool UpdateCntrDest(List<string> cntrs, string dest) {
            var res = false;
            var db = new SqlHelper<object>().GetInstance();
            var models = db.Queryable<Container>().Where(a => cntrs.Contains(a.S_CODE)).ToList();
            if (models.Count > 0) {
                models.ForEach(a => {
                    a.S_DEST = dest;
                    db.Updateable(a).UpdateColumns(it => new { it.S_DEST }).ExecuteCommand();
                });
                res = true;
            }
            return res;
        }
        /// <summary>
        /// 更新托盘来源
        /// </summary>
        /// <param name="cntr"></param>
        /// <param name="src"></param>
        /// <returns></returns>
        internal static bool UpdateCntrSrc(string cntr, string src) {
            var res = false;
            var db = new SqlHelper<object>().GetInstance();
            var model = db.Queryable<Container>().Where(a => a.S_CODE == cntr).First();
            if (model != null) {
                model.S_SRC = src;
                model.T_MODIFY = DateTime.Now;
                res = db.Updateable(model).UpdateColumns(it => new { it.S_SRC, it.T_MODIFY }).ExecuteCommand() > 0;
            }
            return res;
        }
        
       

        /// <summary>
        /// 
@@ -321,49 +225,11 @@
            if (models.Count > 0) {
                models.ForEach(a => {
                    a.N_E_STATE = state;
                    db.Updateable(a).UpdateColumns(it => new { it.N_E_STATE,it.S_ERR_DESC }).ExecuteCommand();
                    db.Updateable(a).UpdateColumns(it => new { it.N_E_STATE }).ExecuteCommand();
                });
                res = true;
            }
            return res;
        }

        internal static bool UpdateCntr(List<string> cntrs, string src, string dest, int state) {
            var res = false;
            var db = new SqlHelper<object>().GetInstance();
            var models = db.Queryable<Container>().Where(a => cntrs.Contains(a.S_CODE)).ToList();
            if (models.Count > 0) {
                models.ForEach(a => {
                    a.S_DEST = dest; a.N_B_STATE = state; 
                    db.Updateable(a).UpdateColumns(it => new { it.S_DEST, it.N_B_STATE, it.S_SRC }).ExecuteCommand();
                });
                res = true;
            }
            return res;
        }
        public static bool ClearCntrInfo(string cntr) {

            var db = new SqlHelper<object>().GetInstance();
            var model = db.Queryable<Container>().Where(a => a.S_CODE == cntr).First();
            if (model != null) {
                model.S_SRC = "";
                model.S_DEST = "";
                model.N_B_STATE = 0;
                model.T_MODIFY = DateTime.Now;

            }
            db.Updateable(model).UpdateColumns(it => new { it.S_SRC, it.S_DEST, it.N_B_STATE, it.T_MODIFY }).ExecuteCommand();
            return db.Deleteable<CntrItemRel>().Where(a => a.S_CNTR_CODE.Trim() == cntr.Trim()).ExecuteCommand() > 0;
        }
        internal static List<Container> GetCntrBySrc(string src, int state, string cntrType = "") {
            var db = new SqlHelper<object>().GetInstance();
            if (cntrType == "") {
                return db.Queryable<Container>().Where(a => a.S_SRC == src && a.N_B_STATE == state).ToList();
            }
            else {
                return db.Queryable<Container>().Where(a => a.S_SRC == src && a.N_B_STATE == state && a.S_TYPE == cntrType).ToList();
            }
        }
   
    }
}

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/wms/LocationHelper.cs

@@ -293,7 +293,7 @@
            try
            {
                db.BeginTran();
                var count = db.Deleteable<LocCntrRel>().Where(it => it.S_LOC_CODE.Trim() == loc).ExecuteCommand();
                db.Deleteable<LocCntrRel>().Where(it => it.S_LOC_CODE.Trim() == loc).ExecuteCommand();
                location.N_CURRENT_NUM = 0;
                location.N_LOCK_STATE = 0;
                location.S_LOCK_STATE = Location.GetLockStateStr(location.N_LOCK_STATE);

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/wms/WCSHelper.cs

@@ -65,14 +65,14 @@
                Where(a => a.S_OP_CODE.Trim() == wmsTaskNo
                && a.N_B_STATE == -1
                );
            if (anomaly == 1)
            /*if (anomaly == 1)
            {
                updateable = updateable.Where(a => a.S_TYPE.Contains("【异常】"));
            }
            else 
            {
                updateable = updateable.Where(a => !a.S_TYPE.Contains("【异常】"));
            }
            }*/
            return updateable.ExecuteCommand() > 0;
        }

@@ -233,7 +233,7 @@
        }
        internal static List<WCSTask> GetWaitingTaskList() {
            var db = new SqlHelper<object>().GetInstance();
            return db.Queryable<WCSTask>().Where(a => a.N_B_STATE == 0).ToList();
            return db.Queryable<WCSTask>().Where(a => a.N_B_STATE == 0).OrderByDescending(a => a.N_PRIORITY).ToList();
        }
    }
}

 HH.WCS.Mobox3/HH.WCS.Mobox3.FJJT/wms/WMSHelper.cs

@@ -307,7 +307,7 @@
                string S_ZONE_CLS_CODE = "";
                if (trayStatus == 0)
                {
                    S_ZONE_CLS_CODE = "KGZ";
                    S_ZONE_CLS_CODE = "KT";
                }
                else if (trayStatus == 1)
                {
@@ -346,10 +346,6 @@
                              .Where((a, b, c) => a.S_AREA_CODE.Trim() == item.S_AREA_CODE.Trim() && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y" && c.S_ZONE_CLS_CODE.Trim() == S_ZONE_CLS_CODE)
                              .OrderBy((a, b, c) => a.N_LAYER)
                              .First();
                            if (location != null)
                            {
                                return location;
                            }
                        }
                    }

@@ -369,7 +365,7 @@
                                 .OrderBy((a, b, c) => a.N_LAYER)
                                 .First();
                }
                LogHelper.Info($"查询结束,立库终点货位:{location}","WMS");
                LogHelper.Info($"查询结束,立库终点货位:{JsonConvert.SerializeObject(location)}","WMS");
            }
            catch (Exception ex) 
            {
@@ -381,15 +377,22 @@

        public static bool addAlarmRecord(string alarmType , string alarmLevel ,string alarmMsg ,string logSite = "WMS") {
            var db = new SqlHelper<object>().GetInstance();
            bool result = true;
            LogHelper.Info(alarmMsg, logSite);
            AlarmRecord alarmRecord = new AlarmRecord() {
                S_ALARM_CODE = GenerateAlarmNo(),
                S_ALARM_TYPE = alarmType,
                S_ALARM_LEVEL = alarmLevel,
                S_ALARM_MSG = alarmMsg,
                S_FILE_NAME = logSite,
            };    
           return db.Insertable<AlarmRecord>(alarmRecord).ExecuteCommand()>0;
            var alarmRecord = db.Queryable<AlarmRecord>().Where(a => a.N_IS_READ == 0 && a.S_ALARM_MSG == alarmMsg).First();
            if (alarmRecord == null) 
            {
                alarmRecord = new AlarmRecord()
                {
                    S_ALARM_CODE = GenerateAlarmNo(),
                    S_ALARM_TYPE = alarmType,
                    S_ALARM_LEVEL = alarmLevel,
                    S_ALARM_MSG = alarmMsg,
                    S_FILE_NAME = logSite,
                };
                result = db.Insertable<AlarmRecord>(alarmRecord).ExecuteCommand() > 0;
            }
            return result;
        }

        public static bool addRfidAnomalyRecord(string rfid ,int anomalyType ,string locCode ,string taskNo) 
@@ -403,7 +406,7 @@
                S_LOC_CODE = locCode,
                S_TASK_NO = taskNo
            };
            return db.Insertable<AlarmRecord>(anomalyRecord).ExecuteCommand() > 0;
            return db.Insertable<RfidAnomalyRecord>(anomalyRecord).ExecuteCommand() > 0;
        }

        /// <summary>
@@ -450,15 +453,15 @@
        /// </summary>
        /// <param name="areaCode">库区</param>
        /// <param name="property">货位属性（1.直连 2.非直连）</param>
        /// <param name="actType">动作类型（0.人工接驳位 1.入库接驳位 2.出库接驳位）</param>
        /// <param name="type">动作类型（0.人工接驳位 1.入库接驳位 2.出库接驳位）</param>
        /// <returns></returns>
        public static Location GetTransfeRelevanceLoc(string areaCode  ,int actType ,int property )
        public static Location GetTransfeRelevanceLoc(string areaCode  ,int type ,int property )
        {
            Location loc = null;
            var db = new SqlHelper<object>().GetInstance();
            loc = db.Queryable<Location>()
                .LeftJoin<TransfeRelevance>((a,b)=> a.S_CODE == b.S_LOC_CODE)
                .Where((a, b) => b.S_RELE_AREA.Trim() == areaCode && b.N_PROPERTY == property && b.N_ACT_TYPE == actType && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y")
                .Where((a, b) => b.S_RELE_AREA.Trim() == areaCode && b.N_PROPERTY == property && b.N_TYPE == type && a.N_CURRENT_NUM == 0 && a.N_LOCK_STATE == 0 && a.C_ENABLE == "Y")
                .First();
            return loc;
        }
@@ -482,16 +485,16 @@
        /// 注：查询任务最少的接驳位
        /// </summary>
        /// <param name="areaCode">库区</param>
        /// <param name="property">货位属性 ( 0.人工 1.直连 2.非直连)</param>
        /// <param name="actType">动作类型 （1.入库接驳位  2.出库接驳位）</param>
        /// <param name="property">货位属性 ( 1.直连 2.非直连)</param>
        /// <param name="type">动作类型 （1.入库接驳位  2.出库接驳位）</param>
        /// <returns></returns>
        public static Location GetMinTaskTransfeLoc(string areaCode ,int actType, int property)
        public static Location GetMinTaskTransfeLoc(string areaCode ,int type, int property)
        {
            var db = new SqlHelper<object>().GetInstance();
            var loc = db.Queryable<Location>()
                .LeftJoin<TransfeRelevance>((a,b) => a.S_CODE == b.S_LOC_CODE)
                .LeftJoin<WCSTask>((a,b,c) => a.S_CODE == c.S_END_LOC && c.N_B_STATE < 3)
                .Where((a, b, c) => b.S_RELE_AREA.Trim() == areaCode  && b.N_ACT_TYPE == actType && b.N_PROPERTY == property  && a.N_LOCK_STATE < 3 && a.C_ENABLE == "Y")
                .Where((a, b, c) => b.S_RELE_AREA.Trim() == areaCode  && b.N_TYPE == type && b.N_PROPERTY == property  && a.N_LOCK_STATE < 3 && a.C_ENABLE == "Y")
                .GroupBy((a, b, c) => a.S_CODE)
                .Select((a, b, c) => new {
                    count = SqlFunc.AggregateCount(c.S_END_LOC),

 HH.WCS.Mobox3/HH.WCS.Mobox3.SXJK/models/TN_VendorList.cs

@@ -13,5 +13,6 @@
        public string VENDOR { get; set; } // 供应商
        public string VENDORNAME { get; set; }  // 供应商名称
        public int FURWEIGHT { get; set; } // 毛皮重量
        public int FURHEIGHT { get; set; } // 高度
    }
}

 HH.WCS.Mobox3/HH.WCS.Mobox3.SXJK/process/TaskProcess.cs

@@ -280,7 +280,8 @@
                                var cntrItemRel = ContainerHelper.GetCntrItemRel(downCntr.S_CNTR_CODE).FirstOrDefault();
                                if (cntrItemRel != null)
                                {
                                    mst.S_START_LOC = mst.S_START_LOC + "-" + cntrItemRel.N_GOODS_HEIGHT;
                                    float height = WMSHelper.getFurHeight(cntrItemRel.LOTATT09);
                                    mst.S_START_LOC = mst.S_START_LOC + "-" + height;
                                }
                            }
                        }
@@ -290,7 +291,8 @@
                        if (endLocCntrRels != null && endLocCntrRels.Count == 1) {
                            var cntrItemRel = ContainerHelper.GetCntrItemRel(endLocCntrRels[0].S_CNTR_CODE).FirstOrDefault();
                            if (cntrItemRel != null) {
                                mst.S_END_LOC = mst.S_END_LOC + "-" + cntrItemRel.N_GOODS_HEIGHT;
                                float height = WMSHelper.getFurHeight(cntrItemRel.LOTATT09);
                                mst.S_END_LOC = mst.S_END_LOC + "-" + height;
                            }
                        }
                    }

 HH.WCS.Mobox3/HH.WCS.Mobox3.SXJK/wms/WMSHelper.cs

@@ -1503,5 +1503,21 @@
            }
            return weight;
        }

        /// <summary>
        ///  查询是否有需要移库的货位
        /// </summary>
        /// <returns></returns>
        public static float getFurHeight(string VENDOR)
        {
            float height = 800;
            var db = new SqlHelper<object>().GetInstance();
            var verdor = db.Queryable<TN_VendorList>().Where(a => a.VENDOR == VENDOR).First();
            if (verdor != null)
            {
                height = verdor.FURHEIGHT;
            }
            return height;
        }
    }
}

 HH.WCS.Mobox3/HH.WCS.Mobox3.TSSG/wms/WMSHelper.cs

@@ -591,11 +591,15 @@
            {
                // 1、查询当前库区-排-物料 有托盘的货位
                var db = new SqlHelper<object>().GetInstance();
                result = db.Queryable<Location>() 
                    .Where(l => l.N_CURRENT_NUM > 0 && l.S_AREA_CODE == area && l.N_ROW == row && l.N_LOCK_STATE == 0 && (l.C_ENABLE != "禁用" && l.C_ENABLE != "N"))
                    .Includes(l => l.LocCntrRel, l => l.CntrItemRel)
                    .OrderByDescending(l => l.N_COL)
                    .First();
                var isLock = db.Queryable<Location>().Where(a => a.S_AREA_CODE == area && a.N_ROW == row && a.N_LOCK_STATE != 0).Count()> 0;
                if (!isLock) 
                {
                    result = db.Queryable<Location>()
                       .Where(l => l.N_CURRENT_NUM > 0 && l.S_AREA_CODE == area && l.N_ROW == row && l.N_LOCK_STATE == 0 && (l.C_ENABLE != "禁用" && l.C_ENABLE != "N"))
                       .Includes(l => l.LocCntrRel, l => l.CntrItemRel)
                       .OrderByDescending(l => l.N_COL)
                       .First();
                }
            }
            catch (Exception ex)
            {

 HH.WCS.Mobox3/HH.WCS.Mobox3.YNJT_BZP/core/Monitor.cs

@@ -50,7 +50,8 @@
            var emptyTrayBuffers = WMSHelper.getEmptyTrayBufferList();
            foreach (var buffer in emptyTrayBuffers)
            {
                if (buffer.T_CREATE.AddMinutes(1) > DateTime.Now) 
                var dateTime = DateTime.Now.AddMinutes(-1);
                if (buffer.T_CREATE < dateTime) 
                {
                    Location startLoc = WMSHelper.GetEmptyTrayStartLoc(buffer.TRAY_TYPE);
                    Location middleLoc = null;
@@ -128,6 +129,9 @@
                                // 更新作业任务状态
                                wmsTask.N_B_STATE = 1;
                                WMSHelper.UpdateTaskState(wmsTask);

                                buffer.IS_CREATED = "Y";
                                WMSHelper.updateEmptyTrayBuffer(buffer);
                            }
                        }
                    }

 HH.WCS.Mobox3/HH.WCS.Mobox3.YNJT_BZP/core/WCSCore.cs

@@ -372,7 +372,6 @@
                                            return agvLoc;
                                        }
                                    }

                                    LogHelper.Info($"任务号：{taskNo},入库接驳位货位都已禁用", "AGV");
                                }
                                else
@@ -410,6 +409,46 @@
                                        WMSHelper.updateEmptyTrayBuffer(emptyTray);
                                    }
                                }
                                else 
                                {
                                    var endLoc = WMSHelper.GetInstockEndLoc(container.N_TYPE, null, 1);
                                    if (endLoc != null)
                                    {
                                        Location agvLoc = null;
                                        var locCodes = Settings.getAgvJBLocList(endLoc.N_ROADWAY, 1);
                                        if (locCodes.Count > 0)
                                        {
                                            foreach (var locCode in locCodes)
                                            {
                                                agvLoc = LocationHelper.GetLoc(locCode);
                                                if (agvLoc != null && agvLoc.C_ENABLE == "Y")
                                                {
                                                    cst.S_END_LOC = agvLoc.S_CODE;
                                                    cst.S_END_AREA = agvLoc.S_AREA_CODE;
                                                    WCSHelper.UpdateTaskEnd(cst);

                                                    mst.S_END_LOC = endLoc.S_CODE;
                                                    mst.S_END_AREA = endLoc.S_AREA_CODE;
                                                    WMSHelper.UpdateTaskEnd(mst);
                                                    LocationHelper.LockLoc(endLoc.S_CODE, 1);
                                                    
                                                    LogHelper.Info($"任务号：{taskNo},AGV申请的终点：{agvLoc.S_CODE}", "AGV");
                                                    return agvLoc;
                                                }
                                            }

                                            LogHelper.Info($"任务号：{taskNo},入库接驳位货位都已禁用", "AGV");
                                        }
                                        else
                                        {
                                            LogHelper.Info($"任务号：{taskNo},没有配置立库接驳位", "AGV");
                                        }
                                    }
                                    else
                                    {
                                        LogHelper.Info($"任务号：{taskNo},立库没有满足条件的空货位", "AGV");
                                    }
                                }
                            }
                        }
                    }

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

@@ -810,6 +810,16 @@
                return "No shift"; // 理论上不会触发
        }

        /// <summary>
        /// 空托解绑
        /// </summary>
        public static ReturnResult emptyTrayUnBind(EmptyTrayUnBindModel model) 
        {
            ReturnResult responseResult = new ReturnResult();
            ContainerHelper.deleteCntrItemRelByCntr(model.rfid);
            return responseResult;
        }

        public class readCodeFeedbackResponse
        {
            public bool verifyResult { get; set; }

 HH.WCS.Mobox3/HH.WCS.Mobox3.YNJT_PT/api/WmsController.cs

@@ -164,6 +164,26 @@
        }

        /// <summary>
        /// 9.空托盘解绑
        /// 业务场景：空托盘回主线
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        public ReturnResult emptyTrayUnBind(EmptyTrayUnBindModel model)
        {
            LogHelper.Info("【9.空托盘解绑】Request：" + JsonConvert.SerializeObject(model), "WMS");
            var result = ApiHelper.emptyTrayUnBind(model);
            LogHelper.Info("【9.空托盘解绑】response：" + JsonConvert.SerializeObject(result), "WMS");
            return result;
        }

        public class EmptyTrayUnBindModel 
        {
            public string rfid { get; set; } // 托盘号
        }

        /// <summary>
        /// 任务状态反馈模型
        /// </summary>
        public class TaskStatusFeedbackModel

 HH.WCS.Mobox3/HH.WCS.Mobox3.YNJT_PT/wms/ContainerHelper.cs

@@ -132,7 +132,15 @@
        internal static bool deleteCntrItemRelByCntr(string cntr)
        {
            var db = new SqlHelper<object>().GetInstance();
            return db.Deleteable<CntrItemRel>().Where(a => a.S_CNTR_CODE == cntr).ExecuteCommand() > 0;
            var container = ContainerHelper.GetCntr(cntr);
            if(container != null)
            {
                db.Deleteable<CntrItemRel>().Where(a => a.S_CNTR_CODE == cntr).ExecuteCommand();
                
                container.N_DETAIL_COUNT = 0;
                db.Updateable(container).ExecuteCommand();
            }
            return true;
        }

        /// <summary>