YG-PVC-WCS/WCS.Workflow/ConvPlc04.cs

using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using WCS.Data;
using WCS.Data.Models;
using WCS.Data.Utils;
using WCS.PLC;
using WCS.PLC.Model.Equipment;

namespace WCS.Workflow
{
    public class ConvPlc04 : Base_Conv
    {
        #region 只读变量

        private readonly string Conv_1143 = "1143";//4堆垛机出口
        private readonly string Conv_1141 = "1141";//5堆垛机出口

        private readonly string Conv_1508 = "1508";//熟化房一
        private readonly string Conv_1509 = "1509";//熟化房二
        private readonly string Conv_1164 = "1164";//熟化房一
        private readonly string Conv_1165 = "1165";//熟化房二

        private readonly string Conv_1136 = "1136";//熟化房入口一
        private readonly string Conv_1138 = "1138";//熟化房入口二

        private readonly string Conv_1137 = "1137";//熟化房出口一
        private readonly string Conv_1139 = "1139";//熟化房出口二

        private readonly string Conv_1161 = "1161";//2号堆垛机出库（3楼男面）
        private readonly string Conv_1159 = "1159";//3号堆垛机出库（3楼男面）
        private readonly string Conv_1160 = "1160";//3号堆垛机出库（3楼男面）
        private readonly string Conv_1152 = "1152";//4号堆垛机出库（3楼男面）
        private readonly string Conv_1151 = "1151";//5号堆垛机出库（3楼男面）

        private readonly string Conv_1155 = "1155";
        private readonly string Conv_1156 = "1156";
        private readonly string Conv_1157 = "1157";
        private readonly string Conv_1158 = "1158";

        #endregion 只读变量

        #region 重载实现

        public override void Run()
        {
            //刷新任务数据
            WCSWorkflow.RefreshData();
            //上传熟化开始结束时间信息
            //ThreadHelper.TaskThread(MatureSignalGet);
            UploadMatureTimeInfo(Conv_1164);
            UploadMatureTimeInfo(Conv_1165);
            //MatureSignalGet();
            //更新熟化连续模式
            ThreadHelper.TaskThread(UploadMatureMode);
            //堆垛机出口执行
            SrmOutConvExeTask();
            //输送线执行
            ConveyorWriteTaskExecute();
            //扫描入库
            Conv_ScanBarCodeExeTask();
            //更新熟化房当前信息到数据库
            ThreadHelper.TaskThread(MatureRoomRefresh);
            //任务完成
            ConvTaskFinish();
            //熟化房申请出库熟化
            ThreadHelper.TaskThread(ReqestInByMatureRoom);
            //进入熟化房请求确认
            RequestInByMatureConv(Conv_1136, Conv_1508);
            RequestInByMatureConv(Conv_1138, Conv_1509);
            //熟化房完成
            MatureConvFinish(Conv_1137, Conv_1508);
            MatureConvFinish(Conv_1139, Conv_1509);
            //熟化房输送线请求入库
            RequestOutByMatureConv(Conv_1137, Conv_1508);
            RequestOutByMatureConv(Conv_1139, Conv_1509);
        }

        #endregion 重载实现

        #region 功能实现

        private static int _atureRoomRefresh = 0;

        private void MatureRoomRefresh()
        {
            if (Interlocked.Exchange(ref _atureRoomRefresh, 1) == 0)
            {
                try
                {
                    Thread.Sleep(6000);
                    var matureRoomSet = SugarBase.DB.Queryable<MatureRoomInfo>().ToList();
                    List<string> list = new List<string>() { Conv_1508, Conv_1509 };
                    foreach (var item in list)
                    {
                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item);
                        var cs = conveyor.EquSignal_Conv;

                        bool isOnLine = cs.DB521_Goodstype == 0 ? false : true;
                        string faultMsg = cs.MatureRoomFault.ToString();
                        var matureRoom = matureRoomSet.FirstOrDefault(v => v.MatureRoomNo == item);
                        //修改熟化房的状态
                        SugarBase.DB.Updateable<MatureRoomInfo>(it => new MatureRoomInfo()
                        {
                            MatureRoomTemperat = cs.DB521_Res04,
                            MatureRoomDate = cs.DB521_Goodssize,
                            MatureRoomIsOnLine = isOnLine,
                            MatureRoomMode = cs.DB521_Goodsstart,
                            MatureRoomTangentStatus = cs.DB521_Goodsend,
                            MatureRoomAlaramsMsg = faultMsg
                        })
                           .Where(it => it.MatureRoomNo == item)
                           .ExecuteCommand();
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _atureRoomRefresh, 0);
                }
            }
        }

        private static int _matureSignalGet = 0;

        private void MatureSignalGet()
        {
            if (Interlocked.Exchange(ref _matureSignalGet, 1) == 0)
            {
                try
                {
                    List<string> list = new List<string>() { Conv_1164,  Conv_1165 };
                    foreach (var item in list)//1164、1165
                    {
                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item);
                        var cs = conveyor.EquSignal_Conv;
                        // 开始与结束信号已被PLC复位，同时开始与结束确认信号为置位状态，开始复位确认信号
                        if (!cs.DB521_B_Outside && !cs.DB521_L_Outside && cs.DB520_Confirm && cs.DB520_TaskDelete)
                        {
                            var converywrite = new WCSWriteToConveyorSignal();
                            converywrite.Plc = plc.Plc;
                            converywrite.DBName = plc.WriteDBName;
                            converywrite.ConveyorNo = item;
                            converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                            converywrite.Confirm = false;
                            converywrite.TaskDelete = false;
                            WriteTaskToBuffer(converywrite);
                        }
                        string matureNo = item == "1164" ? "A" : "B";
                        if (!cs.DB521_B_Outside && !cs.DB521_L_Outside) continue;
                        int isContinueMode = cs.DB521_F_Outside == true ? 1 : 0;//是否连续熟化模式
                        int num = cs.DB521_Goodstype;//熟化架数量
                        if (cs.DB521_B_Outside && !cs.DB520_Confirm)//开始熟化标志    DB520_Confirm  开始确认标志
                        {
                            //调用上传WMS的接口上传熟化房信息
                            var param = new GetMatureContinueParam
                            {
                                MatureRoomNo = matureNo,
                                IsContinueMode = isContinueMode,
                                MatureStartTime = DateTime.Now,
                                MatureEndTime = null,
                                MatureFrameNum = num
                            };
                            //BaseWorkflow.GetMatureContinueMode(param, cs, plc, 1, item);
                            if (BaseWorkflow.GetMatureContinueMode(param))
                            {
                                var converywrite = new WCSWriteToConveyorSignal();
                                converywrite.Plc = plc.Plc;
                                converywrite.DBName = plc.WriteDBName;
                                converywrite.ConveyorNo = item;
                                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                                converywrite.Confirm = true;
                                WriteTaskToBuffer(converywrite,true);
                            }
                        }
                        if (cs.DB521_L_Outside && !cs.DB520_TaskDelete)////结束熟化标志  DB520_TaskDelete 结束确认标志
                        {
                            //调用上传WMS的接口上传熟化房信息
                            var param = new GetMatureContinueParam
                            {
                                MatureRoomNo = matureNo,
                                IsContinueMode = isContinueMode,
                                MatureStartTime = null,
                                MatureEndTime = DateTime.Now,
                                MatureFrameNum = num
                            };
                            //BaseWorkflow.GetMatureContinueMode(param, cs, plc, 2, item);
                            if (BaseWorkflow.GetMatureContinueMode(param))
                            {
                                var converywrite = new WCSWriteToConveyorSignal();
                                converywrite.Plc = plc.Plc;
                                converywrite.DBName = plc.WriteDBName;
                                converywrite.ConveyorNo = item;
                                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                                converywrite.TaskDelete = true;
                                WriteTaskToBuffer(converywrite);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _matureSignalGet, 0);
                }
            }
        }
        //private void MatureSignalGet()
        //{           
        //        try
        //        {
        //            List<string> list = new List<string>() { Conv_1164, Conv_1165 };
        //            foreach (var item in list)//1164、1165
        //            {
        //                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
        //                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item);
        //                var cs = conveyor.EquSignal_Conv;
        //                // 开始与结束信号已被PLC复位，同时开始与结束确认信号为置位状态，开始复位确认信号
        //                if (!cs.DB521_B_Outside && !cs.DB521_L_Outside && cs.DB520_Confirm && cs.DB520_TaskDelete)
        //                {
        //                    var converywrite = new WCSWriteToConveyorSignal();
        //                    converywrite.Plc = plc.Plc;
        //                    converywrite.DBName = plc.WriteDBName;
        //                    converywrite.ConveyorNo = item;
        //                    converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
        //                    converywrite.Confirm = false;
        //                    converywrite.TaskDelete = false;
        //                    WriteTaskToBuffer(converywrite);
        //                }
        //                string matureNo = item == "1164" ? "A" : "B";
        //                if (!cs.DB521_B_Outside && !cs.DB521_L_Outside) return;
        //                int isContinueMode = cs.DB521_F_Outside == true ? 1 : 0;//是否连续熟化模式
        //                int num = cs.DB521_Goodstype;//熟化架数量
        //                if (cs.DB521_B_Outside && !cs.DB520_Confirm)//开始熟化标志    DB520_Confirm  开始确认标志
        //                {
        //                    //调用上传WMS的接口上传熟化房信息
        //                    var param = new GetMatureContinueParam
        //                    {
        //                        MatureRoomNo = matureNo,
        //                        IsContinueMode = isContinueMode,
        //                        MatureStartTime = DateTime.Now,
        //                        MatureEndTime = null,
        //                        MatureFrameNum = num
        //                    };
        //                    //BaseWorkflow.GetMatureContinueMode(param, cs, plc, 1, item);
        //                    if (BaseWorkflow.GetMatureContinueMode(param))
        //                    {
        //                        var converywrite = new WCSWriteToConveyorSignal();
        //                        converywrite.Plc = plc.Plc;
        //                        converywrite.DBName = plc.WriteDBName;
        //                        converywrite.ConveyorNo = item;
        //                        converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

        //                        converywrite.Confirm = true;
        //                        WriteTaskToBuffer(converywrite);
        //                    }
        //                }
        //                if (cs.DB521_L_Outside && !cs.DB520_TaskDelete)////结束熟化标志  DB520_TaskDelete 结束确认标志
        //                {
        //                    //调用上传WMS的接口上传熟化房信息
        //                    var param = new GetMatureContinueParam
        //                    {
        //                        MatureRoomNo = matureNo,
        //                        IsContinueMode = isContinueMode,
        //                        MatureStartTime = null,
        //                        MatureEndTime = DateTime.Now,
        //                        MatureFrameNum = num
        //                    };
        //                    //BaseWorkflow.GetMatureContinueMode(param, cs, plc, 2, item);
        //                    if (BaseWorkflow.GetMatureContinueMode(param))
        //                    {
        //                        var converywrite = new WCSWriteToConveyorSignal();
        //                        converywrite.Plc = plc.Plc;
        //                        converywrite.DBName = plc.WriteDBName;
        //                        converywrite.ConveyorNo = item;
        //                        converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

        //                        converywrite.TaskDelete = true;
        //                        WriteTaskToBuffer(converywrite);
        //                    }
        //                }
        //            }
        //        }
        //        catch (Exception ex)
        //        {
        //            LogMessageHelper.RecordLogMessage(ex);
        //        }               
            
        //}

        private static int _uploadMode = 0;

        private void UploadMatureMode()
        {
            if (Interlocked.Exchange(ref _uploadMode, 1) == 0)
            {
                try
                {
                    List<string> list = new List<string>() { Conv_1164, Conv_1165 };
                    string s = "BakeMode_";
                    foreach (var item in list)
                    {
                        var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                        var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == item);
                        var cs = conveyor.EquSignal_Conv;
                        string matureNo = item == "1164" ? "A" : "B";
                        var value = s + matureNo;
                        //获取连续模式值
                        var plcValue = cs.DB521_F_Outside ? "1" : "0";
                        var sysset = SugarBase.DB.Queryable<WCS_SYSSET>().Where(v => v.SET_ID == value).First();
                        if (sysset != null)
                        {
                            if (plcValue != sysset.SET_VALUE)
                            {
                                string result = TryCachHelper.TryTranExecute((db) =>
                                {
                                    db.Updateable<WCS_SYSSET>(it => new WCS_SYSSET()
                                    {
                                        SET_VALUE = plcValue,
                                    })
                                       .Where(it => it.SET_ID == value)
                                       .ExecuteCommand();
                                });
                                if (!string.IsNullOrWhiteSpace(result))
                                {
                                    throw new Exception(result);
                                }
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _uploadMode, 0);
                }
            }
        }

        private void Conv_ScanBarCodeExeTask()
        {
            Conv_ScanningIn(Conv_1155, Conv_1155);
            //Conv_ScanningIn(Conv_1156, Conv_1156);
            //Conv_ScanningIn(Conv_1157, Conv_1157);
            Conv_ScanningIn(Conv_1158, Conv_1158);
        }

        private void ConvTaskFinish()
        {
            ConveyorTaskFinish(PlcName, Conv_1155, false, true);
            ConveyorTaskFinish(PlcName, Conv_1156, false, true);
            ConveyorTaskFinish(PlcName, Conv_1157, false, true);
            ConveyorTaskFinish(PlcName, Conv_1158, false, true);
        }

        protected override WCS_TASK ScanningCallWmsInterface(GetInTaskParam param)
        {
            if (param.EquipmentNo == Conv_1155 || param.EquipmentNo == Conv_1156 || param.EquipmentNo == Conv_1157 || param.EquipmentNo == Conv_1158)
            {
                param.Memo1 = "1";
            }
            return base.ScanningCallWmsInterface(param);
        }

        private void Conv_ScanningIn(string convNo, string exceptionConvNo, bool isCurAddressByNext = true)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB520_Confirm) return;
                var task = QueryTaskByBarcode(cs, convNo);
                if ((convNo == Conv_1155 || convNo == Conv_1158) && cs.DB521_Goodstype == 0)
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]外捡高度为零,WCS默认标识为1", convNo), true, LogLevelEnum.INFO.ToString());
                }

                if (task == null)
                {
                    if (WcsScanConvIsUsed(convNo))
                    {
                        var param = new GetInTaskParam();
                        param.ContainerBarCode = cs.BarCodeStr;
                        param.ContainerType = cs.DB521_Goodstype > 0 ? cs.DB521_Goodstype : 1;
                        param.MatBarCode = string.Empty;
                        param.WareHouseId = Current.Pvchouseputong;
                        param.EquipmentNo = convNo;
                        param.EndPostion = srm;
                        param.Memo1 = "1";
                        param.Memo2 = exceptionConvNo;
                        task = ThreadHelper.TaskThread(BaseWorkflow.GetWcsInTask, param);
                    }
                }
                //判断任务是否存在，或已经执行
                if (task == null || task.TASK_WKSTATUS >= 2) return;

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                converywrite.Tasknum = task.TASK_NO;
                converywrite.Goodssize = 0;//
                converywrite.Goodsstart = Convert.ToInt32(convNo);

                if (task.TASK_COMTYPE == (int)ComTypeEnum.托盘异常退回)
                {
                    converywrite.Notask = true;
                    converywrite.Goodsend = Convert.ToInt32(exceptionConvNo);
                }
                else if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 2 && v.TASK_POSIDNEXT == convNo))
                {
                    converywrite.Notask = true;
                    converywrite.Goodsend = Convert.ToInt32(exceptionConvNo);
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]条码[{1}]不能入库，存在出库到该位置的任务。", convNo, cs.BarCodeStr), true, LogLevelEnum.INFO.ToString());
                }
                else
                {
                    if (isCurAddressByNext)
                    {
                        converywrite.Goodsend = Convert.ToInt32(convNo);
                    }
                    else
                    {
                        var routeSet = EquRouteHelper.QueryRoute(convNo, task.TASK_POSIDTO);
                        var route = routeSet.SingleOrDefault(v => v.ROUTE_STARTPOS == convNo);
                        converywrite.Goodsend = Convert.ToInt32(route.ROUTE_SONPOS);
                    }
                }

                if (convNo == Conv_1155)
                {
                    LogMessageHelper.RecordLogMessage(string.Format("输送线[{0}]任务[{1}]条码[{2}]外检高度[{3}](零值默认为1)。", convNo, task.TASK_NO, cs.BarCodeStr, cs.DB521_Goodstype), true, LogLevelEnum.INFO.ToString());
                }
                WriteInfoToConv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void MatureConvFinish(string convNo, string matureRoomNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB523_Fault) return;
                if (cs.DB521_Tasknum > 10000) return;

                //if (cs.DB521_BCR_Noread) throw new Exception(string.Format("输送线[{0}]报读码错误，但是存在请求。", convNo));

                //if (string.IsNullOrWhiteSpace(cs.BarCodeStr)) throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                MatureRoomCache atureRooCache = null;
                string barcode = cs.BarCodeStr;
                if (barcode.ToUpper().Contains("ERROR") ||
                    barcode.ToUpper().Contains("N") ||
                    barcode.Contains("?") ||
                    string.IsNullOrWhiteSpace(barcode))
                {
                    if (SugarBase.DB.Queryable<WCS_TASK>().Any(v => v.TASK_COMTYPE == 1 && v.TASK_POSIDFROM == matureRoomNo &&
                                  (v.TASK_WKSTATUS <= 1 || v.TASK_WKSTATUS == 7 || v.TASK_WKSTATUS == 9 || (v.TASK_WKSTATUS == 2 && v.TASK_POSIDNEXT == convNo))))
                    {
                        throw new Exception(string.Format("扫码失败，熟化房[{0}]输送线[{1}]存在未完成的任务，不能重复请求生成任务，请检查熟化房与输送线对接是否存在问题。", matureRoomNo, convNo));
                    }
                    if (Current.TaskSet.Any(v => v.TASK_COMTYPE == 1 && v.TASK_OutMatureRoomDate != null &&
                                (v.TASK_WKSTATUS <= 1 || v.TASK_WKSTATUS == 7 || v.TASK_WKSTATUS == 9 || (v.TASK_WKSTATUS == 2 && v.TASK_POSIDNEXT == convNo))))
                    {
                        throw new Exception(string.Format("扫码失败，熟化房[{0}]输送线[{1}]存在未完成的任务，不能重复请求生成任务，请检查熟化房与输送线对接是否存在问题。", matureRoomNo, convNo));
                    }

                    atureRooCache = SugarBase.DB.Queryable<MatureRoomCache>().Where(v => v.MatureRoomNo.Contains(matureRoomNo) && SqlFunc.IsNullOrEmpty(v.Remark)).OrderBy(v => v.InMatureRoomDate).First();
                    barcode = atureRooCache.BARCODE;
                    //throw new Exception(string.Format("扫码失败，熟化房[{0}]输送线[{1}]请求入库查询到队列中的条码[{2}]", matureRoomNo, convNo, barcode));
                    LogMessageHelper.RecordLogMessage(string.Format("扫码失败，熟化房[{0}]输送线[{1}]请求入库查询到队列中的条码[{2}]", matureRoomNo, convNo, barcode), true);
                }
                else
                {
                    atureRooCache = SugarBase.DB.Queryable<MatureRoomCache>().Where(v => v.MatureRoomNo.Contains(matureRoomNo) && SqlFunc.IsNullOrEmpty(v.Remark)).OrderBy(v => v.InMatureRoomDate).First();
                    if (barcode != atureRooCache.BARCODE)
                    {
                        throw new Exception(string.Format("扫码成功，熟化房[{0}]读取到条码[{1}]但是与熟化房队列条码[{2}]不一致，请检查是否存在问题。", matureRoomNo, barcode, atureRooCache.BARCODE));
                    }
                    LogMessageHelper.RecordLogMessage(string.Format("扫码成功，读取到条码[{0}]熟化房[{1}]", barcode, matureRoomNo));
                }

                var task = Current.TaskSet.FirstOrDefault(v => v.TASK_BOXBARCODE == barcode);
                if (task == null) return;

                if (task.TASK_WKSTATUS == (int)WkStatus.熟化房熟化完成) return;
                if (task.TASK_WKSTATUS == (int)WkStatus.完成任务) return;
                if (task.TASK_WKSTATUS != (int)WkStatus.熟化房熟化中) return;
                if (task.TASK_WKSTATUS <= 1) return;

                //var matureTask = Current.TaskSet.Where(v => v.TASK_WKSTATUS == (int)WkStatus.熟化房熟化中).OrderBy(v => v.TASK_InMatureRoomDate).FirstOrDefault();
                //if (task.TASK_BOXBARCODE.Trim() != matureTask.TASK_BOXBARCODE.Trim())
                //{
                //    throw new Exception(string.Format("熟化房[{0}]出口[{1}]扫描条码[{2}]与任务列表中条码[{3}]不一致，请检查条码问题。", matureRoomNo, convNo, cs.BarCodeStr, matureTask.TASK_BOXBARCODE));
                //}
                var roomNo = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == matureRoomNo);
                var roomNocs = roomNo.EquSignal_Conv;
                int hours = roomNocs.DB521_Goodssize - 4;
                //DateTime inMaturedate = task.TASK_InMatureRoomDate.GetValueOrDefault().AddHours(hours);
                //if (inMaturedate > SugarBase.DB.GetDate())
                //{
                //    throw new Exception(string.Format("条码[{0}]开始熟化时间[{1}]比要求烘烤时间低于4小时以上(严重错误)，不能出库完成,请检查熟化是否存在问题。", task.TASK_BOXBARCODE, task.TASK_InMatureRoomDate, hours));
                //}
                //修改状态
                string result = TryCachHelper.TryTranExecute((db) =>
                {
                    DateTime dt = db.GetDate();
                    int wkstatus = task.TASK_COMTYPE == 1 ? 14 : 99;
                    if (atureRooCache.CurrentMatureNum < atureRooCache.MatureNum)
                    {
                        wkstatus = 14;
                        //修改任务的状态
                        db.Updateable<WCS_TASK>(it => new WCS_TASK()
                        {
                            TASK_WKSTATUS = wkstatus,
                            TASK_POSIDCUR = convNo,
                            TASK_EDITUSERNO = "WCS",
                            TASK_EDITDATETIME = DateTime.Now
                        })
                           .Where(it => it.TASK_NO == task.TASK_NO)
                           .ExecuteCommand();
                    }
                    else
                    {
                        //修改任务的状态
                        db.Updateable<WCS_TASK>(it => new WCS_TASK()
                        {
                            TASK_WKSTATUS = wkstatus,
                            TASK_POSIDCUR = convNo,
                            TASK_OutMatureRoomDate = dt,
                            TASK_EDITUSERNO = "WCS",
                            TASK_EDITDATETIME = DateTime.Now
                        })
                           .Where(it => it.TASK_NO == task.TASK_NO)
                           .ExecuteCommand();
                    }

                    //添加修改明细
                    string msg = string.Format("任务[{0}]熟化房熟化完成", task.TASK_NO);
                    CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, task.TASK_POSIDTO, msg);
                });
                if (!string.IsNullOrWhiteSpace(result))
                {
                    throw new Exception(result);
                }
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void RequestOutByMatureConv(string convNo, string matureRoomNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB523_Fault) return;
                if (cs.DB521_Tasknum > 10000) return;

                //if (cs.DB521_BCR_Noread) throw new Exception(string.Format("输送线[{0}]报读码错误，但是存在请求。", convNo));

                //if (string.IsNullOrWhiteSpace(cs.BarCodeStr)) throw new Exception(string.Format("输送线[{0}]存在请求信号，但没读取到条码信息。", convNo));
                string barcode = cs.BarCodeStr;
                WCS_TASK task = null;
                if (cs.BarCodeStr.ToUpper().Contains("ERROR") ||
                    cs.BarCodeStr.ToUpper().Contains("N") ||
                    cs.BarCodeStr.Contains("?") ||
                    string.IsNullOrWhiteSpace(cs.BarCodeStr))
                {
                    task = Current.TaskSet.SingleOrDefault(v => v.TASK_COMTYPE == 1 && v.TASK_POSIDFROM == matureRoomNo && (v.TASK_POSIDCUR == matureRoomNo || v.TASK_POSIDCUR == convNo));
                    if (task == null)
                    {
                        task = Current.TaskSet.SingleOrDefault(v => v.TASK_WKSTATUS == (int)WkStatus.熟化房熟化完成 && (v.TASK_POSIDCUR == convNo || v.TASK_POSIDCUR == matureRoomNo));
                    }
                }
                else
                {
                    task = Current.TaskSet.FirstOrDefault(v => v.TASK_BOXBARCODE == barcode && v.TASK_COMTYPE == 1);
                    if (task == null)
                    {
                        var matureRoom = SugarBase.DB.Queryable<MatureRoomCache>().First(v => v.BARCODE == barcode);
                        if (matureRoom.MatureNum > 1 && matureRoom.CurrentMatureNum < matureRoom.MatureNum)
                        {
                            //是多次熟化任务(只支持48小时多次熟化)
                            task = Current.TaskSet.FirstOrDefault(v => v.TASK_BOXBARCODE == barcode && v.MatureNum.GetValueOrDefault() == 4 && v.TASK_COMTYPE == 2);
                        }
                    }
                }

                if (task == null || task.TASK_POSIDNEXT == convNo) return;
                //下发任务
                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                converywrite.Tasknum = task.TASK_NO;
                converywrite.Goodssize = 0;//
                converywrite.Goodsstart = Convert.ToInt32(convNo);
                converywrite.Goodsend = converywrite.Goodsstart;
                WriteInfoToConvMRoom(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private void ConveyorWriteTaskExecute()
        {
        }

        private void SrmOutConvExeTask()
        {
            SrmOutConvExeTask(Conv_1143, true);
            SrmOutConvExeTask(Conv_1141, true);
            SrmOutConvExeTask(Conv_1161, true);
            SrmOutConvExeTask(Conv_1160, false);
            SrmOutConvExeTask(Conv_1152, true);
            SrmOutConvExeTask(Conv_1151, true);
        }

        /// <summary>
        /// 堆垛机出口输送线任务执行(任务目标地址的下个地址只支持单一地址)
        /// </summary>
        private void SrmOutConvExeTask(string convNo, bool endPosIsCurConv = false)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB523_Fault) return;
                var taskSet = Current.TaskSet.Where(v => v.TASK_POSIDNEXT == convNo).ToList();
                var task = taskSet.SingleOrDefault(v => v.TASK_WKSTATUS == (int)WkStatus.堆垛机完成);
                if (task == null)
                {
                    throw new Exception(string.Format("堆垛机出口输送线[{0}]存在请求信号，但没查询到任务信息。", convNo));
                }

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                converywrite.Tasknum = task.TASK_NO;
                converywrite.Goodscode = 0;
                converywrite.Goodstype = 0;
                converywrite.Goodssize = 0;
                converywrite.Goodsstart = Convert.ToInt32(convNo);

                if (endPosIsCurConv)
                {
                    converywrite.Goodsend = converywrite.Goodsstart;
                }
                else
                {
                    var routeSet = EquRouteHelper.QueryRoute(convNo, task.TASK_POSIDTO);
                    var routes = routeSet.Where(v => v.ROUTE_STARTPOS == convNo).ToList();
                    if (routes.Count == 1)
                    {
                        converywrite.Goodsend = Convert.ToInt32(routes[0].ROUTE_SONPOS);
                    }
                    else
                    {
                        throw new Exception(string.Format("输送线[{0}]任务[{1}]请求该函数不支持多个分支输送地址，请编写扩展函数。", convNo, task.TASK_NO));
                    }
                }
                WriteInfoToConv(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        private static int _reqestInByMatureRoom = 0;

        /// <summary>
        /// 熟化房申请出库熟化
        /// </summary>
        private void ReqestInByMatureRoom()
        {
            if (Interlocked.Exchange(ref _reqestInByMatureRoom, 1) == 0)
            {
                try
                {
                    Thread.Sleep(60000);
                    //if ((DateTime.Now.Hour == 8 && DateTime.Now.Minute >= 30) || (DateTime.Now.Hour > 8 && DateTime.Now.Hour < 14))
                    //{
                    if (Current.SysSets.FirstOrDefault(v => v.SET_ID == Conv_1508).SET_VALUE == "0")
                    {
                        ReqestInByMatureRoomItem(Conv_1508, Conv_1136);
                    }
                    if (Current.SysSets.FirstOrDefault(v => v.SET_ID == Conv_1509).SET_VALUE == "0")
                    {
                        ReqestInByMatureRoomItem(Conv_1509, Conv_1138);
                    }
                    //}
                }
                catch (Exception ex)
                {
                    LogMessageHelper.RecordLogMessage(ex);
                }
                finally
                {
                    Interlocked.Exchange(ref _reqestInByMatureRoom, 0);
                }
            }
        }

        private void ReqestInByMatureRoomItem(string convNo, string matureInConvNo)
        {
            bool a = false;
            //检测是否存在去熟化房的未执行任务
            TryCachHelper.TryTranExecute((db) =>
            {
                a = db.Queryable<WCS_TASK>().Any(v => v.TASK_POSIDTO == convNo && v.TASK_WKSTATUS < 13);
            });
            if (a) return;

            var matureinConvNo = ConveyorHelper.GetConveyorSignal(PlcName, matureInConvNo);
            //if (matureinConvNo.DB521_Tasknum > 0 || matureinConvNo.CvDB51_PH_Status) return;
            var conv_1141 = ConveyorHelper.GetConveyorSignal(PlcName, "1141");
            var conv_1143 = ConveyorHelper.GetConveyorSignal(PlcName, "1143");
            if ((conv_1141.DB521_Tasknum > 0 || conv_1141.CvDB51_PH_Status) && (conv_1143.DB521_Tasknum > 0 || conv_1143.CvDB51_PH_Status)) return;

            var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
            var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
            var cs = conveyor.EquSignal_Conv;

            if (cs.DB521_Goodstype != 1) return;//检测是否在线
            if (cs.DB521_Goodssize < 2) return;//检测烘烤时间是否正确
            //if (cs.DB521_Goodsstart != 1) return;//检测是否自动状态
            //if (cs.DB521_Goodsend == 1) return;//切线中，不能出库到熟化
            if (cs.DB521_Res04 == 0) return;//熟化房温度不能为零

            //int mature_Count = Current.TaskSet.Count(v => v.TASK_WKSTATUS == (int)WkStatus.熟化房熟化中 && v.TASK_POSIDNEXT == convNo);
            var mature_InTaskCount = Current.TaskSet.Count(v => v.TASK_MatureDate == cs.DB521_Goodssize && v.TASK_MatureTemperat <= cs.DB521_Res04 && v.TASK_MatureType == 1);
            //var mature_InTaskCount = Current.TaskSet.Count(v => v.TASK_MatureDate == cs.DB521_Goodssize && v.TASK_MatureType == 1);
            var mature_OutTaskCount = Current.TaskSet.Count(v => v.TASK_POSIDTO == matureInConvNo);
            if ((mature_InTaskCount + mature_OutTaskCount) < 60)
            {
                var param = new GetOutTaskParam();
                param.OutId = convNo;
                param.OutEndPostion = convNo;
                param.OutType = 1;
                param.WareHouseId = Current.Pvchouseputong;
                param.TASK_MatureDate = cs.DB521_Goodssize;
                param.TASK_MatureTemperat = cs.DB521_Res04;
                //调用WMS接口生成出库任务
                ThreadHelper.TaskThread(BaseWorkflow.GetOutTask, param, 2000);
            }
        }

        private void UploadMatureTimeInfo(string conNo)
        {
            try
            {        
                    var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                    var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == conNo);
                    var cs = conveyor.EquSignal_Conv;
                    // 开始与结束信号已被PLC复位，同时开始与结束确认信号为置位状态，开始复位确认信号
                    if(!cs.DB521_B_Outside && !cs.DB521_L_Outside)
                    {
                        if (cs.DB520_Confirm || cs.DB520_TaskDelete)
                        {
                        var converywrite = new WCSWriteToConveyorSignal();
                        converywrite.Plc = plc.Plc;
                        converywrite.DBName = plc.WriteDBName;
                        converywrite.ConveyorNo = conNo;
                        converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;
                        converywrite.Confirm = false;
                        converywrite.TaskDelete = false;
                        WriteTaskToBuffer(converywrite, true);
                        return;
                        }
                    }                 
                    string matureNo = conNo == "1164" ? "A" : "B";
                    if (!cs.DB521_B_Outside && !cs.DB521_L_Outside) return;
                    int isContinueMode = cs.DB521_F_Outside == true ? 1 : 0;//是否连续熟化模式
                    int num = cs.DB521_Goodstype;//熟化架数量
                    //开始熟化信号true，开始确认信号、结束熟化信号false，此时上传开始熟化信息
                    if (cs.DB521_B_Outside && !cs.DB520_Confirm && !cs.DB521_L_Outside)//开始熟化标志    DB520_Confirm  开始确认标志
                    {
                        //调用上传WMS的接口上传熟化房信息
                        var param = new GetMatureContinueParam
                        {
                            MatureRoomNo = matureNo,
                            IsContinueMode = isContinueMode,
                            MatureStartTime = DateTime.Now,
                            MatureEndTime = null,
                            MatureFrameNum = num
                        };
                        //BaseWorkflow.GetMatureContinueMode(param, cs, plc, 1, item);
                        if (BaseWorkflow.GetMatureContinueMode(param))
                        {
                            var converywrite = new WCSWriteToConveyorSignal();
                            converywrite.Plc = plc.Plc;
                            converywrite.DBName = plc.WriteDBName;
                            converywrite.ConveyorNo = conNo;
                            converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                            converywrite.Confirm = true;
                            WriteTaskToBuffer(converywrite, true);
                        }
                    }
                    //开始、结束熟化信号为true，结束熟化确认信号false，此时上传结束熟化信息
                    else if (cs.DB521_L_Outside && !cs.DB520_TaskDelete && cs.DB521_B_Outside)////结束熟化标志  DB520_TaskDelete 结束确认标志
                    {
                        //调用上传WMS的接口上传熟化房信息
                        var param = new GetMatureContinueParam
                        {
                            MatureRoomNo = matureNo,
                            IsContinueMode = isContinueMode,
                            MatureStartTime = null,
                            MatureEndTime = DateTime.Now,
                            MatureFrameNum = num
                        };
                        //BaseWorkflow.GetMatureContinueMode(param, cs, plc, 2, item);
                        if (BaseWorkflow.GetMatureContinueMode(param))
                        {
                            var converywrite = new WCSWriteToConveyorSignal();
                            converywrite.Plc = plc.Plc;
                            converywrite.DBName = plc.WriteDBName;
                            converywrite.ConveyorNo = conNo;
                            converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                            converywrite.TaskDelete = true;
                            WriteTaskToBuffer(converywrite);
                        }
                    }        
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }         
        }

        private void RequestInByMatureConv(string convNo, string matureRoomNo)
        {
            try
            {
                var plc = Current.PlcSet.FirstOrDefault(v => v.PLC_NAME == PlcName);
                var conveyor = plc.WCS_EquipmentInfoSet.FirstOrDefault(v => v.Equ_No == convNo);
                var cs = conveyor.EquSignal_Conv;

                if (!cs.DB521_Request) return;
                if (cs.DB523_Fault) return;
                if (cs.CvDB51_PH_Status) return;
                if (cs.DB521_Tasknum == 0) return;

                var task = Current.TaskSet.SingleOrDefault(v => v.TASK_NO == cs.DB521_Tasknum);

                var converywrite = new WCSWriteToConveyorSignal();
                converywrite.Plc = plc.Plc;
                converywrite.DBName = plc.WriteDBName;
                converywrite.ConveyorNo = convNo;
                converywrite.WriteStartAddress = cs.EquDbInfo_ReadWrite.DBReadIndox;

                converywrite.Remark_TaskNo = cs.DB521_Tasknum.ToString();
                converywrite.Remark = matureRoomNo;

                WriteInfoToConv_Room(cs, converywrite);
            }
            catch (Exception ex)
            {
                LogMessageHelper.RecordLogMessage(ex);
            }
        }

        /// <summary>
        /// 写入任务信息到输送机
        /// </summary>
        /// <param name="converySignal"></param>
        /// <param name="converywrite"></param>
        /// <param name="isNotTask"></param>
        public void WriteInfoToConv_Room(ConvSignal converySignal, WCSWriteToConveyorSignal converywrite)
        {
            if (converySignal.DB520_Tasknum == converywrite.Tasknum &&
                converySignal.DB520_Goodscode == converywrite.Goodscode &&
                converySignal.DB520_Goodstype == converywrite.Goodstype &&
                converySignal.DB520_Goodssize == converywrite.Goodssize &&
                converySignal.DB520_Goodsstart == converywrite.Goodsstart &&
                converySignal.DB520_Goodsend == converywrite.Goodsend &&
                converySignal.DB520_Notask == converywrite.Notask &&
                converySignal.DB520_TaskDelete == converywrite.TaskDelete &&
                converySignal.DB520_RollerTurn == converywrite.UpMatRequest &&
                converySignal.DB520_Res01 == converywrite.Res01 &&
                converySignal.DB520_Res02 == converywrite.Res02 &&
                converySignal.DB520_Res03 == converywrite.Res03 &&
                converySignal.DB520_Res04 == converywrite.Res04)
            {
                string result = TryCachHelper.TryTranExecute((db) =>
                {
                    var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == Convert.ToInt32(converywrite.Remark_TaskNo));
                    if (task == null) throw new Exception(string.Format("任务[{0}]未查询到信息.输送线[{1}]执行失败。", converywrite.Remark_TaskNo, converywrite.ConveyorNo));
                    int wkstatus = (int)WkStatus.熟化房熟化中;

                    var matureRoomItem = db.Queryable<MatureRoomCache>().First(v => v.BARCODE == task.TASK_BOXBARCODE);
                    if (matureRoomItem == null)
                    {
                        DateTime dt = db.GetDate();
                        int updatecount = db.Updateable<WCS_TASK>(it => new WCS_TASK()
                        {
                            TASK_WKSTATUS = wkstatus,
                            TASK_POSIDCUR = converywrite.Remark,
                            TASK_POSIDNEXT = converywrite.Remark,
                            TASK_EDITUSERNO = "WCS",
                            TASK_EDITDATETIME = DateTime.Now,
                            TASK_InMatureRoomDate = dt
                        })
                          .Where(it => it.TASK_NO == task.TASK_NO).ExecuteCommand();
                        if (updatecount <= 0)
                        {
                            throw new Exception(string.Format("任务[{0}]进入熟化房确认修改任务信息失败。", task.TASK_NO));
                        }
                        var matureRoom = new MatureRoomCache();
                        matureRoom.BARCODE = task.TASK_BOXBARCODE;
                        matureRoom.MatureRoomNo = converywrite.Remark;
                        matureRoom.MatureRoomName = matureRoom.MatureRoomNo == "1509" ? "B" : "A";
                        matureRoom.InMatureRoomDate = db.GetDate();
                        matureRoom.CurrentMatureNum = 1;
                        matureRoom.MatureNum = task.MatureNum.GetValueOrDefault();
                        if (db.Insertable(matureRoom).ExecuteCommand() <= 0)
                        {
                            throw new Exception(string.Format("任务[{0}]进入熟化房添加熟化房条码[{1}]进入队列失败。", task.TASK_NO, task.TASK_BOXBARCODE));
                        }
                    }
                    else if (matureRoomItem.CurrentMatureNum >= matureRoomItem.MatureNum)
                    {
                        throw new Exception(string.Format("任务[{0}]条码[{1}]进入熟化房次数不正确,请检查问题。", task.TASK_NO, task.TASK_BOXBARCODE));
                    }
                    else
                    {
                        int updatecount = db.Updateable<WCS_TASK>(it => new WCS_TASK()
                        {
                            TASK_WKSTATUS = wkstatus,
                            TASK_POSIDCUR = converywrite.Remark,
                            TASK_POSIDNEXT = converywrite.Remark,
                            TASK_EDITUSERNO = "WCS",
                            TASK_EDITDATETIME = DateTime.Now
                        })
                          .Where(it => it.TASK_NO == task.TASK_NO).ExecuteCommand();
                        if (updatecount <= 0)
                        {
                            throw new Exception(string.Format("任务[{0}]进入熟化房确认修改任务信息失败。", task.TASK_NO));
                        }

                        int matureNum = matureRoomItem.CurrentMatureNum + 1;
                        DateTime lastdt = db.GetDate();
                        int updateMature = db.Updateable<MatureRoomCache>(it => new MatureRoomCache()
                        {
                            CurrentMatureNum = matureNum,
                            InMatureRoomDate = lastdt,
                            Remark = ""
                        })
                         .Where(it => it.BARCODE == task.TASK_BOXBARCODE).ExecuteCommand();
                        if (updateMature <= 0)
                        {
                            throw new Exception(string.Format("任务[{0}]进入熟化房确认修改熟化次数信息失败。", task.TASK_NO));
                        }
                    }

                    string msg = string.Format("任务[{0}]已从输送线[{1}]进入熟化房[{2}]中", converywrite.Remark_TaskNo, converywrite.ConveyorNo, converywrite.Remark);
                    CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, converywrite.Remark, msg);

                    ConfirmTask(converySignal, converywrite);
                });
                if (!string.IsNullOrWhiteSpace(result))
                {
                    throw new Exception(string.Format("任务[{0}]输送机[{1}]执行失败，原因：[{1}]", converywrite.Remark_TaskNo, converywrite.ConveyorNo, result));
                }
            }
            else
            {
                WriteTaskToBuffer(converywrite);
            }
        }

        /// <summary>
        /// 写入任务信息到输送机
        /// </summary>
        /// <param name="converySignal"></param>
        /// <param name="converywrite"></param>
        /// <param name="isNotTask"></param>
        public void WriteInfoToConvMRoom(ConvSignal converySignal, WCSWriteToConveyorSignal converywrite)
        {
            if (converySignal.DB520_Tasknum == converywrite.Tasknum &&
                converySignal.DB520_Goodscode == converywrite.Goodscode &&
                converySignal.DB520_Goodstype == converywrite.Goodstype &&
                converySignal.DB520_Goodssize == converywrite.Goodssize &&
                converySignal.DB520_Goodsstart == converywrite.Goodsstart &&
                converySignal.DB520_Goodsend == converywrite.Goodsend &&
                converySignal.DB520_Notask == converywrite.Notask &&
                converySignal.DB520_TaskDelete == converywrite.TaskDelete &&
                converySignal.DB520_RollerTurn == converywrite.UpMatRequest &&
                converySignal.DB520_Res01 == converywrite.Res01 &&
                converySignal.DB520_Res02 == converywrite.Res02 &&
                converySignal.DB520_Res03 == converywrite.Res03 &&
                converySignal.DB520_Res04 == converywrite.Res04)
            {
                string result = TryCachHelper.TryTranExecute((db) =>
                {
                    var task = db.Queryable<WCS_TASK>().First(v => v.TASK_NO == converywrite.Tasknum);

                    int updatecount = db.Updateable<WCS_TASK>(it => new WCS_TASK()
                    {
                        TASK_WKSTATUS = (int)WkStatus.输送机执行,
                        TASK_POSIDNEXT = converywrite.Goodsend.ToString(),
                        //TASK_ITEM5 = converywrite.Goodsstart.ToString(),
                        TASK_EDITUSERNO = "WCS",
                        TASK_EDITDATETIME = DateTime.Now
                    })
                      .Where(it => it.TASK_NO == task.TASK_NO).ExecuteCommand();
                    if (updatecount <= 0)
                    {
                        throw new Exception(string.Format("任务[{0}]出熟化房确认修改任务信息失败。", task.TASK_NO));
                    }
                    var matureroom = db.Queryable<MatureRoomCache>().Single(v => v.BARCODE == task.TASK_BOXBARCODE);
                    if (matureroom == null)
                    {
                        throw new Exception(string.Format("任务[{0}]条码[{1}]出熟化房确认修改任务信息失败,队列中未找到该条码", task.TASK_NO));
                    }
                    else if (matureroom.CurrentMatureNum >= matureroom.MatureNum)
                    {
                        var matureRoom_dis = new MatureRoomCache_Dis();
                        matureRoom_dis.BARCODE = task.TASK_BOXBARCODE;
                        matureRoom_dis.MatureRoomNo = matureroom.MatureRoomNo;
                        matureRoom_dis.MatureRoomName = matureroom.MatureRoomName;
                        matureRoom_dis.InMatureRoomDate = matureroom.InMatureRoomDate;
                        matureRoom_dis.OutMatureRoomDate = db.GetDate();
                        matureRoom_dis.CurrentMatureNum = matureroom.CurrentMatureNum;
                        matureRoom_dis.MatureNum = matureroom.MatureNum;

                        if (db.Deleteable(matureroom).ExecuteCommand() <= 0)
                        {
                            throw new Exception(string.Format("任务[{0}]出熟化房删除熟化房条码[{1}]失败。", task.TASK_NO, task.TASK_BOXBARCODE));
                        }
                        if (db.Insertable(matureRoom_dis).ExecuteCommand() <= 0)
                        {
                            throw new Exception(string.Format("任务[{0}]出熟化房添加熟化房条码[{1}]到历史队列失败。", task.TASK_NO, task.TASK_BOXBARCODE));
                        }
                    }
                    else
                    {
                        int updateMatureRoom = db.Updateable<MatureRoomCache>(it => new MatureRoomCache()
                        {
                            Remark = "1"
                        })
                        .Where(it => it.BARCODE == task.TASK_BOXBARCODE).ExecuteCommand();
                        if (updateMatureRoom <= 0)
                        {
                            throw new Exception(string.Format("任务[{0}]出熟化房确认修改熟化房信息失败。", task.TASK_NO));
                        }
                    }

                    string msg = string.Format("任务已下发给输送机[{0}]执行,起点地址[{1}]目标地址[{2}]", converywrite.ConveyorNo, converywrite.Goodsstart, converywrite.Goodsend);
                    CommonData.AddWCS_TASK_DTL(db, task.TASK_NO, task.TASK_NO, task.TASK_POSIDCUR, converywrite.Goodsend.ToString(), msg);

                    ConfirmTask(converySignal, converywrite);
                });
                if (!string.IsNullOrWhiteSpace(result))
                {
                    throw new Exception(string.Format("任务[{0}]输送机[{1}]执行失败，原因：[{1}]", converywrite.Tasknum, converywrite.ConveyorNo, result));
                }
            }
            else
            {
                WriteTaskToBuffer(converywrite);
            }
        }

        #endregion 功能实现
    }
}