ECS / WCS_BH2_WangBan · Files

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;

namespace HH_WCS_Standard
{
    public class SingleSrmExcute : I_Excute_S
    {
        private BaseBll _bll = new BaseBll();
        public VM_SrmRead vM_SrmRead;
        public VM_SrmWrite vM_SrmWrite;
        private I_Device device;

        #region 变量

        public static bool IsWriteErrMsg = false;

        #endregion 变量

        public SingleSrmExcute(F_ServiceModel f_ServiceModel) : base(f_ServiceModel)
        {
            vM_SrmRead = f_ServiceModel.vM_ReadModel as VM_SrmRead;
            vM_SrmWrite = f_ServiceModel.vM_WriteModel as VM_SrmWrite;
            device = this.f_service.device;
        }

        public override BllResult Excute()
        {
            //发送心跳
            if (!Heartbeat().Success)
            {
                return BllResult.Error();
            }

            //有无故障
            if (!NoError().Success)
            {
                return BllResult.Error();
            }

            if (vM_SrmRead.Fork1_State == E_SrmForkState.任务完成.GetIndexInt())
            {
                //堆垛机任务完成
                return FinishTask();
            }
            else if (vM_SrmRead.Fork1_State == E_SrmForkState.待机.GetIndexInt())
            {
                //堆垛机空闲
                if (vM_SrmWrite.Fork1TaskType_1 == E_SrmTaskType.删除任务.GetIndexInt() || vM_SrmWrite.Fork1TaskType_1 == E_SrmTaskType.任务完成.GetIndexInt())
                {
                    //堆垛机写入区还有数据，清空数据
                    return this.PutEmptyAddress();
                }
                else if (vM_SrmWrite.SRM_Axis_NO == E_SrmTaskAction.无.GetIndexInt())
                {
                    //堆垛机可以查找任务
                    var result = GetNewTask();
                    return result;
                }
                return BllResult.Sucess();
            }
            else
            {
                //堆垛机任务中断或执行中
                return BllResult.Error();
            }
        }

        public BllResult GetNewTask()
        {
            var AllTask = App.taskList.ToList().FindAll(a => App.poseList.Where(p => p.wcRoadWay == device.RoadWay).Select(b => b.wcName).Contains(a.FromPlace) && (a.NextState >= E_TaskState.下发堆垛机取货任务.GetIndexInt() && a.NextState <= E_TaskState.响应堆垛机任务完成.GetIndexInt()));
            if (AllTask.Count == 0)
            {
                //LogExecute.logNet.WriteDebug($"查找待下发任务：{device.Name}没有待下发任务");
                return BllResult.Error();
            }

            var againtasks = AllTask.FindAll(a => (a.NowState == E_TaskState.下发堆垛机取货任务.GetIndexInt() || a.NowState == E_TaskState.下发堆垛机放货任务.GetIndexInt()) && a.SendAgainFlag != 0);
            if (againtasks != null && againtasks.Count != 0)
            {
                if (againtasks.Count == 1)
                {
                    //处理需要重新下发的任务
                    return SendTask(againtasks[0]);
                }
                else
                {
                    LogExecute.logNet.WriteError($"查询到{device.Name}有多条待恢复任务");
                    return BllResult.Error($"查询到{device.Name}有多条待恢复任务");
                }
            }

            #region 个人觉得满入这里用不到，因为没有任何地方给fullinflag 赋值，当有满入的时候，系统立马就去处理了，在满入故障中就直接分配到了新的仓位。

            //var fullintasks = AllTask.FindAll(a => (a.NowState == E_TaskState.下发堆垛机取货任务.GetIndexInt() || a.NowState == E_TaskState.下发堆垛机放货任务.GetIndexInt()) && a.FullInFlag != 0);
            //if (fullintasks != null && fullintasks.Count != 0 && vM_SrmRead.Fork1_Goods!=0)
            //{
            //    if (againtasks.Count == 1)
            //    {
            //        //处理需要满入的任务
            //        return SendTask(fullintasks[0]);
            //    }
            //    else
            //    {
            //        LogExecute.logNet.WriteError($"查询到{device.Name}有多条满入待恢复任务");
            //        return BllResult.Error($"查询到{device.Name}有多条满入待恢复任务");
            //    }
            //}

            #endregion 个人觉得满入这里用不到，因为没有任何地方给fullinflag 赋值，当有满入的时候，系统立马就去处理了，在满入故障中就直接分配到了新的仓位。

            var taskcount = AllTask.FindAll(a => a.NowState == E_TaskState.下发堆垛机取货任务.GetIndexInt() || a.NowState == E_TaskState.下发堆垛机放货任务.GetIndexInt()).Count;
            if (taskcount > 0)
            {
                //堆垛机有任务待恢复
                LogExecute.logNet.WriteDebug($"{device.Name}有任务待恢复");
                return BllResult.Sucess();
            }

            if (vM_SrmRead.Fork1_Goods == 0)  //货叉无货
            {
              
                //int maxY = App.poseList.Where(a => a.wcType == "WareCell").Max(a => a.Ypose);
                if (vM_SrmRead.AxisY_NO == 202 || vM_SrmRead.AxisY_NO == 201)
                {
                    var intask = AllTask.FindAll(a => a.FromPlace == "InStationA01" && a.NextState == E_TaskState.下发堆垛机取货任务.GetIndexInt()).OrderBy(a => a.Task_CreateTime).ToList();
                    if (intask.Count() != 0)
                    {
                        var sendresult = SendTask(intask[0]);
                        if (sendresult.Success)
                        {
                            LogExecute.logNet.WriteDebug($"{device.Name}下发入库取货任务成功,任务号{intask[0].tNo}");
                            return BllResult.Sucess();
                        }
                        else
                            LogExecute.logNet.WriteError($"{device.Name}下发入库取货任务失败，任务号是{intask[0].tNo},错误原因是{sendresult.Msg}");
                    }

                }
                if (vM_SrmRead.Status_Port_OutStation == 1)
                    //出库站台空闲
                {
                    //List<I_Task> SAllTask = AllTask.FindAll(a => a.NextState == E_TaskState.下发堆垛机取货任务.GetIndexInt() && a.ToPlace == "OutStationA01").OrderBy(a => a.Task_CreateTime).ToList();
                    List<I_Task> SAllTask = AllTask.FindAll(a => a.NowState == E_TaskState.任务创建.GetIndexInt() && a.Type != E_TaskType.托盘入库.GetIndexString()).OrderBy(a => a.Priority).ThenBy(a => a.Task_CreateTime).ToList();
                    if (SAllTask.Count == 0) //无出库任务
                    {
                        List<I_Task> SSAllTask = AllTask.FindAll(a => a.NextState == E_TaskState.下发堆垛机取货任务.GetIndexInt() && a.ToPlace != "OutStationA01").OrderBy(a => a.Task_CreateTime).ToList();
                        foreach (var task in SSAllTask)
                        {
                            //if (!string.IsNullOrWhiteSpace(task.preTaskNo))
                            //{
                            //    var _tasks = SAllTask.FirstOrDefault(a => a.tNo_WMS == task.preTaskNo);
                            //    if (_tasks != null)
                            //    {
                            //        var result = SendTask(_tasks);
                            //        if (result.Success)
                            //        {
                            //            LogExecute.logNet.WriteDebug($"{device.Name}任务下发成功，任务号{_tasks.tNo}");
                            //            return BllResult.Sucess($"{device.Name}任务下发成功，任务号{_tasks.tNo}");
                            //        }
                            //        else
                            //        {
                            //            LogExecute.logNet.WriteError($"{device.Name}任务下发失败，任务号{_tasks.tNo},错误原因是{result.Msg}");
                            //        }
                            //    }
                            //}
                            var sendResult = SendTask(task);
                            if (sendResult.Success)
                            {
                                LogExecute.logNet.WriteDebug($"{device.Name}任务下发成功，任务号{task.tNo}");
                                return BllResult.Sucess($"{device.Name}任务下发成功，任务号{task.tNo}");
                            }
                            else
                            {
                                LogExecute.logNet.WriteDebug($"{device.Name}任务下发失败，任务号{task.tNo},错误原因是{sendResult.Msg}");
                            }
                        }

                    }
                    else
                    {
                        foreach (var task in SAllTask)
                        {

                            //if (!string.IsNullOrWhiteSpace(task.preTaskNo))
                            //{
                            //    var _tasks = SAllTask.FirstOrDefault(a => a.tNo_WMS == task.preTaskNo);
                            //    if (_tasks != null)
                            //    {
                            //        var result = SendTask(_tasks);
                            //        if (result.Success)
                            //        {
                            //            LogExecute.logNet.WriteDebug($"{device.Name}任务下发成功，任务号{_tasks.tNo}");
                            //            return BllResult.Sucess($"{device.Name}任务下发成功，任务号{_tasks.tNo}");
                            //        }
                            //        else
                            //        {
                            //            LogExecute.logNet.WriteError($"{device.Name}任务下发失败，任务号{_tasks.tNo},错误原因是{result.Msg}");
                            //        }
                            //    }
                            //}

                            #region 里仓位出库任务检查

                            ////判读该任务的是否为出库任务，如果是出库任务，且为里仓位出库任务，需要判读该仓位的外仓位有出库任务，不执行）
                            //var pose = App.poseList.FirstOrDefault(a => a.wcName == task.FromPlace && a.wcRoadWay == device.RoadWay);
                            //if (pose.wcType == "WareCell" && (pose.Xpose == 3 || pose.Xpose == 4))
                            //{
                            //    var _pose = App.poseList.FirstOrDefault(a => a.Xpose == pose.Xpose - 2 && a.Ypose == pose.Ypose && a.Zpose == pose.Zpose);
                            //    if (_pose != null)
                            //    {
                            //        var _task = SAllTask.FirstOrDefault(a => a.FromPlace == _pose.wcName);
                            //        if (_task != null)
                            //            continue;
                            //    }
                            //}

                            #endregion 里仓位出库任务检查

                            var sendResult = SendTask(task);
                            if (sendResult.Success)
                            {
                                LogExecute.logNet.WriteDebug($"{device.Name}任务下发成功，任务号{task.tNo}");
                                return BllResult.Sucess($"{device.Name}任务下发成功，任务号{task.tNo}");
                            }
                            else
                            {
                                LogExecute.logNet.WriteError($"{device.Name}任务下发失败，任务号{task.tNo},错误原因是{sendResult.Msg}");
                            }
                        }
                    }

                }
                else //出库站台占用(入库和移库任务)
                {
                    
                    //List<I_Task> SAllTask = AllTask.FindAll(a =>((a.Type != E_TaskType.分拣出库.ToString() && a.ToPlace != "InStationA01") || a.Type != E_TaskType.托盘出库.ToString()) && a.NextState == E_TaskState.下发堆垛机取货任务.GetIndexInt()).OrderBy(a => a.Task_CreateTime).ToList(); // && a.ToPlace != "OutStationA01"
                    List<I_Task> SAllTask = AllTask.FindAll(a => 
                        (
                        (a.Type == E_TaskType.分拣出库.GetIndexString() && a.FromPlace == "InStationA01") 
                        || a.Type == E_TaskType.托盘入库.GetIndexString() 
                        || a.Type == E_TaskType.库内移库.GetIndexString()
                        ) 
                        && a.NextState == E_TaskState.下发堆垛机取货任务.GetIndexInt()
                    ).OrderBy(a => a.Task_CreateTime).ToList(); // && a.ToPlace != "OutStationA01" 
                    foreach (var task in SAllTask)
                    {
                        
                        //if (!string.IsNullOrWhiteSpace(task.preTaskNo))
                        //{
                        //    var _tasks = SAllTask.FirstOrDefault(a => a.tNo_WMS == task.preTaskNo);
                        //    if (_tasks != null)
                        //    {
                        //        var result = SendTask(_tasks);
                        //        if (result.Success)
                        //        {
                        //            LogExecute.logNet.WriteDebug($"{device.Name}任务下发成功，任务号{_tasks.tNo}");
                        //            return BllResult.Sucess($"{device.Name}任务下发成功，任务号{_tasks.tNo}");
                        //        }
                        //        else
                        //        {
                        //            LogExecute.logNet.WriteError($"{device.Name}任务下发失败，任务号{_tasks.tNo},错误原因是{result.Msg}");
                        //        }
                        //    }
                        //}
                        LogExecute.logNet.WriteDebug($"{device.Name}找到待下达任务，任务号{task.tNo}");
                        var sendResult = SendTask(task);
                        if (sendResult.Success)
                        {
                            LogExecute.logNet.WriteDebug($"{device.Name}任务下发成功，任务号{task.tNo}");
                            return BllResult.Sucess($"{device.Name}任务下发成功，任务号{task.tNo}");
                        }
                        else
                        {
                            LogExecute.logNet.WriteDebug($"{device.Name}任务下发失败，任务号{task.tNo},错误原因是{sendResult.Msg}");
                        }
                    }
                }
            }
            else  //货叉有货
            {
                AllTask = AllTask.FindAll(a => a.NextState == E_TaskState.下发堆垛机放货任务.GetIndexInt()).OrderBy(a => a.Task_CreateTime).ToList();
                if (AllTask != null && AllTask.Count != 0)
                {
                    if (AllTask.Count > 1)
                    {
                        LogExecute.logNet.WriteError($"查询到{device.Name}有多条放货任务");
                        return BllResult.Error($"查询到{device.Name}有多条放货任务");
                    }
                    var sendresult = SendTask(AllTask[0]);
                    if (sendresult.Success)
                    {
                        LogExecute.logNet.WriteDebug($"{device.Name}下发放货任务成功,任务号{AllTask[0].tNo}");
                        return BllResult.Sucess();
                    }
                    else
                        LogExecute.logNet.WriteError($"{device.Name}下发放货任务失败，任务号是{AllTask[0].tNo},错误原因是{sendresult.Msg}");
                }
            }
            return BllResult.Sucess();
        }

        public BllResult NoError()
        {
            if (vM_SrmRead.SRM_Mode == E_SrmMode.联机.GetIndexInt())
            {
                //IsWriteErrMsg = true;
                if (vM_SrmRead.SRM_Err == 0 && vM_SrmRead.Fork1_Err == 0) //&& vM_SrmRead.Fork1_Zero==1
                {
                    IsWriteErrMsg = true;
                    vM_SrmRead.SrmErrMsg = "";
                    App.srmErrMsg = "";
                    return BllResult.Sucess();
                }
                else
                {
                    if (IsWriteErrMsg)
                    {
                        GetSrmErrMsg();
                        LogExecute.SrmlogNet.WriteError($"{vM_SrmRead.Name}报错\r堆垛机错误：{vM_SrmRead.SrmErrMsg}");
                        IsWriteErrMsg = false;
                    }
                    return BllResult.Error();
                }
            }
            else
            {
                if (vM_SrmRead.SRM_Err == 0 && vM_SrmRead.Fork1_Err == 0 && vM_SrmRead.Fork1_Zero == 1)
                {
                    IsWriteErrMsg = true;
                    vM_SrmRead.SrmErrMsg = "";
                    App.srmErrMsg = "";
                    LogExecute.SrmlogNet.WriteError($"{vM_SrmRead.Name}不是联机状态，当前状态为{Enum.GetName(typeof(E_SrmMode), vM_SrmRead.SRM_Mode)}");
                    return BllResult.Error();
                }
                else
                {
                    GetSrmErrMsg();
                    if (!IsWriteErrMsg)
                    {
                        LogExecute.SrmlogNet.WriteError($"{vM_SrmRead.Name}不是联机状态，当前状态{Enum.GetName(typeof(E_SrmMode), vM_SrmRead.SRM_Mode)},错误：{vM_SrmRead.SrmErrMsg}");
                        IsWriteErrMsg = true;
                    }
                    return BllResult.Error();
                }
            }
        }

        public BllResult Heartbeat()
        {
            if (vM_SrmWrite.SRM_Heart == 32767)
            {
                vM_SrmWrite.SRM_Heart = 0;
            }
            else
            {
                vM_SrmWrite.SRM_Heart++;
            }

            vM_SrmWrite.LatTime = DateTime.Now;
            var tmp = this.f_service.GetWriteAddres("SRM_Heart", vM_SrmWrite.SRM_Heart.ToString());
            var result = this.PutWriteAddress(new List<I_Device_Address> { tmp });
            if (!result.Success)
            {
                LogExecute.logNet.WriteError($"发送{vM_SrmRead.Name}心跳数据失败:{result.Msg}");
                return BllResult.Error();
            }
            else
            {
                return BllResult.Sucess();
            }
        }

        public BllResult GetSrmErrMsg()
        {
            string errMsg = "";
            List<I_Device_Address> list = f_service.ReadAddressList.FindAll(t => Regex.IsMatch(t.Member, "SrmError_[0-9]{2}") || Regex.IsMatch(t.Member, "Fork1Error_[0-9]{2}") || Regex.IsMatch(t.Member, "TaskError_[0-9]{2}") || Regex.IsMatch(t.Member, "OtherError_[0-9]{2}") || Regex.IsMatch(t.Member, "Alarm[0-9]{2}") || t.Member == "Fork1_TakeErr" || t.Member == "Fork1_EmptyOut" || t.Member == "Fork1_TakeErr2" || t.Member == "Fork1_FullIn");
            foreach (I_Device_Address tmpaddress in list)
            {
                if ((tmpaddress.value.ToLower() == "true" || tmpaddress.value == "1") && !string.IsNullOrWhiteSpace(tmpaddress.Name))
                {
                    errMsg += tmpaddress.Name + "\r\n";
                }
            }
            vM_SrmRead.SrmErrMsg = errMsg;
            App.srmErrMsg = errMsg;
            return BllResult.Sucess(errMsg, "成功");
        }

        #region 正常流程任务操作

        public BllResult FinishTask()
        {
            if (vM_SrmWrite.Fork1_Code == "HandTask")
            {
                //手动创建的任务
                vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.任务完成.GetIndexInt();
                var finishtask_send = this.PutWriteAddress();
                if (finishtask_send.Success)
                {
                    LogExecute.logNet.WriteDebug($"{vM_SrmRead.Name}完成任务成功，任务为手动任务");
                    return BllResult.Sucess();
                }
                else
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name}完成任务失败（出现异常），任务为手动任务,错误原因是{finishtask_send.Msg}");
                    return BllResult.Error();
                }
            }
            else
            {
                var finishtask = App.taskList.FirstOrDefault(a => a.PalletOrBoxNo == vM_SrmRead.Fork1_Code && (a.NextState == E_TaskState.响应堆垛机任务完成.GetIndexInt() || a.NextState == E_TaskState.响应堆垛机取货完成.GetIndexInt()));
                if (finishtask != null)
                {
                    //非手动创建的任务
                    vM_SrmWrite.Fork1TaskType_1 = 10;
                    BaseDal<I_Task> baseDal = new BaseDal<I_Task>();
                    baseDal.BeginTran();
                    var finishtask_update = _bll.NextStateChange(finishtask, baseDal);
                    if (finishtask_update.Success)
                    {
                        var finishtask_send = this.PutWriteAddress();
                        if (finishtask_send.Success)
                        {
                            baseDal.CommitTran();
                            _bll.NextStateChangeCache(finishtask);
                            LogExecute.logNet.WriteDebug($"{vM_SrmRead.Name}完成任务成功，任务号:{finishtask.tNo},取货仓位{finishtask.FromPlace}，目标仓位{finishtask.ToPlace}");
                            return BllResult.Sucess();
                        }
                        else
                        {
                            baseDal.RollbackTran();
                            LogExecute.logNet.WriteError($"{vM_SrmRead.Name}完成任务失败（发送失败），任务号:{finishtask.tNo},取货仓位{finishtask.FromPlace}，目标仓位{finishtask.ToPlace}");
                            return BllResult.Error();
                        }
                    }
                    else
                    {
                        baseDal.RollbackTran();
                        LogExecute.logNet.WriteError($"{vM_SrmRead.Name}完成任务失败（更新数据库异常），任务号:{finishtask.tNo},取货仓位{finishtask.FromPlace}，目标仓位{finishtask.ToPlace}");
                        return BllResult.Error();
                    }
                }
                else
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name}完成任务失败（找不到托盘号对应的任务），托盘号:{vM_SrmRead.Fork1_Code}");
                    return BllResult.Error();
                }
            }
        }

        public BllResult SendTask(I_Task task)
        {
            var sendtask_frompose = App.poseList.FirstOrDefault(a => a.wcName == task.FromPlace && a.wcRoadWay == device.RoadWay);
            var sendtask_topose = App.poseList.FirstOrDefault(a => a.wcName == task.ToPlace && a.wcRoadWay == device.RoadWay);
            if (sendtask_frompose == null || sendtask_topose == null)
            {
                LogExecute.logNet.WriteError($"{vM_SrmRead.Name}下发任务失败（找不到坐标），任务号:{task.tNo},取货仓位{task.FromPlace}，目标仓位{task.ToPlace}");
                return BllResult.Error();
            }

            if (task.SendAgainFlag == 0 && task.FullInFlag == 0)
            {
                if (task.NextState == E_TaskState.下发堆垛机取货任务.GetIndexInt())
                {
                    vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.到位置取.GetIndexInt();
                    vM_SrmWrite.Fork1_Pick_AxisX_NO = sendtask_frompose.Xpose;
                    vM_SrmWrite.Fork1_Pick_AxisY_NO = sendtask_frompose.Ypose;
                    vM_SrmWrite.Fork1_Pick_AxisZ_NO = sendtask_frompose.Zpose;
                }
                // (task.NextState==E_TaskState.下发堆垛机放货任务.GetIndexInt())
                else
                {
                    vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.到位置放.GetIndexInt();
                    vM_SrmWrite.Fork1_Release_AxisX_NO = sendtask_topose.Xpose;
                    vM_SrmWrite.Fork1_Release_AxisY_NO = sendtask_topose.Ypose;
                    vM_SrmWrite.Fork1_Release_AxisZ_NO = sendtask_topose.Zpose;
                }
                vM_SrmWrite.SRM_NO = 4;
                vM_SrmWrite.SRM_Axis_NO = 1;
                vM_SrmWrite.Fork1_Code = task.PalletOrBoxNo;
                vM_SrmWrite.Goods_Type = int.Parse(task.Height);
                BaseDal<I_Task> taskDb = new BaseDal<I_Task>();
                taskDb.BeginTran();
                var sendtask_Result = _bll.NextStateChange(task, taskDb);
                if (sendtask_Result.Success)
                {
                    var sendtask_Send = this.PutWriteAddress();
                    if (sendtask_Send.Success)
                    {
                        taskDb.CommitTran();
                        _bll.NextStateChangeCache(task);
                        LogExecute.logNet.WriteDebug($"{device.Name}任务下发成功，任务号{task.tNo},目标仓位{task.ToPlace}");
                        return BllResult.Sucess($"{device.Name}任务下发成功，任务号{task.tNo}");
                    }
                    else
                    {
                        taskDb.RollbackTran();
                        LogExecute.logNet.WriteError($"{device.Name}任务下发失败（写入异常）,任务号是{task.tNo},异常原因是{sendtask_Send.Msg}");
                        return BllResult.Error($"{device.Name}任务下发失败（写入异常）,任务号是{task.tNo},异常原因是{sendtask_Send.Msg}");
                    }
                }
                else
                {
                    taskDb.RollbackTran();
                    LogExecute.logNet.WriteError($"{device.Name} 任务下发失败（更新数据库异常）,任务号是{task.tNo},异常原因是{sendtask_Result.Msg}");
                    return BllResult.Error($"{device.Name} 任务下发失败（更新数据库异常）,任务号是{task.tNo},异常原因是{sendtask_Result.Msg}");
                }
            }
            else
            {
                //需要重发的任务
                if (task.NowState == E_TaskState.下发堆垛机取货任务.GetIndexInt())
                {
                    vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.到位置取.GetIndexInt();
                    vM_SrmWrite.Fork1_Pick_AxisX_NO = sendtask_frompose.Xpose;
                    vM_SrmWrite.Fork1_Pick_AxisY_NO = sendtask_frompose.Ypose;
                    vM_SrmWrite.Fork1_Pick_AxisZ_NO = sendtask_frompose.Zpose;
                }
                // (task.NowState == E_TaskState.下发堆垛机放货任务.GetIndexInt())
                else
                {
                    vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.到位置放.GetIndexInt();
                    vM_SrmWrite.Fork1_Release_AxisX_NO = sendtask_topose.Xpose;
                    vM_SrmWrite.Fork1_Release_AxisY_NO = sendtask_topose.Ypose;
                    vM_SrmWrite.Fork1_Release_AxisZ_NO = sendtask_topose.Zpose;
                }
                vM_SrmWrite.SRM_NO = 4;
                vM_SrmWrite.SRM_Axis_NO = E_SrmTaskAction.一号货叉.GetIndexInt();
                vM_SrmWrite.Fork1_Code = task.PalletOrBoxNo;
                BaseDal<I_Task> _taskDb = new BaseDal<I_Task>();
                Dictionary<string, object> lstColumnValues = new Dictionary<string, object>();
                lstColumnValues.Add("SendAgainFlag", 0);
                var finishtask_update = _taskDb.Update(lstColumnValues, a => a.tNo == task.tNo);
                if (finishtask_update.Success)
                {
                    var finishtask_send = this.PutWriteAddress();
                    if (finishtask_send.Success)
                    {
                        //提交事务
                        _taskDb.CommitTran();
                        //更改缓存中的重发状态
                        task.SendAgainFlag = 0;
                        LogExecute.logNet.WriteDebug($"{vM_SrmRead.Name}重发任务成功，任务号:{task.tNo},取货仓位{task.FromPlace}，目标仓位{task.ToPlace}");
                        return BllResult.Sucess();
                    }
                    else
                    {
                        _taskDb.RollbackTran();
                        LogExecute.logNet.WriteError($"{vM_SrmRead.Name}重发任务失败（发送异常），任务号:{task.tNo},取货仓位{task.FromPlace}，目标仓位{task.ToPlace}");
                        return BllResult.Error($"{vM_SrmRead.Name}重发任务失败（发送异常），任务号:{task.tNo},取货仓位{task.FromPlace}，目标仓位{task.ToPlace}");
                    }
                }
                else
                {
                    _taskDb.RollbackTran();
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name}重发任务失败（更新数据库异常），任务号:{task.tNo},取货仓位{task.FromPlace}，目标仓位{task.ToPlace}");
                    return BllResult.Error();
                }
            }
        }

        #endregion 正常流程任务操作

        #region 任务手动操作

        /// <summary>
        /// 删除任务
        /// </summary>
        /// <returns></returns>
        public override BllResult DeleteTask()
        {
            if (vM_SrmRead.SRM_Mode == E_SrmMode.联机.GetIndexInt())
            {
                vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.删除任务.GetIndexInt();
                vM_SrmWrite.LatTime = DateTime.Now;
                BllResult sendResult = this.PutWriteAddress();
                if (sendResult.Success)
                {
                    LogExecute.logNet.WriteDebug($"删除{device.Name}任务成功，托盘号{vM_SrmRead.Fork1_Code}");
                    return BllResult.Sucess($"删除{device.Name}任务成功");
                }
                else
                {
                    LogExecute.logNet.WriteError($"删除{device.Name}任务失败,托盘号{vM_SrmWrite.Fork1_Code}");
                    return BllResult.Error($"删除{device.Name}任务失败");
                }
            }
            else
            {
                LogExecute.logNet.WriteError($"删除{device.Name}任务失败,堆垛机当前状态不允许删除");
                return BllResult.Error($"删除{device.Name}任务失败,堆垛机当前状态不允许删除");
            }
        }

        /// <summary>
        /// 手动完成任务
        /// </summary>
        /// <returns></returns>
        public override BllResult HandFinishExcute()
        {
            if (vM_SrmRead.SRM_Mode == E_SrmMode.联机.GetIndexInt() && vM_SrmRead.Fork1_State != E_SrmForkState.待机.GetIndexInt())
            {
                var finishtaskresult = FinishTask();
                if (finishtaskresult.Success)
                {
                    LogExecute.logNet.WriteDebug($"手动完成{device.Name}任务成功,托盘号{vM_SrmRead.Fork1_Code}");
                    return BllResult.Error($"手动完成{device.Name}任务成功,托盘号{vM_SrmRead.Fork1_Code}");
                }
                else
                {
                    LogExecute.logNet.WriteError($"手动完成{device.Name}任务失败,托盘号{vM_SrmRead.Fork1_Code},错误信息是{finishtaskresult.Msg}");
                    return BllResult.Error($"手动完成{device.Name}任务失败,托盘号{vM_SrmRead.Fork1_Code}，错误信息是{finishtaskresult.Msg}");
                }
            }
            else
            {
                LogExecute.logNet.WriteError($"手动完成{device.Name}任务失败,堆垛机当前状态不允许手动完成");
                return BllResult.Error($"手动完成{device.Name}任务失败,堆垛机当前状态不允许手动完成");
            }
        }

        /// <summary>
        /// 重新下发任务
        /// </summary>
        /// <returns></returns>
        public override BllResult HandReqExcute()
        {
            if (vM_SrmRead.Fork1_State == E_SrmForkState.任务中断.GetIndexInt() || vM_SrmRead.Fork1_State == E_SrmForkState.待机.GetIndexInt())
            {
                var reqtask = App.taskList.FirstOrDefault(a => (a.NowState == E_TaskState.下发堆垛机取货任务.GetIndexInt() || a.NowState == E_TaskState.下发堆垛机放货任务.GetIndexInt()));
                if (reqtask == null)
                {
                    LogExecute.logNet.WriteError($"重新下发{device.Name}任务失败,任务中无待下发的任务");
                    return BllResult.Error($"重新下发{device.Name}任务失败,任务中无待下发的任务");
                }
                else
                {
                    BaseDal<I_Task> baseDal = new BaseDal<I_Task>();
                    Dictionary<string, object> lstColumnValues = new Dictionary<string, object>();
                    lstColumnValues.Add("SendAgainFlag", 4);
                    var updateresult = baseDal.Update(lstColumnValues, a => a.tNo == reqtask.tNo);
                    if (updateresult.Success)
                    {
                        reqtask.SendAgainFlag = 4;
                        LogExecute.logNet.WriteDebug($"重新下发{device.Name}任务，更新任务重发标志成功");
                        return BllResult.Sucess($"重新下发{device.Name}任务，更新任务重发标志成功");
                    }
                    else
                    {
                        LogExecute.logNet.WriteError($"重新下发{device.Name}任务，更新任务重发标志失败");
                        return BllResult.Error($"重新下发{device.Name}任务，更新任务重发标志失败");
                    }
                }
            }
            else
            {
                LogExecute.logNet.WriteError($"重新下发{device.Name}任务失败,堆垛机不处于恢复状态");
                return BllResult.Error($"重新下发{device.Name}任务失败,堆垛机不处于恢复状态");
            }
        }

        /// <summary>
        /// 继续执行任务
        /// </summary>
        /// <returns></returns>
        public override BllResult HandContinueExcute()
        {
            return BllResult.Error($"继续执行{device.Name}任务失败");
        }

        #endregion 任务手动操作

        #region 特殊故障处理

        /// <summary>
        /// 满入处理
        /// </summary>
        /// <returns></returns>
        public override BllResult FullInExcute()
        {
            if (vM_SrmRead.Fork1_FullIn == 1 && vM_SrmRead.SRM_Mode == E_SrmMode.联机.GetIndexInt() && vM_SrmRead.Fork1_State == E_SrmForkState.任务中断.GetIndexInt())
            {
                var tasks = App.taskList.ToList().FindAll(a => a.PalletOrBoxNo == vM_SrmWrite.Fork1_Code);
                if (tasks.Count == 0)
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name},未找到满入托盘号{vM_SrmWrite.Fork1_Code}对应的任务");
                    return BllResult.Error($"{vM_SrmRead.Name},未找到满入托盘号{vM_SrmWrite.Fork1_Code}对应的任务");
                }

                if (tasks.Count != 1)
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name},找到多条满入托盘号{vM_SrmWrite.Fork1_Code}对应的任务");
                    return BllResult.Error($"{vM_SrmRead.Name},找到多条满入托盘号{vM_SrmWrite.Fork1_Code}对应的任务");
                }
                //请求WMS满入仓位
                var fullinexcuteresult = _bll.FullInExcute(tasks[0].tNo_WMS);
                if (!fullinexcuteresult.Success)
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name},满入处理失败：{fullinexcuteresult.Msg}");
                    return BllResult.Error($"{vM_SrmRead.Name},满入处理失败：{fullinexcuteresult.Msg}");
                }
                //成功后重新下发
                var deleteresult = DeleteTask();
                if (!deleteresult.Success)
                {
                    LogExecute.logNet.WriteError($"满入故障处理失败，删除当前堆垛机任务失败");
                    return BllResult.Error($"满入故障处理失败，删除当前堆垛机任务失败");
                }
                Thread.Sleep(500);
                vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.到位置放.GetIndexInt();
                vM_SrmWrite.Fork1_Release_AxisX_NO = fullinexcuteresult.Data.Xpose;
                vM_SrmWrite.Fork1_Release_AxisY_NO = fullinexcuteresult.Data.Ypose;
                vM_SrmWrite.Fork1_Release_AxisZ_NO = fullinexcuteresult.Data.Zpose;

                vM_SrmWrite.SRM_NO = 4;
                vM_SrmWrite.SRM_Axis_NO = E_SrmTaskAction.一号货叉.GetIndexInt();
                vM_SrmWrite.Fork1_Code = tasks[0].PalletOrBoxNo;

                var srmwriteresult = PutWriteAddress();
                if (srmwriteresult.Success)
                {
                    LogExecute.logNet.WriteDebug($"{vM_SrmRead.Name}满入处理成功，重新分配的库位为：{fullinexcuteresult.Data.wcName}");
                    return BllResult.Sucess($"{vM_SrmRead.Name},满入处理成功，重新分配的库位为：{fullinexcuteresult.Data.wcName}");
                }
                else
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name}满入处理：获取新库位后写入PLC失败，请重试");
                    return BllResult.Error($"{vM_SrmRead.Name}满入处理：获取新库位后写入PLC失败，请重试");
                }
            }
            else
            {
                LogExecute.logNet.WriteError($"{vM_SrmRead.Name}满入处理,未存在满入错误或未处于联机状态");
                return BllResult.Error($"{vM_SrmRead.Name}满入处理,未存在满入错误或未处于联机状态");
            }
        }

        /// <summary>
        /// 空出处理
        /// </summary>
        /// <returns></returns>
        public override BllResult EmptyOutExcute()
        {
            if (vM_SrmRead.Fork1_EmptyOut == 1 && vM_SrmRead.SRM_Mode == E_SrmMode.联机.GetIndexInt() && vM_SrmRead.Fork1_State == E_SrmForkState.任务中断.GetIndexInt())
            {
                var tasks = App.taskList.ToList().FindAll(a => a.PalletOrBoxNo == vM_SrmWrite.Fork1_Code);
                if (tasks.Count != 1)
                {
                    //多条任务
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name},找到多条空出托盘号{vM_SrmWrite.Fork1_Code}对应的任务");
                    return BllResult.Error($"{vM_SrmRead.Name},找到多条空出托盘号{vM_SrmWrite.Fork1_Code}对应的任务");
                }
                else
                {
                    var emptyoutresult = _bll.EmptyOutExcute(tasks[0].tNo_WMS);
                    if (!emptyoutresult.Success)
                    {
                        LogExecute.logNet.WriteError($"{vM_SrmRead.Name}空出处理失败,错误原因是：{emptyoutresult.Msg}。");
                        return BllResult.Error($"{vM_SrmRead.Name}空出处理失败，错误原因是：{emptyoutresult.Msg}。");
                    }
                }
                var deleteresult = DeleteTask();
                if (deleteresult.Success)
                {
                    LogExecute.logNet.WriteDebug($"{vM_SrmRead.Name}空出处理成功");
                    return BllResult.Sucess($"{vM_SrmRead.Name},空出处理成功");
                }
                else
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name},空出删除堆垛机任务失败，请重试，错误原因{deleteresult.Msg}.");
                    return BllResult.Error($"{vM_SrmRead.Name},空出删除堆垛机任务失败，请重试，错误原因{deleteresult.Msg}.");
                }
            }
            else
            {
                LogExecute.logNet.WriteError($"{vM_SrmRead.Name}空出处理,未存在空出错误或未出于联机状态");
                return BllResult.Error($"{vM_SrmRead.Name}空出处理,未存在空出错误或未出于联机状态");
            }
        }

        public override BllResult TakeErrorExcute()
        {
            if (vM_SrmRead.Fork1_TakeErr == 1 && vM_SrmRead.SRM_Mode == E_SrmMode.联机.GetIndexInt() && vM_SrmRead.Fork1_State == E_SrmForkState.任务中断.GetIndexInt())
            {
                var tasks = App.taskList.ToList().FindAll(a => a.PalletOrBoxNo == vM_SrmWrite.Fork1_Code);
                if (tasks.Count != 1)
                {
                    //多条任务
                    LogExecute.logNet.WriteError($"找到{vM_SrmRead.Name}多条取货错托盘号{vM_SrmWrite.Fork1_Code}对应的任务.");
                    return BllResult.Error($"找到{vM_SrmRead.Name}多条取货错托盘号{vM_SrmWrite.Fork1_Code}对应的任务.");
                }
                else
                {
                    var takeerrorresult = _bll.TakeErrExcute(tasks[0].tNo_WMS);
                    if (!takeerrorresult.Success)
                    {
                        LogExecute.logNet.WriteError($"{vM_SrmRead.Name}取货错处理失败,错误原因是：{takeerrorresult.Msg}.");
                        return BllResult.Error($"{vM_SrmRead.Name}取货错处理失败,错误原因是{takeerrorresult.Msg}.");
                    }
                }
                var deleteresult = DeleteTask();
                if (deleteresult.Success)
                {
                    LogExecute.logNet.WriteDebug($"{vM_SrmRead.Name}取货错处理成功,托盘号号{vM_SrmWrite.Fork1_Code}.");
                    return BllResult.Sucess($"{vM_SrmRead.Name},取货错处理成功,托盘号{vM_SrmWrite.Fork1_Code}.");
                }
                else
                {
                    LogExecute.logNet.WriteError($"{vM_SrmRead.Name}取货错下发堆垛机任务失败{deleteresult.Msg}.");
                    return BllResult.Error($"{vM_SrmRead.Name}取货错下发堆垛机任务失败，请重试{deleteresult.Msg}.");
                }
            }
            else
            {
                LogExecute.logNet.WriteError($"{vM_SrmRead.Name}未存在取货错错误或未出于联机状态");
                return BllResult.Error($"{vM_SrmRead.Name}未存在取货错错误或未出于联机状态");
            }
        }

        #endregion 特殊故障处理

        /// <summary>
        /// 手动下发设备任务
        /// </summary>
        /// <param name="taskType"></param>
        /// <param name="frompose"></param>
        /// <param name="topose"></param>
        /// <returns></returns>
        public override BllResult HandDeviceTask(int taskType, string frompose, string topose)
        {
            //有无故障
            if (!NoError().Success)
            {
                return BllResult.Error("堆垛机存在故障，无法下发手动任务");
            }

            if (vM_SrmRead.Fork1_State == E_SrmForkState.待机.GetIndexInt())
            {
                if (vM_SrmWrite.SRM_Axis_NO == E_SrmTaskAction.无.GetIndexInt())
                {
                    //堆垛机可以下发手动任务
                    var sendtask_frompose = App.poseList.FirstOrDefault(a => a.wcName == frompose && a.wcRoadWay == device.RoadWay);
                    var sendtask_topose = App.poseList.FirstOrDefault(a => a.wcName == topose && a.wcRoadWay == device.RoadWay);
                    if (sendtask_frompose == null || sendtask_topose == null)
                    {
                        LogExecute.logNet.WriteError($"{vM_SrmRead.Name}下发手动任务失败（找不到坐标）,取货仓位{frompose}，目标仓位{topose}.");
                        return BllResult.Error($"{vM_SrmRead.Name}下发手动任务失败（找不到坐标）,取货仓位{frompose}，目标仓位{topose}.");
                    }
                    vM_SrmWrite.SRM_NO = 4;
                    vM_SrmWrite.SRM_Axis_NO = E_SrmTaskAction.一号货叉.GetIndexInt();
                    vM_SrmWrite.Fork1_Code = "HandTask";
                    if (taskType == E_SrmTaskType.到位置取.GetIndexInt())
                    {
                        //走取
                        vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.到位置取.GetIndexInt();
                        vM_SrmWrite.Fork1_Pick_AxisX_NO = sendtask_frompose.Xpose;
                        vM_SrmWrite.Fork1_Pick_AxisY_NO = sendtask_frompose.Ypose;
                        vM_SrmWrite.Fork1_Pick_AxisZ_NO = sendtask_frompose.Zpose;
                    }
                    else if (taskType == E_SrmTaskType.到位置放.GetIndexInt())
                    {
                        //走放
                        vM_SrmWrite.Fork1TaskType_1 = E_SrmTaskType.到位置放.GetIndexInt();
                        vM_SrmWrite.Fork1_Release_AxisX_NO = sendtask_topose.Xpose;
                        vM_SrmWrite.Fork1_Release_AxisY_NO = sendtask_topose.Ypose;
                        vM_SrmWrite.Fork1_Release_AxisZ_NO = sendtask_topose.Zpose;
                    }
                    else
                    {
                        LogExecute.logNet.WriteError($"{vM_SrmRead.Name}下发手动任务失败，下发的动作非走取或走放.");
                        return BllResult.Error($"{vM_SrmRead.Name}下发手动任务失败，下发的动作非走放或走取走放.");
                    }
                    var finishtask_send = this.PutWriteAddress();
                    if (finishtask_send.Success)
                    {
                        LogExecute.logNet.WriteDebug($"{vM_SrmRead.Name}手动任务成功，取货仓位{frompose}，目标仓位{topose}");
                        return BllResult.Sucess($"{vM_SrmRead.Name}手动任务成功，取货仓位{frompose}，目标仓位{topose}");
                    }
                    else
                    {
                        LogExecute.logNet.WriteError($"{vM_SrmRead.Name}手动任务失败，请重试");
                        return BllResult.Error($"{vM_SrmRead.Name}手动任务失败，请重试");
                    }
                }
            }
            return BllResult.Error("堆垛机当前状态不允许下发手动任务");
        }
    }
}