出库修改

海波 张

4 天以前 27e00e4c0d354727728ac4b8770b1575b5077399

 process/TaskProcess.cs

@@ -174,6 +174,7 @@
                        NDCApi.ChangeOrderParam(mst.S_CODE, 1, startSite);
                        NDCApi.ChangeOrderParam(mst.S_CODE, 2, endSite);
                        NDCApi.ChangeOrderParam(mst.S_CODE, 4, "0");
                        Thread.Sleep(1000);
                        NDCApi.ChangeOrderParam(mst.S_CODE, 6, "2");
                    }
                }
@@ -203,13 +204,16 @@
        /// <param name="state"></param>
        internal static void OperateStatus(WMSTask mst, int state)
        {
            if (state == 4)
            if (state == 4)//取货完成
            {
                CacheBitUpdate(mst, true);
            }
            if (state == 6)//卸货完成
            {
                CacheBitUpdate(mst, false);
                //退库任务不绑定
                if (!LocationHelper.GetErroArea(mst.S_END_AREA)) {
                    CacheBitUpdate(mst, false);
                }  
            }
            if (state == 7)
            {
@@ -261,7 +265,9 @@
                            //改一段任务终点
                            task.S_END_LOC = end.S_CODE;
                            task.S_END_AREA = end.S_AREA_CODE;
                            db.Updateable(task).UpdateColumns(it => new { it.S_END_LOC, it.S_END_AREA }).ExecuteCommand();
                            task.S_END_AREA_NAME = end.S_AREA_Name;

                            db.Updateable(task).UpdateColumns(it => new { it.S_END_LOC, it.S_END_AREA ,it.S_END_AREA_NAME}).ExecuteCommand();
                            kt.Status = "Y";
                            db.Updateable(kt).UpdateColumns(it => new { it.Status }).ExecuteCommand();
                            db.CommitTran();
@@ -269,6 +275,7 @@
                            LogHelper.Info($"任务{task.S_CODE}改道成功，改参数2为{site},参数6为2，4为0", "改道安全交互");
                            NDCApi.ChangeOrderParam(task.S_CODE, 2, site);
                            NDCApi.ChangeOrderParam(task.S_CODE, 4, "0");
                            Thread.Sleep(1000);
                            NDCApi.ChangeOrderParam(task.S_CODE, 6, "2");
                            return;
                        }
@@ -346,10 +353,9 @@
                        {
                            endList = LocationHelper.GetAllLocList1(workFlow.ENDAREA);
                        }

                        

                        balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);


                        balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);

@@ -360,7 +366,7 @@
                                //LogHelper.Info($"改道安全交互item信息" + JsonConvert.SerializeObject(item), "改道安全交互");
                                foreach (var item1 in balanceConnectionList)
                                {
                                    if (item1.CONNEC_ROADWAY == item.N_ROADWAY && item1.N_CURRENT_NUM < 2)
                                    if (item1.CONNEC_ROADWAY == item.N_ROADWAY)
                                    {
                                        connection = item1;
                                      
@@ -376,6 +382,7 @@
                                }
                            }
                        }


                        if (connection == null)
                        {
@@ -397,11 +404,6 @@
                        db.Updateable(wcsTask).UpdateColumns(it => new { it.S_END_LOC }).ExecuteCommand();
                        db.CommitTran();

                        

                       


                        LocationHelper.LockLoc(connection.S_CODE, "入库锁", 1);
                        var endLoc1 = LocationHelper.GetLocOne(task.S_END_LOC);
                        endLoc1.N_LOCK_STATE = 0;
@@ -411,19 +413,24 @@
                        //改一段任务终点
                        task.S_END_LOC = connection.S_CODE;
                        task.S_END_AREA = connection.S_AREA_CODE;
                        db.Updateable(task).UpdateColumns(it => new { it.S_END_LOC, it.S_END_AREA }).ExecuteCommand();

                        task.S_END_AREA_NAME = connection.S_AREA_Name;
                        db.Updateable(task).UpdateColumns(it => new { it.S_END_LOC, it.S_END_AREA,it.S_END_AREA_NAME }).ExecuteCommand();


                        //改二段任务起点
                        wcsTask.S_START_LOC = connection.S_CODE;
                        wcsTask.S_START_AREA = connection.S_AREA_CODE;
                        db.Updateable(wcsTask).UpdateColumns(it => new { it.S_START_LOC, it.S_START_AREA }).ExecuteCommand();

                        wcsTask.S_START_AREA_NAME = connection.S_AREA_Name;
                        db.Updateable(wcsTask).UpdateColumns(it => new { it.S_START_LOC, it.S_START_AREA,it.S_START_AREA_NAME}).ExecuteCommand();
                        db.CommitTran();

                        var site = LocationHelper.GetAgvSiteZc(connection.S_CODE);
                        LogHelper.Info($"任务{task.S_CODE}改道成功，改参数2为{site},参数6为2,4为1024", "改道安全交互");
                        NDCApi.ChangeOrderParam(task.S_CODE, 2, site);
                        NDCApi.ChangeOrderParam(task.S_CODE, 4, "1024");
                        Thread.Sleep(1000);
                        NDCApi.ChangeOrderParam(task.S_CODE, 6, "2");

                        //} else if (workFlow.FLOWNAME.Contains("出库")) {
@@ -441,6 +448,7 @@
                    else {
                        LogHelper.Info($"当前任务{task.S_CODE}接驳位{task.S_END_LOC}可用,当前库区{wcsTask.S_END_AREA}当前巷道{loc1.N_ROADWAY}可用，不需要改道，直接修改参数6为2，4为1024", "改道安全交互");
                        NDCApi.ChangeOrderParam(task.S_CODE, 4, "1024");
                        Thread.Sleep(1000);
                        NDCApi.ChangeOrderParam(task.S_CODE, 6, "2");
                    }
                }
@@ -515,17 +523,50 @@

                if (mst.S_TYPE.Contains("出库"))
                {
                    var wcsTask = TaskHelper.GetTaskByWork("wcs", mst.S_OP_CODE);
                    if (wcsTask == null) {
                        LogHelper.Info($"推送任务{mst.S_CODE}，没找到作业:{mst.S_OP_CODE}对应的出库任务", "NDC");
                    //查找对应作业，是接驳位就查询对应立库任务


                    var wmsWork = TaskHelper.GetWmsWork(mst.S_OP_CODE);

                    if (wmsWork==null)
                    {
                        LogHelper.Info($"推送任务{mst.S_CODE}，没找到作业:{mst.S_OP_CODE}", "NDC");
                        return false;
                    }

                    if (wcsTask.S_B_STATE=="未执行")
                    if (!string.IsNullOrEmpty(wmsWork.CONNECTION))
                    {
                        LogHelper.Info($"推送任务{mst.S_CODE}，对应的Wcs出库任务未执行，暂不推送", "NDC");
                        return false;
                        var wcsTask = TaskHelper.GetTaskByWork("wcs", mst.S_OP_CODE);
                        if (wcsTask == null)
                        {
                            LogHelper.Info($"推送任务{mst.S_CODE}，没找到作业:{mst.S_OP_CODE}对应的出库任务", "NDC");
                            return false;
                        }

                        if (wcsTask.S_B_STATE == "未执行")
                        {
                            LogHelper.Info($"推送任务{mst.S_CODE}，对应的Wcs出库任务未执行，暂不推送", "NDC");
                            return false;
                        }

                        //接驳位两个agv任务，a任务取货完成 推送b任务
                        var agvTask = LocationHelper.GetConnectionTask(wmsWork.CONNECTION,"agv");

                        LogHelper.Info($"推送任务{mst.S_CODE}，当前接驳位{wmsWork.CONNECTION}，第一个agv任务信息"+JsonConvert.SerializeObject(agvTask), "NDC");
                        if (agvTask==null)
                        {
                            LogHelper.Info($"推送任务{mst.S_CODE}，当前接驳位{wmsWork.CONNECTION}，agv任务没找到，暂不推送", "NDC");
                            return false;
                        }

                        if (agvTask.S_B_STATE!="取货完成")
                        {
                            LogHelper.Info($"推送任务{mst.S_CODE}，当前接驳位{wmsWork.CONNECTION}，agv任务{agvTask.S_CODE},状态{agvTask.S_B_STATE}，暂不推送", "NDC");
                            return false;
                        }
                    }


                }


@@ -612,6 +653,15 @@
            }
            return result;
        }

        internal static LocationRecordsResult LocationRecords(LocationRecordsParme model) {
            var result = new LocationRecordsResult();
            var db = new SqlHelper<object>().GetInstance();
            
            return result;
        }

        

        internal static Result MesUdeItem(MesUdeItemParme model)
        {
@@ -738,15 +788,22 @@
                    var TrayLocation = db.Queryable<LocCntrRel>().Where(e => e.S_CNTR_CODE == model.TOOLS_NO).ToList();
                    if (TrayLocation.Count() > 0)
                    {
                        LogHelper.Info("查询到该工装已经绑定了货位信息", "物料绑定解绑");
                        throw new Exception("查询到该工装已经绑定了货位信息");
                        LogHelper.Info("查询到该工装托盘码已经绑定了货位信息", "物料绑定解绑");
                        throw new Exception("查询到该工装托盘码已经绑定了货位信息");
                    }
                    var TrayItems = db.Queryable<CntrItemRel>().Where(e => e.S_CNTR_CODE == model.TOOLS_NO).ToList();
                    if (TrayItems.Count() > 0)
                    {
                        LogHelper.Info("查询到该工装已经绑定了物料信息", "物料绑定解绑");
                        throw new Exception("查询到该工装已经绑定了物料信息");
                        LogHelper.Info("查询到该工装托盘码已经绑定了物料信息", "物料绑定解绑");
                        throw new Exception("查询到该工装托盘码已经绑定了物料信息");
                    }
                    var Tray = db.Queryable<Container>().Where(e => e.S_CODE == model.TOOLS_NO).ToList();
                    if (Tray.Count() > 0)
                    {
                        LogHelper.Info("查询到该工装托盘码已经绑定了容器信息", "物料绑定解绑");
                        throw new Exception("查询到该工装托盘码已经绑定了容器信息");
                    }

                    var Locations = db.Queryable<Location>().Where(e => e.S_CODE == model.LOCATION_CODE)?.First();
                    if (Locations == null)
                    {
@@ -897,7 +954,7 @@
            {
                db.RollbackTran();
                LogHelper.Info("物料绑定解绑异常:" + e.Message, "物料绑定解绑");
                result.errMsg = "物料绑定解绑异常";
                result.errMsg = "物料绑定解绑异常" + e.Message;
                result.errCode = 1;
                result.success = false;
                return result;
@@ -923,30 +980,23 @@
            try
            {
                var task = TaskHelper.GetTaskByWorkNo(model.task_no, "agv");
                var wcsTask = TaskHelper.GetTaskByWorkNo(model.task_no,"wcs");
                if (task != null && wcsTask != null)

                var wcsTask = TaskHelper.GetTaskByWorkNo(model.task_no, "wcs");

                if (task != null)
                {
                    LogHelper.Info($"cancelTask1取消agv任务{task.S_CODE}：", "取消");
                    if (task.S_B_STATE.Trim() == "未执行")
                    {
                        //未执行直接修改状态为取消
                        LogHelper.Info("cancelTask1取消agv任务：", "取消");
                        TaskHelper.opMesTask(task, 3);
                        TaskHelper.Fail(task);
                        TaskProcess.CacheBitCancelUpdate(task);
                        if (task.S_TYPE.Contains("入库") || task.S_TYPE.Contains("回库"))
                        {
                            ContainerHelper.delCntr(task.S_CNTR_CODE);
                            ContainerHelper.delCntrItem(task.S_CNTR_CODE);
                        }
                        
                       
                        TaskHelper.Fail(wcsTask);
                        TaskProcess.OperateStatus(wcsTask, 7);
                        result.errCode = 0;
                        result.errMsg = "取消成功";
                        result.success = true;
                        return result;
                    }
                    else if (task.S_B_STATE.Trim() != "取消"  && task.S_B_STATE.Trim() != "失败")
                    else if (task.S_B_STATE.Trim() != "取消" && task.S_B_STATE.Trim() != "失败" && task.S_B_STATE.Trim() != "完成")
                    {
                        var db = new SqlHelper<object>().GetInstance();
                        var qhflag = db.Queryable<WmsTaskAction>().Where(a => a.S_TASK_CODE == task.S_CODE && a.S_ACTION == "4").First();
@@ -960,19 +1010,13 @@
                            result.success = false;
                            return result;
                        }

                        TaskHelper.opMesTask(task, 3);
                        //已推送但是没有完成或者取消，通知hosttoagv
                        TaskHelper.Fail(task);
                        

                        NDCApi.CancelOrder(task.S_CODE.Trim());
                        TaskProcess.CacheBitCancelUpdate(task);
                        if (task.S_TYPE.Contains("入库") || task.S_TYPE.Contains("回库"))
                        {
                            ContainerHelper.delCntr(task.S_CNTR_CODE);
                            ContainerHelper.delCntrItem(task.S_CNTR_CODE);
                        }
                        TaskHelper.Fail(wcsTask);
                        TaskProcess.OperateStatus(wcsTask, 7);

                        result.errCode = 0;
                        result.errMsg = "取消成功";
                        result.success = true;
@@ -990,11 +1034,52 @@
                    result.errMsg = $"{model.task_no}任务不存在";
                    result.success = false;
                }

                if (wcsTask != null)
                {
                    LogHelper.Info($"cancelTask1取消Wcs任务{wcsTask.S_CODE}", "取消");
                    if (wcsTask.S_B_STATE.Trim() == "未执行")
                    {
                        //未执行直接修改状态为取消
                        if (task.S_TYPE.Contains("入库") || task.S_TYPE.Contains("回库"))
                        {
                            ContainerHelper.delCntr(task.S_CNTR_CODE);
                            ContainerHelper.delCntrItem(task.S_CNTR_CODE);
                        }
                        TaskHelper.Fail(wcsTask);
                        TaskProcess.OperateStatus(wcsTask, 7);
                        result.errCode = 0;
                        result.errMsg = "取消成功";
                        result.success = true;
                        return result;
                    }
                    else if (wcsTask.S_B_STATE.Trim() != "取消" && wcsTask.S_B_STATE.Trim() != "失败" && wcsTask.S_B_STATE.Trim() != "完成")
                    {
                        var db = new SqlHelper<object>().GetInstance();
                        var qhflag = db.Queryable<WmsTaskAction>().Where(a => a.S_TASK_CODE == task.S_CODE && a.S_ACTION == "5").First();


                        if (qhflag != null)
                        {
                            LogHelper.Info($"该任务{task.S_CODE}已经取货完成", "取消");
                            result.errCode = 1;
                            result.errMsg = "任务已经取货完成，不允许取消";
                            result.success = false;
                            return result;
                        }
                        WcsTask.WcsCancellTask(wcsTask);
                        TaskHelper.Fail(wcsTask);
                        TaskProcess.OperateStatus(wcsTask, 7);
                        result.errCode = 0;
                        result.errMsg = "取消成功";
                        result.success = true;
                    }
                }
            }
            catch (Exception ex)
            {

                LogHelper.Info("cancelTask1取消任务异常："+ex.Message, "取消");
                LogHelper.Info("cancelTask1取消任务异常：" + ex.Message, "取消");
                result.errCode = 1;
                result.errMsg = "取消任务异常";
                return result;
@@ -1302,7 +1387,262 @@

        }

       

        /// <summary>
        /// 添加mes任务
        /// </summary>
        internal static Result addMesTaskInWorkArea(InWorkAreaParme model)
        {
            var result = new Result();
            var TOOLSTYPE = "";
            try
            {
                if (string.IsNullOrEmpty(model.BUSI_TYPE.ToString()))
                {
                    LogHelper.Info("InWorkArea任务下发失败，缺少参数BUSI_TYPE。", "Mes任务下发");
                    throw new Exception("缺少参数BUSI_TYPE");
                }
                if (string.IsNullOrEmpty(model.PROD_NO))
                {
                    LogHelper.Info("InWorkArea任务下发失败，缺少参数PROD_NO。", "Mes任务下发");
                    throw new Exception("缺少参数PROD_NO");
                }
                if (string.IsNullOrEmpty(model.Location_To))
                {
                    LogHelper.Info("InWorkArea任务下发失败，终点为空。", "Mes任务下发");
                    throw new Exception("缺少终点Location_To");
                }
                if (string.IsNullOrEmpty(model.CHECK_INFO))
                {
                    LogHelper.Info("InWorkArea任务下发失败，缺少参数CHECK_INFO。", "Mes任务下发");
                    throw new Exception("缺少参数CHECK_INFO");
                }
                if (string.IsNullOrEmpty(model.task_no))
                {
                    LogHelper.Info("InWorkArea任务下发失败，缺少参数task_no。", "Mes任务下发");
                    throw new Exception("缺少参数task_no");
                }

                if (model.Task_type==2)
                {
                    //呼叫胶料出库



                  var   workFlow = TaskHelper.selectWorkFlowByType(model.BUSI_TYPE);

                  


                    if (workFlow == null)
                    {
                        LogHelper.Info($"InWorkArea任务下发失败，BUSI_TYpe:{model.BUSI_TYPE},没找到对应作业流程", "Mes任务下发");
                        throw new Exception($"BUSI_TYpe:{model.BUSI_TYPE},没找到对应作业流程");
                    }
                    else
                    {
                        LogHelper.Info($"作业流程信息" + JsonConvert.SerializeObject(workFlow), "Mes任务下发");
                    }

                    //出库任务

                    //接驳位
                    var connection = "";

                    //接驳位库区
                    var connectionArea = "";


                    //查找给定终点
                    var end = LocationHelper.GetLoc(model.Location_To);
                    LogHelper.Info($"InWorkArea出库任务下发终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");


                    if (end == null)
                    {
                        LogHelper.Info($"InWorkArea出库任务下发失败，终点:{model.Location_To},没找到", "Mes任务下发");
                        throw new Exception($"终点:{model.Location_To},没找到");
                    }


                    var unlimitedLocation = TaskHelper.GetMesKtLoc();

                    //标记终点货位是否可以无限制下任务
                    var endLocFlag = true;

                    foreach (var item in unlimitedLocation)
                    {
                        //出库终点货位在配置里 可以无限制下任务
                        if (item.Loc.Contains(model.Location_To))
                        {
                            endLocFlag = false;
                            break;
                        }
                    }

                    if (endLocFlag)
                    {
                        var endTask = TaskHelper.GetTaskByEndLoc(model.Location_To);
                        if (endTask != null)
                        {
                            LogHelper.Info($"InWorkArea出库任务下发失败，终点:{model.Location_To}有任务执行中，任务号:{endTask.S_CODE}", "Mes任务下发");
                            throw new Exception($"终点:{model.Location_To}有任务执行中，任务号:{endTask.S_CODE}");
                        }
                    }



                    //查找起点
                    List<Location> strrtList;

                    Location start = null;


                    if (!string.IsNullOrEmpty(workFlow.ZONECODE))
                    {
                        strrtList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
                    }
                    else
                    {
                        strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
                    }



                    if (workFlow.FLOWCODE == "9")
                    {
                            //根据制品编号寻找立库区对应物料托盘
                            start = LocationHelper.FindStartcolByLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA, workFlow.ROADWAY, workFlow.CONNECTION);
                            if (start == null)
                            {
                                strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
                                var itemFlag = LocationHelper.FindStartcolByLoclistAndItemFlag(strrtList, model.PROD_NO, workFlow.STARTAREA);
                                LogHelper.Info($"InWorkArea满托出库任务没找到起点，校验是否有库存但是设备报警{itemFlag}", "Mes任务下发");
                                if (itemFlag)
                                {
                                    result.errMsg = "满托出库作业有库存但设备报警";
                                    result.errCode = 2001;
                                    result.success = true;
                                    return result;
                                }
                            }


                        LogHelper.Info($"InWorkArea出库任务下发起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");

                        if (start == null)
                        {
                            LogHelper.Info($"InWorkArea出库任务下发失败，起点库区{workFlow.STARTAREA},没找到起点", "Mes任务下发");
                            throw new Exception($"起点库区{workFlow.STARTAREA},没找到起点");
                        }




                        //获取托盘码
                        var cntrCode = LocationHelper.GetLocCntrCode(start.S_CODE);

                        if (workFlow.SENDWCS == "Y")
                        {

                            //正式代码，调用接口寻找可用接驳位
                            var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
                                 
                            //根据接驳位任务数量获取均衡接驳位集合优先任务数少的接驳位
                            var balanceConnectionList = LocationHelper.GetBalanceConnectionList(connectionList);
                            foreach (var item in balanceConnectionList)
                            {
                                if (item.loc.CONNEC_ROADWAY == start.N_ROADWAY)
                                {
                                    connection = item.loc.S_CODE;
                                    connectionArea = item.loc.S_AREA_Name;
                                    LogHelper.Info($"InWorkArea出库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
                                    break;
                                }
                            }

                            if (connection == "")
                            {
                                LogHelper.Info($"InWorkArea出库任务下发寻找接驳位失败", "Mes任务下发");
                                throw new Exception($"InWorkArea出库任务下发寻找接驳位失败");
                            }
                        }


                        //起点终点查找成功，创建作业

                        var taskType = int.Parse(workFlow.FLOWCODE);

                        var operation = new WmsWork
                        {
                            // 作业号
                            S_CODE = model.task_no,
                            // 作业类型
                            N_TYPE = taskType,
                            // 作业类型
                            S_TYPE = workFlow.FLOWNAME,
                            // 起点货位
                            S_START_LOC = start.S_CODE,
                            // 起点库区编码
                            S_START_AREA = start.S_AREA_CODE,
                            //接驳位
                            CONNECTION = connection,
                            // 终点货位
                            S_END_LOC = end.S_CODE,
                            // 终点库区编码
                            S_END_AREA = end.S_AREA_CODE,
                            // 容器编码
                            S_CNTR_CODE = cntrCode,
                            // 作业定义名称
                            S_OP_DEF_NAME = workFlow.FLOWNAME,
                            //优先级
                            N_PRIORITY = model.Priority,
                            //工装类型
                            TOOLSTYPE = TOOLSTYPE,
                            //起点库区名称
                            S_START_AREA_NAME = start.S_AREA_Name,
                            //起点库区名称
                            S_END_AREA_NAME = end.S_AREA_Name,
                            //起点库区名称
                            CONNECTION_AREA = connectionArea
                        };

                        //创建作业
                        if (WMSHelper.CreateWmsWork(operation))
                        {
                            if (connection != "")
                            {
                                LocationHelper.LockLoc(operation.S_START_LOC, "出库锁", 2);
                                LocationHelper.LockLoc(operation.S_END_LOC, "入库锁", 1);
                                LocationHelper.LockLoc(operation.CONNECTION, "入库锁", 1);
                            }


                            LogHelper.Info($"InWorkArea出库作业创建成功{operation.S_CODE}", "Mes任务下发");
                            result.errMsg = "出库作业创建成功";
                            result.errCode = 0;
                            result.success = true;
                            return result;
                        }
                        else
                        {
                            LogHelper.Info($"InWorkArea出库任务下发创建作业失败", "Mes任务下发");
                            throw new Exception($"InWorkArea出库任务下发创建作业失败");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Info("InWorkArea任务下发异常" + ex.Message, "Mes任务下发");
                result.errMsg = "InWorkArea任务下发异常" + ex.Message;
                result.errCode = 1;
                result.success = false;
                throw;
            }

            return result;
        }


            /// <summary>
@@ -1468,65 +1808,114 @@
                    {

                        //正式代码，调用接口寻找可用接驳位
                        var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
                        var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
                        if (usableConnectionList != null && usableConnectionList.code == "0")
                        //var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
                        //var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
                        //if (usableConnectionList != null && usableConnectionList.code == "0")
                        //{
                        //    var balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);
                        //    LogHelper.Info($"ZCSendTask入库任务下发寻找可用接驳位" + JsonConvert.SerializeObject(balanceConnectionList), "Mes任务下发");

                        //    if (workFlow.FLOWCODE == "1" || workFlow.FLOWCODE == "2")
                        //    {
                        //        //满托入
                        //        balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);

                        //        if (TOOLSTYPE == "25" || TOOLSTYPE == "35") {
                        //            LogHelper.Info($"ZCSendTask入库任务工装是二合一库,需要物料均衡", "Mes任务下发");
                        //            balanceLocList = LocationHelper.RoadWayBalance1ByItem(balanceLocList, model.PROD_NO);
                        //        }



                        //    }
                        //    else if (workFlow.FLOWCODE == "3")
                        //    {
                        //        //空托入立库区
                        //        cntrCount = 0;
                        //        LogHelper.Info($"ZCSendTask入库任务,寻找立库区空货位", "Mes任务下发");
                        //        balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
                        //    }

                        //    LogHelper.Info($"ZCSendTask入库任务下发寻找终点数量{balanceLocList.Count}", "Mes任务下发");

                        //    foreach (var item in balanceLocList)
                        //    {
                        //        if (item.S_LOCK_STATE == "无" && item.N_CURRENT_NUM == 0)
                        //        {
                        //           // LogHelper.Info($"ZCSendTask入库任务下发item信息" + JsonConvert.SerializeObject(item), "Mes任务下发");
                        //            foreach (var item1 in balanceConnectionList)
                        //            {
                        //                if (item1.CONNEC_ROADWAY == item.N_ROADWAY)
                        //                {
                        //                    connection = item1.S_CODE;
                        //                    connectionArea = item1.S_AREA_Name;
                        //                    end = item;
                        //                    LogHelper.Info($"ZCSendTask入库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
                        //                    break;
                        //                }
                        //            }
                        //            if (end!=null)
                        //            {
                        //                LogHelper.Info($"ZCSendTask入库任务下发寻找到终点{end.S_CODE}", "Mes任务下发");
                        //                break;
                        //            }
                        //        }
                        //    }
                        //    if (connection == "")
                        //    {
                        //        LogHelper.Info($"ZCSendTask入库任务下发没找到接驳位", "Mes任务下发");
                        //        throw new Exception($"ZCSendTask入库任务下发没找到接驳位");
                        //    }
                        //}
                        //else
                        //{
                        //    LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位接口失败", "Mes任务下发");
                        //    throw new Exception($"ZCSendTask入库任务下发寻找接驳位接口失败");
                        //}


                        if (workFlow.FLOWCODE == "1" || workFlow.FLOWCODE == "2" || workFlow.FLOWCODE == "5" || workFlow.FLOWCODE == "8" || workFlow.FLOWCODE == "11")
                        {
                            var balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);
                            LogHelper.Info($"ZCSendTask入库任务下发寻找可用接驳位" + JsonConvert.SerializeObject(balanceConnectionList), "Mes任务下发");
                            //满托入

                            if (workFlow.FLOWCODE == "1" || workFlow.FLOWCODE == "2")
                            if (TOOLSTYPE == "25" || TOOLSTYPE == "35")
                            {
                                //满托入
                                balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
                                LogHelper.Info($"ZCSendTask入库任务工装是二合一库,需要物料均衡", "Mes任务下发");
                                end = LocationHelper.FindBalanceEndcolByLocListItem(endList, workFlow.ENDAREA, workFlow.ROADWAY, workFlow.CONNECTION, model.task_no, model.PROD_NO);

                            }
                            else if (workFlow.FLOWCODE == "3")
                            {
                                //空托入立库区
                                cntrCount = 0;
                                LogHelper.Info($"ZCSendTask入库任务,寻找立库区空货位", "Mes任务下发");
                                balanceLocList = LocationHelper.FindBalanceEndLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
                            else {
                                end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY, workFlow.CONNECTION, model.task_no);
                            }

                            LogHelper.Info($"ZCSendTask入库任务下发寻找终点数量{balanceLocList.Count}", "Mes任务下发");

                            foreach (var item in balanceLocList)
                            {
                                if (item.S_LOCK_STATE == "无" && item.N_CURRENT_NUM == 0)
                                {
                                   // LogHelper.Info($"ZCSendTask入库任务下发item信息" + JsonConvert.SerializeObject(item), "Mes任务下发");
                                    foreach (var item1 in balanceConnectionList)
                                    {
                                        if (item1.CONNEC_ROADWAY == item.N_ROADWAY && item1.N_CURRENT_NUM < 2)
                                        {
                                            connection = item1.S_CODE;
                                            connectionArea = item1.S_AREA_Name;
                                            end = item;
                                            LogHelper.Info($"ZCSendTask入库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
                                            break;
                                        }
                                    }
                                    if (connection == "")
                                    {
                                        LogHelper.Info($"ZCSendTask入库任务下发没找到接驳位", "Mes任务下发");
                                        throw new Exception($"ZCSendTask入库任务下发没找到接驳位");
                                    }

                                    if (end!=null)
                                    {
                                        LogHelper.Info($"ZCSendTask入库任务下发寻找到终点{end.S_CODE}", "Mes任务下发");
                                        break;
                                    }
                                }
                            }
                        }
                        else
                        else if (workFlow.FLOWCODE == "3" || workFlow.FLOWCODE == "10")
                        {
                            LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位失败", "Mes任务下发");
                            throw new Exception($"ZCSendTask入库任务下发寻找接驳位失败");
                            //空托入立库区
                            cntrCount = 0;
                            LogHelper.Info($"ZCSendTask入库任务,寻找立库区空货位", "Mes任务下发");
                            end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY, workFlow.CONNECTION, model.task_no);
                        }

                       
                        if (end == null)
                        {
                            LogHelper.Info($"ZCSendTask入库任务{model.task_no}下发失败，终点库区{workFlow.ENDAREA},没找到终点巷道或接驳位不可用", "Mes任务下发");
                            throw new Exception($"{model.task_no}下发失败终点库区{workFlow.ENDAREA},没找到终点,巷道或接驳位不可用");
                        }

                        var jb = LocationHelper.GetConnectionByEnd(workFlow.CONNECTION, end.N_ROADWAY);

                        if (jb==null)
                        {
                            LogHelper.Info($"ZCSendTask入库任务下发库区{workFlow.CONNECTION}，巷道{end.N_ROADWAY},没找到接驳位", "Mes任务下发");
                            throw new Exception($"ZCSendTask入库任务下发库区{workFlow.CONNECTION}，巷道{end.N_ROADWAY},没找到接驳位");
                        }


                        connection = jb.S_CODE;
                        connectionArea = jb.S_AREA_Name;


                    }
                    else {
                        if (workFlow.FLOWCODE == "3")
@@ -1554,16 +1943,14 @@
                        }
                     }


                    


                    LogHelper.Info($"ZCSendTask入库任务下发终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");

                    if (end == null) {
                        LogHelper.Info($"ZCSendTask入库任务下发失败，终点库区{workFlow.ENDAREA},没找到终点", "Mes任务下发");
                        throw new Exception($"终点库区{workFlow.ENDAREA},没找到终点");
                        LogHelper.Info($"ZCSendTask入库任务{model.task_no}下发失败，终点库区{workFlow.ENDAREA},没找到终点", "Mes任务下发");
                        throw new Exception($"{model.task_no}下发失败终点库区{workFlow.ENDAREA},没找到终点");
                    }



                    //添加托盘物料关联表
                    if (cntrCount != 0)
@@ -1580,7 +1967,7 @@
                        var EXPIRED_TIME = model.EXPIRED_TIME.ToString();
                        if (EXPIRED_TIME == "0001/1/1 0:00:00")
                        {
                            rel.expireTime = model.SHELF_LIFE_TIME.AddHours(model.EXPIRED_REP);
                            rel.expireTime = model.PRODUCE_TIME.AddHours(model.EXPIRED_REP);
                            LogHelper.Info($"失效时间为0001/1/1 0:00:00，修改为：{rel.expireTime}", "Mes任务下发");
                        }
                        else
@@ -1591,7 +1978,7 @@
                        var SHELF_LIFE_TIME = model.SHELF_LIFE_TIME.ToString();
                        if (SHELF_LIFE_TIME == "0001/1/1 0:00:00")
                        {
                            rel.takeEffectTime = model.SHELF_LIFE_TIME.AddHours(-model.SHELF_REP);
                            rel.takeEffectTime = model.PRODUCE_TIME.AddHours(-model.SHELF_REP);
                            LogHelper.Info($"生效时间为0001/1/1 0:00:00，修改为：{rel.takeEffectTime}", "Mes任务下发");
                        }
                        else
@@ -1763,7 +2150,7 @@



                    if (workFlow.FLOWCODE == "9")
                    if (workFlow.FLOWCODE == "9" || workFlow.FLOWCODE == "4" || workFlow.FLOWCODE == "6")
                    {
                        if (TOOLSTYPE == "85" || TOOLSTYPE == "95")
                        {
@@ -1773,7 +2160,7 @@
                        else
                        {
                            //根据制品编号寻找立库区对应物料托盘
                            start = LocationHelper.FindStartcolByLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA, workFlow.ROADWAY);
                            start = LocationHelper.FindStartcolByLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA, workFlow.ROADWAY,workFlow.CONNECTION);
                            if (start == null)
                            {
                                strrtList = LocationHelper.GetAllLocList2(workFlow.STARTAREA);
@@ -1911,7 +2298,7 @@
                        var balanceConnectionList = LocationHelper.GetBalanceConnectionList(connectionList);
                        foreach (var item in balanceConnectionList)
                        {
                            if (item.loc.N_CURRENT_NUM < 2 && item.loc.CONNEC_ROADWAY==start.N_ROADWAY)
                            if (item.loc.CONNEC_ROADWAY==start.N_ROADWAY)
                            {
                                connection = item.loc.S_CODE;
                                connectionArea = item.loc.S_AREA_Name;
@@ -1997,8 +2384,6 @@
                    LogHelper.Info("ZCSendTask出库任务下发失败，Task_type不等于1或2", "Mes任务下发");
                    throw new Exception("Task_type不等于1或2");
                }



            }
            catch (Exception ex)