Mes接口修改

海波 张

7 天以前 b67787b031e357c60565d3e1aa8b829706e520e2

 core/Monitor.cs

@@ -1,4 +1,5 @@
using HH.WCS.ZhongCeJinTan.api;
using HH.WCS.Mobox3.ZhongCeJinTan.dispatch;
using HH.WCS.ZhongCeJinTan.api;
using HH.WCS.ZhongCeJinTan.dispatch;
using HH.WCS.ZhongCeJinTan.process;
using HH.WCS.ZhongCeJinTan.util;
@@ -86,11 +87,177 @@

        public static void UpdateOutTaskPriority()
        {
            //var ts1 = DateTime.Now.Subtract(datetime).TotalMinutes;
            var db = new SqlHelper<object>().GetInstance();
            //var st = Settings.outMinutePriority;

            var st = TaskHelper.GetOutMinutePriority();

            if (st==null)
            {
                return;
            }

            var list = TaskHelper.GetWcsTaskListByState("执行", "agv", "出库");

            foreach (var item in list)
            {
                var wcsTask = TaskHelper.GetTaskByState("完成", "wcs", item.S_OP_CODE, "出库");
                if (wcsTask != null) {
                    var action = db.Queryable<WmsTaskAction>().Where(p => p.S_TASK_CODE == item.S_CODE && p.N_ACTION_CODE == 1).First();
                    if (action != null)
                    {
                        var action3 = db.Queryable<WmsTaskAction>().Where(p => p.S_TASK_CODE == item.S_CODE && p.N_ACTION_CODE == 3).First();
                        if (action3 == null)
                        {
                            if (DateTime.Now.Subtract(action.T_CREATE).TotalMinutes > st.Minute)
                            {
                                item.N_PRIORITY += st.Priority;
                                db.Updateable(item).UpdateColumns(it => new { it.N_PRIORITY }).ExecuteCommand();
                                NDCApi.ChangeOrderPri(item.S_CODE, item.N_PRIORITY);
                            }
                        }
                    }
                }
            }
            int sp = st.Minute * 60000;
            Thread.Sleep(sp);
        }

        private static object locker1 = new object();


        /// <summary>
        /// agv动作缓存处理
        /// </summary>
        /// <param name="model"></param>
        public static void agvActionManage()
        {

            var db = new SqlHelper<object>().GetInstance();


            try
            {
                lock (locker1)
                {
                    var operations = db.Queryable<AgvActionState>().OrderBy(a => a.T_CREATE).ToList().Take(50);
                    foreach (var model in operations)
                    {
                        var wmsTask = TaskHelper.GetTask(model.task_no);
                        LogHelper.Info("agvActionManage--任务信息" + JsonConvert.SerializeObject(wmsTask), "agv动作缓存");
                        LogHelper.Info("agvActionManage--参数信息" + JsonConvert.SerializeObject(model), "agv动作缓存");
                        if (wmsTask != null)
                        {
                            if (model.state <= 7)
                            {
                                //有任务号请求
                                switch (model.state)
                                {
                                    case 1:
                                        TaskHelper.opMesTask(wmsTask, 1);
                                        TaskHelper.Begin(wmsTask, model.forklift_no);
                                        //胎面交互
                                        TaskHelper.TmSafety(wmsTask);
                                        break;
                                    case 3:
                                        TaskHelper.UpdateStatus(wmsTask, "开始取货");
                                        break;
                                    case 4:
                                        TaskHelper.UpdateStatus(wmsTask, "取货完成");
                                        LocationHelper.UnLockLoc(wmsTask.S_START_LOC);
                                        TaskProcess.OperateStatus(wmsTask, 4);
                                        break;
                                    case 5:
                                        TaskHelper.UpdateStatus(wmsTask, "开始卸货");
                                        break;
                                    case 6:
                                        TaskHelper.UpdateStatus(wmsTask, "卸货完成");
                                        LocationHelper.UnLockLoc(wmsTask.S_END_LOC);
                                        TaskProcess.OperateStatus(wmsTask, 6);

                                        //如果是二段任务则下发立库任务
                                        var wcsTask = TaskHelper.GetTaskByState("未执行", "wcs", wmsTask.S_OP_CODE, "入库");
                                        if (wcsTask != null)
                                        {
                                            LocationHelper.LockLoc(wcsTask.S_START_LOC, "出库锁", 2);
                                            WcsTask.WcsTaskEntity(wcsTask);
                                        }
                                        break;
                                    case 2:
                                        //空托出或者满托出任务完成判断是否要提高入库优先级

                                        LogHelper.Info($"任务{wmsTask.S_CODE}完成，判断入库优先级", "入库优先级");
                                        TaskProcess.inPri(wmsTask);
                                        TaskHelper.End(wmsTask);
                                       
                                        break;
                                    case 7:
                                        if (!LocationHelper.GetErroArea(wmsTask.S_END_AREA)) {
                                            TaskHelper.opMesTask(wmsTask, 3);
                                        }
                                            
                                        var wcsTask1 = TaskHelper.GetTaskByWorkNo(wmsTask.S_OP_CODE, "wcs");
                                            if (wcsTask1 != null)
                                            {
                                                //agv执行通知 wcs取消  
                                                WcsTask.WcsCallback(wmsTask, model.state, model.forklift_no.ToString());
                                                TaskHelper.Fail(wcsTask1);
                                                TaskProcess.OperateStatus(wcsTask1, 7);
                                            }
                                        

                                        TaskHelper.Fail(wmsTask);
                                        TaskProcess.OperateStatus(wmsTask, 7);
                                        //入库或者回库任务取消删除托盘物料
                                        if (wmsTask.S_TYPE.Contains("入库") || wmsTask.S_TYPE.Contains("回库"))
                                        {
                                            ContainerHelper.delCntr(wmsTask.S_CNTR_CODE);
                                            ContainerHelper.delCntrItem(wmsTask.S_CNTR_CODE);
                                        }
                                        else {
                                            //出库取消判断接驳位是否有货，有货需要解绑
                                            if (!WcsTask.WcsCvstate(wmsTask))
                                            {
                                                LogHelper.Info($"Wcs立库接驳位无货，解绑货位:{wmsTask.S_START_LOC}", "立库");
                                                TaskProcess.OperateStatus(wmsTask, 4);
                                                ContainerHelper.delCntr(wmsTask.S_CNTR_CODE);
                                                ContainerHelper.delCntrItem(wmsTask.S_CNTR_CODE);
                                            }
                                        }
                                        
                                      
                                       
                                        break;

                                }
                                TaskHelper.AddActionRecord(wmsTask.S_CODE, model.state, model.forklift_no, model.ext_data);
                            }
                            else
                            {
                                //安全请求等
                                TaskProcess.OperateReq(model.task_no, model.state, model.forklift_no, model.ext_data);
                            }
                            db.Deleteable(model).ExecuteCommand();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Info("agvActionManage--异常信息" + ex.Message, "agv动作缓存");
                throw;
            }

        }


          
            




        private static object locker = new object();
        /// <summary>
        /// 自动出库空托
        /// </summary>
@@ -99,172 +266,192 @@

            try
            {
                var ktTaskList = db.Queryable<MesKtTask>().Where(a => a.Status == "N" ).ToList();
                foreach (var kt in ktTaskList)
                lock (locker)
                {
                    if (DateTime.Now.Subtract(kt.CreateDate).TotalMinutes < 1)
                    var ktTaskList = db.Queryable<MesKtTask>().Where(a => a.Status == "N").OrderBy(b => b.CreateDate).ToList();
                    foreach (var kt in ktTaskList)
                    {
                        continue;
                    }
                        LogHelper.Info($"空托出库缓存信息" + JsonConvert.SerializeObject(kt), "空托出库");

                    var workFlow = TaskHelper.selectWorkFlowByType(kt.BUSI_TYPE, kt.TOOLS_TPYE);


                    if (workFlow == null)
                    {
                        LogHelper.Info($"空托出库任务下发失败，流程编号:{kt.BUSI_TYPE},工装类型{kt.TOOLS_TPYE},没找到对应作业流程", "空托出库");
                        throw new Exception($"BUSI_TYpe:{kt.BUSI_TYPE},没找到对应作业流程");
                    }
                    else
                    {
                        LogHelper.Info($"空托出库作业流程信息" + JsonConvert.SerializeObject(workFlow), "空托出库");
                    }



                    //出库任务

                    //接驳位
                    var connection = "";

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


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


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





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

                    Location start = null;


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




                    //寻找立库区空托
                    start = LocationHelper.FindStartcolByLoclistAndcntr(strrtList, workFlow.STARTAREA);


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

                    if (start == null)
                    {
                        LogHelper.Info($"空托出库任务下发失败，起点库区{workFlow.STARTAREA},没找到起点", "空托出库");
                        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)
                        var tm = DateTime.Now.Subtract(kt.CreateDate).TotalMinutes;
                        LogHelper.Info($"空托{kt.task_no}出库缓存时间间隔信息：{tm}", "空托出库");
                        if (tm < 1)
                        {
                            if (item.loc.N_CURRENT_NUM < 2)
                            continue;
                        }

                        var workFlow = TaskHelper.selectWorkFlowByType(kt.BUSI_TYPE, kt.TOOLS_TPYE);


                        if (workFlow == null)
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败，流程编号:{kt.BUSI_TYPE},工装类型{kt.TOOLS_TPYE},没找到对应作业流程", "空托出库");
                            continue;
                        }
                        else
                        {
                            LogHelper.Info($"空托{kt.task_no}出库作业流程信息" + JsonConvert.SerializeObject(workFlow), "空托出库");
                        }



                        //出库任务

                        //接驳位
                        var connection = "";

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


                        //查找给定终点
                        var end = LocationHelper.GetLoc(kt.Location_To);
                        LogHelper.Info($"空托{kt.task_no}出库任务下发终点信息" + JsonConvert.SerializeObject(end), "空托出库");


                        if (end == null)
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败，终点:{kt.Location_To},没找到", "空托出库");
                            continue;
                        }





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

                        Location start = null;


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




                        //寻找立库区空托
                        start = LocationHelper.FindStartcolByLoclistAndcntr(strrtList, workFlow.STARTAREA);


                        LogHelper.Info($"空托{kt.task_no}出库任务下发起点信息" + JsonConvert.SerializeObject(start), "空托出库");

                        if (start == null )
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败，起点库区{workFlow.STARTAREA},没找到起点", "空托出库");
                            continue;
                        }
                        if (start.S_LOCK_STATE!="无")
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败，起点{start.S_CODE}有锁", "空托出库");
                            continue;
                        }



                        //获取托盘码
                        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)
                            {
                                connection = item.loc.S_CODE;
                                connectionArea = item.loc.S_AREA_Name;
                                LogHelper.Info($"空托出库任务下发寻找到可用接驳位{connection}", "空托出库");
                                break;
                                if (item.loc.N_CURRENT_NUM < 2 && item.loc.CONNEC_ROADWAY == start.N_ROADWAY)
                                {
                                    connection = item.loc.S_CODE;
                                    connectionArea = item.loc.S_AREA_Name;
                                    LogHelper.Info($"空托{kt.task_no}出库任务下发寻找到可用接驳位{connection}", "空托出库");
                                    break;
                                }
                            }

                            if (connection == "")
                            {
                                LogHelper.Info($"空托{kt.task_no}出库任务下发寻找接驳位失败", "Mes任空托出库务下发");
                                continue;
                            }
                        }

                        if (connection == "")

                        var startTask = TaskHelper.GetTaskByStartLoc(start.S_CODE);
                        if (startTask != null)
                        {
                            LogHelper.Info($"空托出库任务下发寻找接驳位失败", "Mes任空托出库务下发");
                            throw new Exception($"空托出库任务下发寻找接驳位失败");
                            LogHelper.Info($"空托{kt.task_no}出库任务下发失败，起点{start.S_CODE}有执行中任务{startTask.S_CODE}", "空托出库");
                            continue;
                        }



                        LocationHelper.LockLoc(start.S_CODE, "出库锁", 2);
                      


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

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

                        var operation = new WmsWork
                        {
                            // 作业号
                            S_CODE = kt.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 = kt.Priority,
                            //工装类型
                            TOOLSTYPE = kt.TOOLS_TPYE,
                            //起点库区名称
                            S_START_AREA_NAME = start.S_AREA_Name,
                            //起点库区名称
                            S_END_AREA_NAME = end.S_AREA_Name,
                            //起点库区名称
                            CONNECTION_AREA = connectionArea
                        };

                        //创建作业
                        if (WMSHelper.CreateWmsWork(operation) && TaskHelper.ChangeMesKtTask(kt))
                        {

                            LogHelper.Info($"空托{kt.task_no}出库作业创建成功{operation.S_CODE}", "空托出库");
                        }
                        else
                        {
                            LogHelper.Info($"空托{kt.task_no}出库任务下发创建作业失败", "空托出库");
                            continue;
                        }

                    }


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

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

                    var operation = new WmsWork
                    {
                        // 作业号
                        S_CODE = kt.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 = kt.Priority,
                        //工装类型
                        TOOLSTYPE = kt.TOOLS_TPYE,
                        //起点库区名称
                        S_START_AREA_NAME = start.S_AREA_Name,
                        //起点库区名称
                        S_END_AREA_NAME = end.S_AREA_Name,
                        //起点库区名称
                        CONNECTION_AREA = connectionArea
                    };

                    //创建作业
                    if (WMSHelper.CreateWmsWork(operation) && TaskHelper.ChangeMesKtTask(kt))
                    {
                        
                        LogHelper.Info($"空托出库作业创建成功{operation.S_CODE}", "空托出库");
                    }
                    else
                    {
                        LogHelper.Info($"空托出库任务下发创建作业失败", "空托出库");
                        throw new Exception($"空托出库任务下发创建作业失败");
                    }

                }
               
    
            }
            catch (Exception ex)
            {

                LogHelper.Info($"空托出库异常信息" + ex.Message, "空托出库");
            }
        }