//using iWareCommon;
//using iWareCommon.Utils;
//using iWareSql;
//using System;
//using System.Collections.Generic;
//using System.Threading;

//using System.Linq;
//using iWareSql.Orm;
//using iWareCC.RgvService;
//using System.Threading.Tasks;
//using iWareSql.Entity.ParamModel;
//using iWareCC.BLL;
//using iWareSql.DataAccess;

//using Newtonsoft.Json;
//using iWareModel;
//using iWareSql.DBModel;
//using iWareCommon.Common.Globle;
//using XiGang.Core.Model;
//using iWareCC.Common.Helper;

//namespace iWareCC
//{
//    /// <summary>
//    /// RGV任务服务线程类
//    /// </summary>
//    public class RgvTaskThreadService : DeviceThreadServiceHandle
//    {

//        private static string _namespace = "iWareCC.RgvThreadService";

//        private RgvTaskThreadService() { }
//        public RgvTaskThreadService(LogType logType)
//        {
//            base.currentLogType = logType;
//        }
//        public override void StartService()
//        {
//            Task.Run(() =>
//            {
//                try
//                {
//                    //自动执行Rgv任务线程
//                    Log4NetHelper.WriteInfoLog(base.currentLogType, "[自动执行Rgv任务线程] 启动了");

//                    base.IssueTaskThread(EDevice.RGV);
//                    base.ConfirmFinishTaskThread(EDevice.RGV);
//                }
//                catch (Exception ex)
//                {
//                    Log4NetHelper.WriteErrorLog(base.currentLogType, "RgvThreadService线程启动出现异常", ex);
//                }
//            });
//        }

//        #region 线程处理

//        #region 自动执行Rgv任务线程

//        /// <summary>
//        /// 自动执行Rgv任务
//        /// </summary>
//        /// <param name="srmName"></param>
//        public override void IssueTask(object deviceId)
//        {
//            var errMsg = "";
//            int i_deviceId = (int)deviceId;
//            while (true)
//            {
//                if (SystemValue.isAllowRuning_RgvThreadService && SystemValue.isStartedModel)
//                {
//                    IssueTaskHandle(i_deviceId, out errMsg);
//                }
//                SystemWarningMsg._lbl_Alert_RgvRelease = errMsg;
//                Thread.Sleep(2000);//2秒一次
//            }

//        }

//        /// <summary>
//        /// 自动执行Rgv任务（线程）
//        /// </summary>
//        /// <param name="srmName"></param>
//        public override void IssueTaskHandle(int deviceId, out string errMsg)
//        {
//            errMsg = "";
//            string logHeader = "方法：DoRgvTaskByThead，参数deviceId：" + deviceId.ToString() + "===";
//            #region 新增异常信息表  【EditBy shaocx,2020-01-20】
//            IDictionary<string, object> logDict = new Dictionary<string, object>();
//            logDict.Add("deviceId", deviceId);
//            iWareSql.Orm.Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "DoRgvTaskByThead", logDict);
//            #endregion
//            try
//            {
//                /*
//                 * 执行发送给Rgv的指令任务
//                 * 1、验证根据设备号是否找到Rgv
//                 * 2、判断设备是否属于任务完成，如果属于任务完成，就继续走3
//                 * 3、判断数据库中是否有可要下发的任务，如果有就下发+验证起始点和目标点是否正确
//                 * 4、下发成功后，更新任务状态
//                 */


//                //2、判断设备是否属于空闲，如果属于空闲，就继续走2
//                bool isOk = ValidateDeviceIsAllowSendTask((int)EDevice.RGV, out errMsg);
//                if (!isOk)
//                {
//                    errMsg = "不允许下发新任务," + errMsg;
//                    return;
//                }
//                var newErrMsg = "";
//                using (DbModel dbModel = new DbModel())
//                {
//                    var partList = GetPartListByDevice(dbModel, deviceId, TaskExcuteTypeEnum.执行任务);
//                    if (partList != null && partList.Count > 0)
//                    {
//                        //首先处理模拟完成的任务
//                        foreach (var item in partList)
//                        {
//                            if (item.IsAllowSimulateExecute == true)
//                            {
//                                Single_IssueTaskHandle(false, item, dbModel, deviceId, exception, false, out newErrMsg);
//                                errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                                return;
//                            }
//                        }
//                        //foreach (var currentTask in partList)
//                        //{
//                        //    Single_IssueTaskHandle(currentTask, dbModel, deviceId, exception, out errMsg);
//                        //    Thread.Sleep(2000);//休眠2秒 【EditBy shaocx,2022-05-04】
//                        //}
//                        //*/
//                        //分隔任务  RGV任务和输送线任务 [EditBy shaocx,2022-04-29]
//                        var q_taskType_出库 = (int)DeviceTaskTypeEnum.出库;
//                        var rgvOutTaskList_出库 = partList.Where(x => x.TaskType == q_taskType_出库).ToList();//rgv出库任务

//                        var q_taskType_立库空托到拆盘机入口 = (int)DeviceTaskTypeEnum.立库空托到拆盘机入口;
//                        var rgvOutTaskList_立库空托到拆盘机入口 = partList.Where(x => x.TaskType == q_taskType_立库空托到拆盘机入口).ToList();//rgv 立库空托到拆盘机入口任务

//                        var q_taskType_组盘入库 = (int)DeviceTaskTypeEnum.组盘入库;
//                        var q_taskType_空托转运到立体库 = (int)DeviceTaskTypeEnum.空托转运到立体库;
//                        var rgvInTaskList = partList.Where(x => x.TaskType == q_taskType_组盘入库 || x.TaskType == q_taskType_空托转运到立体库).ToList();//rgv入库任务


//                        var q_taskType_空托转运到拆盘机入口 = (int)DeviceTaskTypeEnum.空托转运到拆盘机入口;
//                        var rgvTaskList_空托转运到拆盘机入口 = partList.Where(x => x.TaskType == q_taskType_空托转运到拆盘机入口).ToList();//rgv 空托转运到拆盘机入口 任务

//                        //纯输送线任务
//                        var q_taskType_拆盘机入口到拆盘机 = (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机;
//                        var q_taskType_空托缓存位转运 = (int)DeviceTaskTypeEnum.空托缓存位转运;
//                        var lineTaskList = partList.Where(x => x.TaskType == q_taskType_拆盘机入口到拆盘机 || x.TaskType == q_taskType_空托缓存位转运).ToList();//纯输送线任务


//                        /*
//                         * 策略：
//                         * 1、优先做发动机出库任务
//                         * 2、如果发动机出库任务下发不成功，则做 立库空托到拆盘机入口 任务
//                         * 3、其次做 组盘入库+空托转运到立体库任务，按顺序执行
//                         * 4、其次做 空托转运到拆盘机入口 任务
//                         * 5、其他纯输送线任务不受上述策略影响
//                         */
//                        if (lineTaskList != null && lineTaskList.Count > 0)
//                        {//纯输送线任务
//                            foreach (var currentTask in lineTaskList)
//                            {
//                                Single_IssueTaskHandle(false, currentTask, dbModel, deviceId, exception, false, out newErrMsg);
//                                errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                            }
//                        }

//                        if (rgvOutTaskList_出库 != null && rgvOutTaskList_出库.Count > 0)
//                        {
//                            //注意：出库任务下发就不要以CreateTime了，而是按照MainTaskSequence，因为在出库任务分解的时候，会出现那种 【EditBy shaocx,2022-05-19】
//                            // 二号堆垛机、二号堆垛机、三号堆垛机出库情况，如果按照CreateTime，排序会变为 二号堆垛机、三号堆垛机、二号堆垛机
//                            //var _partTask = rgvOutTaskList_出库.OrderBy(x => x.CreateTime).First();
//                            var _partTask = rgvOutTaskList_出库.OrderBy(x => x.MainTaskSequence).ThenBy(x => x.CreateTime).First();
//                            var validateLastSameToPlaceIsFinished = ValidateLastSameToPlaceIsFinished(dbModel, _partTask, true, ref newErrMsg);
//                            //var vaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE = VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE(dbModel, _partTask, ref newErrMsg);
//                            if (validateLastSameToPlaceIsFinished == true)
//                            {
//                                //每次只下发第一个出库任务
//                                Single_IssueTaskHandle(true, _partTask, dbModel, deviceId, exception, true, out newErrMsg);
//                                errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                                if (string.IsNullOrEmpty(errMsg))
//                                {//说明下发任务成功
//                                    return;//结束此次循环
//                                }
//                            }
//                            else
//                            {
//                                errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                            }
//                        }
//                        //如果发动机出库任务下发不成功，则做 立库空托到拆盘机入口 任务
//                        if (rgvOutTaskList_立库空托到拆盘机入口 != null && rgvOutTaskList_立库空托到拆盘机入口.Count > 0)
//                        {
//                            Single_IssueTaskHandle(true, rgvOutTaskList_立库空托到拆盘机入口.OrderBy(x => x.CreateTime).First(), dbModel, deviceId, exception, true, out newErrMsg);
//                            errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                            if (string.IsNullOrEmpty(errMsg))
//                            {//说明下发任务成功
//                                return;//结束此次循环
//                            }
//                        }
//                        //其次做 组盘入库+空托转运到立体库任务，按顺序执行
//                        if (rgvInTaskList != null && rgvInTaskList.Count > 0)
//                        {
//                            var _partTask = rgvInTaskList.OrderBy(x => x.CreateTime).First();
//                            var validateLastSameToPlaceIsFinished = ValidateLastSameToPlaceIsFinished(dbModel, _partTask, false, ref newErrMsg);
//                            //var vaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE = VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE22(dbModel, _partTask, ref newErrMsg);
//                            if (validateLastSameToPlaceIsFinished == true)
//                            {
//                                //按顺序下发
//                                Single_IssueTaskHandle(true, _partTask, dbModel, deviceId, exception, false, out newErrMsg);
//                                errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                                if (string.IsNullOrEmpty(errMsg))
//                                {//说明下发任务成功
//                                    return;//结束此次循环
//                                }
//                            }
//                            else
//                            {
//                                errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                            }
//                        }
//                        //其次做 空托转运到拆盘机入口 任务
//                        if (rgvTaskList_空托转运到拆盘机入口 != null && rgvTaskList_空托转运到拆盘机入口.Count > 0)
//                        {
//                            Single_IssueTaskHandle(true, rgvTaskList_空托转运到拆盘机入口.OrderBy(x => x.CreateTime).First(), dbModel, deviceId, exception, false, out newErrMsg);
//                            errMsg += newErrMsg + SysGloble.SPLIT_STR;
//                            if (string.IsNullOrEmpty(errMsg))
//                            {//说明下发任务成功
//                                return;//结束此次循环
//                            }
//                        }
//                        //*/
//                        /*
//                        //分隔任务  RGV任务和输送线任务 [EditBy shaocx,2022-04-29]
//                        var q_taskType1 = (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机;
//                        var q_taskType2 = (int)DeviceTaskTypeEnum.空托缓存位转运;
//                        var lineTaskList = partList.Where(x => x.TaskType == q_taskType1 || x.TaskType == q_taskType2).ToList();//输送线任务
//                        var rgvTaskList = partList.Where(x => x.TaskType != q_taskType1 && x.TaskType != q_taskType2).ToList();//rgv任务

//                        if (rgvTaskList != null && rgvTaskList.Count > 0)
//                        {
//                            Single_IssueTaskHandle(true, rgvTaskList.First(), dbModel, deviceId, exception, out errMsg);
//                            Thread.Sleep(2000);//休眠2秒 【EditBy shaocx,2022-05-04】
//                        }

//                        if (lineTaskList != null && lineTaskList.Count > 0)
//                        {
//                            foreach (var currentTask in lineTaskList)
//                            {
//                                Single_IssueTaskHandle(false, currentTask, dbModel, deviceId, exception, out errMsg);
//                            }
//                        }
//                        //*/
//                    }
//                    else
//                    {
//                        errMsg = "没有任务要发送给Rgv";
//                    }
//                }
//            }
//            catch (Exception ex)
//            {
//                errMsg = "出现异常：" + ex.Message;
//                SysExceptionInfoHandler.GetExceptionInfoForError("自动执行Rgv任务（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
//                SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
//            }
//        }

//        /// <summary>
//        /// 
//        /// </summary>
//        /// <param name="isRgvTask"></param>
//        /// <param name="currentTask"></param>
//        /// <param name="dbModel"></param>
//        /// <param name="deviceId"></param>
//        /// <param name="exception"></param>
//        /// <param name="isOutStoreTask">是否是出库任务</param>
//        /// <param name="errMsg"></param>
//        private void Single_IssueTaskHandle(bool isRgvTask, Task_Part currentTask, DbModel dbModel, int deviceId, iWareSql.Orm.Base_SysExceptionInfo exception,
//            bool isOutStoreTask,
//            out string errMsg)
//        {
//            errMsg = "";

//            if (MyExtendHelper.IsAllowSimulatorHandle(currentTask))
//            {//如果是模拟完成

//            }
//            else
//            {//非模拟完成
//                #region //3、判断数据库中是否有可要下发的任务，如果有就下发
//                //验证起始点和目标点是否正确
//                RealPlaceEntity realPlaceEntity = null;
//                //if (!ValdiatePalceIsRight(dbModel, (int)currentTask.SourcePlace, (int)currentTask.ToPlace, ref realPlaceEntity))
//                //{
//                //    errMsg = "验证起始点和目标点是否正确失败";
//                //    PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                //    return;
//                //}

//                //验证是否可以下发任务
//                var isOk = ValidateDeviceIsAllowSendTask(isRgvTask, (int)EDevice.RGV, currentTask, out errMsg);
//                if (!isOk)
//                {
//                    errMsg = "不允许下发新任务," + errMsg;
//                    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    return;
//                }
//                //要判断起点是否有库存，如果起点没有库存，则报错 【EditBy shaocx,2022-05-15】
//                var sourcePlaceStore = dbModel.V_AllStore.Where(x => x.StationId == currentTask.SourcePlace).FirstOrDefault();
//                if (sourcePlaceStore == null)
//                {
//                    errMsg = "不允许下发新任务," + string.Format("起点{0},{1}没有找到库存信息，无法下发RGV任务!", currentTask.SourcePlace.ToString(), currentTask.RealSourcePlace);
//                    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    return;
//                }
//                //验证目标点是否已经有库存 【EditBy shaocx,2022-04-15】
//                isOk = ValidateIsHasStoreForToPlace((int)EDevice.RGV, currentTask.ToPlace, currentTask.RealToPlace, out errMsg);
//                if (!isOk)
//                {
//                    errMsg = "不允许下发新任务," + errMsg;
//                    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    return;
//                }

//                //if (isRgvTask)
//                if (currentTask.TaskType == (int)DeviceTaskTypeEnum.出库) //修改为只对出库任务的判断，因为我发现有次出现过，下发了去1012的任务，但当时1012竟然有货，导致rgv不执行任务，然后导致rgv不执行其他入库任务的情况 【EditBy shaocx,2022-05-21】
//                {
//                    isOk = ValidateIsExistNoFinished(dbModel, currentTask, ref  errMsg);
//                    if (!isOk)
//                    {
//                        errMsg = "不允许下发新任务," + errMsg;
//                        //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                        return;
//                    }
//                }

//                //增加验证 【EditBy shaocx,2022-05-07】
//                var vaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012 = VaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012(dbModel, currentTask, ref errMsg);
//                if (vaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012)
//                {
//                    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    return;
//                }
//                var vaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation = VaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation(dbModel, currentTask, ref errMsg);
//                if (vaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation)
//                {
//                    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    return;
//                }

//                //验证起点光电是否有货存在 【EditBy shaocx,2022-05-11】
//                //var isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealSourcePlace);
//                //if (isGD_HasCatogryForRgvStattion == false)
//                //{
//                //    errMsg = "不允许下发新任务,起点位置" + currentTask.RealSourcePlace + "有光电显示无货存在";
//                //    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                //    return;
//                //}


//                //如果目标位置有光电显示有货存在，则不允许下发任务，是为了防止1014到1020的任务的，如果1020上有货，就不发任务 【EditBy shaocx,2022-04-30】
//                //全部任务都要验证目标点是否有货 【EditBy shaocx,2022-05-08】
//                //isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealToPlace);
//                //if (isGD_HasCatogryForRgvStattion)
//                //{
//                //    errMsg = "不允许下发新任务,目标位置" + currentTask.RealToPlace + "有光电显示有货存在";
//                //    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                //    return;
//                //}


//                if (isOutStoreTask)
//                {//如果是出库任务，则需要检测立体库出库口上面有货才可以下发任务 [EditBy shaocx,2022-05-11]
//                    //休眠1秒
//                    Thread.Sleep(3000);//增加休眠3秒的判断
//                    //var isGD_HasCatogryForSoruceRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealSourcePlace);
//                    //if (!isGD_HasCatogryForSoruceRgvStattion)
//                    //{
//                    //    errMsg = "不允许下发新任务,起始位置" + currentTask.RealSourcePlace + "有光电显示没有货存在！！";
//                    //    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    //    return;
//                    //}
//                    //再次判断出库任务，目标位置是否有发动机
//                    //因为我发现有次出现过，下发了去1012的任务，但当时1012竟然有货，导致rgv不执行任务，然后导致rgv不执行其他入库任务的情况 【EditBy shaocx,2022-07-24】
//                    //isGD_HasCatogryForRgvStattion = MyExtendHelper.IsGD_HasCatogryForRgvStattion(currentTask.RealToPlace);
//                    //if (isGD_HasCatogryForRgvStattion)
//                    //{
//                    //    errMsg = "不允许下发新任务,目标位置" + currentTask.RealToPlace + "有光电显示有货存在";
//                    //    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    //    return;
//                    //}
//                }


//                //验证是否存在 同一个起点，同一个目标点，并且是 未完成的的任务
//                isOk = ValidateIsHasNoFinishedSameTask((int)EDevice.RGV, currentTask, out errMsg);
//                if (!isOk)
//                {
//                    errMsg = "不允许下发新任务," + errMsg;
//                    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    return;
//                }
//                //同一个关联任务的其他设备任务
//                //判断和堆垛机的连接任务是不是已经完成了
//                var queryTaskState1 = (int)SubTaskStateEnum.未开始;
//                var queryTaskState2 = (int)SubTaskStateEnum.已下发;
//                var relevanceTask = dbModel.Task_Part.Where(x => x.MainTaskId == currentTask.MainTaskId && x.TaskSequence < currentTask.TaskSequence && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)).FirstOrDefault();
//                if (relevanceTask != null)
//                {
//                    errMsg = string.Format("关联{0}任务未完成，所以RGV任务不允许下发！关联任务号:{1}", relevanceTask.DeviceName, relevanceTask.PlcTaskId);
//                    //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                    return;
//                }

//                #region 增加验证 【EditBy shaocx,2022-05-15】
//                //来源位置的库位状态
//                var sourcePlace = dbModel.Base_Station.Where(o => o.Id == currentTask.SourcePlace).FirstOrDefault();
//                if (sourcePlace == null)
//                {
//                    throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.SourcePlace.ToString()));
//                }
//                var toPlace = dbModel.Base_Station.Where(o => o.Id == currentTask.ToPlace).FirstOrDefault();
//                if (toPlace == null)
//                {
//                    throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.ToPlace.ToString()));
//                }

//                DeviceTaskTypeEnum _DeviceTaskTypeEnum;
//                if (EnumberHelper.GetEnumObject<DeviceTaskTypeEnum>(currentTask.TaskType.ToString(), out _DeviceTaskTypeEnum) == false)
//                {
//                    throw new Exception("枚举值不正确!");
//                }

//                #endregion


//                //下发
//                SdaResEntity sdaResult = new SdaResEntity();
//                var log = TaskRequestLogHandler.GetTask(currentTask.Id,
//              (int)currentTask.DeviceId, currentTask.PlcTaskId, currentTask.RealSourcePlace.ToString(),
//              currentTask.RealToPlace.ToString(), "给RGV发送任务指令", "sys");
//                try
//                {
//                    if (MyExtendHelper.IsAllowSimulatorHandle(currentTask))
//                    {
//                        sdaResult.result = true;
//                    }
//                    else
//                    {
//                        sdaResult = new RgvService.RgvServiceClient().SendRgvTask(deviceId, Convert.ToInt32(currentTask.PlcTaskId), Convert.ToString(currentTask.RealSourcePlace), Convert.ToString(currentTask.RealToPlace));
//                    }
//                    if (sdaResult.result == false)
//                    {//给Rgv下发指令失败
//                        errMsg = sdaResult.resMsg;
//                        exception.exceptionMsg = string.Format("发送指令给Rgv失败,设备号{0},任务ID{1},起始位{2}，目标位{3},errMsg{4}", deviceId, currentTask.Id, currentTask.SourcePlace.ToString(), currentTask.ToPlace.ToString(), errMsg);
//                        SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
//                        TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult).ToString(), log, null);
//                        return;
//                    }
//                    else
//                    {
//                        TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求成功, JsonConvert.SerializeObject(sdaResult).ToString(), log, null);
//                    }
//                }
//                catch (Exception ex)
//                {
//                    errMsg = "出现异常:" + ex.Message;
//                    SysExceptionInfoHandler.GetExceptionInfoForError("给RGV发送任务指令出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
//                    SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
//                    TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(sdaResult).ToString(), log, ex);
//                    return;
//                }

//                #endregion
//            }

//            TranferStoreForRgv(currentTask, deviceId, dbModel, "RGV任务下发后", out errMsg);
//            if (!string.IsNullOrEmpty(errMsg))
//            {
//                //PartTaskHandler.WriteOperationRemarkForPartTask(currentTask.Id, errMsg);
//                return;
//            }

//            //4、下发成功后，更新任务状态
//            currentTask.IsReleased = true;
//            currentTask.ModifyBy = SysGloble.WCSSystem;
//            currentTask.ModifyTime = DateTime.Now;
//            var changeState = SubTaskStateEnum.已下发;
//            currentTask.TaskState = (int)changeState;
//            currentTask.TaskStateName = changeState.ToString();
//            currentTask.OperationRemark = "任务已下发给设备";
//            currentTask.IssueTime = DateTime.Now;//下发时间
//            //修改Task_Main的状态
//            UpdateMainTaskStatus(dbModel, currentTask.MainTaskId, currentTask.TaskType, "下发任务给RGV");


//            //推送MES
//            var mainTask = MainTaskHandler.GetMainTaskById(dbModel, currentTask.MainTaskId);
//            MesService.UpdateIsNeedOnLineForMainTask(mainTask);

//            int i = dbModel.SaveChanges();
//            if (i <= 0)
//            {
//                errMsg = "更新数据库失败,更新条数:" + i;
//            }
//            else
//            {

//            }
//        }

//        #endregion

//        #region 自动结束Rgv任务线程

//        /// <summary>
//        /// 自动结束Rgv任务线程
//        /// </summary>
//        /// <param name="srmName"></param>
//        public override void ConfirmFinishTask(object deviceId)
//        {
//            string errMsg = "";
//            int i_deviceId = (int)deviceId;
//            while (true)
//            {
//                if (SystemValue.isAllowRuning_RgvThreadService_Finish && SystemValue.isStartedModel)
//                {
//                    ConfirmFinishTaskHandle(i_deviceId, out errMsg);
//                }
//                SystemWarningMsg._lbl_Alert_RgvReleaseFinish = errMsg;
//                Thread.Sleep(2000);
//            }

//        }

//        /// <summary>
//        /// 自动结束Rgv任务线程（线程）
//        /// </summary>
//        /// <param name="srmName"></param>
//        public override void ConfirmFinishTaskHandle(int deviceId, out string errMsg)
//        {
//            errMsg = "";
//            var remark = "自动结束Rgv任务线程（线程）";
//            #region 新增异常信息表  【EditBy shaocx,2020-01-20】
//            IDictionary<string, object> logDict = new Dictionary<string, object>();
//            logDict.Add("deviceId", deviceId);
//            iWareSql.Orm.Base_SysExceptionInfo exception = SysExceptionInfoHandler.GetExceptionInfo<IDictionary<string, object>>(base.currentLogType, _namespace, "FinishRgvTaskByThead", logDict);
//            #endregion
//            try
//            {
//                /*
//                 * 执行发送给Rgv的指令任务
//                 * 1、验证根据设备号是否找到Rgv
//                 * 2、判断设备是否属于任务完成，如果属于任务完成，就继续走3
//                 * 3、判断数据库中是否有可要完成的任务，如果有判断是否跟Rgv中的完成任务相符，如果相符就处理
//                 * 4、更新任务状态
//                 */

//                int int_deviceId = (int)deviceId;


//                //*/
//                using (DbModel dbModel = new DbModel())
//                {
//                    var partList = GetPartListByDevice(dbModel, deviceId, TaskExcuteTypeEnum.结束任务);
//                    if (partList != null && partList.Count > 0)
//                    {
//                        foreach (var currentTask in partList)
//                        {
//                            SingleConfirmFinishTaskHandle(currentTask, int_deviceId, dbModel, remark, out errMsg);
//                        }
//                    }
//                    else
//                    {
//                        errMsg = "没有RGV任务要处理";
//                        return;
//                    }
//                }
//            }
//            catch (Exception ex)
//            {
//                errMsg = "出现异常:" + ex.Message;
//                SysExceptionInfoHandler.GetExceptionInfoForError("自动结束Rgv任务线程（线程）出现异常,deviceId:" + deviceId + ",异常:" + ex.Message, ex, ref exception);
//                SysExceptionInfoHandler.InsertExceptionInfo(exception, true);
//            }
//        }


//        private void SingleConfirmFinishTaskHandle(Task_Part currentTask, int int_deviceId, DbModel dbModel, string remark, out string errMsg)
//        {
//            #region //3、判断数据库中是否有可要完成的任务，如果有判断是否跟Rgv中的完成任务相符，如果相符就处理

//            DeviceTaskTypeEnum rgvTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), currentTask.TaskType.ToString());

//            //同一个关联任务的其他设备任务
//            //判断和堆垛机的连接任务是不是已经完成了
//            var queryTaskState1 = (int)SubTaskStateEnum.未开始;
//            var queryTaskState2 = (int)SubTaskStateEnum.已下发;
//            var relevanceTask = dbModel.Task_Part.Where(x => x.MainTaskId == currentTask.MainTaskId && x.TaskSequence < currentTask.TaskSequence && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)).FirstOrDefault();
//            if (relevanceTask != null)
//            {
//                errMsg = string.Format("关联{0}任务未完成，所以RGV任务不允许完成！关联任务号:{1}", relevanceTask.DeviceName, relevanceTask.PlcTaskId);
//                return;
//            }

//            #endregion

//            //注意：这里不需要判断设备是否完成，直接就结束任务
//            //2、判断设备是否属于任务完成，如果属于任务完成，就继续走2
//            var isTaskFinished = ValidateDeviceTaskIsFinsished(int_deviceId, currentTask, Convert.ToInt32(currentTask.PlcTaskId), currentTask.IsAllowSimulateExecute, out errMsg);
//            if (!isTaskFinished) return;

//            //4、更新任务状态
//            currentTask.FinishTime = DateTime.Now;//完成时间
//            currentTask.IsFinished = true;
//            currentTask.TaskState = (int)SubTaskStateEnum.已完成;
//            currentTask.TaskStateName = SubTaskStateEnum.已完成.ToString();
//            currentTask.OperationRemark = "已完成";
//            currentTask.ModifyBy = SysGloble.WCSSystem;
//            currentTask.ModifyTime = DateTime.Now;


//            using (var trans = dbModel.Database.BeginTransaction())
//            {
//                try
//                {
//                    //推送MES
//                    var mainTask = MainTaskHandler.GetMainTaskById(dbModel, currentTask.MainTaskId);
//                    MesService.UpdateIsNeedOnLineForMainTask(mainTask);

//                    //注意：一定是先要保存数据库，才再跟plc交互！！！！！
//                    var i = dbModel.SaveChanges();
//                    if (i <= 0)
//                    {
//                        throw new Exception("修改条数为0");
//                    }

//                    var isRgvTask = IsRgvTask(currentTask);
//                    if (isRgvTask)
//                    {//如果是RGV任务，则需要去给RGV任务确认
//                        SdaResEntity confirmTaskFinish = null;
//                        var log = TaskRequestLogHandler.GetTask(currentTask.Id,
//            (int)currentTask.DeviceId, currentTask.PlcTaskId, currentTask.RealSourcePlace.ToString(),
//            currentTask.RealToPlace.ToString(), "给RGV发送任务完成确认指令", "sys");
//                        try
//                        {
//                            //任务完成处理成功，需要再给RGV发送任务完成确认信号
//                            if (MyExtendHelper.IsAllowSimulatorHandle(currentTask))
//                            {
//                                confirmTaskFinish = new SdaResEntity()
//                                {
//                                    result = true
//                                };
//                            }
//                            else
//                            {
//                                confirmTaskFinish = new RgvService.RgvServiceClient().WriteRGV_FinishACK((int)EDevice.RGV, true, Convert.ToInt32(currentTask.PlcTaskId));
//                            }
//                            if (!confirmTaskFinish.result)
//                            {
//                                TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(confirmTaskFinish), log, null);
//                                trans.Rollback();
//                                return;
//                            }
//                            else
//                            {
//                                TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求成功, JsonConvert.SerializeObject(confirmTaskFinish), log, null);
//                            }
//                        }
//                        catch (Exception ex)
//                        {
//                            errMsg = "出现异常:" + ex.Message;
//                            Log4NetHelper.WriteErrorLog(LogType.RgvThreadService, errMsg, ex);
//                            TaskRequestLogHandler.InsertTask(base.currentLogType, RequestStatusEnum.请求失败, JsonConvert.SerializeObject(confirmTaskFinish), log, ex);
//                            trans.Rollback();
//                            return;
//                        }

//                        //*/
//                    }



//                    trans.Commit();


//                }
//                catch (Exception)
//                {
//                    trans.Rollback();
//                    throw;
//                }
//            }
//        }


//        #endregion

//        #endregion

//        #region 库存处理

//        /// <summary>
//        /// 库存转移
//        /// </summary>
//        /// <param name="currentTask"></param>
//        /// <param name="int_deviceId"></param>
//        /// <param name="dbModel"></param>
//        /// <param name="remark"></param>
//        /// <param name="errMsg"></param>
//        private void TranferStoreForRgv(Task_Part currentTask, int int_deviceId, DbModel dbModel, string remark, out string errMsg)
//        {

//            //来源位置的库位状态
//            var sourcePlace = dbModel.Base_Station.Where(o => o.Id == currentTask.SourcePlace).FirstOrDefault();
//            if (sourcePlace == null)
//            {
//                throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.SourcePlace.ToString()));
//            }
//            var toPlace = dbModel.Base_Station.Where(o => o.Id == currentTask.ToPlace).FirstOrDefault();
//            if (toPlace == null)
//            {
//                throw new Exception(string.Format("根据库位号{0}没有找到库位信息!", currentTask.ToPlace.ToString()));
//            }

//            //验证目标点是否已经有库存 【EditBy shaocx,2022-04-15】
//            var isOk = ValidateIsHasStoreForToPlace((int)EDevice.RGV, currentTask.ToPlace, currentTask.RealToPlace, out errMsg);
//            if (!isOk)
//            {
//                errMsg = "不允许下发新任务," + errMsg;
//                return;
//            }

//            #region 3、变更库位状态(任务占用、锁定)

//            UpdateStationLockInfoWhenFinished(dbModel, sourcePlace, toPlace, currentTask.Id, "RGV任务完成，出库任务处理");

//            #endregion

//            toPlace.IsFull = true;


//            sourcePlace.IsFull = false;

//            DeviceTaskTypeEnum _DeviceTaskTypeEnum;
//            if (EnumberHelper.GetEnumObject<DeviceTaskTypeEnum>(currentTask.TaskType.ToString(), out _DeviceTaskTypeEnum) == false)
//            {
//                throw new Exception("枚举值不正确!");
//            }
//            //修改来源和目标的CVP关系，更新库存
//            UpdateStore(dbModel, sourcePlace, toPlace, _DeviceTaskTypeEnum, currentTask);


//            //5、如果是出库任务，则需要更新计划出库明细表和计划出库主表的信息
//            if (currentTask.TaskType == (int)DeviceTaskTypeEnum.出库)
//            {
//                PlanOutTaskHandler.UpdatePlanStateToFinished(dbModel, currentTask.MainTaskId, remark);
//            }
//        }

//        #endregion

//        #region 公共处理

//        /// <summary>
//        /// 是否是RGV任务
//        /// </summary>
//        /// <param name="_task"></param>
//        /// <returns></returns>
//        private bool IsRgvTask(Task_Part _task)
//        {
//            var isRgvTask = true;
//            if (_task.TaskType == (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机 || _task.TaskType == (int)DeviceTaskTypeEnum.空托缓存位转运)
//            {
//                isRgvTask = false;
//            }
//            return isRgvTask;
//        }

//        /// <summary>
//        /// 判断相同目的地的RGV任务，上一个是否完成了
//        /// </summary>
//        /// <param name="dbModel"></param>
//        /// <param name="currentTask"></param>
//        /// <param name="errMsg"></param>
//        /// <returns></returns>
//        public bool ValidateLastSameToPlaceIsFinished(DbModel dbModel, Task_Part currentTask, bool isOutStoreForFDJ, ref string errMsg)
//        {
//            ////判断和堆垛机(或RGV)的连接任务是不是已经完成了
//            var queryTaskState1 = (int)SubTaskStateEnum.未开始;
//            var queryTaskState2 = (int)SubTaskStateEnum.已下发;
//            var queryDeviceId = (int)EDevice.RGV;
//            //同一个RGV的，并且是同种类型的（即相同目的地的）
//            Task_Part otherSrmTask = null;
//            if (isOutStoreForFDJ)
//            {//是发动机出库
//                otherSrmTask = dbModel.Task_Part.Where(x => x.DeviceId == queryDeviceId
//                 && x.Id != currentTask.Id
//                 && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
//                 && x.MainTaskSequence <= currentTask.MainTaskSequence
//                 && x.RealToPlace == currentTask.RealToPlace
//                 ).FirstOrDefault();
//            }
//            else
//            {//非发动机出库
//                otherSrmTask = dbModel.Task_Part.Where(x => x.DeviceId == queryDeviceId
//                 && x.Id != currentTask.Id
//                 && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
//                 && x.CreateTime < currentTask.CreateTime
//                 && x.RealToPlace == currentTask.RealToPlace
//                 ).FirstOrDefault();
//            }
//            if (otherSrmTask != null)
//            {
//                errMsg = "上一个RGV任务(即相同目的地的" + currentTask.RealToPlace + ")未完成，所以本次任务不允许下发！上一个RGV任务号:" + otherSrmTask.PlcTaskId + "，本次RGV任务号:" + currentTask.PlcTaskId;
//                return false;
//            }
//            return true;
//        }


//        /// <summary>
//        /// 判断RGV任务，上一个RGV存在已下发的任务
//        /// </summary>
//        /// <param name="dbModel"></param>
//        /// <param name="currentTask"></param>
//        /// <param name="errMsg"></param>
//        /// <returns></returns>
//        public bool ValidateIsExistNoFinished(DbModel dbModel, Task_Part currentTask, ref string errMsg)
//        {
//            ////判断和堆垛机(或RGV)的连接任务是不是已经完成了
//            var queryTaskState2 = (int)SubTaskStateEnum.已下发;
//            var queryDeviceId = (int)EDevice.RGV;

//            var q_taskType_拆盘机入口到拆盘机 = (int)DeviceTaskTypeEnum.拆盘机入口到拆盘机;
//            var q_taskType_空托缓存位转运 = (int)DeviceTaskTypeEnum.空托缓存位转运;

//            //判断都是RGV任务，前面是否有 已下发 的任务，如果有，就报错
//            var otherSrmTask = dbModel.Task_Part.Where(x => x.DeviceId == queryDeviceId
//                 && x.Id != currentTask.Id
//                 && (x.TaskState == queryTaskState2)
//                //&& x.CreateTime < currentTask.CreateTime
//                 && (x.TaskType != q_taskType_拆盘机入口到拆盘机 && x.TaskType != q_taskType_空托缓存位转运)
//                 ).FirstOrDefault();
//            if (otherSrmTask != null)
//            {
//                errMsg = "上一个RGV任务是已下发状态，所以本次任务不允许下发！上一个RGV任务号:" + otherSrmTask.PlcTaskId + "，本次RGV任务号:" + currentTask.PlcTaskId;
//                return false;
//            }
//            return true;
//        }

//        /// <summary>
//        /// 是否 距离上一次出库任务的下发时间小于设定的值
//        /// </summary>
//        /// <param name="edm"></param>
//        /// <param name="partTask"></param>
//        /// <param name="errMsg"></param>
//        /// <returns></returns>
//        public bool VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE(DbModel edm, Task_Part partTask, ref string errMsg)
//        {
//            var queryToPlace = ((int)EDevice.出库口1012).ToString();

//            var queryTaskState1 = (int)SubTaskStateEnum.已完成;

//            var queryDeviceId = (int)EDevice.RGV;

//            var task = edm.Task_Part.Where(x =>
//                x.DeviceId == queryDeviceId
//                && x.RealToPlace == queryToPlace
//                && x.TaskState == queryTaskState1).OrderByDescending(x => x.IssueTime).FirstOrDefault();//获取最新下发完成的出库任务
//            if (task != null)
//            {
//                //得到下发时间
//                var issueTime = (DateTime)task.IssueTime;
//                var nowTime = DateTime.Now;
//                TimeSpan ts = nowTime - issueTime;
//                if (ts.Seconds <= SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE)
//                {
//                    errMsg = "距离上一次出库任务的下发时间小于设定的" + SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE + "秒";
//                    return false;
//                }
//            }
//            return true;
//        }

//        /// <summary>
//        /// 是否 距离上一次出库任务的下发时间小于设定的值
//        /// </summary>
//        /// <param name="edm"></param>
//        /// <param name="partTask"></param>
//        /// <param name="errMsg"></param>
//        /// <returns></returns>
//        public bool VaidateIsMIN_OUTSTORE_RGV_TASK_JIANGE22(DbModel edm, Task_Part partTask, ref string errMsg)
//        {
//            var q_taskType_组盘入库 = (int)DeviceTaskTypeEnum.组盘入库;
//            var q_taskType_空托转运到立体库 = (int)DeviceTaskTypeEnum.空托转运到立体库;

//            var queryTaskState1 = (int)SubTaskStateEnum.已完成;

//            var queryDeviceId = (int)EDevice.RGV;

//            var task = edm.Task_Part.Where(x =>
//                 x.DeviceId == queryDeviceId
//                && x.RealToPlace == partTask.RealToPlace
//                && (x.TaskType == q_taskType_组盘入库 || x.TaskType == q_taskType_空托转运到立体库)
//                && x.TaskState == queryTaskState1).OrderByDescending(x => x.IssueTime).FirstOrDefault();//获取上一次入库，并且是同一个目标点的任务
//            if (task != null)
//            {
//                //得到下发时间
//                var issueTime = (DateTime)task.IssueTime;
//                var nowTime = DateTime.Now;
//                TimeSpan ts = nowTime - issueTime;
//                if (ts.Seconds <= SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE)
//                {
//                    errMsg = "距离上一次组盘入库/空托转运到立体库的任务下发时间小于设定的" + SysGloble.MIN_OUTSTORE_RGV_TASK_JIANGE + "秒";
//                    return false;
//                }
//            }
//            return true;
//        }


//        /// <summary>
//        /// 是否存在 创建时间早于当前的任务的未结束的任务,去1012的任务
//        /// </summary>
//        /// <param name="edm"></param>
//        /// <param name="partTask"></param>
//        /// <param name="errMsg"></param>
//        /// <returns></returns>
//        public bool VaidateIsExistNoIssuedTaskBeforeCurrTaskTo1012(DbModel edm, Task_Part partTask, ref string errMsg)
//        {
//            var queryDeviceId = (int)EDevice.RGV;
//            var queryToPlace = ((int)EDevice.出库口1012).ToString();
//            if (partTask.RealToPlace == queryToPlace)
//            {
//                //判断创建时间早于当前的任务是否下发了，如果没下发，就也不允许下发
//                var queryTaskState1 = (int)SubTaskStateEnum.未开始;
//                var queryTaskState2 = (int)SubTaskStateEnum.已下发;
//                var list = edm.Task_Part.Where(x => x.RealToPlace == queryToPlace
//                    && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
//                    && x.DeviceId == queryDeviceId
//                    // && x.CreateTime < partTask.CreateTime
//                    && x.Id != partTask.Id
//                    && x.MainTaskSequence <= partTask.MainTaskSequence
//                    ).FirstOrDefault();
//                if (list != null)
//                {
//                    errMsg = "存在都是去向1012的任务，创建时间早于当前任务，但是未开始或已下发的任务" + list.PlcTaskId + "，因为要严格控制出库顺序,不允许下发当前任务：" + partTask.PlcTaskId;
//                    return true;
//                }
//            }
//            return false;
//        }

//        /// <summary>
//        /// 是否存在 创建时间早于当前的任务的未结束的任务
//        /// </summary>
//        /// <param name="edm"></param>
//        /// <param name="partTask"></param>
//        /// <param name="errMsg"></param>
//        /// <returns></returns>
//        public bool VaidateIsExistNoIssuedTaskBeforeCurrTaskToSameInStoreStation(DbModel edm, Task_Part partTask, ref string errMsg)
//        {
//            var q_taskType_组盘入库 = (int)DeviceTaskTypeEnum.组盘入库;
//            var q_taskType_空托转运到立体库 = (int)DeviceTaskTypeEnum.空托转运到立体库;
//            var queryDeviceId = (int)EDevice.RGV;


//            //判断创建时间早于当前的任务是否下发了，如果没下发，就也不允许下发
//            var queryTaskState1 = (int)SubTaskStateEnum.未开始;
//            var queryTaskState2 = (int)SubTaskStateEnum.已下发;
//            var list = edm.Task_Part.Where(x =>
//                x.RealToPlace == partTask.RealToPlace
//                && (x.TaskType == q_taskType_组盘入库 || x.TaskType == q_taskType_空托转运到立体库)
//                && (x.TaskState == queryTaskState1 || x.TaskState == queryTaskState2)
//                && x.DeviceId == queryDeviceId
//                && x.CreateTime < partTask.CreateTime).FirstOrDefault();
//            if (list != null)
//            {
//                errMsg = "存在都是去向相同" + partTask.RealToPlace + "的入库任务，创建时间早于当前任务，但是未开始或已下发的任务" + list.PlcTaskId + "，因为要严格控制入库顺序,不允许下发当前任务：" + partTask.PlcTaskId;
//                return true;
//            }

//            return false;
//        }


//        /// <summary>
//        /// 更新主任务的状态
//        /// </summary>
//        /// <param name="edm"></param>
//        /// <param name="mainTaskId"></param>
//        /// <param name="rgvTaskTypeValue"></param>
//        /// <param name="remark"></param>
//        private void UpdateMainTaskStatus(DbModel edm, int mainTaskId, int rgvTaskTypeValue, string remark)
//        {
//            DeviceTaskTypeEnum rgvTaskTypeEnum = (DeviceTaskTypeEnum)Enum.Parse(typeof(DeviceTaskTypeEnum), rgvTaskTypeValue.ToString());
//            MainTaskStatusEnum changeTaskStatus = default(MainTaskStatusEnum);
//            switch (rgvTaskTypeEnum)
//            {
//                case DeviceTaskTypeEnum.组盘入库:
//                    changeTaskStatus = MainTaskStatusEnum.入库中;
//                    MainTaskHandler.UpdateTaskStatus(edm, mainTaskId, changeTaskStatus, remark);
//                    break;
//                case DeviceTaskTypeEnum.出库:
//                    changeTaskStatus = MainTaskStatusEnum.已完成;
//                    MainTaskHandler.UpdateTaskStatus(edm, mainTaskId, changeTaskStatus, remark);

//                    //如果是有计划的，需要处理下计划表的状态
//                    UpdatePlanOut(edm, mainTaskId);
//                    break;
//                case DeviceTaskTypeEnum.空托缓存位转运:
//                case DeviceTaskTypeEnum.空托转运到拆盘机入口:
//                case DeviceTaskTypeEnum.立库空托到拆盘机入口:
//                case DeviceTaskTypeEnum.拆盘机入口到拆盘机:
//                    changeTaskStatus = MainTaskStatusEnum.已完成;
//                    MainTaskHandler.UpdateTaskStatus(edm, mainTaskId, changeTaskStatus, remark);
//                    break;
//                default:
//                    return;//其他状态不予处理
//            }

//        }

//        private void UpdatePlanOut(DbModel edm, int mainTaskId)
//        {
//            var planDetail = edm.Plan_OutTaskDetail.FirstOrDefault(x => x.MainTaskId == mainTaskId);
//            if (planDetail != null)
//            {
//                planDetail.OutTaskDetailState = (int)OutTaskDetailStateEnum.完成;
//                planDetail.OutTaskDetailStateName = OutTaskDetailStateEnum.完成.ToString();
//                planDetail.FinishTime = DateTime.Now;//增加计划子表完成时间 【EditBy shaocx,2022-06-20】
//                planDetail.OperationRemark = "RGV任务完成，修改状态为完成";
//                //查找Main表
//                var outTask = edm.Plan_OutTask.FirstOrDefault(x => x.Id == planDetail.M_PlanId);
//                if (outTask != null)
//                {
//                    var queryOutTaskDetailState1 = (int)OutTaskDetailStateEnum.完成;
//                    var queryOutTaskDetailState2 = (int)OutTaskDetailStateEnum.已取消;
//                    var allCount = edm.Plan_OutTaskDetail.Where(x => x.M_PlanId == outTask.Id).Count();//所有计划
//                    outTask.Qty = allCount;//重新赋值总数量

//                    var count = edm.Plan_OutTaskDetail.Where(x => x.M_PlanId == outTask.Id && (x.OutTaskDetailState == queryOutTaskDetailState1 || x.OutTaskDetailState == queryOutTaskDetailState2)).Count();//已下发的计划
//                    var finishedCount = count + 1;
//                    var changeOutPlanStateEnum = default(OutPlanStateEnum);
//                    if (finishedCount >= allCount)
//                    {
//                        changeOutPlanStateEnum = OutPlanStateEnum.全部下发;
//                        outTask.PlanState = (int)changeOutPlanStateEnum;
//                        outTask.PlanStateName = changeOutPlanStateEnum.ToString();
//                        outTask.OperationRemark = "RGV任务完成，全部下发";

//                        outTask.Qty_Finish = outTask.Qty;
//                        outTask.Qty_NoFinish = 0;
//                        //修改齐套性为已齐套 [EditBy shaocx,2022-05-16]
//                        outTask.IsPickFinished = true;
//                        //更新计划进度
//                        outTask.PlanRate = 100;
//                    }
//                    else
//                    {
//                        changeOutPlanStateEnum = OutPlanStateEnum.部分下发;
//                        outTask.PlanState = (int)changeOutPlanStateEnum;
//                        outTask.PlanStateName = changeOutPlanStateEnum.ToString();
//                        outTask.OperationRemark = "RGV任务完成，部分下发";
//                        outTask.Qty_Finish = finishedCount;
//                        outTask.Qty_NoFinish = outTask.Qty - finishedCount;
//                        //更新计划进度
//                        outTask.PlanRate = CSharpHelper.ExecPercentRetInt(finishedCount, allCount);
//                    }
//                }
//            }
//        }

//        /// <summary>
//        /// 修改CVP的数据
//        /// </summary>
//        /// <param name="edm"></param>
//        /// <param name="rgvTaskTypeEnum"></param>
//        /// <param name="rgvTask"></param>
//        private void UpdateStore(DbModel dbModel, Base_Station sourcePlace, Base_Station toPlace, DeviceTaskTypeEnum rgvTaskTypeEnum, Task_Part rgvTask)
//        {
//            switch (rgvTaskTypeEnum)
//            {
//                case DeviceTaskTypeEnum.组盘入库:
//                default://其他

//                    TransferStoreWhenFinished(rgvTask, dbModel, rgvTask.SalverId, toPlace, "RGV任务被下发,重新绑定新的CVP关系", rgvTaskTypeEnum, EDeviceType.RGV);
//                    break;
//                case DeviceTaskTypeEnum.拆盘机入口到拆盘机:
//                case DeviceTaskTypeEnum.出库://注意：RGV出库的时候，目前是将库存删除掉！！！！
//                    StoreHandler.ClearStockByPlaceId(dbModel, sourcePlace, "RGV出库任务被下发,删除库存");
//                    //记录主表的出库时间
//                    var mainTask = dbModel.Task_Main.Where(x => x.TaskNo == rgvTask.MainTaskNo).First();
//                    mainTask.OutStoreTime = DateTime.Now;
//                    break;
//            }
//        }


//        public bool ValidateDeviceIsAllowSendTask(bool isRgvTask, int int_deviceId, Task_Part task, out string errMsg)
//        {
//            errMsg = "";
//            if (FormCC.IsSimulationPLC)
//            {
//                return true;
//            }
//            if (!base.ValidateDeviceIsAllowSendTask(int_deviceId, out errMsg))
//            {
//                return false;
//            }
//            bool isNeedValidateRealSourceAndToPlace = true;
//            if (task.RealSourcePlace == ((int)EDevice.堆垛机1出库口1001).ToString()
//                || task.RealSourcePlace == ((int)EDevice.堆垛机2出库口1003).ToString()
//                || task.RealSourcePlace == ((int)EDevice.堆垛机3出库口1005).ToString()
//                || task.RealSourcePlace == ((int)EDevice.堆垛机4出库口1008).ToString()
//                )
//            {//如果是立体库出库口，则不需要校验起点和终点是否是自动模式啊，运行模式啊
//                isNeedValidateRealSourceAndToPlace = false;
//            }
//            using (var rgvServie = new RgvService.RgvServiceClient())
//            {
//                SdaResEntity sdaResult = rgvServie.IsAllowSendTask(isNeedValidateRealSourceAndToPlace, int_deviceId, task.RealSourcePlace, task.RealToPlace, isRgvTask);
//                if (sdaResult.result == false)
//                {
//                    errMsg = sdaResult.resMsg;
//                    Log4NetHelper.WriteErrorLog(currentLogType, "验证RGV不可以下发新任务,int_deviceId:" + int_deviceId + ",sdaResultStr:" + JsonConvert.SerializeObject(sdaResult));
//                }
//                return sdaResult.result;
//            }
//        }

//        /// <summary>
//        /// 验证Rgv是否可以接受任务
//        /// </summary>
//        /// <param name="int_deviceId">设备号，不需要</param>
//        /// <param name="taskId">任务号，需要</param>
//        /// <returns></returns>
//        public override bool ValidateDeviceIsOK(int int_deviceId, Task_Part _task, int taskId, out string errMsg)
//        {
//            errMsg = "";
//            // Rgv没有所谓的空闲状态，有任务直接发即可
//            if (Wms_EquipmentSituationHandler.IsEquipmentBreakdown(int_deviceId).result)
//            {//如果设备已经设定为 故障状态，不允许下发任务！！！ [EditBy shaocx,2020-12-07]
//                return false;
//            }
//            return true;
//        }

//        /// <summary>
//        /// 验证Rgv是否任务完成
//        /// </summary>
//        /// <param name="int_deviceId"></param>
//        /// <returns>0表示没有任务完成，其他表示任务完成，并返回任务号</returns>
//        public override bool ValidateDeviceTaskIsFinsished(int int_deviceId, Task_Part _task, int taskId, bool? isAllowSimulateExecute, out string errMsg)
//        {
//            errMsg = "";
//            if (FormCC.IsSimulationPLC)
//            {
//                return true;
//            }
//            if (MyExtendHelper.IsAllowSimulatorHandle(_task))
//            {//模拟代码！发布时移除该代码
//                errMsg = "任务要求强制模拟完成";
//                return true;
//            }
//            var isRgvTask = IsRgvTask(_task);

//            if (isRgvTask == false)
//            {
//                //注意：这里不需要跟rgv确认完成，发送任务就自动完成任务了 【EditBy shaocx,2022-04-13】
//                return true;
//            }
//            else
//            {
//                var result = new RgvService.RgvServiceClient().IsTaskFinish(int_deviceId, taskId);
//                if (result.result) return true;
//                else
//                {
//                    errMsg = result.resMsg;
//                    return false;
//                }
//            }
//        }
//        #endregion
//    }
//}