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>
    /// 单叉堆垛机标准实现
    /// </summary>
    public class SingeForkStockerExcute : StockerExcute
    {
        /// <summary>
        /// 记录堆垛机当前所在的列
        /// </summary>
        public int CurrentColumn { get; private set; }

        public override BllResult Excute(List<Equipment> stockers, OPCHelp plc)
        {
            try
            {
                foreach (var stocker in stockers)
                {
                    CurrentColumn = int.Parse(stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "CurrentColumn").Value);
                    //var plc = plcs.Find(t => t.IP == stocker.IP);

                    ExcuteSingle(stocker, plc);
                    //心跳
                    Heartbeat(stocker, plc);

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

        /// <summary>
        /// 以堆垛机状态驱动，重写堆垛机控制逻辑
        /// </summary>
        /// <param name="stocker"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ExcuteSingle(Equipment stocker, OPCHelp 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 lastStatus>={TaskEntityStatus.下发任务.GetIndexInt()} and lastStatus < {TaskEntityStatus.任务完成.GetIndexInt()} and zoneCode = 'LK'");
                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;
                var taskId = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskNo").Value;
                var taskActionType = stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskType").Value;
                #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.RowIndex.ToString(),locationForResend.Line.ToString(),locationForResend.Layer.ToString(), 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.RowIndex.ToString(),locationForResend.Line.ToString(),locationForResend.Layer.ToString(), 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)
                        {
                            BllResult<Equipment> stationResult = AppSession.Bll.GetOutStationByIndex(taskForResend.Station,int.Parse(taskForResend.Port));
                            if (!stationResult.Success)
                            {
                                Logger.Log($"重新下发任务时，根据任务号{taskForResend.Id}未能获取到站台号：{stationResult.Msg}", LogLevel.Error);
                                return BllResultFactory.Error();
                            }
                            return ResendTask(stocker, plc, stationResult.Data.RowIndex.ToString(), "0","0", 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)
                        {
                            BllResult<Equipment> stationResult = AppSession.Bll.GetOutStationByIndex(taskForResend.Station,int.Parse(taskForResend.Port));
                            if (!stationResult.Success)
                            {
                                Logger.Log($"重新下发任务时，根据任务号{taskForResend.Id}未能获取到站台号：{stationResult.Msg}", LogLevel.Error);
                                return BllResultFactory.Error();
                            }
                            return ResendTask(stocker, plc, stationResult.Data.RowIndex.ToString(), "0","0", taskForResend, ForkTaskFlag.库外出库);
                        }

                        #endregion
                        //判断堆垛机货叉上是不是有货，有货就只能接受放货任务，无货就可以接受取货任务
                        if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1ForkHasPallet").Value == "True")
                        {
                            //有货，则查找同巷道的取货任务完成状态的任务，同一个堆垛机，单叉情况下最多一条
                            #region 判断是否超出一条
                            if(tasks.Count(t=>(t.LastStatus== TaskEntityStatus.响应堆垛机库内取货任务完成.GetIndexInt()) || t.LastStatus == TaskEntityStatus.响应堆垛机库外取货任务完成.GetIndexInt()) > 1)
                            {
                                Logger.Log($"堆垛机{stocker.Name}显示货叉上有货，但是对应的任务超过1条，请检查状态为{TaskEntityStatus.响应堆垛机库内取货任务完成}和{TaskEntityStatus.响应堆垛机库外取货任务完成}的任务", LogLevel.Error);
                                return BllResultFactory.Error();
                            }
                            #endregion
                            //先找库内取货完成的任务
                            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.库内放货}成功,库位编码：{location.Code}", 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())
                                    {
                                        BllResult<Equipment> stationResult = AppSession.Bll.GetOutStationByIndex(task.Station,int.Parse(task.Port));
                                        if (!stationResult.Success)
                                        {
                                            Logger.Log($"下发堆垛机库外出库任务时，根据任务号{task.Id}未能获取到站台号：{stationResult.Msg}", LogLevel.Error);
                                            return BllResultFactory.Error();
                                        }
                                        //库内取，那么库外放
                                        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.库外出库, stationResult.Data.RowIndex.ToString(), "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.库内放货}成功,库位：{location.Code}", 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();
                            }
                            //查看是否有开关控制
                            //todo://huhai-2019-06-04 去掉开关相关的
                            //if (stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "WCSCanOut").Value != "True")
                            //{
                            //    //过滤去1号站台的出库任务
                            //    tempTasks = tempTasks.Where(t => (t.Type==TaskType.整盘入库.GetIndexInt()||t.Type==TaskType.空容器入库.GetIndexInt())||t.Station != 1).ToList();
                            //}
                            if (tempTasks.Count == 0)
                            {
                                return BllResultFactory.Error();
                            }
                            else
                            {
                                //判断堆垛机的位置
                                TaskEntity task = null;
                                if (CurrentColumn == 0&&stocker.EquipmentProps.Find(t=>t.EquipmentTypePropTemplateCode== "CurrentStation").Value!="0")
                                {
                                    //先入库
                                    //同巷道内的入库
                                    if (ExcuteIn(tempTasks, locations, stocker, plc,stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "CurrentStation").Value).Success)
                                    {
                                        return BllResultFactory.Sucess();
                                    }
                                }

                                //出库性质的取货
                                ///获取同巷道的离堆垛机优先级最高且最近的一条任务
                                task = tempTasks.Where(t => locations.Count(a => a.Code == t.SourceLocation) > 0 
                                && t.LastStatus == TaskEntityStatus.下发任务.GetIndexInt() && t.FirstStatus == TaskEntityStatus.下发任务.GetIndexInt() )
                                .OrderByDescending(t => t.Priority).ThenBy(t => Math.Abs(locationsResult.Data.First(a => a.Code == t.SourceLocation).Line - CurrentColumn))
                                .FirstOrDefault();
                                if (task != null)
                                {
                                    ////todo:huhai-2019-06-04  增加判断前面是否有出库任务（整盘出库任务除外）未完成
                                    //if (task.Type == TaskType.出库查看.GetIndexInt() || task.Type == TaskType.分拣出库.GetIndexInt() || task.Type == TaskType.补充入库.GetIndexInt()
                                    //    || task.Type == TaskType.盘点.GetIndexInt())
                                    //{
                                    //    var st = tempTasks.Where(t => t.Station == task.Station && t.Port == task.Port && t.FirstStatus > 10).ToList();
                                    //    if (st.Count >= 1)
                                    //    {
                                    //        Logger.Log($"站台{task.Station} 存在需要回库的任务，请稍后进行出库操作", LogLevel.Warning);
                                    //        if (ExcuteIn(tempTasks, locations, stocker, plc).Success)
                                    //        {
                                    //            return BllResultFactory.Sucess();
                                    //        }
                                    //        return BllResultFactory.Error($"站台{task.Station} 存在需要回库的任务，请稍后进行出库操作");
                                    //    }
                                    //}// 如果是整盘的任务则，需要判断这个任务对应的口是否 出库查看、分拣出库、补充入库、盘点任务
                                    //else if(task.Type==TaskType.整盘出库.GetIndexInt()|| task.Type==TaskType.空容器出库.GetIndexInt())
                                    //{
                                    //    var st = tempTasks.Where(t => t.Port == task.Port && t.FirstStatus > 10
                                    //      && (t.Type == TaskType.出库查看.GetIndexInt() || t.Type == TaskType.分拣出库.GetIndexInt() || t.Type == TaskType.盘点.GetIndexInt() 
                                    //      || t.Type == TaskType.补充入库.GetIndexInt()|| t.Type==TaskType.整盘入库.GetIndexInt())
                                    //    ).ToList();
                                    //    if (st != null && st.Count > 0)
                                    //    {
                                    //        Logger.Log($"站台{task.Station} 存在需要回库的任务，请稍后进行出库操作", LogLevel.Warning);
                                    //        if (ExcuteIn(tempTasks, locations, stocker, plc).Success)
                                    //        {
                                    //            return BllResultFactory.Sucess();
                                    //        }
                                    //        return BllResultFactory.Error($"站台{task.Station} 存在需要回库的任务，请稍后进行出库操作");
                                    //    }
                                    //}
                                   /* //todo:huhai-2019-06-04 移库判断
                                    var result = AppSession.Bll.ExecuteTaskRequest<int>(task.Id);
                                    if (!result.Success)
                                    {
                                        Logger.Log($"任务{task.Id}安排移库失败", LogLevel.Warning);
                                        return BllResultFactory.Error(result.Msg);
                                    }
                                    if (result.Data != task.Id)
                                    {
                                        var t1 = AppSession.Bll.GetCommonModelByCondition<TaskEntity>($" where id={result.Data} ");
                                        if (!t1.Success && t1.Data.Count == 0)
                                        {
                                            return BllResultFactory.Error($"任务ID:{task.Id}请求WMS是否移库，WMS返回的任务ID:{result.Data}在数据库为查询到相应任务");
                                        }
                                        //再库外取货
                                        if (ExcuteIn(tempTasks, locations, stocker, plc).Success)
                                        {
                                            return BllResultFactory.Sucess();
                                        }
                                        Logger.Log($"任务:{task.Id}有需要移动库位的移库任务:{t1.Data[0].Id}需要先执行...", LogLevel.Info);
                                        return BllResultFactory.Error($"任务:{task.Id}有需要移动库位的移库任务:{t1.Data[0].Id}需要先执行...") ;
                                    } */
                                    //先更改任务状态
                                    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(), "0", task.Id.ToString());
                                        if (sendResult.Success)
                                        {
                                            Logger.Log($"下发堆垛机{stocker.Name},任务：{task.Id},任务类型：{task.Type},货叉类型：{ForkTaskFlag.库内取货}成功,库位：{location.Code},出库口:{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 && t.Id==int.Parse(taskId));
                    if (task != null && task.Id.ToString()==taskId&& taskActionType==ForkTaskFlag.库内取货.GetIndexString())
                    {
                        //更新任务状态
                        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);
                            var sendResult = plc.WriteAddress(new List<EquipmentProp> { prop });
                            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.DestinationLocation) > 0);
                    if (task != null && task.Id.ToString() == taskId&& taskActionType==ForkTaskFlag.库内放货.GetIndexString())
                    {
                        //调用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);
                            var sendResult = plc.WriteAddress(new List<EquipmentProp> { prop });
                            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.DestinationLocation) > 0);
                    if (task != null && task.Id.ToString() == taskId&& taskActionType==ForkTaskFlag.库外入库.GetIndexString())
                    {
                        //更新任务状态
                        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);
                            var sendResult = plc.WriteAddress(new List<EquipmentProp> { prop });
                            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.Id.ToString() == taskId&& taskActionType==ForkTaskFlag.库外出库.GetIndexString())
                    {
                        //更新任务状态
                        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);
                            var sendResult = plc.WriteAddress(new List<EquipmentProp> { prop });
                            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}");
                        }
                    }
                    //Logger.Log($"堆垛机完成任务时，没有找到对应的任务{taskId}-动作{taskActionType}不匹配",LogLevel.Info);
                    //return BllResultFactory.Error($"堆垛机完成任务时，没有找到对应的任务{taskId}-动作{taskActionType}不匹配");
                }
                else
                {
                    //未知情况
                    Logger.Log($"堆垛机{stocker.Name}出现了未知的执行状态：{stocker.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == "Fork1TaskExcuteStatus").Value}", LogLevel.Warning);
                    return BllResultFactory.Sucess();
                }
            }
            return BllResultFactory.Sucess();
        }

        /// <summary>
        /// 重写库外取货逻辑
        /// </summary>
        public BllResult ExcuteIn(List<TaskEntity> tempTasks, List<Location> locations, Equipment stocker, OPCHelp 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)
            {
                return ExcuteInInner(stocker, plc, task);
            }
            return BllResultFactory.Error();
        }

        private BllResult ExcuteInInner(Equipment stocker, OPCHelp plc, TaskEntity task)
        {
            //下发堆垛机入库任务
            //todo:huhai-2019-06-04 移库判断
            /* var result = AppSession.Bll.ExecuteTaskRequest<int>(task.Id);
            if (!result.Success)
            {
                Logger.Log("移库的时候出现错误", LogLevel.Warning, null);
                return BllResultFactory.Error(result.Msg);
            } */
            
            BllResult<Equipment> stationResult = AppSession.Bll.GetInStationByIndex(task.Station,int.Parse(task.Port));
            if (!stationResult.Success)
            {
                Logger.Log($"堆垛机入库时，根据任务号{task.Id}未能获取到站台号：{stationResult.Msg}", LogLevel.Error);
                return BllResultFactory.Error();
            }
            /*if (result.Data != task.Id)
            {
                var t1 = AppSession.Bll.GetCommonModelByCondition<TaskEntity>($" where id={result.Data} ");
                if (!t1.Success && t1.Data.Count == 0)
                {
                    Logger.Log($"任务ID:{task.Id}请求WMS是否移库，WMS返回的任务ID:{result.Data}在数据库为查询到相应任务", LogLevel.Warning, null);
                    return BllResultFactory.Error($"任务ID:{task.Id}请求WMS是否移库，WMS返回的任务ID:{result.Data}在数据库为查询到相应任务");
                }
                return BllResultFactory.Error($"任务:{task.Id}有需要移动库位的移库任务:{t1.Data[0].Id}需要先执行...") ;
            } */
            task.FirstStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
            task.LastStatus = TaskEntityStatus.下发堆垛机库外取货任务.GetIndexInt();
            var temp = AppSession.Bll.UpdateCommonModel<TaskEntity>(task);
            if (temp.Success)
            {
                BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, ForkTaskFlag.库外入库, stationResult.Data.RowIndex.ToString(), "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}");
            }
        }

        /// <summary>
        /// 重写库外取货逻辑
        /// </summary>
        public BllResult ExcuteIn(List<TaskEntity> tempTasks, List<Location> locations, Equipment stocker, OPCHelp plc,string station)
        {
            var task = tempTasks.FirstOrDefault(t => t.FirstStatus == TaskEntityStatus.响应接入口位置到达.GetIndexInt() && t.LastStatus == TaskEntityStatus.响应接入口位置到达.GetIndexInt() && locations.Count(a => a.Code == t.DestinationLocation) > 0&&t.Station?.ToString()==station);
            if (task != null)
            {
                return ExcuteInInner(stocker, plc, task);
            }
            return BllResultFactory.Error();
        }

        private BllResult ResendTask(Equipment stocker, OPCHelp plc, string row,string column,string layer, TaskEntity taskForResend, ForkTaskFlag forkTaskFlag)
        {
            BllResult sendResult = SendTaskToStocker(stocker, plc, ForkAction.货叉1号, forkTaskFlag, row,column,layer, 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();
            }
        }
    }
}