RCS / RCS_Differential_Slam_Changsha · Files

using RCS.Model.Comm;
using RCS.Model.Entity;
using RCS.Model.PLC;
using RCS.WinClient.Common;
using SqlSugar;
using System.Collections.ObjectModel;
using System.Data;



namespace RCS.WinClient.Service
{
    public class TaskManage
    {
        private static object taskBuildLock = new object();

        /// <summary>
        /// 任务创建
        /// </summary>
        /// <param name="strTaskId">任务ID</param>
        /// <param name="strTaskGroup">任务群组</param>
        /// <param name="strTaskPallet">任务条码</param>
        /// <param name="intTaskLevel">任务等级</param>
        /// <param name="strAgvNo">执行AGV</param>
        /// <param name="startBarcode">起点</param>
        /// <param name="endBarcode">终点</param>
        /// <param name="strTaskNo">任务号</param>
        /// <returns></returns>
        public static BllResult<Base_Task> TaskBuild(string strTaskId, string strTaskGroup, string strTaskPallet, int intTaskLevel, string strAgvNo, string startBarcode, string endBarcode, string strTaskNo, string startStationName, string endStationName)
        {
            lock (taskBuildLock)
            {
                try
                {
                    #region 校验数据、获取任务号
                    Base_Agv agv = null;
                    //Base_Station startStation = null;
                    Base_Station endStation = null;
                    if (!string.IsNullOrEmpty(strTaskNo) && App.TaskList.Any(t => t.TaskNo == strTaskNo))
                    {
                        return BllResult<Base_Task>.Sucess($"已经存在任务");
                    }
                    if (!string.IsNullOrEmpty(strAgvNo))
                    {
                        agv = App.AgvList.FirstOrDefault(x => x.AgvNo == strAgvNo);
                        if (agv != null && agv.AgvTask != null)
                        {
                            var msg = $"AGV【{agv.AgvNo}】已有【{agv.AgvTask.TaskID}】的任务【{agv.AgvTask.TaskNo}】，不能下发【{strTaskId}】任务！";
                            return BllResult<Base_Task>.Error(msg);
                        }
                        var tempTask = App.TaskList.FirstOrDefault(x => x.TaskAgvNo == strAgvNo);
                        if (tempTask != null)
                        {
                            var msg = $"AGV【{agv.AgvNo}】已有【{tempTask.TaskID}】的任务【{tempTask.TaskNo}】，不能下发【{strTaskId}】任务";
                            return BllResult<Base_Task>.Error(msg);
                        }
                    }
                    if (!string.IsNullOrEmpty(startStationName) && !string.IsNullOrEmpty(endStationName))
                    {
                        if (App.TaskList.Any(t => t.Initial == startStationName && t.Target == endStationName))
                        {
                            var msg = $"存在从工位【{startStationName}】到工位【{endStationName}】的任务，请稍后下发";
                            return BllResult<Base_Task>.Error(msg);
                        }
                    }
                    if (strTaskId == EnumMsg.TaskType.取消充电.ToString())
                    {
                        if (string.IsNullOrEmpty(startBarcode) || string.IsNullOrEmpty(endBarcode))
                        {
                            if (agv != null && !string.IsNullOrEmpty(agv.Barcode))
                            {
                                startBarcode = agv.Barcode;
                                endBarcode = agv.Barcode;
                            }
                            else
                            {
                                var msg = $"【取消充电】任务没有起点和终点，AGV也不在点位上，无法下发【取消充电】任务";
                                return BllResult<Base_Task>.Error(msg);
                            }
                        }
                    }

                    var startPoint = App.PointList.FirstOrDefault(t => t.Barcode == startBarcode);
                    var endPoint = App.PointList.FirstOrDefault(t => t.Barcode == endBarcode);
                    if (startPoint == null || endPoint == null)
                    {
                        var msg = "任务起点或是终点未找到!";
                        return BllResult<Base_Task>.Error(msg);
                    }
                    if (!startPoint.IsEnable || !endPoint.IsEnable)
                    {
                        var msg = "任务起点或是终点被禁用!";
                        return BllResult<Base_Task>.Error(msg);
                    }

                    if (strTaskId == EnumMsg.TaskType.充电.ToString() || strTaskId == EnumMsg.TaskType.取消充电.ToString())
                    {
                        if (string.IsNullOrWhiteSpace(endStationName))
                        {
                            endStation = App.StationList.FirstOrDefault(t => t.StationType == EnumMsg.StationType.充电桩 &&
                                                                            (t.Barcode == endBarcode || t.Barcode == endBarcode.Point().Data.PreBarcode));
                        }
                        else
                        {
                            endStation = App.StationList.FirstOrDefault(t => t.Name == endStationName && t.StationType == EnumMsg.StationType.充电桩);
                        }
                        if (endStation == null)
                        {
                            var msg = $"创建【{strTaskId}】任务失败，因为充电桩【{endStationName}】不存在！";
                            App.ExFile.MessageError("TaskBuild", msg);
                            return BllResult<Base_Task>.Error(msg);
                        }
                        endStationName = endStation.Name;
                    }

                    if (string.IsNullOrEmpty(strTaskNo))
                    {
                        var result = ComnMethod.GetTaskNo();
                        if (!result.Success)
                        {
                            return BllResult<Base_Task>.Error($"当前任务号获取失败");
                        }
                        strTaskNo = result.Msg;
                    }

                    if (strTaskId == EnumMsg.TaskType.充电.ToString())
                    {
                        agv.ChooseStation = endStation.Name;
                        endStation.IsLocked = true;
                        var updateAgvResult = UpdateManage.UpdateAgvMsg(agv);
                        var updateAtationResult = UpdateManage.UpdateStation(endStation);
                    }

                    #endregion

                    #region 给Base_Task赋值
                    Base_Task task = new Base_Task();
                    task.TaskNo = strTaskNo;
                    task.TaskID = strTaskId;
                    task.TaskGroup = strTaskGroup;
                    task.TaskLevel = intTaskLevel;
                    task.TaskSplitStep = 1;
                    task.TaskAgvNo = strAgvNo;
                    task.IsSubmit = false;
                    task.TaskPallet = strTaskPallet;

                    //获取任务起点终点站台
                    task.Initial = startStationName;
                    task.Target = endStationName;

                    task.StartPoint = startBarcode.Point().Data;
                    task.EndPoint = endBarcode.Point().Data;
                    task.StartBarcode = startBarcode;
                    task.EndBarcode = endBarcode;

                    task.AcceptTime = DateTime.Now;
                    task.SubTaskList = new ObservableCollection<Base_SubTask>();
                    task.BeginTime = null;
                    task.EndTime = null;
                    task.TaskErrMsg = "";
                    task.Direction = 0;
                    #endregion

                    //更新数据库
                    BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                    var insertresult = _taskDb.Insert(task);
                    if (!insertresult.Success)
                    {
                        var msg = $"创建任务【{task.TaskNo}】时插入数据库失败，原因：{insertresult.Msg}";
                        App.ExFile.MessageError("TaskBuild", msg);
                        return BllResult<Base_Task>.Error(msg);
                    }
                    else
                    {
                        App.AppDispatcher.Invoke(new Action(() =>
                        {
                            App.TaskList.Add(task);
                        }));
                        return BllResult<Base_Task>.Sucess(task, $"创建任务【{task.TaskNo}】成功！");
                    }
                }
                catch (Exception ex)
                {
                    var msg = $"建立任务【{strTaskId}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                    App.ExFile.MessageError("TaskBuild", msg);
                    return BllResult<Base_Task>.Error(msg);
                }
            }
        }

        /// <summary>
        /// 任务删除
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public static BllResult TaskDelete(string taskNo)
        {
            try
            {
                var task = App.TaskList.FirstOrDefault(a => a.TaskNo == taskNo);
                if (task == null)
                {
                    return BllResult.Error($"删除任务【{taskNo}】失败，未查询到对应的任务！");
                }
                return TaskDelete(task);
            }
            catch (Exception ex)
            {
                var msg = $"删除任务【{taskNo}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageError("TaskDelete", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 任务删除
        /// </summary>
        /// <param name="task"></param>
        /// <returns></returns>
        public static BllResult TaskDelete(Base_Task task)
        {
            try
            {
                if (task == null)
                {
                    return BllResult.Error($"删除任务失败，任务不能为空！");
                }
                var subTask = task.SubTaskList.FirstOrDefault();
                var agv = App.AgvList.FirstOrDefault(x => x.AgvNo == task.TaskAgvNo);
                if (subTask != null && agv != null && subTask.SubTaskState == EnumMsg.SubTaskState.已删除 && agv.AgvState == EnumMsg.State.忙碌)
                {
                    return BllResult.Sucess($"删除任务【{task.TaskNo}】成功，标记为已删除，等待AGV不忙碌后执行删除！");
                }
                //if (subTask != null && subTask.SubTaskState >= EnumMsg.SubTaskState.已执行 && subTask.SubTaskType == EnumMsg.AgvTaskType.充电)
                //{
                //    return BllResult.Error($"不能删除任务【{task.TaskNo}】，正在执行充电动作，为了保护充电桩，不允许删除任务！");
                //}

                //如果子任务是行走，并且已经执行，且车正在忙碌中，就不能删除，会让不在点位上停，导致丢位置。要标记为已删除，然后等车停下来，再删除。
                if (subTask != null && subTask.SubTaskState >= EnumMsg.SubTaskState.已执行 && subTask.SubTaskType == EnumMsg.AgvTaskType.行走)
                {
                    if (agv != null && agv.AgvState == EnumMsg.State.忙碌)
                    {
                        subTask.SubTaskState = EnumMsg.SubTaskState.已删除;
                        return BllResult.Sucess($"删除任务【{task.TaskNo}】成功，标记为已删除，等待AGV不忙碌后执行删除！");
                    }
                }

                #region 清除数据库数据
                BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                BaseDal<Base_SubTask> _sonTaskDb = new BaseDal<Base_SubTask>();
                BaseDal<Base_PathPoint> _pathPointDb = new BaseDal<Base_PathPoint>();

                _taskDb.BeginTran();
                BllResult deleteresult1 = BllResult.Sucess();
                BllResult deleteresult2 = BllResult.Sucess();
                if (task.SubTaskList.Count > 0)
                {
                    if (task.SubTaskList[0].PathPointList.Count > 0)
                    {
                        deleteresult1 = _pathPointDb.Delete(it => it.SubTaskNo == task.SubTaskList[0].SubTaskNo);
                    }
                    deleteresult2 = _sonTaskDb.Delete(it => it.TaskNo == task.TaskNo);
                }
                var deleteresult3 = _taskDb.Delete(it => it.TaskNo == task.TaskNo);
                if (deleteresult1.Success && deleteresult2.Success && deleteresult3.Success)
                {
                    _taskDb.CommitTran();
                    task.EndTime = DateTime.Now;
                    task.TaskState = EnumMsg.ErrMsg.手动删除任务.ToString();

                    #region 插入主任务历史记录表
                    try
                    {
                        Log_Task Logtask = new Log_Task();
                        Logtask.ID = task.ID;
                        Logtask.TaskNo = task.TaskNo;
                        Logtask.TaskID = task.TaskID;
                        Logtask.TaskGroup = task.TaskGroup;
                        Logtask.TaskLevel = task.TaskLevel;
                        Logtask.TaskSplitStep = task.TaskSplitStep;
                        Logtask.TaskAgvNo = task.TaskAgvNo;
                        Logtask.IsSubmit = task.IsSubmit;
                        Logtask.TaskPallet = task.TaskPallet;
                        Logtask.Initial = task.Initial;
                        Logtask.Target = task.Target;
                        Logtask.StartPoint = task.StartPoint;
                        Logtask.EndPoint = task.EndPoint;
                        Logtask.StartBarcode = task.StartBarcode;
                        Logtask.EndBarcode = task.EndBarcode;
                        Logtask.AcceptTime = task.AcceptTime;
                        Logtask.BeginTime = task.BeginTime;
                        Logtask.EndTime = DateTime.Now;
                        Logtask.TaskErrMsg = task.TaskErrMsg;
                        Logtask.Direction = task.Direction;
                        Logtask.TaskState = task.TaskState;
                        //更新数据库
                        BaseDal<Log_Task> _logtaskDb = new BaseDal<Log_Task>();
                        var insertresultTask = _logtaskDb.Insert(Logtask);
                    }
                    catch (Exception ex)
                    {
                        var msg = $"插入主任务历史记录表任务完成发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                        App.ExFile.MessageError("subTaskManage", msg);
                    }
                    #endregion
                }
                else
                {
                    _taskDb.RollbackTran();
                    var msg = $"删除任务【{task.TaskNo}】失败，主任务数据库删除失败！删除路径：{deleteresult1.Msg}，删除子任务：{deleteresult2.Msg}，删除主任务：{deleteresult3.Msg}";
                    App.ExFile.MessageError("TaskDelete", msg);
                    return BllResult.Error(msg);
                }
                //if (task.TaskAgvNo != "")    UpdateManage.InsertAgvMilage(task);

                #endregion

                #region 任务手动删除，告知界面完成

                // 删除充电任务的时候，如果AGV匹配了充电桩，要修改站台信息
                if (agv != null && task.TaskID == EnumMsg.TaskType.充电.ToString() && !string.IsNullOrEmpty(agv.ChooseStation))
                {
                    Base_Station station = App.StationList.Find(a => a.Name == agv.ChooseStation);
                    if (station != null)
                    {
                        station.IsLocked = false;
                        UpdateManage.UpdateStation(station);
                    }
                    //取消任务的时候，如果AGV有执行
                    agv.ChooseStation = "";
                    UpdateManage.UpdateAgvMsg(agv);
                }

                App.AppDispatcher.Invoke(new Action(() =>
                {
                    if (agv != null)
                    {
                        if (agv.AgvTask == task)
                        {
                            agv.AgvTask.SubTaskList.Clear();
                            agv.AgvTask = null;
                        }
                        agv.FreeTime = DateTime.Now;
                    }
                    App.TaskList.Remove(task);
                }));

                #endregion 任务手动删除，告知界面完成

                return BllResult.Sucess($"成功删除任务【{task.TaskNo}】！");
            }
            catch (Exception ex)
            {
                var msg = $"删除任务【{task.TaskNo}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageError("TaskDelete", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 任务获取小车
        /// </summary>
        /// <returns></returns>
        public static int AgvGetTask()
        {
            int taskNum = 0;
            try
            {
                if (!App.TaskList.Where(x => !x.IsSubmit).Any())
                {
                    return taskNum;
                }
                //var agv9011 = App.AgvList.FirstOrDefault(x => x.AgvNo == "A33_9011");
                //var agv9010 = App.AgvList.FirstOrDefault(x => x.AgvNo == "A33_9010");

                var agvList = App.AgvList.Where(x => x.IsEnable && x.IsOnline &&
                                                    (x.AgvTask == null ||
                                                     x.AgvTask.TaskID == EnumMsg.TaskType.充电.ToString() ||
                                                     x.AgvTask.TaskID == EnumMsg.TaskType.取消充电.ToString() ||
                                                     x.AgvTask.TaskID == EnumMsg.TaskType.手动行走.ToString()))
                                          .ToList();
                //如果没有可用的小车，就不分解任务。如果没有未下发任务，就不分解任务。
                if (!agvList.Any())
                {
                    //App.ExFile.MessageLog("AgvGetTask", $"有任务，但是车都有任务，9011【{agv9011.IsEnable}】【{agv9011.IsOnline}】在执行【{agv9011.AgvTask?.TaskID}】任务【{agv9011.AgvTask?.TaskNo}】，9010【{agv9010.IsEnable}】【{agv9010.IsOnline}】在执行【{agv9010.AgvTask?.TaskID}】任务【{agv9010.AgvTask?.TaskNo}】，所以都不能接任务");
                    return taskNum;
                }

                //816点位的X负方向是【A33_9002】执行，正方向是【A33_9001】执行
                var middlePoint = App.PointList.FirstOrDefault(t => t.Barcode == "716");

                #region 检查已经分配AGV的任务，如果小车不能用，不在线，就把分配的AGV编码改为空
                for (int index = 0; index < App.TaskList.Count; index++)
                {
                    Base_Task task = App.TaskList[index];
                    if (task.IsSubmit) continue;
                    if (string.IsNullOrEmpty(task.TaskAgvNo)) continue;
                    // 判断配送任务能否执行
                    if (!CheckTask(task)) continue;
                    //如果任务未提交，且已经分配AGV，但是AGV不能使用就删除任务分配的小车
                    Base_Agv agv = App.AgvList.FirstOrDefault(a => a.AgvNo == task.TaskAgvNo);
                    //如果是配送任务未下发，且分配的车不可用，就换车来执行
                    if (!agv.IsEnable || !agv.IsOnline)
                    {
                        continue;
                    }
                    //预分配AGV，这样如果小车在充电，就会自动取消充电
                    task.PredictAgvNo = agv.AgvNo;
                    // 判断AGV能否执行任务
                    if (!CheckAgv(task, agv, middlePoint)) continue;
                    TaskSubmit(task, agv);
                    return taskNum;
                }
                #endregion

                #region 把【未分配AGV、未下发】的任务，分配执行的AGV，修改任务的下发状态改为ture

                //找出【未停止、未提交给AGV、未分配AGV】的主任务，按照优先级排序
                List<Base_Task> tasks = App.TaskList.Where(x => x.TaskState != "Stop" && !x.IsSubmit && string.IsNullOrEmpty(x.TaskAgvNo))
                                                    .OrderByDescending(x => x.TaskLevel)
                                                    .ThenBy(x => x.AcceptTime)
                                                    .ToList();
                for (int index = 0; index < tasks.Count; index++)
                {
                    Base_Task task = tasks[index];
                    // 判断配送任务能否执行
                    if (!CheckTask(task)) continue;

                    Base_Agv agv = null;

                    //如果只有一辆车，这辆车就跑全场
                    if (App.AgvList.Count(t => t.IsEnable) == 1)
                    {
                        agv = agvList.FirstOrDefault();
                    }
                    else
                    {
                        //816点位的X负方向是【A33_9002】执行，正方向是【A33_9001】执行
                        if (task.StartPoint.IntX <= middlePoint.IntX && task.EndPoint.IntX <= middlePoint.IntX)
                        {
                            agv = agvList.FirstOrDefault(t => t.AgvNo == "A33_9002");
                        }
                        else if (task.StartPoint.IntX >= middlePoint.IntX && task.EndPoint.IntX >= middlePoint.IntX)
                        {
                            agv = agvList.FirstOrDefault(t => t.AgvNo == "A33_9001");
                        }
                    }

                    //先分配车，如果满足条件就直接提交，不满足就记录车号
                    if (agv != null)
                    {
                        //给任务预分配AGV，这样如果小车在充电，就会自动取消充电
                        task.PredictAgvNo = agv.AgvNo;
                        // 判断AGV能否执行任务
                        if (!CheckAgv(task, agv, middlePoint)) continue;
                        TaskSubmit(task, agv);
                        return taskNum;
                    }
                }
                #endregion

                return taskNum;
            }
            catch (Exception ex)
            {
                App.ExFile.MessageError("TaskManage", $"任务获取小车发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}");
                return taskNum;
            }
        }

        /// <summary>
        /// 检查任务是否可以执行，不可以就写入错误提示
        /// </summary>
        /// <param name="task">主任务</param>
        /// <param name="agv">分配的AGV</param>
        /// <returns></returns>
        private static bool CheckTask(Base_Task task)
        {
            // 判断取货任务能否执行
            if (task.TaskID == EnumMsg.TaskType.站台取货到料点.ToString())
            {
                var initial = App.EquipmentList.FirstOrDefault(t => t.Name == task.Initial);
                if (initial != null)
                {
                    if (initial.Type == EnumPLC.EquipmentType.HuaHengStation.ToString())
                    {
                        var placeholder = initial[EnumPLC.PLCHuaHengProps.Placeholder.ToString()];
                        if (placeholder != null && placeholder.Value == EnumPLC.PLCBool.False.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Initial}】无货，不能取货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】无货，不能取货！");
                            return false;
                        }
                        var direction = initial[EnumPLC.PLCHuaHengProps.Direction.ToString()];
                        if (direction != null && direction.Value == EnumPLC.PLCBool.False.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Initial}】的货物是送往维修房的，不能取货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】的货物是送往维修房的，不能取货！");
                            return false;
                        }
                    }
                }
            }
            // 判断放货任务能否执行
            if (task.TaskID == EnumMsg.TaskType.料点放货到站台.ToString())
            {
                var target = App.EquipmentList.FirstOrDefault(t => t.Name == task.Target);
                if (target != null)
                {
                    if (target.Type == EnumPLC.EquipmentType.HuaHengStation.ToString())
                    {
                        var placeholder = target[EnumPLC.PLCHuaHengProps.Placeholder.ToString()];
                        if (placeholder != null && placeholder.Value == EnumPLC.PLCBool.True.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Target}】有货，不能放货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Target}】有货，不能放货！");
                            return false;
                        }
                        var acsPlaceholder = target[EnumPLC.ACSHuaHengProps.ACSPlaceholder.ToString()];
                        if (acsPlaceholder != null && acsPlaceholder.Value != EnumPLC.ACSPlaceholder.无预占.GetIndexString())
                        {
                            task.TaskErrMsg = $"站台【{task.Initial}】被预占，不能放货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】被预占，不能放货！");
                            return false;
                        }
                    }
                }
            }
            // 判断配送任务能否执行
            if (task.TaskID == EnumMsg.TaskType.站台到站台配送.ToString())
            {
                var initial = App.EquipmentList.FirstOrDefault(t => t.Name == task.Initial);
                if (initial != null)
                {
                    if (initial.Type == EnumPLC.EquipmentType.HuaHengStation.ToString())
                    {
                        var placeholder = initial[EnumPLC.PLCHuaHengProps.Placeholder.ToString()];
                        if (placeholder != null && placeholder.Value == EnumPLC.PLCBool.False.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Initial}】无货，不能取货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】无货，不能取货！");
                            return false;
                        }
                        var direction = initial[EnumPLC.PLCHuaHengProps.Direction.ToString()];
                        if (direction != null && direction.Value == EnumPLC.PLCBool.False.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Initial}】的货物是送往维修房的，不能取货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】的货物是送往维修房的，不能取货！");
                            return false;
                        }
                    }
                }

                var target = App.EquipmentList.FirstOrDefault(t => t.Name == task.Target);
                if (target != null)
                {
                    if (target.Type == EnumPLC.EquipmentType.HuaHengStation.ToString())
                    {
                        var placeholder = target[EnumPLC.PLCHuaHengProps.Placeholder.ToString()];
                        if (placeholder != null && placeholder.Value == EnumPLC.PLCBool.True.ToString())
                        {
                            task.TaskErrMsg = $"站台【{task.Target}】有货，不能放货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Target}】有货，不能放货！");
                            return false;
                        }
                        var acsPlaceholder = target[EnumPLC.ACSHuaHengProps.ACSPlaceholder.ToString()];
                        if (acsPlaceholder != null && acsPlaceholder.Value != EnumPLC.ACSPlaceholder.无预占.GetIndexString())
                        {
                            task.TaskErrMsg = $"站台【{task.Initial}】被预占，不能放货！";
                            //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，站台【{task.Initial}】被预占，不能放货！");
                            return false;
                        }
                    }
                }
            }
            //同一个站台，如果有多个取货任务，那么需要等前面的取货完成，才能下发后面的         
            var pickTask = App.TaskList.FirstOrDefault(x => x.Initial == task.Initial && x.SubTaskList.Count(y => y.SubTaskType == EnumMsg.AgvTaskType.上升到顶) == 2 &&
                                                           (x.TaskLevel > task.TaskLevel || x.TaskLevel == task.TaskLevel && x.AcceptTime < task.AcceptTime));
            if (pickTask != null)
            {
                task.TaskErrMsg = $"需要等待前面的任务【{pickTask.TaskNo}】先取货！";
                return false;
            }
            //同一个站台，如果有多个放货任务，那么需要等前面的放货完成，才能下发后面的
            var putTask = App.TaskList.FirstOrDefault(x => x.Target == task.Target && x.SubTaskList.Any(y => y.SubTaskType == EnumMsg.AgvTaskType.上升到顶) &&
                                                           (x.TaskLevel > task.TaskLevel || x.TaskLevel == task.TaskLevel && x.AcceptTime < task.AcceptTime));
            if (putTask != null)
            {
                task.TaskErrMsg = $"需要等待前面的任务【{putTask.TaskNo}】先放货！";
                return false;
            }
            ////101立库口点位，9011车的避让点在这里，9010不能过来
            //var point101 = App.PointList.FirstOrDefault(t => t.Barcode == "101");
            ////512站台点位，9011车最远从101跑到512，再继续走到513就会撞到在514避让的9010车
            //var point512 = App.PointList.FirstOrDefault(t => t.Barcode == "512");
            ////任务不能超过两辆车的运行极限
            //if ((task.StartPoint.IntX > point512.IntX && task.EndPoint.IntX <= point101.IntX) ||
            //    (task.EndPoint.IntX > point512.IntX && task.StartPoint.IntX <= point101.IntX))
            //{
            //    task.TaskErrMsg = $"任务超过运行极限，AGV不能从101立库口到512站台之后！";
            //    return false;
            //}
            return true;
        }

        /// <summary>
        /// 检查AGV是否可以执行任务，不可以就写入错误提示
        /// </summary>
        /// <param name="task">新任务</param>
        /// <param name="excutingTask">执行中主任务</param>
        /// <param name="agv">用来执行新任务的AGV</param>
        /// <returns></returns>
        private static bool CheckAgv(Base_Task task, Base_Agv agv, Base_Point middlePoint)
        {
            //还有任务未执行完就不能执行任务
            if (agv.AgvTask != null)
            {
                return false;
            }
            //货叉必须在低位才能执行任务
            if (task.TaskID != EnumMsg.TaskType.手动顶升.ToString() && task.TaskID != EnumMsg.TaskType.手动下降.ToString() && agv.HeightState != EnumMsg.HeightState.低位)
            {
                task.TaskErrMsg = $"AGV顶升不在低位，不能执行任务！";
                return false;
            }
            if (agv.InStock != EnumMsg.InStock.全部无货)
            {
                if (task.EndPoint.PointType == EnumMsg.PointType.充电点 || task.EndPoint.PointType == EnumMsg.PointType.整体旋转点)
                {
                    task.TaskErrMsg = $"AGV有货的时候，不能去充电点、旋转点！";
                    return false;
                }
            }

            // 当电量过低，就只能执行 行走避让 和 充电 任务
            if (task.TaskID != EnumMsg.TaskType.手动行走.ToString() && task.TaskID != EnumMsg.TaskType.充电.ToString() &&
                (agv.Voltage <= App.GetKeyValue("DangerCharge") || agv.power <= App.GetKeyValue("DangerVoltage")))
            {
                task.TaskErrMsg = $"AGV【{agv.AgvTask.TaskNo}】的电量过低，只能执行【充电】和【行走】！";
                return false;
            }
            //有时候会出现并发问题，导致有任务还生成了行走避让，所以AGV不在行走任务的起点，就直接删除行走任务
            if (task.TaskID == EnumMsg.TaskType.手动行走.ToString())
            {
                if (task.StartBarcode != agv.Barcode)
                {
                    TaskDelete(task);
                    return false;
                }
            }
            // 判断取货任务能否执行
            if (task.TaskID == EnumMsg.TaskType.站台取货到料点.ToString() || task.TaskID == EnumMsg.TaskType.站台到站台配送.ToString())
            {
                if (agv.InStock != EnumMsg.InStock.全部无货)
                {
                    task.TaskErrMsg = "执行任务必须要AGV无货！";
                    //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，执行取货任务必须要AGV无货！");
                    return false;
                }
            }
            // 判断放货任务能否执行
            if (task.TaskID == EnumMsg.TaskType.料点放货到站台.ToString())
            {
                if (agv.InStock == EnumMsg.InStock.全部无货)
                {
                    task.TaskErrMsg = "执行任务必须要AGV有货！";
                    //App.ExFile.MessageBusinessErr("AgvGetTask", $"任务【{task.TaskNo}】不能下发，执行放货任务必须要AGV有货！");
                    return false;
                }
            }
            // 充电时候只能下发取消充电任务
            if (agv.AgvState == EnumMsg.State.充电中)
            {
                if (task.TaskID == EnumMsg.TaskType.取消充电.ToString())
                {
                    return true;
                }
                task.TaskErrMsg = "任务不能下发，充电时候只能执行取消充电任务！";
                return false;
            }

            //找另一辆车，如果存在，为了防止撞击，需要在线、在点位上，才能下发当前任务
            if (task.TaskID != EnumMsg.TaskType.手动顶升.ToString() && task.TaskID != EnumMsg.TaskType.手动下降.ToString() && task.TaskID != EnumMsg.TaskType.取消充电.ToString())
            {
                var otherAgv = App.AgvList.FirstOrDefault(x => x.AgvNo != agv.AgvNo);
                if (otherAgv != null && otherAgv.IsEnable)
                {
                    if (!otherAgv.IsOnline)
                    {
                        task.TaskErrMsg = $"AGV【{otherAgv.AgvNo}】状态是存在、离线，防止撞击不能下任务！";
                        return false;
                    }
                    if (string.IsNullOrEmpty(otherAgv.Barcode))
                    {
                        task.TaskErrMsg = $"AGV【{otherAgv.AgvNo}】不在点位上，防止撞击不能下任务！";
                        return false;
                    }
                    if (agv.AgvNo == "A33_9002")
                    {
                        if (task.StartPoint.IntX > middlePoint.IntX || task.EndPoint.IntX > middlePoint.IntX)
                        {
                            task.TaskErrMsg = $"任务不能下发，因为9002运行距离限制！";
                            return false;
                        }
                    }
                    if (agv.AgvNo == "A33_9001")
                    {
                        if (task.StartPoint.IntX < middlePoint.IntX || task.EndPoint.IntX < middlePoint.IntX)
                        {
                            task.TaskErrMsg = "任务不能下发，因为9001运行距离限制！";
                            return false;
                        }
                    }
                }
            }

            return agv.AgvState == EnumMsg.State.自动空闲;
        }

        /// <summary>
        /// 提交任务给AGV，并调用【任务回传】接口向上游系统回传状态
        /// </summary>
        /// <param name="task"></param>
        /// <param name="agv"></param>
        public static void TaskSubmit(Base_Task task, Base_Agv agv)
        {
            try
            {
                //BllResult result = BllResult.Sucess();
                ////维修房站台
                //var repairStation = App.StationList.FirstOrDefault(t => t.Name == "维修房");
                ////如果是要往维修房站台放货，就先写入【请求站台预占】信号
                //if (repairStation != null && task.Target == repairStation.Name)
                //{
                //    task.CommandSending = true;
                //    EquipmentExecutor.Instance.RequestOperator(repairStation.Name, EnumMsg.TaskRequestType.请求站台预占, true);
                //    Thread.Sleep(EquipmentExecutor.Instance.Delay);
                //    result = EquipmentExecutor.Instance.RequestOperator(repairStation.Name, EnumMsg.TaskRequestType.请求站台预占, true);
                //}
                //if (!result.Success)
                //{
                //    task.CommandSending = false;
                //    App.ExFile.MessageBusinessErr($"TaskSubmit", $"任务提交的时候，站台预先占位失败，{result.Msg}");
                //    return;
                //}

                BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                var updateresult = _taskDb.Update(it => it.TaskNo == task.TaskNo, it => new Base_Task()
                {
                    TaskErrMsg = "",
                    IsSubmit = true,
                    TaskAgvNo = agv.AgvNo,
                });
                if (updateresult.Success)
                {
                    //路径创建完成，返回任务执行中
                    task.TaskErrMsg = "";
                    task.IsSubmit = true;
                    task.TaskAgvNo = agv.AgvNo;
                    agv.AgvTask = task;
                }
                //task.CommandSending = false;
            }
            catch (Exception ex)
            {
                //if (task != null) task.CommandSending = false;
                App.ExFile.MessageError($"TaskManage", $"下发任务【{task.TaskNo}】发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}");
            }
        }

        /// <summary>
        /// 任务的分解
        /// </summary>
        public static void TaskSplit()
        {
            List<Base_Task> taskList = App.TaskList
                                          .Where(a => a.IsSubmit && a.BeginTime == null && a.SubTaskList.Count == 0)
                                          .ToList();
            Random random = new Random();
            foreach (Base_Task task in taskList)
            {
                try
                {
                    List<Base_SubTask> sonTaskList = new List<Base_SubTask>();
                    List<Config_TaskSplit> splitList = App.Config_TaskSplitList.FindAll(a => a.TaskID == task.TaskID);
                    int intNum = random.Next(99999);
                    bool flag = false;
                    if (splitList.Count == 0)
                    {
                        flag = true;
                        task.TaskErrMsg = EnumMsg.ErrMsg.分解任务未找到任务ID.ToString();
                    }
                    foreach (Config_TaskSplit config in splitList)
                    {
                        if (config.SerialNo < task.TaskSplitStep) continue;
                        Base_SubTask sonTask = new Base_SubTask();
                        sonTask.SubTaskType = config.AgvTaskType;

                        #region 起点终点确认，如果是特定的点位，需要二次计算起点
                        if (Enum.IsDefined(typeof(EnumMsg.ConfigToFromPoint), config.FromPoint))
                        {
                            if (config.AgvTaskType == EnumMsg.AgvTaskType.充电)
                            {
                                sonTask.StartPoint = task.EndPoint;
                            }
                            else
                            {
                                sonTask.StartPoint = ComnMethod.GetTaskPoint(task, config.FromPoint);
                            }
                        }
                        else
                        {
                            sonTask.StartPoint = App.PointList.Find(a => a.Barcode == config.FromPoint.GetIndexString());
                        }

                        if (Enum.IsDefined(typeof(EnumMsg.ConfigToFromPoint), config.ToPoint))
                        {
                            sonTask.EndPoint = ComnMethod.GetTaskPoint(task, config.ToPoint);
                        }
                        else
                        {
                            sonTask.EndPoint = App.PointList.Find(a => a.Barcode == config.ToPoint.GetIndexString());
                        }

                        #endregion 

                        if (sonTask.StartPoint == null || sonTask.EndPoint == null)
                        {
                            flag = true;
                            task.TaskErrMsg = EnumMsg.ErrMsg.分解任务未找到起点或终点.ToString();
                            break;
                        }

                        //跨区域重新分配起点终点属性
                        List<Base_Point> listPoints = ComnMethod.GetAreaPoint(sonTask.StartPoint, sonTask.EndPoint);
                        if (listPoints == null)
                        {
                            flag = true;
                            task.TaskErrMsg = EnumMsg.ErrMsg.分解任务未找到起点或终点.ToString();
                            break;
                        }

                        sonTask.StartPoint = listPoints.First();
                        sonTask.EndPoint = listPoints.LastOrDefault();
                        sonTask.StartBarcode = listPoints.First().Barcode;
                        sonTask.EndBarcode = listPoints.LastOrDefault().Barcode;

                        if (sonTask.StartPoint.Barcode == sonTask.EndPoint.Barcode && sonTask.SubTaskType == EnumMsg.AgvTaskType.行走 && sonTask.TaskRequestType > EnumMsg.TaskRequestType.任务完成信号)
                        {
                            continue;
                        }

                        sonTask.SerialNo = config.SerialNo;
                        sonTask.SubTaskNo = $"{intNum + config.SerialNo}";
                        sonTask.TaskNo = task.TaskNo;
                        sonTask.WaitTime = config.WaitTime;
                        sonTask.IsCarry = config.IsCarry;
                        sonTask.TaskRequestType = config.TaskRequestType;
                        // 如果子任务是充电、取消充电，那就找到站台，然后任务根据站台的方向、长度来设置子任务的车头方向和充电距离
                        if (sonTask.SubTaskType == EnumMsg.AgvTaskType.充电 || sonTask.SubTaskType == EnumMsg.AgvTaskType.取消充电)
                        {
                            var endSt = App.StationList.Find(a => a.Barcode == sonTask.EndPoint.Barcode && a.StationType == EnumMsg.StationType.充电桩);
                            if (endSt != null)
                            {
                                sonTask.AgvOri = endSt.StationOri;
                                sonTask.ChargeLength = endSt.Length;
                            }
                        }
                        else
                        {
                            sonTask.AgvOri = sonTask.EndPoint.AgvOri;
                        }
                        //如果配送任务，并且是【升降到指定高度】动作，就要找出主任务的站台，然后去找到站台高度，记录到子任务的高度中 
                        if (config.AgvTaskType == EnumMsg.AgvTaskType.升降到指定高度)
                        {
                            var stationTypeList = new EnumMsg.StationType[] { EnumMsg.StationType.工位, EnumMsg.StationType.缓存区,
                                                                              EnumMsg.StationType.上料区, EnumMsg.StationType.接料口 };
                            var stationName = config.FromPoint == EnumMsg.ConfigToFromPoint.任务起点 ? task.Initial : task.Target;
                            var startStation = App.StationList.Find(a => a.Name == stationName && stationTypeList.Contains(a.StationType));
                            if (startStation != null)
                            {
                                sonTask.ChargeLength = startStation.Length;
                            }
                        }
                        sonTask.PathPointList = new List<Base_PathPoint>();
                        sonTask.SubTaskState = EnumMsg.SubTaskState.初始化;
                        sonTask.BeginTime = null;
                        sonTask.EndTime = null;
                        sonTaskList.Add(sonTask);
                    }

                    //如果拆解失败，就跳出拆解下个任务
                    if (flag) continue;

                    BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                    BaseDal<Base_SubTask> _sonTaskDb = new BaseDal<Base_SubTask>();

                    //将拆解的任务插入到子任务表中，并且更新主任务表的开始时间
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        foreach (Base_SubTask getSonTask in sonTaskList)
                        {
                            task.SubTaskList.Add(getSonTask);
                        }
                        task.BeginTime = DateTime.Now;
                    }));

                    //更新数据库
                    _taskDb.BeginTran();
                    var insertresult = _sonTaskDb.Insert(sonTaskList);
                    var updateresult = _taskDb.Update(it => it.TaskNo == task.TaskNo,
                                                      it => new Base_Task()
                                                      {
                                                          BeginTime = task.BeginTime
                                                      });
                    if (insertresult.Success && updateresult.Success)
                    {
                        _taskDb.CommitTran();
                    }
                    else
                    {
                        _taskDb.RollbackTran();
                        App.AppDispatcher.Invoke(new Action(() =>
                        {
                            task.BeginTime = null;
                            task.SubTaskList.Clear();
                        }));
                        var msg = $"拆解任务【{task}】生成子任务的时候，插入数据库失败，插入子任务：{insertresult.Msg}，修改主任务状态： {updateresult.Msg}";
                        App.ExFile.MessageError("TaskSplit", msg);
                    }
                }
                catch (Exception ex)
                {
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        task.BeginTime = null;
                        task.SubTaskList.Clear();
                    }));
                    var msg = $"拆解任务【{task}】生成子任务的时候，发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                    App.ExFile.MessageError("TaskSplit", msg);
                }
            }
        }

        /// <summary>
        /// 为路径被卡住，建立路径失败的子任务，增加一条行走子任务，来避让其他任务。
        /// </summary>
        public static void AvoidSubTask()
        {
            // 建立路径失败的子任务
            var task = App.TaskList.FirstOrDefault(x => x.BeginTime != null && x.SubTaskList.Count > 0 &&
                                                        x.SubTaskList[0].SubTaskState == EnumMsg.SubTaskState.建立路径失败 &&
                                                        x.SubTaskList[0].SubTaskType == EnumMsg.AgvTaskType.行走);
            if (task == null) return;
            var taskAgvNo = App.AgvList.FirstOrDefault(x => x.AgvNo == task.TaskAgvNo);
            if (string.IsNullOrEmpty(taskAgvNo.Barcode))
            {
                return;
            }
            //如果是一个手动行走或是充电任务被阻挡，导致任务建立路径失败，就删除充电任务
            if (task.TaskID == EnumMsg.TaskType.手动行走.ToString() || task.TaskID == EnumMsg.TaskType.充电.ToString())
            {
                TaskDelete(task);
                return;
            }

            // 已经建立路径的子任务
            var taskExecuting = App.TaskList.FirstOrDefault(x => x.BeginTime != null && x.SubTaskList.Count > 0 &&
                                                                 x.SubTaskList[0].SubTaskState >= EnumMsg.SubTaskState.已建立路径 &&
                                                                 x.SubTaskList[0].SubTaskType == EnumMsg.AgvTaskType.行走);
            if (taskExecuting == null) return;
            //如果是一个手动行走或是充电任务阻挡了路径生成，就删除充电任务
            if (taskExecuting.TaskID == EnumMsg.TaskType.手动行走.ToString() || taskExecuting.TaskID == EnumMsg.TaskType.充电.ToString())
            {
                TaskDelete(taskExecuting);
                return;
            }

            var homeBarcode = ComnMethod.GetHomeBarcode(taskExecuting, taskAgvNo);
            if (string.IsNullOrEmpty(homeBarcode) || homeBarcode == taskAgvNo.Barcode)
            {
                return;
            }

            //新建一条避让的子任务
            Base_SubTask newSubTask = new Base_SubTask();
            newSubTask.SubTaskType = EnumMsg.AgvTaskType.行走;
            newSubTask.StartPoint = App.PointList.FirstOrDefault(x => x.Barcode == taskAgvNo.Barcode);
            newSubTask.EndPoint = App.PointList.FirstOrDefault(x => x.Barcode == homeBarcode);
            newSubTask.StartBarcode = newSubTask.StartPoint.Barcode;
            newSubTask.EndBarcode = newSubTask.EndPoint.Barcode;
            newSubTask.SerialNo = 99;
            newSubTask.SubTaskNo = App.AvoidSubTaskNo;
            newSubTask.TaskNo = task.TaskNo;
            newSubTask.WaitTime = 0;
            newSubTask.IsCarry = false;
            newSubTask.TaskRequestType = EnumMsg.TaskRequestType.信号发送完成;
            newSubTask.AgvOri = newSubTask.EndPoint.AgvOri;
            newSubTask.ChargeLength = 0;
            newSubTask.PathPointList = new List<Base_PathPoint>();
            newSubTask.SubTaskState = EnumMsg.SubTaskState.初始化;
            newSubTask.BeginTime = null;
            newSubTask.EndTime = null;

            App.AppDispatcher.Invoke(new Action(() =>
            {
                //将建立路径失败的子任务，修改为初始化
                var subTask = task.SubTaskList[0];
                subTask.SubTaskState = EnumMsg.SubTaskState.初始化;
                subTask.StartPoint = newSubTask.EndPoint;
                subTask.StartBarcode = subTask.StartPoint.Barcode;

                //插入到第一条，用来执行避让，先让开路径，让另外的任务可以继续执行。
                task.SubTaskList.Insert(0, newSubTask);
            }));
        }

        /// <summary>
        /// 子任务任务完成
        /// </summary>
        /// <param name="clientMsg"></param>
        /// <returns></returns>
        public static BllResult SonTaskFinish(Base_Agv agv)
        {
            try
            {
                Base_SubTask sonTask = agv.AgvTask.SubTaskList.First();
                BaseDal<Base_Task> _taskDb = new BaseDal<Base_Task>();
                BaseDal<Base_SubTask> _sonTaskDb = new BaseDal<Base_SubTask>();
                BaseDal<Base_PathPoint> _pathPointDb = new BaseDal<Base_PathPoint>();

                //更新子任务,删除路径
                BllResult deleteresult1 = BllResult.Sucess();
                _sonTaskDb.BeginTran();
                BllResult deleteresult2 = _pathPointDb.Delete(it => it.SubTaskNo == sonTask.SubTaskNo);
                BllResult deleteresult3 = _sonTaskDb.Delete(it => it.SubTaskNo == sonTask.SubTaskNo);
                //如果是最后一条子任务，就把主任务也删除
                if (agv.AgvTask.SubTaskList.Count == 1)
                {
                    deleteresult1 = _taskDb.Delete(it => it.TaskNo == agv.AgvTask.TaskNo);
                }
                if (deleteresult1.Success && deleteresult2.Success && deleteresult3.Success)
                {
                    _sonTaskDb.CommitTran();
                    sonTask.EndTime = DateTime.Now;
                    sonTask.SubTaskState = EnumMsg.SubTaskState.已完成;

                    #region 插入子任务历史记录表
                    try
                    {
                        //新增任务历史表数据的插入
                        BaseDal<Log_SubTask> _logSubTaskDb = new BaseDal<Log_SubTask>();
                        Log_SubTask subTask = new Log_SubTask();

                        subTask.ID = sonTask.ID;
                        subTask.TaskNo = sonTask.TaskNo;
                        subTask.SerialNo = sonTask.SerialNo;
                        subTask.SubTaskNo = sonTask.SubTaskNo;
                        subTask.SubTaskType = sonTask.SubTaskType;
                        subTask.ChargeLength = sonTask.ChargeLength;
                        subTask.WaitTime = sonTask.WaitTime;
                        subTask.IsCarry = sonTask.IsCarry;
                        subTask.TaskRequestType = sonTask.TaskRequestType;
                        subTask.DialOri = sonTask.DialOri;
                        subTask.AgvOri = sonTask.AgvOri;
                        subTask.StartPoint = sonTask.StartPoint;
                        subTask.EndPoint = sonTask.EndPoint;
                        subTask.StartBarcode = sonTask.StartBarcode;
                        subTask.EndBarcode = sonTask.EndBarcode;
                        subTask.BeginTime = sonTask.BeginTime;
                        subTask.EndTime = sonTask.EndTime;
                        subTask.SubTaskState = EnumMsg.SubTaskState.已完成;
                        //更新数据库
                        var insertresultSubTask = _logSubTaskDb.Insert(subTask);
                    }
                    catch (Exception ex)
                    {
                        var msg = $"插入子任务历史记录表任务完成发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                        App.ExFile.MessageError("subTaskManage", msg);
                    }
                    #endregion

                    #region 插入主任务历史记录表
                    if (agv.AgvTask.SubTaskList.Count == 1)
                    {
                        try
                        {
                            Log_Task Logtask = new Log_Task();
                            Logtask.ID = agv.AgvTask.ID;
                            Logtask.TaskNo = agv.AgvTask.TaskNo;
                            Logtask.TaskID = agv.AgvTask.TaskID;
                            Logtask.TaskGroup = agv.AgvTask.TaskGroup;
                            Logtask.TaskLevel = agv.AgvTask.TaskLevel;
                            Logtask.TaskSplitStep = agv.AgvTask.TaskSplitStep;
                            Logtask.TaskAgvNo = agv.AgvTask.TaskAgvNo;
                            Logtask.IsSubmit = agv.AgvTask.IsSubmit;
                            Logtask.TaskPallet = agv.AgvTask.TaskPallet;
                            Logtask.Initial = agv.AgvTask.Initial;
                            Logtask.Target = agv.AgvTask.Target;
                            Logtask.StartPoint = agv.AgvTask.StartPoint;
                            Logtask.EndPoint = agv.AgvTask.EndPoint;
                            Logtask.StartBarcode = agv.AgvTask.StartBarcode;
                            Logtask.EndBarcode = agv.AgvTask.EndBarcode;
                            Logtask.AcceptTime = agv.AgvTask.AcceptTime;
                            Logtask.BeginTime = agv.AgvTask.BeginTime;
                            Logtask.EndTime = DateTime.Now;
                            Logtask.TaskErrMsg = agv.AgvTask.TaskErrMsg;
                            Logtask.Direction = agv.AgvTask.Direction;
                            Logtask.TaskState = "已完成";
                            //更新数据库
                            BaseDal<Log_Task> _logtaskDb = new BaseDal<Log_Task>();
                            var insertresultTask = _logtaskDb.Insert(Logtask);
                        }
                        catch (Exception ex)
                        {
                            var msg = $"插入主任务历史记录表任务完成发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                            App.ExFile.MessageError("subTaskManage", msg);
                        }
                    }

                    #endregion
                }
                else
                {
                    _sonTaskDb.RollbackTran();
                    var msg = $"完成子任务失败，删除任务和路径失败，原因：{deleteresult1.Msg}  {deleteresult2.Msg}  {deleteresult3.Msg}";
                    App.ExFile.MessageError("SonTaskFinish", msg);
                    return BllResult.Error(msg);
                }

                if (agv.AgvTask.SubTaskList.Count == 1)
                {
                    #region 告知WEB界面任务完成

                    //var ToWeb = WebApiClient.ToWebTaskRefresh(task, 99);

                    #endregion 告知WEB界面任务完成

                    //更新任务里程
                    UpdateManage.InsertAgvMilage(agv.AgvTask);
                    //20180925
                    //更新充电记录
                    if (sonTask.SubTaskType == EnumMsg.AgvTaskType.充电 || sonTask.SubTaskType == EnumMsg.AgvTaskType.取消充电)
                    {
                        if (agv.AgvTask.TaskID == "充电")
                        {
                            agv.ChargeTime = DateTime.Now;
                        }
                        agv.StartVoltage = agv.Voltage;
                        //充电任务结束,记录开始充电电量
                        UpdateManage.InsertAgvCharge(agv.AgvTask);
                    }
                    //取消充电后，要解锁充电桩
                    if (sonTask.SubTaskType == EnumMsg.AgvTaskType.取消充电 && !string.IsNullOrEmpty(agv.ChooseStation))
                    {
                        Base_Station station = App.StationList.Find(a => a.Name == agv.ChooseStation);
                        if (station != null)
                        {
                            station.IsLocked = false;
                            UpdateManage.UpdateStation(station);
                        }
                        agv.ChooseStation = "";
                    }
                    //更新界面
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        App.TaskList.Remove(agv.AgvTask);
                        agv.AgvTask.SubTaskList.RemoveAt(0);
                        agv.AgvTask = null;
                        agv.FreeTime = DateTime.Now;
                        //agv.ChooseStation = "";
                        agv.Milage = 0;
                    }));
                    UpdateManage.UpdateAgvMsg(agv);
                }
                else
                {
                    App.AppDispatcher.Invoke(new Action(() =>
                    {
                        agv.AgvTask.SubTaskList.RemoveAt(0);
                    }));
                }
                return BllResult.Sucess();
            }
            catch (Exception ex)
            {
                var msg = $"任务完成发生异常，原因：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageError("TaskManage", msg);
                return BllResult.Error(msg);
            }
        }


        #region 测试任务

        /// <summary>
        /// 循环行走任务
        /// </summary>
        public static void WalkTask()
        {
            try
            {
                foreach (var crcleTask in App.ManualCycleList)
                {
                    string fromBarcode = crcleTask.FromBarcode;
                    string toBarcode = crcleTask.ToBarcode;
                    string strTaskID = crcleTask.TaskType;
                    string agvNo = crcleTask.AgvNo;
                    if (agvNo != string.Empty)
                    {
                        Base_Agv agv = App.AgvList.FirstOrDefault(b => b.AgvNo == agvNo);
                        //if (agv.AgvState != EnumMsg.State.自动空闲) continue;
                        Base_Task fTask = App.TaskList.FirstOrDefault(a => a.IsSubmit && a.TaskAgvNo == agv.AgvNo);
                        #region 注释间隔时间
                        //int intTaskTime = 0;
                        //if (agv.taskTime != DateTime.MinValue)
                        //{
                        //    TimeSpan ts1 = new TimeSpan(agv.taskTime.Ticks);
                        //    TimeSpan ts2 = new TimeSpan(DateTime.Now.Ticks);
                        //    TimeSpan ts3 = ts2.Subtract(ts1).Duration();
                        //    intTaskTime = ts3.Minutes * 60 + ts3.Seconds;
                        //}
                        //if (intTaskTime < App.TaskTime) continue;
                        #endregion

                        if (fTask == null)
                        {
                            if (agv.Barcode == toBarcode)
                            {
                                fromBarcode = toBarcode;
                                toBarcode = fromBarcode;
                            }
                            TaskBuild(strTaskID, "", "", 1, agv.AgvNo, agv.Barcode, toBarcode, "", "", "");
                        }
                    }
                    else
                    {
                        var fTask = App.TaskList.Where(a => a.TaskID == strTaskID).ToList();
                        if (fTask.Count != 0)
                        {
                            if (fTask.Count == 1 && fTask[0].IsSubmit)
                            {
                                //判断当前任务起点和终点
                                fromBarcode = fTask[0].EndBarcode;
                                toBarcode = fTask[0].StartBarcode;
                            }
                            else
                            {
                                continue;
                            }
                        }
                        TaskBuild(strTaskID, "", "", 1, "", fromBarcode, toBarcode, "", "", "");
                    }
                }
            }
            catch (Exception ex)
            {
                ComnMethod.Message(ex.ToString());
            }
        }

        #endregion 测试任务
    }
}