ECS / WCS_LiuzhouZhituo · Files

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HHECS.Bll;
using HHECS.Model;
using HHECS.OPC;
using S7.Net;

namespace HHECS.Common
{
    /// <summary>
    /// todo:湘电单叉双伸位堆垛机处理函数
    /// </summary>
    public class XiangdianStockerExcute : IStockerExcute
    {

        #region 接口实现 

        /// <summary>
        /// 标记这个堆垛机处理类所处理的设备类型
        /// </summary>
        public EquipmentType EquipmentType { get; set; }

        /// <summary>
        /// 标记堆垛机是否可以执行任务
        /// 由于我们是抓一次数据然后处理一次数据
        /// </summary>
        public bool CanExcute { get; set; }

        /// <summary>
        /// 记录堆垛机当前所在的列
        /// </summary>
        public int CurrentColumn { get; private set; }

        public BllResult Excute(List<Equipment> stockers, List<Plc> plcs)
        {
            try
            {
                foreach (var stocker in stockers)
                {
                    //对于每一个堆垛机而言，每一次处理开始都是可执行的
                    //CanExcute = true;
                    //一般根据堆垛机的位置来决定是否执行入库任务 hack:这里默认堆垛机在站台旁时列为0
                    CurrentColumn = int.Parse(stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "CurrentColumn").Value);
                    //if (CurrentColumn == 0)
                    //{
                    //    //先处理入库
                    //    ExcuteTaskIn(stocker, plcs.Find(t => t.IP == stocker.IP));
                    //}
                    ////处理出库
                    //ExcuteTaskOut(stocker, plcs.Find(t => t.IP == stocker.IP));
                    ////先处理入库
                    //ExcuteTaskIn(stocker, plcs.Find(t => t.IP == stocker.IP));
                    ////处理巷道内移库(巷道间的移库交给出库处理，这个处理同巷道内的移库）
                    //ExcuteTaskTransferInRoadway(stocker, plcs.Find(t => t.IP == stocker.IP));
                    ////处理堆垛机任务完成
                    //ExcuteTaskComplete(stocker, plcs.Find(t => t.IP == stocker.IP));
                    ////任务下发错误处理
                    //ExcuteTaskError(stocker, plcs.Find(t => t.IP == stocker.IP));

                    ExcuteSingle(stocker, plcs.Find(t => t.IP == stocker.IP));
                    //心跳
                    Heartbeat(stocker, plcs.Find(t => t.IP == stocker.IP));

                }
                return BllResultFactory.Sucess();
            }
            catch (Exception ex)
            {
                Logger.Log($"堆垛机处理过程中出现异常：{ex.Message}", LogLevel.Exception);
                return BllResultFactory.Error($"堆垛机处理过程中出现异常：{ex.Message}");
            }
        }

        private void Heartbeat(Equipment stocker, Plc plc)
        {
            var prop = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSHeartBeat");
            prop.Value = "1";
            var result = S7Helper.PlcSplitWrite(plc, new List<EquipmentProp>() { prop }, 20);
            if (!result.Success)
            {
                Logger.Log($"发送堆垛机{stocker.Name}心跳数据失败:{result.Msg}", LogLevel.Error);
            }
        }

        /// <summary>
        /// 以堆垛机状态驱动，重写堆垛机控制逻辑
        /// </summary>
        /// <param name="stocker"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ExcuteSingle(Equipment stocker, Plc plc)
        {
            //联机、无故障
            if (Validate(stocker).Success)
            {
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.任务执行中.GetIndexString())
                {
                    //任务执行中就return
                    return BllResultFactory.Sucess();
                }
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.任务中断_出错.GetIndexString())
                {
                    //由人工处理，一般为空出和重入
                    return BllResultFactory.Sucess();
                }
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.下发任务错误.GetIndexString())
                {
                    //由人工处理，需要重新下发任务
                    return BllResultFactory.Sucess();
                }

                #region 任务和货位
                //找出所有未完成的任务
                var tasksResult = AppSession.Bll.GetCommonModelByCondition<TaskEntity>($"where status < {TaskEntityStatus.任务完成}");
                if (!tasksResult.Success)
                {
                    //如果没有找到任务就直接返回
                    return BllResultFactory.Error(tasksResult.Msg);
                }
                //找出同巷道的库位
                var locationsResult = AppSession.Bll.GetAllLocations(null, null, null, null, stocker.RoadWay, null, null);
                if (!locationsResult.Success)
                {
                    return BllResultFactory.Error(locationsResult.Msg);
                }

                var tasks = tasksResult.Data;
                var locations = locationsResult.Data;
                #endregion

                //堆垛机待机情况下
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.待机.GetIndexString())
                {
                    //货叉任务待机时，可执行放和取任务，同时当执行完成时，交互后堆垛机会从任务完成更新为待机
                    if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag").Value == ForkTaskFlag.任务完成.GetIndexString())
                    {
                        return ClearWCSData(stocker, plc);
                    }
                    else if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag").Value == ForkTaskFlag.无任务.GetIndexString())
                    {
                        #region 优先处理重新下发的任务

                        var taskForResend = tasks.FirstOrDefault(t => t.FirstStatus == TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt() && t.LastStatus == TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt() && locations.Count(a => a.Code == t.SourceLocation) > 0 && t.SendAgain == 1);
                        if (taskForResend != null)
                        {
                            var locationForResend = locations.Find(t => t.Code == taskForResend.SourceLocation);
                            return ResendTask(stocker, plc, locationForResend, taskForResend,ForkTaskFlag.库内取货);
                        }

                        taskForResend = tasks.FirstOrDefault(t => t.FirstStatus == TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt() && t.LastStatus == TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt() && locations.Count(a => a.Code == t.DestinationLocation) > 0 && t.SendAgain == 1);
                        if (taskForResend != null)
                        {
                            var locationForResend = locations.Find(t => t.Code == taskForResend.DestinationLocation);
                            return ResendTask(stocker, plc, locationForResend, taskForResend,ForkTaskFlag.库内放货);
                        }

                        taskForResend = tasks.FirstOrDefault(t => t.FirstStatus == TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt() && t.LastStatus == TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt() && locations.Count(a => a.Code == t.DestinationLocation) > 0 && t.SendAgain == 1);
                        if (taskForResend != null)
                        {
                            return ResendTask(stocker, plc, null, taskForResend, ForkTaskFlag.库外入库);
                        }

                        taskForResend = tasks.FirstOrDefault(t => t.FirstStatus == TaskEntityStatus.下发堆垛机库外放货任务.GetIndexInt() && t.LastStatus == TaskEntityStatus.下发堆垛机库外放货任务.GetIndexInt() && locations.Count(a => a.Code == t.SourceLocation) > 0 && t.SendAgain == 1);
                        if (taskForResend != null)
                        {
                            return ResendTask(stocker, plc, null, taskForResend, ForkTaskFlag.库外出库);
                        }

                        #endregion
                        //判断堆垛机货叉上是不是有货，有货就只能接受放货任务，无货就可以接受取货任务
                        if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1ForkHasPallet").Value == "True")
                        {
                            //有货，则查找同巷道的取货任务完成状态的任务，同一个堆垛机，单叉情况下最多一条
                            //先找库内取货完成的任务
                            var task = tasks.FirstOrDefault(t => (t.FirstStatus == TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt() && t.LastStatus == TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt()) && locations.Count(a => a.Code == t.SourceLocation) > 0);
                            if (task == null)
                            {
                                //如果没有就找库外取货完成的任务
                                task = tasks.FirstOrDefault(t => (t.FirstStatus == TaskEntityStatus.响应堆垛机库外取货任务完成.GetIndexInt() && t.LastStatus == TaskEntityStatus.响应堆垛机库外取货任务完成.GetIndexInt()) && locations.Count(a => a.Code == t.DestinationLocation) > 0);
                            }
                            if (task == null)
                            {
                                //如果还是没有找到任务，那就说明的确没有这条任务，或是认为原因导致的，但此时又显示货叉有货，所以这里是有问题的，做个日志
                                Logger.Log($"堆垛机{stocker.Name}显示货叉上有货，但是没有对应的任务", LogLevel.Error);
                                return BllResultFactory.Error();
                            }
                            else
                            {
                                //判断任务类型
                                //巷道内移库
                                if (task.Type == TaskType.移库.GetIndexInt() && locations.Count(t => t.Code == task.DestinationLocation) > 0)
                                {
                                    //下发
                                    task.FirstStatus = TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt();
                                    task.LastStatus = TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt();
                                    var tempResult = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                    if (tempResult.Success)
                                    {
                                        var location = locations.Find(t => t.Code == task.DestinationLocation);
                                        BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库内放货, location.RowIndex.ToString(), location.Line.ToString(), location.Layer.ToString(), "0", task.Id.ToString());
                                        if (sendResult.Success)
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内放货}成功", LogLevel.Success);
                                            return BllResultFactory.Sucess();
                                        }
                                        else
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内放货}失败:{sendResult.Msg};回滚任务{task.Id}状态。", LogLevel.Error);
                                            //回滚任务状态，记录日志
                                            task.FirstStatus = TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt();
                                            task.LastStatus = TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt();
                                            AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                            return BllResultFactory.Error();
                                        }
                                    }
                                    else
                                    {
                                        Logger.Log($"下发堆垛机{stocker.Name}巷道内移库任务时，更新任务{task.Id}状态失败：{tempResult.Msg}", LogLevel.Error);
                                        return BllResultFactory.Error($"下发堆垛机{stocker.Name}巷道内移库任务时，更新任务{task.Id}状态失败：{tempResult.Msg}");
                                    }
                                }
                                else
                                {
                                    //除了巷道内移库之外，就是取货到站台，或从站台取货到库位了
                                    if (task.FirstStatus == TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt())
                                    {
                                        //库内取，那么库外放
                                        task.FirstStatus = TaskEntityStatus.下发堆垛机库外放货任务.GetIndexInt();
                                        task.LastStatus = TaskEntityStatus.下发堆垛机库外放货任务.GetIndexInt();
                                        var tempResult = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                        if (tempResult.Success)
                                        {
                                            BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库外出库, "0", "0", "0", task.Station.ToString(), task.Id.ToString());
                                            if (sendResult.Success)
                                            {
                                                Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库外出库}成功", LogLevel.Success);
                                                return BllResultFactory.Sucess();
                                            }
                                            else
                                            {
                                                Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库外出库}失败:{sendResult.Msg};回滚任务{task.Id}状态。", LogLevel.Error);
                                                //回滚任务状态，记录日志
                                                task.FirstStatus = TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt();
                                                task.LastStatus = TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt();
                                                AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                                return BllResultFactory.Error();
                                            }
                                        }
                                        else
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name}库外放货任务时，更新任务{task.Id}状态失败：{tempResult.Msg}", LogLevel.Error);
                                            return BllResultFactory.Error($"下发堆垛机{stocker.Name}库外放货任务时，更新任务{task.Id}状态失败：{tempResult.Msg}");
                                        }
                                    }
                                    else
                                    {
                                        //库外取，那么库内放
                                        //下发
                                        task.FirstStatus = TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt();
                                        task.LastStatus = TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt();
                                        var tempResult = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                        if (tempResult.Success)
                                        {
                                            var location = locations.Find(t => t.Code == task.DestinationLocation);
                                            BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库内放货, location.RowIndex.ToString(), location.Line.ToString(), location.Layer.ToString(), "0", task.Id.ToString());
                                            if (sendResult.Success)
                                            {
                                                Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内放货}成功", LogLevel.Success);
                                                return BllResultFactory.Sucess();
                                            }
                                            else
                                            {
                                                Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内放货}失败:{sendResult.Msg};回滚任务{task.Id}状态。", LogLevel.Error);
                                                //回滚任务状态，记录日志
                                                task.FirstStatus = TaskEntityStatus.响应堆垛机库外取货任务完成.GetIndexInt();
                                                task.LastStatus = TaskEntityStatus.响应堆垛机库外取货任务完成.GetIndexInt();
                                                AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                                return BllResultFactory.Error();
                                            }
                                        }
                                        else
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name}库内放货时，更新任务{task.Id}状态失败：{tempResult.Msg}", LogLevel.Error);
                                            return BllResultFactory.Error($"下发堆垛机{stocker.Name}库内放货时，更新任务{task.Id}状态失败：{tempResult.Msg}");
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            //无货,说明完全处在空闲状态
                            //判断任务限制情况
                            var tempTasks = tasks;
                            //hack：关于拣选的限制暂时没有做
                            if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "TaskLimit").Value == TaskLimit.限制出库.GetIndexString())
                            {
                                //限制出库，则不能执行下发状态的出库性质任务
                                var temp = tasks.Where(t => t.FirstStatus == TaskEntityStatus.下发任务.GetIndexInt() && t.LastStatus == TaskEntityStatus.下发任务.GetIndexInt()).Where(t => t.Type != TaskType.整盘入库.GetIndexInt() && t.Type != TaskType.空容器入库.GetIndexInt()).ToList();
                                tempTasks = tasks.Where(t => temp.Count(a => a.Id == t.Id) == 0).ToList();
                            }
                            else if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "TaskLimit").Value == TaskLimit.限制入库.GetIndexString())
                            {
                                //限制入库，则不能响应待入状态的入库性质任务
                                tempTasks = tasks.Where(t => t.FirstStatus != TaskEntityStatus.响应接入口位置到达.GetIndexInt() && t.LastStatus != TaskEntityStatus.响应接入口位置到达.GetIndexInt()).ToList();
                            }
                            if (tempTasks.Count == 0)
                            {
                                return BllResultFactory.Error();
                            }
                            else
                            {
                                //判断堆垛机的位置
                                TaskEntity task = null;
                                if (CurrentColumn == 0)
                                {
                                    //先入库
                                    //同巷道内的入库
                                    if (ExcuteIn(tempTasks, locations, stocker, plc).Success)
                                    {
                                        return BllResultFactory.Sucess();
                                    }
                                }

                                //出库性质的取货
                                ///获取同巷道的离堆垛机优先级最高且最近的一条任务
                                task = tasks.Where(t => locations.Count(a => a.Code == t.SourceLocation) > 0 && t.LastStatus == TaskEntityStatus.下发任务.GetIndexInt() && t.FirstStatus == TaskEntityStatus.下发任务.GetIndexInt() && (t.Type != TaskType.整盘入库.GetIndexInt() && t.Type != TaskType.空容器入库.GetIndexInt())).OrderByDescending(t => t.Priority).ThenBy(t => Math.Abs(locationsResult.Data.First(a => a.Code == t.SourceLocation).Line - CurrentColumn)).FirstOrDefault();
                                if (task != null)
                                {
                                    //先更改任务状态
                                    task.FirstStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                                    task.LastStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                                    var tempResult = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                    if (tempResult.Success)
                                    {
                                        var location = locationsResult.Data.Find(t => t.Code == task.SourceLocation);
                                        BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库内取货, location.RowIndex.ToString(), location.Line.ToString(), location.Layer.ToString(), task.Station.ToString(), task.Id.ToString());
                                        if (sendResult.Success)
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内取货}成功,出库口:{task.Station}", LogLevel.Info);
                                            return BllResultFactory.Sucess();
                                        }
                                        else
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内取货}失败:{sendResult.Msg};回滚任务{task.Id}状态。", LogLevel.Error);
                                            task.FirstStatus = TaskEntityStatus.下发任务.GetIndexInt();
                                            task.LastStatus = TaskEntityStatus.下发任务.GetIndexInt();
                                            AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                            return BllResultFactory.Error();
                                        }
                                    }
                                    else
                                    {
                                        Logger.Log($"下发堆垛机{stocker.Name}库内取货时，更新任务{task.Id}状态失败：{tempResult.Msg}", LogLevel.Error);
                                        return BllResultFactory.Error($"下发堆垛机{stocker.Name}库内取货时，更新任务{task.Id}状态失败：{tempResult.Msg}");
                                    }
                                }

                                //再库外取货
                                if (ExcuteIn(tempTasks, locations, stocker, plc).Success)
                                {
                                    return BllResultFactory.Sucess();
                                }

                            }
                        }
                    }
                    else if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag").Value == ForkTaskFlag.删除任务.GetIndexString())
                    {
                        return ClearWCSData(stocker, plc);
                    }
                    else
                    {
                        //hack:其他情况1-库内取货，2-库内放货，3-库外入库，4库外出库， 5重新分配入库地址,暂时不做处理，这里也应不需要处理这些情况

                    }
                }
                else if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.任务完成.GetIndexString())
                {
                    //todo:响应任务完成
                    //一共4种完成情况
                    //库内取货完成
                    var task = tasks.FirstOrDefault(t => t.LastStatus == TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt() && t.FirstStatus == TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt() && locations.Count(a => a.Code == t.SourceLocation) > 0);
                    if (task != null)
                    {
                        //更新任务状态
                        task.FirstStatus = TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt();
                        task.LastStatus = TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt();
                        var tempResult = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                        if (tempResult.Success)
                        {
                            //标记交换区地址，任务完成10
                            var prop = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag");
                            prop.Value = "10";
                            var sendResult = S7Helper.PlcSplitWrite(plc, new List<EquipmentProp> { prop }, 20);
                            if (sendResult.Success)
                            {
                                Logger.Log($"堆垛机{stocker.Name}完成库内取货成功，任务:{task.Id}", LogLevel.Success);
                                return BllResultFactory.Sucess();
                            }
                            else
                            {
                                Logger.Log($"堆垛机{stocker.Name}完成库内取货失败，任务:{task.Id}，原因：{sendResult.Msg}", LogLevel.Error);
                                task.FirstStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                                task.LastStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                                AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                return BllResultFactory.Error();
                            }
                        }
                        else
                        {
                            Logger.Log($"完成堆垛机{stocker.Name}库内取货时，更新任务{task.Id}状态失败：{tempResult.Msg}", LogLevel.Error);
                            return BllResultFactory.Error($"完成堆垛机{stocker.Name}库内取货时，更新任务{task.Id}状态失败：{tempResult.Msg}");
                        }
                    }
                    //库内放货完成
                    task = tasks.FirstOrDefault(t => t.LastStatus == TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt() && t.FirstStatus == TaskEntityStatus.下发堆垛机库内放货任务.GetIndexInt() && locations.Count(a => a.Code == t.SourceLocation) > 0);
                    if (task != null)
                    {
                        //调用WMS任务完成接口
                        var tempResult = AppSession.Bll.CompleteTask(task.Id.ToString());
                        if (tempResult.Success)
                        {
                            //标记交换区地址，任务完成10
                            var prop = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag");
                            prop.Value = "10";
                            var sendResult = S7Helper.PlcSplitWrite(plc, new List<EquipmentProp> { prop }, 20);
                            if (sendResult.Success)
                            {
                                Logger.Log($"堆垛机{stocker.Name}完成库内放货成功，任务:{task.Id}", LogLevel.Success);
                                return BllResultFactory.Sucess();
                            }
                            else
                            {
                                //hack:这里如果更新PLC地址失败，WMS端并不会回滚，此时应考虑如何人工处理；
                                Logger.Log($"堆垛机{stocker.Name}完成库内放货失败，任务:{task.Id}，原因：{sendResult.Msg}", LogLevel.Error);
                                return BllResultFactory.Error();
                            }
                        }
                        else
                        {
                            Logger.Log($"完成堆垛机{stocker.Name}库内放货失败，任务{task.Id}请求WMS接口失败：{tempResult.Msg}", LogLevel.Error);
                            return BllResultFactory.Error($"完成堆垛机{stocker.Name}库内放货失败，任务{task.Id}请求WMS接口失败：{tempResult.Msg}");
                        }
                    }
                    //库外取货完成时
                    task = tasks.FirstOrDefault(t => t.LastStatus == TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt() && t.FirstStatus == TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt() && locations.Count(a => a.Code == t.SourceLocation) > 0);
                    if (task != null)
                    {
                        //更新任务状态
                        task.FirstStatus = TaskEntityStatus.响应堆垛机库外取货任务完成.GetIndexInt();
                        task.LastStatus = TaskEntityStatus.响应堆垛机库外取货任务完成.GetIndexInt();
                        var tempResult = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                        if (tempResult.Success)
                        {
                            //标记交换区地址，任务完成10
                            var prop = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag");
                            prop.Value = "10";
                            var sendResult = S7Helper.PlcSplitWrite(plc, new List<EquipmentProp> { prop }, 20);
                            if (sendResult.Success)
                            {
                                Logger.Log($"堆垛机{stocker.Name}完成库外取货成功，任务:{task.Id}", LogLevel.Success);
                                return BllResultFactory.Sucess();
                            }
                            else
                            {
                                Logger.Log($"堆垛机{stocker.Name}完成库外取货失败，任务:{task.Id}，原因：{sendResult.Msg}", LogLevel.Error);
                                task.FirstStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                task.LastStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                return BllResultFactory.Error();
                            }
                        }
                        else
                        {
                            Logger.Log($"完成堆垛机{stocker.Name}库外取货时，更新任务{task.Id}状态失败：{tempResult.Msg}", LogLevel.Error);
                            return BllResultFactory.Error($"完成堆垛机{stocker.Name}库外取货时，更新任务{task.Id}状态失败：{tempResult.Msg}");
                        }
                    }
                    //库外放货完成时
                    task = tasks.FirstOrDefault(t => t.LastStatus == TaskEntityStatus.下发堆垛机库外放货任务.GetIndexInt() && t.FirstStatus == TaskEntityStatus.下发堆垛机库外放货任务.GetIndexInt() && locations.Count(a => a.Code == t.SourceLocation) > 0);
                    if (task != null)
                    {
                        //更新任务状态
                        task.FirstStatus = TaskEntityStatus.响应堆垛机库外放货任务完成.GetIndexInt();
                        task.LastStatus = TaskEntityStatus.响应堆垛机库外放货任务完成.GetIndexInt();
                        var tempResult = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                        if (tempResult.Success)
                        {
                            //标记交换区地址，任务完成10
                            var prop = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag");
                            prop.Value = "10";
                            var sendResult = S7Helper.PlcSplitWrite(plc, new List<EquipmentProp> { prop }, 20);
                            if (sendResult.Success)
                            {
                                Logger.Log($"堆垛机{stocker.Name}完成库外放货成功，任务:{task.Id}", LogLevel.Success);
                                return BllResultFactory.Sucess();
                            }
                            else
                            {
                                Logger.Log($"堆垛机{stocker.Name}完成库外放货失败，任务:{task.Id}，原因：{sendResult.Msg}", LogLevel.Error);
                                task.FirstStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                task.LastStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                return BllResultFactory.Error();
                            }
                        }
                        else
                        {
                            Logger.Log($"完成堆垛机{stocker.Name}库外放货时，更新任务{task.Id}状态失败：{tempResult.Msg}", LogLevel.Error);
                            return BllResultFactory.Error($"完成堆垛机{stocker.Name}库外放货时，更新任务{task.Id}状态失败：{tempResult.Msg}");
                        }
                    }
                }
                else
                {
                    //未知情况
                    Logger.Log($"堆垛机{stocker.Name}出现了未知的执行状态：{stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value}", LogLevel.Warning);
                    return BllResultFactory.Sucess();
                }
            }
            return BllResultFactory.Sucess();
        }

        private BllResult ResendTask(Equipment stocker, Plc plc, Location locationForResend, TaskEntity taskForResend,ForkTaskFlag forkTaskFlag)
        {
            BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, forkTaskFlag, locationForResend == null?"0":locationForResend.RowIndex.ToString(), locationForResend==null?"0":locationForResend.Line.ToString(), locationForResend==null?"0":locationForResend.Layer.ToString(), taskForResend.Station.ToString(), taskForResend.Id.ToString());
            if (sendResult.Success)
            {
                taskForResend.SendAgain = 2;
                AppSession.Bll.UpdateCommonModel<TaskEntity>(taskForResend);
                Logger.Log($"重新下发堆垛机{stocker.Name},任务：{taskForResend.Id},任务类型：{taskForResend.Type},货叉类型：{forkTaskFlag}成功,出库口:{taskForResend.Station}", LogLevel.Info);
                return BllResultFactory.Sucess();
            }
            else
            {
                Logger.Log($"重新下发堆垛机{stocker.Name},任务：{taskForResend.Id},任务类型：{taskForResend.Type},货叉类型：{forkTaskFlag}失败:{sendResult.Msg};", LogLevel.Error);
                return BllResultFactory.Error();
            }
        }

        private BllResult ClearWCSData(Equipment stocker, Plc plc)
        {
            //表示堆垛机已经收到WCS发送给他的任务完成信号，此时WCS可以清除自己的交换区地址
            BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.无, ForkTaskFlag.无任务, "0", "0", "0", "0", "0");
            if (sendResult.Success)
            {
                Logger.Log($"任务完成后，清除堆垛机{stocker.Name}交换区地址成功", LogLevel.Info);
                return BllResultFactory.Sucess();
            }
            else
            {
                Logger.Log($"任务完成后，清除堆垛机{stocker.Name}交换区地址失败", LogLevel.Error);
                return BllResultFactory.Error();
            }
        }

        /// <summary>
        /// 通用条件验证
        /// </summary>
        /// <param name="stocker"></param>
        /// <returns></returns>
        private BllResult Validate(Equipment stocker)
        {
            //联机，无故障
            if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "OperationModel").Value == OperationModel.联机.GetIndexString() && stocker.EquipmentProps.Where(t => t.EquipmentTypePropTemplate.IsMonitor == true).Count(t => t.Value != t.EquipmentTypePropTemplate.MonitorCompareValue) == 0)
            {
                return BllResultFactory.Sucess();
            }
            else
            {
                return BllResultFactory.Error();
            }
        }

        /// <summary>
        /// 重写库外取货逻辑
        /// </summary>
        public BllResult ExcuteIn(List<TaskEntity> tempTasks, List<Location> locations, Equipment stocker, Plc plc)
        {
            var task = tempTasks.FirstOrDefault(t => t.FirstStatus == TaskEntityStatus.响应接入口位置到达.GetIndexInt() && t.LastStatus == TaskEntityStatus.响应接入口位置到达.GetIndexInt() && locations.Count(a => a.Code == t.DestinationLocation) > 0);
            if (task != null)
            {
                //下发堆垛机入库任务
                task.FirstStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                task.LastStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                var temp = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                if (temp.Success)
                {
                    var location = locations.Find(t => t.Code == task.DestinationLocation);
                    BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库外入库, "0", "0", "0", task.Station.ToString(), task.Id.ToString());
                    if (sendResult.Success)
                    {
                        Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库外入库}成功", LogLevel.Success);
                        return BllResultFactory.Sucess();
                    }
                    else
                    {
                        Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库外入库}失败:{sendResult.Msg};回滚任务{task.Id}状态。", LogLevel.Error);
                        //回滚任务状态，记录日志
                        task.FirstStatus = TaskEntityStatus.响应接入口位置到达.GetIndexInt();
                        task.LastStatus = TaskEntityStatus.响应接入口位置到达.GetIndexInt();
                        AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                        return BllResultFactory.Error();
                    }
                }
                else
                {
                    Logger.Log($"下发堆垛机{stocker.Name}库外取货时，更新任务{task.Id}状态失败：{temp.Msg}", LogLevel.Error);
                    return BllResultFactory.Error($"下发堆垛机{stocker.Name}库外取货时，更新任务{task.Id}状态失败：{temp.Msg}");
                }
            }
            return BllResultFactory.Error();
        }

        public BllResult ExcuteTaskError(Equipment stocker, Plc plc)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// 堆垛机任务完成，这里任务号由软件来记
        /// </summary>
        /// <param name="stocker"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ExcuteTaskComplete(Equipment stocker, Plc plc)
        {
            if (ValidateStockerForCompleteTask(stocker).Success && CanExcute)
            {
                //获取堆垛机正在执行的这条任务
                var tasksResult = AppSession.Bll.GetCommonModelByCondition<TaskEntity>($"where status > {(int)TaskEntityStatus.下发任务} and status<{(int)TaskEntityStatus.任务完成}");
                if (tasksResult.Success)
                {
                    var tasks = tasksResult.Data;
                    var locationsResult = AppSession.Bll.GetAllLocations(null, null, null, null, stocker.RoadWay, null, null);
                    if (locationsResult.Success)
                    {
                        var locations = locationsResult.Data;
                        //一共4种完成情况
                        //库内取货完成
                        var task = tasks.FirstOrDefault(t => t.LastStatus == TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt() && t.FirstStatus == TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt() && locations.Count(a => a.Code == t.SourceLocation) > 0);
                        if (task != null)
                        {
                            //判断是否巷道内移库
                            if (task.Type == TaskType.移库.GetIndexInt() && locations.Count(t => t.Code == task.DestinationLocation) > 0)
                            {
                                //下发移库任务
                                var location = locations.First(t => t.Code == task.DestinationLocation);

                            }
                            else
                            {
                                //如果不是巷道内的移库，那么就全是出库性质任务

                            }
                        }

                    }
                }

            }
            return BllResultFactory.Sucess();
        }

        public BllResult ExcuteTaskIn(Equipment stocker, Plc plc)
        {
            try
            {
                //校验入库条件
                if (ValidateStockerIn(stocker).Success && CanExcute)
                {
                    //找出入库状态的任务
                    var tasksResult = AppSession.Bll.GetCommonModelByCondition<TaskEntity>($"where status = {(int)TaskEntityStatus.响应接入口位置到达}");
                    if (tasksResult.Success)
                    {
                        //过滤一次任务类型
                        var tasks = tasksResult.Data.Where(t => t.Type != TaskType.整盘出库.GetIndexInt() && t.Type != TaskType.空容器出库.GetIndexInt()).ToList();
                        if (tasks.Count > 0)
                        {
                            //找出同巷道的任务
                            var locationsResult = AppSession.Bll.GetAllLocations(null, null, null, null, stocker.RoadWay, null, null);
                            if (locationsResult.Success)
                            {
                                var task = tasks.FirstOrDefault(t => locationsResult.Data.Count(a => a.Code == t.DestinationLocation) > 0);
                                if (task != null)
                                {
                                    //更改任务状态
                                    task.FirstStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                    task.LastStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                    var temp = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                    if (temp.Success)
                                    {
                                        //说明找到了则下发
                                        var location = locationsResult.Data.Find(t => t.Code == task.DestinationLocation);
                                        BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库外入库, "0", "0", "0", task.Station.ToString(), task.Id.ToString());
                                        if (sendResult.Success)
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库外入库}成功,入库口:{task.Station}", LogLevel.Info);
                                            //手动标记堆垛机为不可执行，以免被再次响应
                                            CanExcute = false;
                                        }
                                        else
                                        {
                                            //回滚任务状态，记录日志
                                            task.FirstStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                            task.LastStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
                                            AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                            Logger.Log($"ExcuteTaskIn回滚任务{task.Id}状态", LogLevel.Info);
                                        }
                                    }
                                    else
                                    {
                                        Logger.Log($"ExcuteTaskIn更新任务{task.Id}状态失败：{temp.Msg}", LogLevel.Error);
                                        return BllResultFactory.Error($"ExcuteTaskIn更新任务{task.Id}状态失败：{temp.Msg}");
                                    }
                                }
                            }
                        }
                    }
                }
                return BllResultFactory.Sucess();
            }
            catch (Exception ex)
            {
                Logger.Log($"堆垛机{stocker.Name}处理[入库任务]过程中出现异常：{ex.Message}", LogLevel.Exception);
                return BllResultFactory.Error($"堆垛机{stocker.Name}处理[入库任务]过程中出现异常：{ex.Message}");
            }
        }

        public BllResult SendTaskToStocker(Equipment stocker, Plc plc, ForkAction forkAction, ForkTaskFlag forkTaskFlag, string forkRow, string forkColumn, string forkLayer, string forkStation, string taskNo)
        {
            try
            {
                List<EquipmentProp> propsToWriter = new List<EquipmentProp>();
                var props = stocker.EquipmentProps;
                var action = props.Find(t => t.EquipmentTypePropTemplateCode == "WCSForkAction");
                action.Value = forkAction.GetIndexString();
                var taskFlag = props.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag");
                taskFlag.Value = forkTaskFlag.GetIndexString();
                var row = props.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1Row");
                row.Value = forkRow;
                var column = props.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1Column");
                column.Value = forkColumn;
                var layer = props.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1Layer");
                layer.Value = forkLayer;
                var station = props.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1Station");
                station.Value = forkStation;
                var task = props.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1Task");
                task.Value = taskNo;
                propsToWriter.AddRange(new List<EquipmentProp>() { action, taskFlag, row, column, layer, station, task });
                return S7Helper.PlcSplitWrite(plc, propsToWriter, 20);
            }
            catch (Exception ex)
            {
                return BllResultFactory.Error($"下发任务出现异常:{ex.Message}");
            }
        }

        public BllResult ExcuteTaskOut(Equipment stocker, Plc plc)
        {
            if (ValidateStockerOut(stocker).Success && CanExcute)
            {
                //找寻下发状态的任务
                var tasksResult = AppSession.Bll.GetCommonModelByCondition<TaskEntity>($"where status = {(int)TaskEntityStatus.下发任务}");
                if (tasksResult.Success)
                {
                    //找寻出库任务
                    var tasks = tasksResult.Data.Where(t => t.Type != TaskType.整盘入库.GetIndexInt() && t.Type != TaskType.空容器入库.GetIndexInt()).ToList();
                    if (tasks.Count > 0)
                    {
                        //找出同巷道的任务
                        var locationsResult = AppSession.Bll.GetAllLocations(null, null, null, null, stocker.RoadWay, null, null);
                        if (locationsResult.Success)
                        {
                            ///获取同巷道的离堆垛机优先级最高且最近的一条任务
                            var task = tasks.Where(t => locationsResult.Data.Count(a => a.Code == t.SourceLocation) > 0).OrderByDescending(t => t.Priority).ThenBy(t => Math.Abs(locationsResult.Data.First(a => a.Code == t.SourceLocation).Line - CurrentColumn)).First();
                            if (task != null)
                            {
                                //先更改任务状态
                                task.FirstStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                                task.LastStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                                var temp = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                if (temp.Success)
                                {
                                    var location = locationsResult.Data.Find(t => t.Code == task.SourceLocation);
                                    BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库内取货, location.RowIndex.ToString(), location.Line.ToString(), location.Layer.ToString(), task.Station.ToString(), task.Id.ToString());
                                    if (sendResult.Success)
                                    {
                                        Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内取货}成功,出库口:{task.Station}", LogLevel.Info);
                                        //手动标记堆垛机为不可执行，以免被再次响应
                                        CanExcute = false;
                                    }
                                    else
                                    {
                                        task.FirstStatus = TaskEntityStatus.下发任务.GetIndexInt();
                                        task.LastStatus = TaskEntityStatus.下发任务.GetIndexInt();
                                        AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                        Logger.Log($"ExcuteTaskOut回滚任务{task.Id}状态", LogLevel.Info);
                                    }
                                }
                                else
                                {
                                    Logger.Log($"ExcuteTaskOut更新任务{task.Id}状态失败：{temp.Msg}", LogLevel.Error);
                                    return BllResultFactory.Error($"ExcuteTaskOut更新任务{task.Id}状态失败：{temp.Msg}");
                                }
                            }
                        }
                    }
                }
            }
            return BllResultFactory.Sucess();
        }

        /// <summary>
        /// 这里写个示例，判断一下同巷道内任务
        /// </summary>
        /// <param name="stocker"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ExcuteTaskTransferInRoadway(Equipment stocker, Plc plc)
        {
            if (ValidateStockerTransferInRoadway(stocker).Success && CanExcute)
            {
                //找寻下发状态的任务
                var tasksResult = AppSession.Bll.GetCommonModelByCondition<TaskEntity>($"where status = {(int)TaskEntityStatus.下发任务} and type = {TaskType.移库.GetIndexInt()}");
                if (tasksResult.Success)
                {
                    //找寻同巷道移库任务
                    var locationsResult = AppSession.Bll.GetAllLocations(null, null, null, null, stocker.RoadWay, null, null);
                    if (locationsResult.Success)
                    {
                        var task = tasksResult.Data.Where(t => locationsResult.Data.Count(a => a.Code == t.SourceLocation) > 0 && locationsResult.Data.Count(a => a.Code == t.DestinationLocation) > 0).OrderByDescending(t => t.Priority).ThenBy(t => Math.Abs(locationsResult.Data.First(a => a.Code == t.SourceLocation).Line - CurrentColumn)).First();
                        if (task != null)
                        {
                            //有则下发
                            //先更改任务状态
                            task.FirstStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                            task.LastStatus = TaskEntityStatus.下发堆垛机库内取货任务.GetIndexInt();
                            var temp = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                            if (temp.Success)
                            {
                                var location = locationsResult.Data.Find(t => t.Code == task.SourceLocation);
                                BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库内取货, location.RowIndex.ToString(), location.Line.ToString(), location.Layer.ToString(), task.Station.ToString(), task.Id.ToString());
                                if (sendResult.Success)
                                {
                                    Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内取货}成功", LogLevel.Info);
                                    //手动标记堆垛机为不可执行，以免被再次响应
                                    CanExcute = false;
                                }
                                else
                                {
                                    task.FirstStatus = TaskEntityStatus.下发任务.GetIndexInt();
                                    task.LastStatus = TaskEntityStatus.下发任务.GetIndexInt();
                                    AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
                                    Logger.Log($"ExcuteTaskOut回滚任务{task.Id}状态", LogLevel.Info);
                                }
                            }
                            else
                            {
                                Logger.Log($"ExcuteTaskTransferInRoadway更新任务{task.Id}状态失败：{temp.Msg}", LogLevel.Error);
                                return BllResultFactory.Error($"ExcuteTaskTransferInRoadway更新任务{task.Id}状态失败：{temp.Msg}");
                            }
                        }
                    }
                }
            }
            return BllResultFactory.Sucess();
        }

        /// <summary>
        /// 堆垛机任务完成条件
        /// </summary>
        /// <param name="stocker"></param>
        /// <returns></returns>
        public BllResult ValidateStockerForCompleteTask(Equipment stocker)
        {
            try
            {
                //1.联机
                //2.货叉有货
                //3.任务执行状态为任务完成
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "OperationModel").Value == OperationModel.联机.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1ForkHasPallet").Value == "True" && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.任务完成.GetIndexString())
                {
                    return BllResultFactory.Sucess();
                }
                else
                {
                    return BllResultFactory.Error();
                }
            }
            catch (Exception ex)
            {
                Logger.Log($"校验堆垛机{stocker.Name}任务完成条件异常：{ex.Message}", LogLevel.Exception, ex);
                return BllResultFactory.Error($"校验堆垛机{stocker.Name}任务完成条件异常：{ex.Message}");
            }
        }

        public BllResult ValidateStockerIn(Equipment stocker)
        {
            try
            {
                //判断条件，这里没有判断货叉故障和堆垛机故障，这特么怎么判断，这么多字段
                //1.操作模式 = 5  联机；
                //2.双货叉原位，任务货叉上无货；
                //3.任务货叉无故障无任务；
                //4.堆垛机无故障
                //5.对应货叉任务类型：0 - 无任务
                //6.对应货叉任务标志：1待机
                //WCS交换区无任务
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "OperationModel").Value == OperationModel.联机.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1ForkHasPallet").Value == "False" && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskNo").Value == "0" && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskType").Value == ForkTaskFlag.无任务.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.待机.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag").Value == ForkTaskFlag.无任务.GetIndexString())
                {
                    return BllResultFactory.Sucess();
                }
                else
                {
                    return BllResultFactory.Error();
                }
            }
            catch (Exception ex)
            {
                Logger.Log($"校验堆垛机{stocker.Name}入库条件异常：{ex.Message}", LogLevel.Exception, ex);
                return BllResultFactory.Error($"校验堆垛机{stocker.Name}入库条件异常：{ex.Message}");
            }
        }

        public BllResult ValidateStockerOut(Equipment stocker)
        {
            try
            {
                //判断条件，这里没有判断货叉故障和堆垛机故障，这特么怎么判断，这么多字段
                //1.操作模式：5  联机；
                //2.任务限制：不等于3； 
                //3.双货叉原位，任务货叉上有货；
                //4.任务货叉无故障无任务；
                //5.堆垛机无故障
                //5.对应货叉任务类型：0 - 无任务
                //6.对应货叉任务标志：1待机
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "OperationModel").Value == OperationModel.联机.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1ForkHasPallet").Value == "False" && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskNo").Value == "0" && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskType").Value == ForkTaskFlag.无任务.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.待机.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "TaskLimit").Value != TaskLimit.限制出库.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag").Value == ForkTaskFlag.无任务.GetIndexString())
                {
                    return BllResultFactory.Sucess();
                }
                else
                {
                    return BllResultFactory.Error();
                }

            }
            catch (Exception ex)
            {
                Logger.Log($"校验堆垛机{stocker.Name}出库条件异常：{ex.Message}", LogLevel.Exception, ex);
                return BllResultFactory.Error($"校验堆垛机{stocker.Name}出库条件异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 同巷道内移库条件判断
        /// </summary>
        /// <param name="stocker"></param>
        /// <returns></returns>
        public BllResult ValidateStockerTransferInRoadway(Equipment stocker)
        {
            try
            {
                //这个同巷道内的移库任务，判断条件与出库一致
                //判断条件，这里没有判断货叉故障和堆垛机故障，这特么怎么判断，这么多字段
                //1.操作模式：5  联机；
                //2.任务限制：不等于3； (同巷道内移库不判断这个）
                //3.双货叉原位，任务货叉上有货；
                //4.任务货叉无故障无任务；
                //5.堆垛机无故障
                //5.对应货叉任务类型：0 - 无任务
                //6.对应货叉任务标志：1待机
                if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "OperationModel").Value == OperationModel.联机.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1ForkHasPallet").Value == "False" && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskNo").Value == "0" && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskType").Value == ForkTaskFlag.无任务.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value == TaskExcuteStatus.待机.GetIndexString() && stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSFork1TaskFlag").Value == ForkTaskFlag.无任务.GetIndexString())
                {
                    return BllResultFactory.Sucess();
                }
                else
                {
                    return BllResultFactory.Error();
                }

            }
            catch (Exception ex)
            {
                Logger.Log($"校验堆垛机{stocker.Name}移库条件异常：{ex.Message}", LogLevel.Exception, ex);
                return BllResultFactory.Error($"校验堆垛机{stocker.Name}移库条件异常：{ex.Message}");
            }
        }

        #endregion
    }
}