mes取消修改

海波 张

2 天以前 5b9da592f9bc117c88244f469418d5a5b29e4266

 process/TaskProcess.cs

@@ -33,6 +33,7 @@
using Container = HH.WCS.ZhongCeJinTan.wms.Container;
using static HH.WCS.ZhongCeJinTan.wms.WcsModel;
using Top.Api;
using HH.WCS.ZhongCeJinTan;

namespace HH.WCS.ZhongCeJinTan.process
{
@@ -141,7 +142,17 @@
            else if (state == 1004) {
                LogHelper.Info($"等待交互，任务号={mst.S_CODE}", "安全交互");

                var wcsCode = mst.S_CODE.Replace(@"_1", "_2");
                var wcsCode = "";

                if (mst.S_TYPE.Contains("入库")|| mst.S_TYPE.Contains("回库"))
                {
                    wcsCode = mst.S_CODE.Replace(@"_1", "_2");
                }

                if (mst.S_TYPE.Contains("出库"))
                {
                    wcsCode = mst.S_CODE.Replace(@"_2", "_1");
                }

                LogHelper.Info($"等待交互，查询校验任务号={wcsCode}", "安全交互");
                //等待rfid校验
@@ -152,8 +163,19 @@
                {
                    if (rfidFlag.S_RESULT.Contains("成功"))
                    {
                        LogHelper.Info($"任务号={mst.S_CODE}，等待交管成功，修改参数", "安全交互");
                        LogHelper.Info($"任务号={mst.S_CODE}，等待交管成功，修改参数6为1,4为0", "安全交互");
                        NDCApi.ChangeOrderParam(mst.S_CODE, 4, "0");
                        NDCApi.ChangeOrderParam(mst.S_CODE, 6, "1");
                    }
                    else {
                        var startSite = LocationHelper.GetAgvSiteZc(mst.S_START_LOC);
                        var endSite = LocationHelper.GetAgvSiteZc(mst.S_END_LOC);
                        LogHelper.Info($"任务{mst.S_CODE}RFID校验失败，改参数1为{startSite},改参数2为{endSite}，参数4为0，6为1", "安全交互");
                        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");
                    }
                }
            }
@@ -182,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)
            {
@@ -211,8 +236,7 @@
            try
            {
               
                //判断接驳位可用
                var flag = true;
               

                //空托入库判断空托出缓存表，有对应记录直接改道到缓存表终点
                if (workFlow.FLOWCODE=="3") {
@@ -241,38 +265,131 @@
                            //改一段任务终点
                            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();
                            var site = LocationHelper.GetAgvSiteZc(end.S_CODE);
                            LogHelper.Info($"任务{task.S_CODE}改道成功，改参数2为{site},参数6为1，4为0", "改道安全交互");
                            LogHelper.Info($"任务{task.S_CODE}改道成功，改参数2为{site},参数6为2，4为0", "改道安全交互");
                            NDCApi.ChangeOrderParam(task.S_CODE, 2, site);
                            NDCApi.ChangeOrderParam(task.S_CODE, 6, "1");
                            NDCApi.ChangeOrderParam(task.S_CODE, 4, "0");
                            Thread.Sleep(1000);
                            NDCApi.ChangeOrderParam(task.S_CODE, 6, "2");
                            return;
                        }
                       
                    }
                }

                //判断巷道可用
                var flag = true;

                //判断接驳位可用
                var flag1 = true;

                if (workFlow.FLOWNAME.Contains("入库"))
                {

                    List<Location> balanceConnectionList = new List<Location>();

                    var loc1 = LocationHelper.GetLocOne(wcsTask.S_END_LOC);
                    //查找可用巷道
                    //判断可用巷道
                    var rowdwa = db.Queryable<RoadWayEnable>().Where(x => x.areaCode == wcsTask.S_END_AREA && x.status == "0" && x.roadWay == loc1.N_ROADWAY.ToString()).First();
                    if (rowdwa == null)
                    {
                        LogHelper.Info($"判断巷道可用,当前库区{wcsTask.S_END_AREA}当前巷道{loc1.N_ROADWAY}可用,不需要改道", "改道安全交互");
                        LogHelper.Info($"当前任务{task.S_CODE}判断巷道可用,当前库区{wcsTask.S_END_AREA}当前巷道{loc1.N_ROADWAY}可用", "改道安全交互");
                        flag = false;
                    }

                    //判断可用接驳位
                    var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
                    var usableConnectionList = WcsTask.WcsPositionAvailable(task.S_CODE, connectionList);

                  
                    if (usableConnectionList != null && usableConnectionList.code == "0")
                    {
                        balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);

                        foreach (var item in balanceConnectionList)
                        {
                            if (item.S_CODE.Contains(task.S_END_LOC))
                            {

                                flag1 = false;
                                LogHelper.Info($"当前任务{task.S_CODE}接驳位{item.S_CODE}可用", "改道安全交互");
                                break;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info($"当前巷道不可用，需要改道", "改道安全交互");
                        var endLoc = LocationHelper.GetLocOne(wcsTask.S_END_LOC);
                        LogHelper.Info($"判断接驳位是否可用接口回复异常", "改道安全交互");
                        throw new Exception($"判断接驳位是否可用接口回复异常");
                    }

                        var endList = LocationHelper.GetAllLocList1(workFlow.ENDAREA);
                        var end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
                        LogHelper.Info($"当前巷道不可用，需要改道，新终点信息" + JsonConvert.SerializeObject(end), "改道安全交互");


                    if (flag || flag1)
                    {

                        LogHelper.Info($"当前任务{task.S_CODE}接驳位{task.S_END_LOC}或者当前库区{wcsTask.S_END_AREA}当前巷道{loc1.N_ROADWAY}不可用，需要改道", "改道安全交互");
                        Location connection = null;


                        Location end = null;

                        //立库均衡后货位集合
                        List<Location> balanceLocList = new List<Location>();

                        var endLoc = LocationHelper.GetLocOne(wcsTask.S_END_LOC);
                        List<Location> endList;
                        if (!string.IsNullOrEmpty(workFlow.ZONECODE))
                        {
                            endList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
                        }
                        else
                        {
                            endList = LocationHelper.GetAllLocList1(workFlow.ENDAREA);
                        }
                        

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

                        balanceConnectionList = LocationHelper.GetConnectionListByst(usableConnectionList.available);

                        foreach (var item in balanceLocList)
                        {
                            if (item.S_LOCK_STATE == "无" && item.N_CURRENT_NUM == 0)
                            {
                                //LogHelper.Info($"改道安全交互item信息" + JsonConvert.SerializeObject(item), "改道安全交互");
                                foreach (var item1 in balanceConnectionList)
                                {
                                    if (item1.CONNEC_ROADWAY == item.N_ROADWAY)
                                    {
                                        connection = item1;
                                      
                                        end = item;
                                        LogHelper.Info($"当前任务{task.S_CODE}寻找到可用接驳位{connection}", "改道安全交互");
                                        break;
                                    }
                                }
                                if (end != null)
                                {
                                    LogHelper.Info($"当前任务{task.S_CODE}寻找到终点{end.S_CODE}", "改道安全交互");
                                    break;
                                }
                            }
                        }


                        if (connection == null)
                        {
                            throw new Exception($"改道寻找不到可用接驳位");
                        }

                        LogHelper.Info($"当前任务{task.S_CODE}，当前巷道不可用，需要改道，新终点信息" + JsonConvert.SerializeObject(end), "改道安全交互");
                        if (end == null)
                        {
                            LogHelper.Info($"当前巷道不可用，终点库区{workFlow.ENDAREA},没找到终点", "改道安全交互");
@@ -286,79 +403,35 @@
                        wcsTask.S_END_LOC = end.S_CODE;
                        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;
                        endLoc1.S_LOCK_STATE = "无";
                        db.BeginTran();
                        db.Updateable(endLoc1).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE }).ExecuteCommand();
                        //改一段任务终点
                        task.S_END_LOC = connection.S_CODE;
                        task.S_END_AREA = connection.S_AREA_CODE;

                        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;

                    var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
                    var usableConnectionList = WcsTask.WcsPositionAvailable(task.S_CODE, connectionList);
                    if (usableConnectionList != null && usableConnectionList.code == "0")
                    {
                        foreach (var item in usableConnectionList.available)
                        {
                            var con = LocationHelper.GetLoc(item);
                            if (con.S_CODE.Contains(task.S_END_LOC))
                            {
                        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();

                                flag = false;
                                LogHelper.Info($"当前任务{task.S_CODE}接驳位{con.S_CODE}可用，不需要改道，直接修改参数6为1，4为1024", "改道安全交互");
                                NDCApi.ChangeOrderParam(task.S_CODE, 6, "1");
                                NDCApi.ChangeOrderParam(task.S_CODE, 4, "1024");
                                break;
                            }
                        }
                    }
                    else
                    {
                        LogHelper.Info($"判断接驳位是否可用接口回复异常", "改道安全交互");
                        throw new Exception($"判断接驳位是否可用接口回复异常");
                    }
                    if (flag)
                    {

                        LogHelper.Info($"当前任务{task.S_CODE}接驳位不可用，需要改道", "改道安全交互");
                        var connection = "";
                        foreach (var item in usableConnectionList.available)
                        {
                            var con = LocationHelper.GetLoc(item);
                            if (con.N_CURRENT_NUM < 2)
                            {
                                connection = con.S_CODE;
                                LogHelper.Info($"改道寻找到可用接驳位{connection}", "改道安全交互");
                                break;
                            }
                        }
                        if (connection == "")
                        {
                            throw new Exception($"改道寻找不到可用接驳位");
                        }

                        var loc = LocationHelper.GetLocOne(connection);

                       
                            LocationHelper.LockLoc(loc.S_CODE, "入库锁", 1);
                            var endLoc = LocationHelper.GetLocOne(task.S_END_LOC);
                            endLoc.N_LOCK_STATE = 0;
                            endLoc.S_LOCK_STATE = "无";
                            db.BeginTran();
                            db.Updateable(endLoc).UpdateColumns(it => new { it.N_LOCK_STATE, it.S_LOCK_STATE }).ExecuteCommand();
                            //改一段任务终点
                            task.S_END_LOC = loc.S_CODE;
                            task.S_END_AREA = loc.S_AREA_CODE;
                            db.Updateable(task).UpdateColumns(it => new { it.S_END_LOC, it.S_END_AREA }).ExecuteCommand();
                            

                            //改二段任务起点
                            wcsTask.S_START_LOC = loc.S_CODE;
                            wcsTask.S_START_AREA = loc.S_AREA_CODE;
                            db.Updateable(wcsTask).UpdateColumns(it => new { it.S_START_LOC ,it.S_START_AREA}).ExecuteCommand();
                            db.CommitTran();
                            
                            var site = LocationHelper.GetAgvSiteZc(loc.S_CODE);
                            LogHelper.Info($"任务{task.S_CODE}改道成功，改参数2为{site},参数6为1,4为1024", "改道安全交互");
                            NDCApi.ChangeOrderParam(task.S_CODE, 2, site);
                            NDCApi.ChangeOrderParam(task.S_CODE, 6, "1");
                            NDCApi.ChangeOrderParam(task.S_CODE, 4, "1024");
                        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("出库")) {
                        //    var endLoc = LocationHelper.GetLocOne(task.S_START_LOC);
@@ -371,6 +444,12 @@
                        //    db.CommitTran();
                        //    LocationHelper.LockLoc(loc.S_CODE, "出库锁", 2);
                        //}
                    }
                    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");
                    }
                }

@@ -444,17 +523,53 @@

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


                }


@@ -481,7 +596,13 @@
                    ndcParme.Add(new param() { name = "DATA", value = "0" });
                }
                else {
                    ndcParme.Add(new param() { name = "DATA", value = "768" });
                    if (work.S_TYPE.Contains("入库") || work.S_TYPE.Contains("回库"))
                    {
                        ndcParme.Add(new param() { name = "DATA", value = "768" });
                    }
                    else {
                        ndcParme.Add(new param() { name = "DATA", value = "0" });
                    }
                }
              

@@ -535,6 +656,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)
        {
@@ -661,15 +791,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)
                    {
@@ -810,14 +947,19 @@
                    }
                    db.CommitTran();
                    LogHelper.Info("绑定解绑", "结束");
                    result.errMsg = "解绑完成";
                    result.errCode = 0;
                    result.success = true;
                    return result;
                    }
                }
            catch (Exception e)
            {
                db.RollbackTran();
                LogHelper.Info("物料绑定解绑异常:" + e.Message, "物料绑定解绑");
                result.errMsg = "物料绑定解绑异常";
                result.errMsg = "物料绑定解绑异常" + e.Message;
                result.errCode = 1;
                result.success = false;
                return result;
            }
            return result;
@@ -841,30 +983,30 @@
            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();
@@ -878,19 +1020,20 @@
                            result.success = false;
                            return result;
                        }

                        //已推送但是没有完成或者取消，通知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);
                            ContainerHelper.delCntrLoc(task.S_CNTR_CODE);
                        }
                        TaskHelper.Fail(wcsTask);
                        TaskProcess.OperateStatus(wcsTask, 7);

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

                        NDCApi.CancelOrder(task.S_CODE.Trim());
                        TaskProcess.CacheBitCancelUpdate(task);

                        result.errCode = 0;
                        result.errMsg = "取消成功";
                        result.success = true;
@@ -908,11 +1051,59 @@
                    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 (wcsTask.S_TYPE.Contains("入库") || wcsTask.S_TYPE.Contains("回库"))
                        {
                            ContainerHelper.delCntr(wcsTask.S_CNTR_CODE);
                            ContainerHelper.delCntrItem(wcsTask.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 == wcsTask.S_CODE && a.S_ACTION == "5").First();

                        LogHelper.Info($"该任务{wcsTask.S_CODE}动作信息"+JsonConvert.SerializeObject(qhflag), "取消");
                        if (qhflag != null)
                        {
                            LogHelper.Info($"该任务{wcsTask.S_CODE}已经取货完成", "取消");
                            result.errCode = 1;
                            result.errMsg = "任务已经取货完成，不允许取消";
                            result.success = false;
                            return result;
                        }

                        if (wcsTask.S_TYPE.Contains("入库") || wcsTask.S_TYPE.Contains("回库"))
                        {
                            ContainerHelper.delCntr(wcsTask.S_CNTR_CODE);
                            ContainerHelper.delCntrItem(wcsTask.S_CNTR_CODE);
                            ContainerHelper.delCntrLoc(wcsTask.S_CNTR_CODE);
                        }
                        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;
@@ -1220,7 +1411,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>
@@ -1355,48 +1801,10 @@
                        throw new Exception($"起点:{model.Location_From},没找到或有锁");
                    }

                    //接驳位
                    var connection = "";

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

                    //如果需要下发wcs立库，则需要寻找可用接驳位
                    if (workFlow.SENDWCS == "Y") {

                        //正式代码，调用接口寻找可用接驳位
                        var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
                        var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
                        if (usableConnectionList != null && usableConnectionList.code == "0")
                        {
                            //根据接驳位任务数量获取均衡接驳位集合优先任务数少的接驳位
                            var balanceConnectionList =  LocationHelper.GetBalanceConnectionList(usableConnectionList.available);
                            foreach (var item in balanceConnectionList)
                            {
                                if (item.loc.N_CURRENT_NUM<2)
                                {
                                    connection = item.loc.S_CODE;
                                    connectionArea = item.loc.S_AREA_Name;
                                    LogHelper.Info($"ZCSendTask入库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
                                    break;
                                }
                            }
                        }
                        else
                        {
                            LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位失败", "Mes任务下发");
                            throw new Exception($"ZCSendTask入库任务下发寻找接驳位失败");
                        }

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

                    //查找终点
                    List<Location> endList ;
                    List<Location> endList;

                    Location end = null;

@@ -1404,63 +1812,169 @@
                    {
                        endList = LocationHelper.GetZoneLoc(workFlow.ZONECODE);
                    }
                    else {
                    else
                    {
                        endList = LocationHelper.GetAllLocList1(workFlow.ENDAREA);
                    }

                    if (workFlow.FLOWCODE == "1")
                    //立库均衡后货位集合
                    List<Location> balanceLocList = new List<Location>();


                    //接驳位
                    var connection = "";

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

                    //如果需要下发wcs立库，则需要寻找可用接驳位
                    if (workFlow.SENDWCS == "Y")
                    {
                        //满托入
                        end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
                    }
                    else if (workFlow.FLOWCODE == "3")
                    {
                        //空托入 优先入缓存区，没有入立库区
                        //var ktHcq = Settings.EmptyPalletBufferArea;
                        cntrCount = 0;
                        //var endList1 = LocationHelper.GetAllLocList1(ktHcq);
                        //end = LocationHelper.FindEndcolByLoc(endList1, ktHcq);
                        //LogHelper.Info($"ZCSendTask入库任务寻找空托缓存区终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
                        //if (end == null)

                        //正式代码，调用接口寻找可用接驳位
                        //var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
                        //var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
                        //if (usableConnectionList != null && usableConnectionList.code == "0")
                        //{
                            LogHelper.Info($"ZCSendTask入库任务没找到空托缓存区终点,寻找立库区空货位", "Mes任务下发");
                            end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
                        //    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
                        //{
                        //    connection = "";
                        //    LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位接口失败", "Mes任务下发");
                        //    throw new Exception($"ZCSendTask入库任务下发寻找接驳位接口失败");
                        //}
                    }
                    else if (workFlow.FLOWCODE == "2")
                    {

                        //85纤维 95钢丝一段任务入三层货架
                        if (TOOLSTYPE == "85" || TOOLSTYPE == "95")

                        if (workFlow.FLOWCODE == "1" || workFlow.FLOWCODE == "2" || workFlow.FLOWCODE == "5" || workFlow.FLOWCODE == "8" || workFlow.FLOWCODE == "11")
                        {
                            //满托入

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

                            }
                            else {
                                end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY, workFlow.CONNECTION, model.task_no);
                            }

                        }
                        else if (workFlow.FLOWCODE == "3" || workFlow.FLOWCODE == "10")
                        {
                            //空托入立库区
                            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")
                        {
                            end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
                            LogHelper.Info($"ZCSendTask入库任务85纤维 95钢丝一段任务入三层货架终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
                        }
                        else
                        else if (workFlow.FLOWCODE == "2")
                        {
                            end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
                            //85纤维 95钢丝一段任务入三层货架
                              end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
                              LogHelper.Info($"ZCSendTask入库任务85纤维 95钢丝一段任务入三层货架终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
                        }
                    }
                    else if (workFlow.FLOWCODE == "12")
                    {
                        //空架子入
                        end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
                        cntrCount = 0;
                        //生成空架子虚拟号
                        cntrCode = ContainerHelper.GenerateCntrNo();
                    }

                        else if (workFlow.FLOWCODE == "12")
                        {
                            //空架子入
                            end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
                            cntrCount = 0;
                            //生成空架子虚拟号
                            cntrCode = ContainerHelper.GenerateCntrNo();
                        }
                        else if (workFlow.FLOWCODE == "0")
                        {
                            //钢丝入库
                            end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
                        }
                     }

                    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)
@@ -1477,7 +1991,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
@@ -1488,7 +2002,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
@@ -1568,6 +2082,14 @@
                    //创建作业
                    if (WMSHelper.CreateWmsWork(operation))
                    {
                        if (connection != "")
                        {
                            LocationHelper.LockLoc(operation.S_START_LOC, "出库锁", 2);
                            LocationHelper.LockLoc(operation.S_END_LOC, "入库锁", 1);
                            LocationHelper.LockLoc(operation.CONNECTION, "其他锁", 3);
                        }


                        LogHelper.Info($"ZCSendTask入库作业创建成功{operation.S_CODE}", "Mes任务下发");
                        result.errMsg = "入库作业创建成功";
                        result.errCode = 0;
@@ -1652,17 +2174,18 @@



                    if (workFlow.FLOWCODE == "9")
                    if (workFlow.FLOWCODE == "9" || workFlow.FLOWCODE == "4" || workFlow.FLOWCODE == "6")
                    {
                        if (TOOLSTYPE == "85" || TOOLSTYPE == "95")
                        {
                            start = LocationHelper.FindStartcolByHjLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA);
                            LogHelper.Info($"ZCSendTask出库任务85纤维 95钢丝一段任务三层货架起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");
                        }
                        else {
                        else
                        {
                            //根据制品编号寻找立库区对应物料托盘
                            start = LocationHelper.FindStartcolByLoclistAndItem(strrtList, model.PROD_NO, workFlow.STARTAREA, workFlow.ROADWAY);
                            if (start==null)
                            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);
@@ -1683,7 +2206,8 @@


                    }
                    else if (workFlow.FLOWCODE == "7") {
                    else if (workFlow.FLOWCODE == "7")
                    {
                        //寻找立库区空托
                        //start = LocationHelper.FindStartcolByLoclistAndcntr(strrtList, workFlow.STARTAREA);
                        //if (start == null)
@@ -1705,7 +2229,8 @@

                        //先查询有没有同终点缓存的记录

                        if (endLocFlag) {
                        if (endLocFlag)
                        {
                            var ktTask = TaskHelper.GetMesKtTask(end.S_CODE);
                            if (ktTask != null)
                            {
@@ -1714,7 +2239,7 @@
                            }
                        }

                      


                        MesKtTask req = new MesKtTask()
                        {
@@ -1724,7 +2249,7 @@
                            CreateDate = DateTime.Now,
                            BUSI_TYPE = model.BUSI_TYPE,
                            TOOLS_TPYE = TOOLSTYPE,
                            task_no=model.task_no,
                            task_no = model.task_no,
                            Status = "N"
                        };

@@ -1745,6 +2270,12 @@
                            LogHelper.Info($"ZCSendTask空托出缓存失败", "Mes任务下发");
                            throw new Exception($"ZCSendTask空托出缓存失败");
                        }
                    }
                    else if (workFlow.FLOWCODE == "5")
                    {
                        //寻找货架区空托
                        start = LocationHelper.FindStartcolByHjArea(strrtList, workFlow.STARTAREA);
                        LogHelper.Info($"ZCSendTask出库任务钢丝空托一段任务起点信息" + JsonConvert.SerializeObject(start), "Mes任务下发");
                    }


@@ -1791,7 +2322,7 @@
                        var balanceConnectionList = LocationHelper.GetBalanceConnectionList(connectionList);
                        foreach (var item in balanceConnectionList)
                        {
                            if (item.loc.N_CURRENT_NUM < 2)
                            if (item.loc.CONNEC_ROADWAY==start.N_ROADWAY)
                            {
                                connection = item.loc.S_CODE;
                                connectionArea = item.loc.S_AREA_Name;
@@ -1849,6 +2380,14 @@
                    //创建作业
                    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($"ZCSendTask出库作业创建成功{operation.S_CODE}", "Mes任务下发");
                        result.errMsg = "出库作业创建成功";
                        result.errCode = 0;
@@ -1869,8 +2408,6 @@
                    LogHelper.Info("ZCSendTask出库任务下发失败，Task_type不等于1或2", "Mes任务下发");
                    throw new Exception("Task_type不等于1或2");
                }



            }
            catch (Exception ex)
@@ -2210,7 +2747,99 @@



           
        ////如果需要下发wcs立库，则需要寻找可用接驳位
        //if (workFlow.SENDWCS == "Y")
        //{

        //    //正式代码，调用接口寻找可用接驳位
        //    var connectionList = LocationHelper.GetConnectionList(workFlow.CONNECTION);
        //    var usableConnectionList = WcsTask.WcsPositionAvailable(model.task_no, connectionList);
        //    if (usableConnectionList != null && usableConnectionList.code == "0")
        //    {
        //        //根据接驳位任务数量获取均衡接驳位集合优先任务数少的接驳位
        //        var balanceConnectionList = LocationHelper.GetBalanceConnectionList(usableConnectionList.available);

        //        LogHelper.Info($"ZCSendTask入库任务下发寻找均衡接驳位" + JsonConvert.SerializeObject(balanceConnectionList), "Mes任务下发");
        //        foreach (var item in balanceConnectionList)
        //        {
        //            if (item.loc.N_CURRENT_NUM < 2)
        //            {
        //                connection = item.loc.S_CODE;
        //                connectionArea = item.loc.S_AREA_Name;
        //                LogHelper.Info($"ZCSendTask入库任务下发寻找到可用接驳位{connection}", "Mes任务下发");
        //                break;
        //            }
        //        }
        //    }
        //    else
        //    {
        //        LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位失败", "Mes任务下发");
        //        throw new Exception($"ZCSendTask入库任务下发寻找接驳位失败");
        //    }

        //    if (connection == "")
        //    {
        //        LogHelper.Info($"ZCSendTask入库任务下发寻找接驳位失败", "Mes任务下发");
        //        throw new Exception($"ZCSendTask入库任务下发寻找接驳位失败");
        //    }
        //}
        //if (workFlow.FLOWCODE == "1")
        //{
        //    //满托入
        //   end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
        //}
        //else if (workFlow.FLOWCODE == "3")
        //{
        //    if (TOOLSTYPE == "35" || TOOLSTYPE == "75")
        //    {
        //        //空托入 优先入缓存区，没有入立库区
        //        //var ktHcq = Settings.EmptyPalletBufferArea;
        //        cntrCount = 0;
        //        //var endList1 = LocationHelper.GetAllLocList1(ktHcq);
        //        //end = LocationHelper.FindEndcolByLoc(endList1, ktHcq);
        //        //LogHelper.Info($"ZCSendTask入库任务寻找空托缓存区终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
        //        //if (end == null)
        //        //{
        //        LogHelper.Info($"ZCSendTask入库任务没找到空托缓存区终点,寻找立库区空货位", "Mes任务下发");
        //        end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
        //        //}
        //        //else
        //        //{
        //        //    connection = "";
        //        //}
        //    }
        //    else
        //    {
        //        end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
        //    }
        //}
        //else if (workFlow.FLOWCODE == "2")
        //{

        //    //85纤维 95钢丝一段任务入三层货架
        //    if (TOOLSTYPE == "85" || TOOLSTYPE == "95")
        //    {
        //        end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
        //        LogHelper.Info($"ZCSendTask入库任务85纤维 95钢丝一段任务入三层货架终点信息" + JsonConvert.SerializeObject(end), "Mes任务下发");
        //    }
        //    else
        //    {
        //        end = LocationHelper.FindBalanceEndcolByLocList(endList, workFlow.ENDAREA, workFlow.ROADWAY);
        //    }
        //}
        //else if (workFlow.FLOWCODE == "12")
        //{
        //    //空架子入
        //    end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
        //    cntrCount = 0;
        //    //生成空架子虚拟号
        //    cntrCode = ContainerHelper.GenerateCntrNo();
        //}
        //else if (workFlow.FLOWCODE == "0")
        //{
        //    //钢丝入库
        //    end = LocationHelper.FindEndcolByLoc(endList, workFlow.ENDAREA);
        //}


        public class signalInfo