高翔 / ECS-ZJHX · Files

using HHECS.Application.Enums;
using HHECS.Application.Error;
using HHECS.Application.Service;
using HHECS.BLL.Services;
using HHECS.BllModel;
using HHECS.Communication;
using HHECS.Communication.PLC;
using HHECS.Dal;
using HHECS.DAL.Repository;
using HHECS.Executor.EquipmentHandler.Truss;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Infrastructure.Enums;
using HHECS.Infrastructure.Notice;
using HHECS.Model.Dtos;
using HHECS.Model.Entities;
using HHECS.Model.Entities.BasicData;
using HHECS.Model.Enums;
using HHECS.Model.Enums.Car;
using HHECS.Model.Enums.Machine;
using HHECS.Model.Enums.Task;
using HHECS.Model.Enums.Warehouse;
using HHHECS.Model.Enums;
using NPOI.POIFS.Crypt.Dsig;
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace HHECS.Executor.EquipmentHandler
{
    /// <summary>
    /// 站台顶层抽象类
    /// </summary>
    public abstract class StationExecute : BaseEquipmentExecute
    {
        #region 属性
        /// <summary>
        /// 用于标记站台的类型
        /// </summary>
        public EquipmentType EquipmentType { get; set; }

        /// <summary>
        /// 用于记录错误文本
        /// </summary>
        public string ErrorText { get; set; }

        /// <summary>
        /// 中控的http请求的head中的origin（中控的安全校验会校验head）
        /// </summary>
        public string origin;

        /// <summary>
        /// 中控的http请求的head中的referer（中控的安全校验会校验head）
        /// </summary>
        public string referer;

        /// <summary>
        /// 叫料的URL
        /// </summary>
        public string callMaterialUrl;

        /// <summary>
        /// 工位的叫料的处理结果
        /// </summary>
        Dictionary<string, List<string>> dicCallInfo = new Dictionary<string, List<string>>();

        #endregion

        protected StationExecute(EquipmentType equipmentType)
        {
            EquipmentType = equipmentType;
            //this.origin= origin;
            //this.referer = referer;
            //this.callMaterialUrl = callMaterialUrl;
            //this.dicCallInfo = dicCallInfo;
        }

        /// <summary>
        /// 具体的站台实现逻辑
        /// </summary>
        /// <param name="stations"></param>
        /// <param name="plcs"></param>
        /// <returns></returns>
        public virtual void Excute(List<Equipment> stations, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                foreach (var station in stations)
                {
                    BllResult result = BllResultFactory.Success();
                    var OperationModel = station[StationProps.OperationModel.ToString()];
                    var TotalError = station[StationProps.TotalError.ToString()];
                    if (OperationModel.Value != OperationModelFlag.Online.GetIndexString() || TotalError.Value != TotalErrorFlag.Normal.GetIndexString())
                    {
                        result = BllResultFactory.Create(BllResultCode.Info, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】失败，请保持设备的联机并且无故障");
                        OnEquipmentExecuteLog(result.Code, station, result.Msg, result.ErrorCode);
                        continue;
                    }
                    #region 判断PLC位置到达

                    var ArriveMessage = station[StationProps.ArriveMessage.ToString()];
                    var WCSACKMessage = station[StationProps.WCSACKMessage.ToString()];
                    var WCSACKLoadStatus = station[StationProps.WCSACKLoadStatus.ToString()];
                    if (ArriveMessage != null && WCSACKMessage != null && WCSACKLoadStatus != null)
                    {
                        //PLC有位置到达，而WCSACK没有回复，则WCS还没有响应
                        if (ArriveMessage.Value == StationMessageFlag.PickReport.GetIndexString() && WCSACKMessage.Value == StationMessageFlag.Default.GetIndexString())
                        {
                            result = ExcuteArrive(station, allEquipments, plc, user);
                        }
                        else if (ArriveMessage.Value == StationMessageFlag.PickReport.GetIndexString() && WCSACKMessage.Value == StationMessageFlag.WCSPLCACK.GetIndexString())
                        {
                            OnEquipmentExecuteLog(BllResultCode.Warning, station, $"{station.Name} 等待电气清除到达信号", ErrorCodeConst.Station_E0002.ToString());
                        }
                        //PLC没位置到达，而WCSACK有回复，则PLC已经响应但还没有清除
                        else if (ArriveMessage.Value == StationMessageFlag.Default.GetIndexString() && WCSACKMessage.Value == StationMessageFlag.WCSPLCACK.GetIndexString() && WCSACKLoadStatus.Value == StationLoadStatus.ArriveReply.GetIndexString())
                        {
                            result = ExcuteACKClear(plc, station);
                        }
                        //记录日志
                        OnEquipmentExecuteLog(result.Code, station, result.Msg, result.ErrorCode);
                        result = BllResultFactory.Success();
                    }

                    #endregion

                    #region 判断PLC发送给WCS的控制指令

                    var controlMessage = station[StationProps.ControlMessage.ToString()];
                    var allowEntry = station[StationProps.AllowEntry.ToString()];
                    if (controlMessage != null && WCSACKMessage != null && WCSACKLoadStatus != null)
                    {
                        //PLC有控制指令，但WCS还未响应
                        if (controlMessage.Value == StationMessageFlag.PLCControl.GetIndexString() && WCSACKMessage.Value == StationMessageFlag.Default.GetIndexString())
                        {
                            result = ExcuteControl(station, allEquipments, plc, user);
                        }
                        else if (controlMessage.Value == StationMessageFlag.PLCControl.GetIndexString() && WCSACKMessage.Value == StationMessageFlag.WCSPLCACK.GetIndexString())
                        {
                            OnEquipmentExecuteLog(BllResultCode.Warning, station, $"{station.Name} 等待电气清除控制信号", ErrorCodeConst.Station_E0003.ToString());
                        }
                        else if (controlMessage.Value == StationMessageFlag.Default.GetIndexString() && WCSACKMessage.Value == StationMessageFlag.WCSPLCACK.GetIndexString() && WCSACKLoadStatus.Value == StationLoadStatus.ControlReply.GetIndexString())
                        {
                            result = ExcuteACKClear(plc, station);
                        }
                        //else if (controlMessage.Value == StationMessageFlag.Default.GetIndexString() && allowEntry.Value == StationAllowEntry.Allow.GetIndexString() && WCSACKMessage.Value == StationMessageFlag.Default.GetIndexString() && WCSACKLoadStatus.Value == StationLoadStatus.Default.GetIndexString())
                        //{
                        //    result = CheckIsSendProductType(plc, station);

                        //}
                        //记录日志
                        OnEquipmentExecuteLog(result.Code, station, result.Msg, result.ErrorCode);
                        result = BllResultFactory.Success();
                    }

                    #endregion

                    #region 判断WCS发送给PLC的控制指令

                    var wcsControlMessage = station[StationProps.WCSControlMessage.ToString()];
                    var plcAck = station[StationProps.ACKMessage.ToString()];
                    if (wcsControlMessage != null && plcAck != null)
                    {
                        //找到当前工位对应的料点是否存在有状态为【agv请求进入光栅】【agv已经进入光栅】【agv请求出来光栅】【agv已经出来光栅】，并且ECS和PLC的信号都为默认的时候处理
                        if (wcsControlMessage.Value == StationMessageFlag.Default.GetIndexString() && plcAck.Value == StationMessageFlag.Default.GetIndexString())
                        {
                            result = ExcuteWCSControl(station, allEquipments, plc, user);
                        }
                        if (wcsControlMessage.Value == StationMessageFlag.WCSControl.GetIndexString() && plcAck.Value == StationMessageFlag.Default.GetIndexString())
                        {
                            OnEquipmentExecuteLog(BllResultCode.Warning, station, $"{station.Name} 等待电气响应WCS端控制指令", ErrorCodeConst.Station_E0004.ToString());
                        }
                        else if (wcsControlMessage.Value == StationMessageFlag.WCSControl.GetIndexString() && plcAck.Value == StationMessageFlag.PLCWCSACK.GetIndexString())
                        {
                            result = ExcuteWCSControlClear(station, plc);
                        }
                        else if (wcsControlMessage.Value == StationMessageFlag.Default.GetIndexString() && plcAck.Value == StationMessageFlag.PLCWCSACK.GetIndexString())
                        {
                            OnEquipmentExecuteLog(BllResultCode.Warning, station, $"{station.Name} 等待电气清除自身ACK信号", ErrorCodeConst.Station_E0004.ToString());
                        }
                        //记录日志
                        OnEquipmentExecuteLog(result.Code, station, result.Msg, result.ErrorCode);
                        result = BllResultFactory.Success();
                    }

                    #endregion

                    #region 判断PLC地址请求

                    var RequestMessage = station[StationProps.RequestMessage.ToString()];
                    var WCSReplyMessage = station[StationProps.WCSReplyMessage.ToString()];
                    if (RequestMessage != null && WCSReplyMessage != null)
                    {
                        //PLC有请求，但WCS没有，则WCS还没有响应
                        if (RequestMessage.Value == StationMessageFlag.AddressRequest.GetIndexString() && WCSReplyMessage.Value == StationMessageFlag.Default.GetIndexString())
                        {
                            result = ExcuteRequest(station, allEquipments, plc, user);
                        }
                        //PLC有请求，但WCS响应,等待PLC处理 
                        else if (RequestMessage.Value == StationMessageFlag.AddressRequest.GetIndexString() && WCSReplyMessage.Value == StationMessageFlag.WCSAddressReply.GetIndexString())
                        {
                            OnEquipmentExecuteLog(BllResultCode.Warning, station, $"{station.Name} 等待电气清除请求信号", ErrorCodeConst.Station_E0001.ToString());
                        }
                        //PLC清除请求，WCS有之前的数据，说明WCS需要清除数据
                        else if (RequestMessage.Value == StationMessageFlag.Default.GetIndexString() && WCSReplyMessage.Value == StationMessageFlag.WCSAddressReply.GetIndexString())
                        {
                            result = ExcuteRequestClear(station, plc);
                        }
                        //记录日志
                        OnEquipmentExecuteLog(result.Code, station, result.Msg, result.ErrorCode);
                        result = BllResultFactory.Success();
                    }

                    #endregion
                }
            }
            catch (Exception ex)
            {

                BllResultFactory.Create(BllResultCode.Exception, ex, $"程序处理逻辑类出现异常：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }

        }

        #region 实现逻辑的方法

        /// <summary>
        /// 地址请求的处理
        /// 注意：allEquipments引用所有设备，此为共享应用
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public virtual BllResult ExcuteRequest(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                //检查运输设备是否可用
                var checkResult = CheckTransportEquipment(station, allEquipments);
                if (!checkResult.Success) return checkResult;

                var init = (int)EnumOrderBodyStatus.初始化;
                var finished = (int)EnumOrderBodyStatus.已完成;
                var busWorkOrderHeadRepository = new BusWorkOrderHeadRepository();
                var busWorkOrderDetailRepository = new BusWorkOrderDetailRepository();
                //获取地址请求对应的工序任务头
                var workOrderHeadResult = GetRequestWorkOrderHead(station, busWorkOrderHeadRepository, out BusWorkOrderHead workOrderHead, out int productType);
                if (!workOrderHeadResult.Success)   return workOrderHeadResult;
                //找出工序任务明细的已开工的最大序号
                var minSerialNumber = busWorkOrderDetailRepository.Where(t => t.HeadKeys == workOrderHead.Keys && t.State > init).Max(t => t.SerialNumber);
                //找出工序任务明细
                var workOrderDetails = busWorkOrderDetailRepository.Where(t => t.HeadKeys == workOrderHead.Keys && t.State < finished && t.SerialNumber >= minSerialNumber)
                                                                   .OrderBy(t => t.SerialNumber).Take(2).ToList();
                if (workOrderDetails.Count < 1)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，找不到工单【{workOrderHead.WorkOrderCode}】的工序任务【{workOrderHead.Id}】的明细数据");
                }
                //获取所有能去的下一个工序的设备列表
                var allowEntryEquipmentResult = GetNextAllowEntryEquipment(station, allEquipments, workOrderDetails.Last());
                ////根据料点关系表返会任务起点和终点点位
                //var allowEntryEquipmentResult = GetNextAllowEntryEquipmentForLocationRel(station, allEquipments, workOrderDetails.Last());
                if (!allowEntryEquipmentResult.Success)
                {
                    allowEntryEquipmentResult.Msg += $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，";
                    return allowEntryEquipmentResult;
                } 
                //生成运输任务
                var transportTaskResult = CreateTransportTask(station, allEquipments, allowEntryEquipmentResult.Data, productType, workOrderHead, user);
                if (!transportTaskResult.Success)
                {
                    transportTaskResult.Msg += $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，";
                    return transportTaskResult;
                } 
                var transportTask = transportTaskResult.Data;
                //设置工序任务实体，
                SetWorkOrder(station, workOrderHead, workOrderDetails, transportTask, user);

                var requestNumber = station[StationProps.RequestNumber.ToString()];
                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        busWorkOrderDetailRepository.UnitOfWork = uw;
                        busWorkOrderHeadRepository.UnitOfWork = uw;
                        //如果生成了桁车任务，就写入桁车任务表
                        if (transportTask.BusTaskTruss != null)
                        {
                            var taskTrussEntityRepository = new BusTaskTrussRepository();
                            taskTrussEntityRepository.UnitOfWork = uw;
                            taskTrussEntityRepository.Insert(transportTask.BusTaskTruss);
                        }
                        //如果生成了AGV任务，就写入桁车任务表
                        if (transportTask.BusAGVTask != null)
                        {
                            var busAGVTaskRepository = new BusAGVTaskRepository();
                            busAGVTaskRepository.UnitOfWork = uw;
                            busAGVTaskRepository.Insert(transportTask.BusAGVTask);
                        }
                        //更新工序任务明细表
                        busWorkOrderDetailRepository.Update(workOrderDetails);
                        //更新工序任务头表
                        busWorkOrderHeadRepository.Update(workOrderHead);
                        //响应设备
                        var sendResult = SendAddressReplyToPlc(station, plc, StationMessageFlag.WCSAddressReply, StationLoadStatus.Default, requestNumber.Value,
                                                               workOrderHead.Id.ToString(), transportTask.ToEquipment.SelfAddress, "", "0", "0", "0", "0");
                        if (sendResult.Success)
                        {
                            uw.Commit();
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求成功，工序任务ID【{workOrderHead.Id}】信息以及下个设备【{transportTask.ToEquipment.SelfAddress}】的地址写入PLC成功！");
                        }
                        else
                        {
                            uw?.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，工序任务ID【{workOrderHead.Id}】的信息写入PLC失败，原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw?.Rollback();
                        return BllResultFactory.Create(BllResultCode.Exception, ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求的时候，处理工序任务ID【{workOrderHead.Id}】发生异常，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Exception, ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求时候，发生异常：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }

        /// <summary>
        /// 清除地址请求的回复
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ExcuteRequestClear(Equipment station, PLCCore plc)
        {
            var result = SendAddressReplyToPlc(station, plc, StationMessageFlag.Default, StationLoadStatus.Default, "0", "0", "0", "0", "0", "0", "0", "0");
            if (result.Success)
            {
                return BllResultFactory.Success($"WCS回复站台【{station.Name}】地址请求后，清除WCS地址区成功");
            }
            else
            {
                return BllResultFactory.Error($"WCS回复站台【{station.Name}】地址请求后，清除WCS地址区失败");
            }
        }

        /// <summary>
        /// 位置到达的处理
        /// 注意：allEquipments引用所有设备，此为共享应用
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public virtual BllResult ExcuteArrive(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                var detailState = (int)EnumOrderBodyStatus.运输中;
                var busWorkOrderHeadRepository = new BusWorkOrderHeadRepository();
                var busWorkOrderDetailRepository = new BusWorkOrderDetailRepository();
                var baseProductHeaderRepository = new BaseProductHeaderRepository();
                // 获取位置到达的工序任务头
                var getResult = GetArriveWorkOrderHead(station, busWorkOrderHeadRepository, out BusWorkOrderHead workOrderHead);
                if (!getResult.Success) return getResult;
                //获取工序任务明细
                var workOrderDetail = busWorkOrderDetailRepository.Where(t => t.HeadKeys == workOrderHead.Keys && t.StationCode == station.WorkStationCode && t.State == detailState)
                                                                  .OrderBy(t => t.SerialNumber).First();
                if (workOrderDetail == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】位置到达，找不到工单【{workOrderHead.WorkOrderCode}】的工序任务【{workOrderHead.Id}】的明细数据");
                }
                //是否存在下一个工序任务明细，用来判断是不是最后的工序
                var existNext = busWorkOrderDetailRepository.Where(t => t.HeadKeys == workOrderHead.Keys && t.SerialNumber > workOrderDetail.SerialNumber).Any();

                //查询产品信息
                var productHeader = baseProductHeaderRepository.Where(t => t.ProductCode == workOrderHead.ProductHeaderCode).First();
                //更新工序任务头
                workOrderHead.NowOprSequenceCode = workOrderDetail.OprSequenceCode;
                workOrderHead.NowStationCode = workOrderDetail.StationCode;
                workOrderHead.NextOprSequenceCode = "";
                workOrderHead.NextStationCode = "";
                workOrderHead.State = existNext ? (int)EnumWorkOrderStatus.生产中 : (int)EnumWorkOrderStatus.已完成;
                workOrderHead.UpdateTime = DateTime.Now;
                workOrderHead.UpdateBy = user.UserCode;
                //更新工序任务明细
                workOrderDetail.ActualStartTime = DateTime.Now;
                workOrderDetail.State = existNext ? (int)EnumOrderBodyStatus.生产中 : (int)EnumOrderBodyStatus.已完成;
                workOrderDetail.UpdateTime = DateTime.Now;
                workOrderDetail.UpdateBy = user.UserCode;

                //var arriveRealAddress = station[StationProps.ArriveRealAddress.ToString()];
                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        busWorkOrderDetailRepository.UnitOfWork = uw;
                        busWorkOrderHeadRepository.UnitOfWork = uw;
                        //更新工序跟踪表
                        busWorkOrderHeadRepository.Update(workOrderHead);
                        busWorkOrderDetailRepository.Update(workOrderDetail);
                        //响应设备
                        BllResult plcResult = NewSendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ArriveReply, workOrderHead.Id.ToString(), productHeader.WcsProductType, "0", "0", 0);
                        if (plcResult.Success)
                        {
                            uw.Commit();
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】位置到达成功，工序任务ID【{workOrderHead.Id}】相关信息写入设备成功");
                        }
                        else
                        {
                            uw?.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】位置到达失败，工序任务ID【{workOrderHead.Id}】信息没写入设备失败，原因：{plcResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw?.Rollback();
                        return BllResultFactory.Create(BllResultCode.Exception, ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】位置到达的时候，处理工序任务ID【{workOrderHead.Id}】发生异常，原因：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Exception, ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】位置到达时候，发生异常：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }

        /// <summary>
        /// 清除ACK回复，包括地址到达和控制指令
        /// </summary>
        /// <param name="plc"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        private BllResult ExcuteACKClear(PLCCore plc, Equipment station)
        {
            //var result = SendAckToPlc(station, plc, StationMessageFlag.Default, StationLoadStatus.Default, "0", "0");
            var result = NewSendAckToPlc(station, plc, StationMessageFlag.Default, StationLoadStatus.Default, "0", 0);
            if (result.Success)
            {
                return BllResultFactory.Success($"WCS应答站台【{station.Name}】后，清除WCS地址区成功");
            }
            else
            {
                return BllResultFactory.Error($"WCS应答站台【{station.Name}】后，清除WCS地址区失败");
            }
        }

        /// <summary>
        /// 执行PLC发送给WCS的控制指令
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <param name="warehouseCode"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public virtual BllResult ExcuteControl(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            var controlType = station[StationProps.ControlType.ToString()];
            if (controlType != null)
            {
                if (controlType.Value == PLCControlType.获取工件型号.GetIndexString())
                {

                    return PostWCSProductType(station, allEquipments, plc, user);
                }
                else
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】执行PLC发给WCS的控制指令失败，任务类型【{controlType.Value}】没有做对应的处理！");
                }
            }
            else
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】执行PLC发给WCS的控制指令失败，设备属性中不存在任务类型【ControlType】");
            }
        }

        /// <summary>
        /// 执行WCS发送给PLC的控制指令
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <param name="warehouseCode"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public virtual BllResult ExcuteWCSControl(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            var OperationModel = station[StationProps.OperationModel.ToString()];
            var Status = station[StationProps.Status.ToString()];
            var TotalError = station[StationProps.TotalError.ToString()];
            if (Status.Value != EquipmentStatus.空闲.GetIndexString())
            {
                return BllResultFactory.Success($"");
            }
            var taskEquipmentRepository = DALHelper.GetFreeSql().GetRepository<BaseTaskEquipment>();
            //该设备 创建时间最新的数据 下发
            var taskEquipments = taskEquipmentRepository
                                                    .Where(u => u.sendStatus == (int)WeldTechnologyEquipmentStatus.init && u.equipmentCode == station.Code)
                                                    .OrderByDescending(u => u.createTime)
                                                    .ToList();
            var sendData = new BaseTaskEquipment();
            if (taskEquipments.Count < 1)
            {
                return BllResultFactory.Success();
            }
            //查找最近一条数据是1分钟之内的就发送给PLC，其余数据状态全部修改为“过期”
            foreach (var item in taskEquipments)
            {
                item.sendStatus = (int)WeldTechnologyEquipmentStatus.expire;
                item.updateTime = DateTime.Now;
                item.updateBy = "ECS";
            }
            var dateDiff = DateTime.Now.Subtract((DateTime)taskEquipments.First().createTime).Duration().TotalSeconds;
            if ((int)dateDiff < 60)
            {
                sendData = taskEquipments[0];
                sendData.sendStatus = (int)WeldTechnologyEquipmentStatus.success;
                //移除可以发送的数据，防止更新过期数据的时候把可以发送的数据同步更新成过期数据
            }
            using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
            {
                try
                {
                    taskEquipmentRepository.UnitOfWork = uw;
                    var issend = taskEquipments.Where(t => t.sendStatus == (int)WeldTechnologyEquipmentStatus.success).ToList();

                    if (!issend.Any())
                    {
                        taskEquipmentRepository.Update(taskEquipments);
                        uw.Commit();
                        return BllResultFactory.Create(BllResultCode.Info, $"工位【{station.WorkStationCode}】的设备【{station.Name}】处理过期数据成功");
                    }
                    //响应设备
                    var sendResult = SendControlToPLC(station, plc, StationMessageFlag.WCSControl, "1", "0", sendData.taskCode, "0", 0, 0, 0, "0");
                    if (sendResult.Success)
                    {
                        taskEquipmentRepository.Update(taskEquipments);
                        uw.Commit();
                        return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】下发任务号成功,任务号[{sendData.taskCode}]!");
                    }
                    else
                    {
                        taskEquipments.ForEach(t => { t.sendStatus = (int)WeldTechnologyEquipmentStatus.fail; });
                        taskEquipmentRepository.Update(taskEquipments);
                        uw.Commit();
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】下发任务号失败,任务号[{sendData.taskCode}]!的信息写入PLC失败,原因：{sendResult.Msg}");
                    }
                }
                catch (Exception ex)
                {
                    uw?.Rollback();
                    return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】下发任务号时候,处理在任务号【{sendData.taskCode}】发生异常,原因：{ex.Message}");
                }
            }

            //var busAGVTaskRepository = new BusAGVTaskRepository();
            //var baseLocationRepository = new BaseLocationRepository();
            //var locations = baseLocationRepository.Where(u => u.StationCode == station.WorkStationCode).ToList(t => t.LocationCode);
            //var agvTasks = busAGVTaskRepository.Where(u =>
            //                                   (locations.Contains(u.StartPosition) &&
            //                                   (
            //                                    u.State == AGVStatusEnum.AGV请求进入起点光栅.GetIndexInt() ||
            //                                    u.State == AGVStatusEnum.AGV已经进入起点光栅.GetIndexInt() ||
            //                                    u.State == AGVStatusEnum.AGV请求出来起点光栅.GetIndexInt() ||
            //                                    u.State == AGVStatusEnum.AGV已经出来起点光栅.GetIndexInt()
            //                                    ))
            //                                   ||
            //                                   (locations.Contains(u.EndPosition) &&
            //                                   (
            //                                    u.State == AGVStatusEnum.AGV请求进入终点光栅.GetIndexInt() ||
            //                                    u.State == AGVStatusEnum.AGV已经进入终点光栅.GetIndexInt() ||
            //                                    u.State == AGVStatusEnum.AGV请求出来终点光栅.GetIndexInt() ||
            //                                    u.State == AGVStatusEnum.AGV已经出来终点光栅.GetIndexInt()
            //                                    )
            //                                   )).ToList();
            ////同一个点位不能同时存在2条相同起点料点或者终点料点的agv任务
            //if (agvTasks.Count <= 0) return BllResultFactory.Error();
            //foreach (var location in locations)
            //{
            //    var temps = agvTasks.Where(t => t.StartPosition == location || t.EndPosition == location).ToList();
            //    if (temps.Count > 1)
            //    {
            //        foreach (var temp in temps) agvTasks.Remove(temp);
            //        NoticeBus.Notice($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】WCS主动控制请求失败，料点【{location}】同时存在多条AGV任务，请去中控上面结束掉已经完成的agv任务", Level.Warning, this);
            //        continue;
            //    }
            //}
            //foreach (var agvTask in agvTasks)
            //{
            //    var agvStatusEnum = (AGVStatusEnum)agvTask.State;
            //    var gratingControlType = GratingControlType.AGV请求进入光栅;
            //    //回复PLC
            //    switch (agvTask.State)
            //    {
            //        case (int)AGVStatusEnum.AGV请求进入起点光栅:
            //        case (int)AGVStatusEnum.AGV请求进入终点光栅:
            //            gratingControlType = GratingControlType.AGV请求进入光栅;
            //            break;
            //        case (int)AGVStatusEnum.AGV已经进入起点光栅:
            //        case (int)AGVStatusEnum.AGV已经进入终点光栅:
            //            gratingControlType = GratingControlType.AGV已经进入光栅;
            //            break;
            //        case (int)AGVStatusEnum.AGV请求出来起点光栅:
            //        case (int)AGVStatusEnum.AGV请求出来终点光栅:
            //            gratingControlType = GratingControlType.AGV请求出来光栅;
            //            break;
            //        case (int)AGVStatusEnum.AGV已经出来起点光栅:
            //        case (int)AGVStatusEnum.AGV已经出来终点光栅:
            //            gratingControlType = GratingControlType.AGV已经出来光栅;
            //            break;
            //        default:
            //            return BllResultFactory.Error($"工位【{station.WorkStationCode}】的设备【{station.Name}】小车任务编号：{agvTask.TaskCode} 对应的任务状态：{((AGVStatusEnum)agvTask.State).ToDescriptionString()} 未找到对应处理阶段");
            //    }
            //    return GratingWCSControl(station, plc, agvStatusEnum, gratingControlType, busAGVTaskRepository, agvTask);
            //}
            //return BllResultFactory.Success();
        }

        /// <summary>
        /// 清除WCS发送给PLC的控制指令
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        private BllResult ExcuteWCSControlClearForAGV(Equipment station, PLCCore plc)
        {
            //调用agv继续执行任务接口
            var ACKBarcode = station[StationProps.ACKBarcode.ToString()];
            var WCSControlBarcode = station[StationProps.WCSControlBarcode.ToString()];
            if (ACKBarcode.Value != WCSControlBarcode.Value)
            {
                return BllResultFactory.Error<BaseProductHeader>($"工位【{station.WorkStationCode}】的设备【{station.Name}】 清除控制请求失败，PLC回复的任务号[{ACKBarcode.Value}]和中控请求的任务号[{WCSControlBarcode.Value}]不一样，请检查！");
            }
            var convertResult = int.TryParse(ACKBarcode.Value, out int barcode);
            if (!convertResult)
            {
                return BllResultFactory.Error<BaseProductHeader>($"工位【{station.WorkStationCode}】的设备【{station.Name}】 清除控制请求失败，agv任务号[{ACKBarcode.Value}]转化为整数失败！");
            }
            if (barcode < 1)
            {
                return BllResultFactory.Error<BaseProductHeader>($"处理工位[{station.WorkStationCode}]的设备[{station.Name}] 清除控制请求失败，agv任务号[{ACKBarcode.Value}]不能小于1！");
            }
            BusAGVTaskRepository busAGVTaskRepository = new BusAGVTaskRepository();
            var aGVTask = busAGVTaskRepository.Where(t => t.Id == barcode).First();
            if (aGVTask == null)
            {
                return BllResultFactory.Error<BaseProductHeader>($"工位【{station.WorkStationCode}】的设备【{station.Name}】 清除控制请求失败，找不到在agv任务号为[{barcode}]的数据");
            }
            if (aGVTask.State != (int)AGVStatusEnum.MES回复请求进入起点光栅 && aGVTask.State != (int)AGVStatusEnum.MES回复已经进入起点光栅 && aGVTask.State != (int)AGVStatusEnum.MES回复请求出来起点光栅 && aGVTask.State != (int)AGVStatusEnum.MES回复已经出来起点光栅 && aGVTask.State != (int)AGVStatusEnum.MES回复请求进入终点光栅 && aGVTask.State != (int)AGVStatusEnum.MES回复已经进入终点光栅 && aGVTask.State != (int)AGVStatusEnum.MES回复请求出来终点光栅 && aGVTask.State != (int)AGVStatusEnum.MES回复已经出来终点光栅)
            {
                return BllResultFactory.Error($"工位【{station.WorkStationCode}】的设备【{station.Name}】 agv任务号[{ACKBarcode.Value}]的状态[{((AGVStatusEnum)aGVTask.State).ToDescriptionString()}]不需要wcs处理,请检查任务号或者状态是否正确");
            }
            AGVService service = new AGVService();
            var entity = new
            {
                TaskNo = aGVTask.TaskCode,
                TaskStatus = aGVTask.State,
                ExtensionField1 = string.IsNullOrEmpty(aGVTask.MaterialDistributeLoadCode)? "big":"small",
                ExtensionField2 = "",
            };
            var agvResult = service.SendContinueTask(entity);
            if (!agvResult.Success)
            {
                return BllResultFactory.Error($"PLC成功响应站台[{station.WorkStationId}]设备[{station.Name}]控制信号后，给agv发送继续任务指令失败，任务号：【{aGVTask.TaskCode}】{agvResult.Msg}");
            }
            return BllResultFactory.Error($"PLC成功响应站台[{station.WorkStationId}]设备[{station.Name}]控制信号后，给agv发送继续任务指令失败，任务号：【{aGVTask.TaskCode}】{agvResult.Msg}");

            //else
            //{
            //    //var result = SendControlToPLC(station, plc, StationMessageFlag.Default, "0", "0", "0", "0");
            //    //if (result.Success)
            //    //{
            //    //    return BllResultFactory.Success($"PLC成功响应站台【{station.Name}】控制信号后，清除WCS地址区成功");
            //    //}
            //    //else
            //    //{
            //    //    return BllResultFactory.Error($"PLC成功响应站台【{station.Name}】控制信号后，清除WCS地址区失败");
            //    //}
            //}
        }

        public virtual BllResult ExcuteWCSControlClear(Equipment station, PLCCore plc)
        {
            //Thread.Sleep(1000);
            var result = SendControlToPLC(station, plc, StationMessageFlag.Default, "0", "0", "0", "0", 0, 0, 0, "0");
            if (result.Success)
            {
                return BllResultFactory.Success($"PLC成功响应站台【{station.Name}】控制信号后，清除WCS地址区成功");
            }
            else
            {
                return BllResultFactory.Error($"PLC成功响应站台【{station.Name}】控制信号后，清除WCS地址区失败");
            }
        }


        /// <summary>
        /// 写入发送给PLC的控制指令
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        #endregion


        #region 新版机器站台的逻辑处理公用方法

        /// <summary>
        /// 叫料
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public BllResult CallMaterialLoad(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            var feed = ZoneCode.Feed.GetIndexInt();
            var autoLocation = LocationIsAutoEnum.Auto.GetIndexInt();

            var locationRepository = new BaseLocationRepository();
            var materialDistributeLoadRepository = new BusMaterialDistributeLoadRepository();

            //该工位对应的，自动的，上料的，料点
            var locationList = locationRepository.Where(t => t.StationCode == station.WorkStationCode && t.ZoneCode == feed && t.CallType == autoLocation).ToList();
            if (locationList.Count < 1)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】的上料点数据为空，请检查");
            }
            var locationCodes = locationList.Select(t => t.LocationCode).ToList();

            //如果当前工位处理过料点的叫料，就不在处理
            if (!dicCallInfo.Keys.Contains(station.WorkStationCode))
            {
                List<string> callinfo = new List<string>();
                foreach (var locationItem in locationList)
                {

                    var equipmentProp = station[locationItem.SensorPropCode.ToString()];
                    if (equipmentProp.Value == "1")
                    {
                        // 如果存在【使用中】的装料配送，就把状态改为【使用完】
                        var use = MaterialDistributeLoadEnum.使用中.GetIndexInt();
                        var finish = MaterialDistributeLoadEnum.使用完.GetIndexInt();
                        //找出所有小于等于【未使用】的配送，等于【使用中】的配送修改为【使用完】，小于【使用中】的配送在下面用于是否还要叫料的判断
                        var distributeLoadHeadList = materialDistributeLoadRepository.Where(t => t.NeedStation == station.WorkStationCode && t.Status <= use && t.EndPosition == locationItem.LocationCode).ToList();
                        if (distributeLoadHeadList.Any(t => t.Status == use))
                        {
                            var distributeLoadTemp = distributeLoadHeadList.Where(t => t.Status == use).ToList();
                            foreach (var item in distributeLoadTemp)
                            {
                                item.Status = finish;
                            }
                            materialDistributeLoadRepository.Update(distributeLoadHeadList);
                            var positionList = string.Join(',', distributeLoadTemp.Select(t => t.EndPosition));
                            NoticeBus.Notice($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】的料点【{positionList}】，已经把【{MaterialDistributeLoadEnum.使用中}】改为【{MaterialDistributeLoadEnum.使用完}】", Level.Success, this);
                        }
                        callinfo.Add(locationItem.LocationCode);
                        continue;
                    }

                }
                callinfo.Add("FrontStationFitupFeed1");
                dicCallInfo.Add(station.WorkStationCode, callinfo);


                // 向中控发送叫料请求【工位编码】
                if (callinfo.Count>0) //dicCallInfo.Keys.Contains(station.WorkStationCode)&&
                {
                    CommonService commonService = new CommonService();
                    var sendData = new { Data = dicCallInfo[station.WorkStationCode] };
                    //var result = commonService.PostJson<object>("SendNoneGoodsPoints:上传库位编码", callMaterialUrl, sendData, origin, referer).Result;
                    //var result = commonService.PostJson<object>("SendNoneGoodsPoints:上传库位编码", callMaterialUrl, sendData).Result;
                    var result = commonService.HttpMan(callMaterialUrl, sendData, "SendNoneGoodsPoints:上传库位编码");
                    if (!result.Success)
                    {
                        dicCallInfo.Remove(station.WorkStationCode);
                        NoticeBus.Notice($"处理设备[{station.Name}]工位[{station.WorkStationId}]，向中控系统发送可用的料点失败！原因【{result.Msg}】！", Level.Error, this);
                    }
                   
                }
                return BllResultFactory.Success("");
            }

            #region 循环该组队一区和二区的料点，哪个区有料就上哪个
            var arrive = MaterialDistributeLoadEnum.配送到达.GetIndexInt();
            var arriveDistributeLoadHeadList = materialDistributeLoadRepository.Where(t => t.NeedStation == station.WorkStationCode && t.Status == arrive).ToList();
            var locationGroupList = locationList.GroupBy(t => t.FitupArea).ToList();
            foreach (var locationGroup in locationGroupList)
            {
                var locationCodeList = locationGroup.Select(t => t.LocationCode).ToList();
                var arriveDistributeLoadHeads = arriveDistributeLoadHeadList.Where(t => locationCodeList.Contains(t.EndPosition)).ToList();
                //如果没齐套，就查找下一组配送
                if (arriveDistributeLoadHeads.Count < locationCodeList.Count) continue;
                //把当前齐套的配送，都改为【使用中】
                arriveDistributeLoadHeads.ForEach(t => t.Status = MaterialDistributeLoadEnum.使用中.GetIndexInt());

                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        materialDistributeLoadRepository.UnitOfWork = uw;
                        materialDistributeLoadRepository.Update(arriveDistributeLoadHeads);
                        //装料信息发送给PLC，并且把装料状态改为【使用中】，最后删除 dicCallInfo的当前工位项。
                        var plcResult = NewSendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", Convert.ToInt32(arriveDistributeLoadHeads[0].WorkpieceNo), "0", arriveDistributeLoadHeads[0].LoadQty.ToString(), locationGroup.First().FitupArea); ;
                        if (plcResult.Success)
                        {
                            dicCallInfo.Remove(station.WorkStationCode);
                            uw.Commit();
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】组队【{locationGroup.Key}区】写入PLC装料数据成功!");
                        }
                        else
                        {
                            uw?.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】组队【{locationGroup.Key}区】区写入PLC装料数据失败，原因：{plcResult.Msg}!");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw?.Rollback();
                        return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】组队{locationGroup.Key}区写入PLC装料数据，发生异常：{ex.Message}!");
                    }
                }
            }
            #endregion
            return BllResultFactory.Success("");
        }

        /// <summary>
        /// 发送工件型号
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public BllResult PostWCSProductType(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            var runing = StepTraceStatus.下料运输中.GetIndexInt();
            //找到下个设备为当前工位并且状态为运输中的工序任务，吧工件型号回复给PLC
            var busWorkOrderHeadRepository = new BusWorkOrderHeadRepository();
            var baseProductHeaderRepository = new BaseProductHeaderRepository();
            var busWorkOrderHeads = busWorkOrderHeadRepository.Where(t => t.NextStationCode == station.WorkStationCode && t.State == runing).ToList();
            if (busWorkOrderHeads.Count != 1)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】回复工件型号的时候找到多条或者没有找到对应的任务，请检查");
            }
            var baseProductHeader = baseProductHeaderRepository.Where(t => t.ProductCode == busWorkOrderHeads[0].ProductHeaderCode).First();
            if (baseProductHeader == null)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】回复工件型号的时候，没有找到产品数据【{busWorkOrderHeads[0].ProductHeaderCode}】");
            }
            BllResult setResult = NewSendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", baseProductHeader.WcsProductType, "0", "0", 0);
            if (setResult.Success)
            {
                //uw.Commit();
                return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】回复工件型号【{baseProductHeader.WcsProductType}】成功!");
            }
            else
            {
                //uw?.Rollback();
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】回复工件型号【{baseProductHeader.WcsProductType}】失败!");
            }

        }

        /// <summary>
        /// 发送工件型号
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public BllResult CheckIsSendProductType(PLCCore plc, Equipment station)
        {
            //判断是否有当前工位为终点并且状态小于完成的运输任务，如果没有任务就报错
            var transfer = ZoneCode.Transfer.GetIndexInt();
            var autoLocation = LocationIsAutoEnum.Auto.GetIndexInt();
            var end = AGVStatusEnum.任务完成.GetIndexInt();
            BaseLocationRepository baseLocationRepository = new BaseLocationRepository();
            BusAGVTaskRepository busAGVTaskRepository = new BusAGVTaskRepository();
            var baseLocationCodes = baseLocationRepository.Where(x => x.StationCode == station.WorkStationCode && x.CallType == autoLocation && x.ZoneCode == transfer).ToList().Select(t => t.LocationCode);
            if (baseLocationCodes.Count()<1)
            {
                return BllResultFactory.Success("");
            }
            var busAGVTasks = busAGVTaskRepository.Where(t => baseLocationCodes.Contains(t.EndPosition) && t.State < end).ToList();
            if (busAGVTasks.Count < 1)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】已经有允许放货，但是PLC没有控制请求工件型号，请检查PLC是否已经存在工件型号！");
            }
            return BllResultFactory.Success("");

        }

        /// <summary>
        /// 获取位置到达对应的工件型号
        /// </summary>
        /// <param name="station"></param>
        /// <param name="stepTraceRepository"></param>
        /// <returns></returns>
        public BllResult<BaseProductHeader> GetArriveProductType(Equipment station, BaseProductHeaderRepository productHeaderRepository, EquipmentProp productType)
        {
            BaseProductHeader productHeader;
            //var productType = station[StationProps.ArriveBackup.ToString()];
            if (string.IsNullOrEmpty(productType.Value))
            {

                return BllResultFactory.Error<BaseProductHeader>($"工位【{station.WorkStationCode}】的设备【{station.Name}】 wcs工件类型不能为空！");

            }
            else
            {
                var convertResult = int.TryParse(productType.Value, out int wcsProductType);
                if (!convertResult)
                {
                    return BllResultFactory.Error<BaseProductHeader>($"工位【{station.WorkStationCode}】的设备【{station.Name}】 位置到达失败，wcs工件型号[{productType.Value}]转化为整数失败！");
                }
                if (wcsProductType < 1)
                {
                    return BllResultFactory.Error<BaseProductHeader>($"处理工位[{station.WorkStationCode}]的设备[{station.Name}] 位置到达失败，wcs工件型号[{productType.Value}]不能小于1！");
                }
                productHeader = productHeaderRepository.Where(t => t.WcsProductType == wcsProductType).First();
                if (productHeader == null)
                {
                    return BllResultFactory.Error<BaseProductHeader>($"工位【{station.WorkStationCode}】的设备【{station.Name}】 位置到达失败，找不到在产品工件类型[{wcsProductType}]的数据");
                }
            }
            return BllResultFactory.Success<BaseProductHeader>(productHeader);
        }


        /// <summary>
        /// 设置工序任务表的 当前工艺路线、下个工艺路线
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="stepTrace"></param>
        /// <returns></returns>
        public BllResult SetBaseStepTraceProcess(Equipment station, BusWorkOrderHead busWorkOrderHead, BaseProductHeader baseProductHeader)
        {
            //获取工艺路线明头
            var processRouteHead = DALHelper.GetFreeSql().GetRepository<BaseProcessRouteHead>().Where(t => t.ProcessCode == baseProductHeader.ProcessCode).First();
            if (processRouteHead == null)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，根据工位线体[{station.LineCode}]没有查询到工艺路线，请检查基础数据");
            }
            //获取所有工艺路线明细
            var processRouteDetails = DALHelper.GetFreeSql().GetRepository<BaseProcessRouteDetail>().Where(t => t.Headkeys == processRouteHead.Keys).ToList();
            if (processRouteDetails == null)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，根据工艺路线Keys[{processRouteHead.Keys}]没有查询到工艺路线明细，请检查基础数据");
            }
            //获取当前工位对应的所有工艺路线明细ID，一个工位的一种物料只对应一个工艺路线明细
            var processRouteDetailIds = DALHelper.GetFreeSql().GetRepository<BaseProcessRouteStation>().Where(t => t.WorkStationCode == station.WorkStationCode).ToList(t => t.BodyKeys);
            if (processRouteDetailIds.Count() == 0)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，根据站台[{station.WorkStationId}]没有检测到对应的工艺路线，请检查基础数据");
            }
            //当前物料的工艺路线明细，再去匹配当前工位对应工艺路线明细，就能筛选出一条工艺路线明细，也就是当前工位的工艺路线明细，
            var currentProcessRouteDetail = processRouteDetails.FirstOrDefault(t => processRouteDetailIds.Contains(t.bodyKeys));
            if (currentProcessRouteDetail == null)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，当前物料编码[{busWorkOrderHead.ProductHeaderCode}]对应的工艺路线明细中，不包含站台对应的工艺路线明细标识[{string.Join(",", processRouteDetailIds)}]，无法确定当前工艺路线，请检查基础数据");
            }
            //根据当前工位的工艺路线明细，筛选出下个工艺路线明细
            var nextProcessRouteDetail = processRouteDetails.Where(t => t.Headkeys == currentProcessRouteDetail.Headkeys && t.OprSequence > currentProcessRouteDetail.OprSequence).OrderBy(t => t.OprSequence).FirstOrDefault();

            if (nextProcessRouteDetail == null)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，当前物料编码[{busWorkOrderHead.ProductHeaderCode}]和线体[{station.LineCode}]对应工序[{currentProcessRouteDetail.Id}][{currentProcessRouteDetail.OprSequenceCode}]没有下个工序，请检查基础数据");
            }
            busWorkOrderHead.ProcessRouteHead = processRouteHead;
            busWorkOrderHead.ProcessRouteDetail = currentProcessRouteDetail;
            busWorkOrderHead.NextProcessRouteDetail = nextProcessRouteDetail;

            busWorkOrderHead.NowOprSequenceCode = currentProcessRouteDetail.OprSequenceCode;
            busWorkOrderHead.NextOprSequenceCode = nextProcessRouteDetail == null ? "0" : nextProcessRouteDetail.OprSequenceCode;
            return BllResultFactory.Success();
        }

        /// <summary>
        /// 获取地址请求对应的工序任务数据
        /// </summary>
        /// <param name="station">当前设备</param>
        /// <param name="busWorkOrderHeadRepository">工序任务头仓库对象</param>
        /// <param name="workOrderHead">工序任务头</param>
        /// <param name="productType">工件类型</param>
        /// <returns></returns>
        public BllResult GetRequestWorkOrderHead(Equipment station, BusWorkOrderHeadRepository busWorkOrderHeadRepository,
                                                 out BusWorkOrderHead workOrderHead, out int productType)
        {
            workOrderHead = null;
            productType = 0;
            //从当前设备获取工件类型
            var requestProductType = station[StationProps.RequestProductType.ToString()];
            var productTypeResult = int.TryParse(requestProductType.Value, out int requestProductTypeValue);
            if (!productTypeResult)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，工件型号【{requestProductType.Value}】转化为整数失败！");
            }
            if (requestProductTypeValue < 1)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，工件型号【{requestProductType.Value}】不能小于1！");
            }
            productType = requestProductTypeValue;
            //获取工序任务头
            var requestBarcode = station[StationProps.RequestBarcode.ToString()];
            if (string.IsNullOrEmpty(requestBarcode.Value))
            {
                //return BllResultFactory.Error<BusWorkOrderHead>($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，没有任务号，请检查PLC地址请求任务号数据！");
                var workOrderHeads = busWorkOrderHeadRepository.Where(t => t.NowStationCode == station.WorkStationCode && t.State < (int)EnumWorkOrderStatus.已完成).ToList();
                if (workOrderHeads.Count == 0)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，既没有工序任务ID，根据工位ID也找不到响应位置到达的工序任务数据，请核对数据！");
                }
                else if (workOrderHeads.Count > 1)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，没有工序任务ID，根据工位ID找到{workOrderHeads.Count}条响应位置到达的工序任务数据，请核对数据！");
                }
                else
                {
                    workOrderHead = workOrderHeads[0];
                }
            }
            else
            {
                var convertResult = int.TryParse(requestBarcode.Value, out int workOrderId);
                if (!convertResult)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，工序任务ID【{requestBarcode.Value}】转化为整数失败！");
                }
                if (workOrderId < 1)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，工序任务ID【{requestBarcode.Value}】不能小于1！");
                }
                workOrderHead = busWorkOrderHeadRepository.Where(t => t.Id == workOrderId).First();
                if (workOrderHead == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，找不到工序任务ID【{workOrderId}】的数据");
                }
            }
            return BllResultFactory.Success();
        }


        /// <summary>
        /// 获取位置到达的工序任务数据
        /// </summary>
        /// <param name="station">当前设备</param>
        /// <param name="busWorkOrderHeadRepository">工序任务头仓库对象</param>
        /// <param name="workOrderHead">工序任务头</param>
        /// <returns></returns>
        public BllResult GetArriveWorkOrderHead(Equipment station, BusWorkOrderHeadRepository busWorkOrderHeadRepository,
                                                out BusWorkOrderHead workOrderHead)
        {
            workOrderHead = null;
            var arriveBarcode = station[StationProps.ArriveBarcode.ToString()];
            if (string.IsNullOrEmpty(arriveBarcode.Value))
            {
                var transporting = (int)StepTraceStatus.下料运输中;
                var confirm = (int)StepTraceStatus.人工确认位置;
                var busWorkOrderHeads = busWorkOrderHeadRepository.Where(t => t.NextStationCode == station.WorkStationCode && (t.State == transporting ||  t.State == confirm)).ToList();
                if (busWorkOrderHeads.Count == 0)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 位置到达失败，既没有工序任务ID，根据工位ID找不到响应地址请求的工序任务数据，请核对数据！");
                }
                else if (busWorkOrderHeads.Count > 1)//组队下料的时候也会生成一个 地址请求 而绗架正在下料的时候也会有  所以会有大概率同时有2个及以上的同位置地址请求
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 位置到达失败，根据工位ID找到{busWorkOrderHeads.Count}条响应地址请求的工序任务数据，请核对数据！");
                }
                else
                {
                    workOrderHead = busWorkOrderHeads[0];
                }
            }
            else
            {
                var convertResult = int.TryParse(arriveBarcode.Value, out int stepTraceId);
                if (!convertResult)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 位置到达失败，工序任务ID【{arriveBarcode.Value}】转化为整数失败！");
                }
                if (stepTraceId < 1)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 位置到达失败，工序任务ID【{arriveBarcode.Value}】不能小于1！");
                }
                workOrderHead = busWorkOrderHeadRepository.Where(t => t.Id == stepTraceId).First();
                if (workOrderHead == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】位置到达失败，找不到工序任务ID【{stepTraceId}】的数据");
                }
            }
            return BllResultFactory.Success();
        }

        /// <summary>
        /// 设置地址请求的工序任务相关操作，更新实体，生成工序任务历史实体、运输任务实体等
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="stepTrace"></param>
        /// <param name="nextEquipment"></param>
        /// <param name="taskCar"></param>
        /// <param name="stepTraceRepository"></param>
        /// <returns></returns>
        public void SetWorkOrder(Equipment station, BusWorkOrderHead busWorkOrderHead, List<BusWorkOrderDetail> workOrderDetails, TransportTask transportTask, User user)
        {
            //设置工序任务明细（生产中的改为完成）
            var currentWorkOrderDetail = workOrderDetails.FirstOrDefault();
            if (currentWorkOrderDetail != null)
            {
                currentWorkOrderDetail.StationCode = station.WorkStationCode;
                currentWorkOrderDetail.EquipmentCode = station.Code;
                currentWorkOrderDetail.ActualEndTime = DateTime.Now;
                currentWorkOrderDetail.State = (int)EnumOrderBodyStatus.已完成;
                currentWorkOrderDetail.UpdateTime = DateTime.Now;
                currentWorkOrderDetail.UpdateBy = user.UserCode;
            }
            //设置工序任务明细（初始化的改为运输中）
            var nextWorkOrderDetail = workOrderDetails.FirstOrDefault(t => t.State < (int)EnumOrderBodyStatus.已完成);
            if (nextWorkOrderDetail != null)
            {
                nextWorkOrderDetail.StationCode = transportTask.ToEquipment.WorkStationCode;
                nextWorkOrderDetail.EquipmentCode = transportTask.ToEquipment.Code;
                nextWorkOrderDetail.State = (int)EnumOrderBodyStatus.运输中;
                nextWorkOrderDetail.UpdateTime = DateTime.Now;
                nextWorkOrderDetail.UpdateBy = user.UserCode;

                //设置工序任务头
                busWorkOrderHead.NextStationCode = nextWorkOrderDetail.StationCode;
                busWorkOrderHead.NextOprSequenceCode = nextWorkOrderDetail.OprSequenceCode;
                busWorkOrderHead.State = (int)EnumWorkOrderStatus.运输中;
            }
            else
            {
                //设置工序任务头
                busWorkOrderHead.NextStationCode = "";
                busWorkOrderHead.NextOprSequenceCode = "";
                busWorkOrderHead.State = (int)EnumWorkOrderStatus.已完成;
            }           
            busWorkOrderHead.UpdateTime = DateTime.Now;
            busWorkOrderHead.UpdateBy = user.UserCode;
        }


        /// <summary>
        /// 检查运输设备，是否可以运输
        /// </summary>
        /// <param name="station">当前设备</param>
        /// <param name="allEquipments">所有设备</param>
        /// <param name="productType">返回的工件类型</param>
        /// <returns></returns>
        public BllResult CheckTransportEquipment(Equipment station, List<Equipment> allEquipments)
        {
            //如果工位有运输设备，就先看看运输设备是否正常
            if (string.IsNullOrWhiteSpace(station.WorkStation.TransportNormal) || station.WorkStation.TransportNormal == EquipmentTypeConst.AGV.ToString())
            {
                return BllResultFactory.Success();
            }
            Equipment transportEquipment = allEquipments.FirstOrDefault(t => t.Code == station.WorkStation.TransportNormal);
            if (transportEquipment == null)
            {
                return BllResultFactory.Error($"找不到工位对应的运输设备【{station.WorkStation.TransportNormal}】");
            }
            if (station.WorkStation.TakeLocation <= 0)
            {
                return BllResultFactory.Error($"当前工位没有设置取货点，请设置！");
            }
            if (transportEquipment.EquipmentType.Code == EquipmentTypeConst.Truss.ToString())
            {
                var validateResult = TrussExcute.Validate(transportEquipment);
                if (validateResult.Success)
                {
                    return BllResultFactory.Success();
                }
                else
                {
                    return BllResultFactory.Create(BllResultCode.Warning, null, $"运输设备不可用，{validateResult.Msg}");
                }
            }
            return BllResultFactory.Error($"没有运输设备类型【{transportEquipment.EquipmentType.Name}】的检查处理！");
        }


        /// <summary>
        /// 生成运输任务，之前已经检查过是否能运输，所以这里直接生成任务
        /// </summary>
        /// <param name="station">当前设备</param>
        /// <param name="allEquipments">所有设备</param>
        /// <param name="nextEquipments">所有能去的目的设备</param>
        /// <param name="productType">工件型号</param>
        /// <param name="busWorkOrderHead">工序任务头</param>
        /// <param name="user">用户</param>
        /// <returns></returns>
        public BllResult<TransportTask> CreateTransportTask(Equipment station, List<Equipment> allEquipments,
                                                            List<Equipment> nextEquipments, int productType,
                                                            BusWorkOrderHead busWorkOrderHead, User user)
        {
            var transportTask = new TransportTask();
            transportTask.FromEquipment = station;
            //获取所有能去的站台列表
            var toStationList = nextEquipments.Select(t => t.WorkStation).ToList();
            //如果没有运输设备，就直接去第一个能去的设备。
            if (string.IsNullOrWhiteSpace(station.WorkStation.TransportNormal))
            {
                transportTask.ToEquipment = nextEquipments[0];
                return BllResultFactory.Success<TransportTask>(transportTask);
            }
            else if (station.WorkStation.TransportNormal == EquipmentTypeConst.AGV.ToString())
            {
                //生成agv任务
                var createTaskResult = CreateAGVTask(allEquipments, station.WorkStation, toStationList, productType, busWorkOrderHead, user);
                if (!createTaskResult.Success || createTaskResult.Data == null)
                {
                    return BllResultFactory.Error<TransportTask>($"生成AGV任务失败，原因：{createTaskResult.Msg}");
                }
                transportTask.BusAGVTask = createTaskResult.Data;
                BaseLocationRepository baseLocationRepository = new BaseLocationRepository();
                var location = baseLocationRepository.Where(u => u.LocationCode == transportTask.BusAGVTask.EndPosition).First();
                transportTask.ToEquipment = allEquipments.FirstOrDefault(u => u.WorkStationCode == location.StationCode);
                return BllResultFactory.Success<TransportTask>(transportTask);

            }

            //如果有运输设备，需要生成运输任务，去运输设备能到达的设备
            Equipment transportEquipment = allEquipments.FirstOrDefault(t => t.Code == station.WorkStation.TransportNormal);
            if (transportEquipment.EquipmentType.Code == EquipmentTypeConst.Truss.ToString())
            {
                //生成桁架任务
                var createTaskResult = TrussExcute.CreateTask(allEquipments, station.WorkStation, toStationList, productType, busWorkOrderHead, user);
                if (!createTaskResult.Success || createTaskResult.Data == null)
                {
                    return BllResultFactory.Error<TransportTask>($"生成桁架任务失败，原因：{createTaskResult.Msg}");
                }
                transportTask.BusTaskTruss = createTaskResult.Data;
                //桁架任务的目标设备
                transportTask.ToEquipment = allEquipments.FirstOrDefault(u => u.WorkStationCode == transportTask.BusTaskTruss.ToStationCode);
                return BllResultFactory.Success<TransportTask>(transportTask);
            }
            //生成RGV任务
            if (transportEquipment.EquipmentType.Code == EquipmentTypeConst.RGV.ToString())
            {
                //生成RGV任务，后续补上
                //return BllResultFactory.Success<TransportTask>(transportTask);
            }
            return BllResultFactory.Error<TransportTask>($"没有运输设备类型【{transportEquipment.EquipmentType.Name}】的任务生成处理！");
        }

        /// <summary>
        /// 站台获取下个允许进入的设备
        /// </summary>
        /// <param name="station">当前设备</param>
        /// <param name="allEquipments">所有设备</param>
        /// <param name="workOrderHead">工序任务头</param>
        /// <param name="workOrderDetail">供需任务明细</param>
        /// <returns></returns>
        public BllResult<List<Equipment>> GetNextAllowEntryEquipment(Equipment station, List<Equipment> allEquipments, BusWorkOrderDetail workOrderDetail)
        {
            var transfer = (int)ZoneCode.Transfer;
            List<Equipment> nextEquipmentList = new List<Equipment>();
            //如果工位有下一个设备地址，就直接找到下个设备，否则通过工作中心、设备的方式来查找下个设备，否则
            if (!string.IsNullOrWhiteSpace(station.GoAddress))
            {
                var nextEquipment = allEquipments.FirstOrDefault(t => t.SelfAddress == station.GoAddress);
                if (nextEquipment == null)
                {
                    return BllResultFactory.Error<List<Equipment>>($"根据当前工位的下一个设备地址，找不到设备，无法分配下一个设备！");
                }
                nextEquipmentList.Add(nextEquipment);
            }
            else
            {
                if (string.IsNullOrWhiteSpace(workOrderDetail.WorkCenterCode))
                {
                    return BllResultFactory.Error<List<Equipment>>($"工单【{workOrderDetail.WorkOrderCode}】的工序任务明细【{workOrderDetail.Id}】【{workOrderDetail.OprSequenceName}】的工作中心为空，无法分配下一个设备！");
                }

                var baseWorkCenterStationRelRepository = new BaseWorkCenterStationRelRepository();
                var workStationCodeList = baseWorkCenterStationRelRepository.Where(t => t.WorkCenterCode == workOrderDetail.WorkCenterCode)
                                                                            .ToList(t => t.WorkStationCode);
                if (workStationCodeList.Count() == 0)
                {
                    return BllResultFactory.Error<List<Equipment>>($"根据工作中心【{workOrderDetail.WorkCenterCode}】找不到所属的工位，请检查基础数据！");
                }

                var baseLocationRepository = new BaseLocationRepository();
                var baseLocations = baseLocationRepository.Where(t => workStationCodeList.Contains(t.StationCode)).ToList();

                var baseLocationRelRepository = new BaseLocationRelRepository();
                var baseLocationRels = baseLocationRelRepository.Where(t => t.StartStationCode == station.WorkStationCode && t.StartZoneCode == transfer).ToList();
                var endStationCodes = baseLocationRels.Select(t => t.EndStationCode).Distinct().ToList();
                workStationCodeList = workStationCodeList.Where(t => endStationCodes.Contains(t)).ToList();
                // 根据站台找到所有对应的设备 按照优先级排序
                nextEquipmentList = allEquipments.Where(t => workStationCodeList.Contains(t.WorkStationCode))
                                                 .OrderBy(x => x.WorkStation.Sequence)
                                                 .ToList();
                if (nextEquipmentList.Count() == 0)
                {
                    return BllResultFactory.Error<List<Equipment>>($"根据工位编码【{string.Join(", ", workStationCodeList)}】找不到对应的设备，请检查基础数据！");
                }
            }

            var checkResult = CheckReadyLoad(nextEquipmentList);
            return checkResult;
        }


        /// <summary>
        /// 站台获取下个允许进入的设备
        /// </summary>
        /// <param name="station">当前设备</param>
        /// <param name="allEquipments">所有设备</param>
        /// <param name="workOrderHead">工序任务头</param>
        /// <param name="workOrderDetail">供需任务明细</param>
        /// <returns></returns>
        public BllResult<List<Equipment>> GetNextAllowEntryEquipmentForLocationRel(Equipment station, List<Equipment> allEquipments, BusWorkOrderDetail workOrderDetail)
        {
            BaseLocationRepository baseLocationRepository = new BaseLocationRepository();
            BaseLocationRelRepository baseLocationRelRepository = new BaseLocationRelRepository();
            var transfer = (int)ZoneCode.Transfer;
            //var locations = DALHelper.GetFreeSql().Select<BaseLocation, BaseLocationRel>()
            //                                      .LeftJoin((a, b) => a.LocationCode == b.StartPositionCode)
            //                                      .Where((a, b) => a.StationCode == station.WorkStationCode && a.ZoneCode == transfer)
            //                                      .ToList((a, b) => new
            //                                      {
            //                                          a.StationCode,
            //                                          a.LocationCode,
            //                                          StartPositionCode = b.StartPositionCode,
            //                                          EndPositionCode = b.EndPositionCode
            //                                      });
            //if (locations.Count < 1)
            //{
            //    return BllResultFactory.Error<List<Equipment>>($"根据当前工位的料点数据，无法找到对应的转运点！,请检查是否录入料点路径信息");
            //}
            //var endlocations = baseLocationRepository.Where(x => locations.Select(t => t.EndPositionCode).Contains(x.LocationCode)).ToList(t=>t.StationCode);
            //var nextEquipmentList = allEquipments.Where(x => endlocations.Contains(x.WorkStationCode)).ToList();


            var baseLocations = baseLocationRelRepository.Where(t => t.StartStationCode == station.WorkStationCode && t.StartZoneCode == transfer).ToList();
            var endStationCodes = baseLocations.Select(t => t.EndStationCode).Distinct().ToList();
            var nextEquipmentList = allEquipments.Where(x => endStationCodes.Contains(x.WorkStationCode)).ToList();
            var checkResult = CheckReadyLoad(nextEquipmentList);
            return checkResult;
        }

        /// <summary>
        /// 从指定的设备列表中选取允许进入的设备
        /// </summary>
        /// <param name="nextEquipmentList">要去的设备列表</param>
        /// <returns></returns>
        public BllResult<List<Equipment>> CheckReadyLoad(List<Equipment> nextEquipmentList)
        {
            //设备必须是“联机、正常、允许进入”都满足才能去，否则就删除
            for (var i = nextEquipmentList.Count - 1; i >= 0; i--)
            {
                if (!(nextEquipmentList[i][StationProps.OperationModel.ToString()]?.Value == OperationModelFlag.Online.GetIndexString() &&
                      nextEquipmentList[i][StationProps.TotalError.ToString()]?.Value == TotalErrorFlag.Normal.GetIndexString() &&
                      nextEquipmentList[i][StationProps.AllowEntry.ToString()]?.Value == StationAllowEntry.Allow.GetIndexString()))
                {
                    nextEquipmentList.RemoveAt(i);
                }
            }
            if (nextEquipmentList.Count() == 0)
            {
                return BllResultFactory.Create<List<Equipment>>(BllResultCode.Warning, null, "没有联机、无故障、允许放货的设备！");
            }
            //找出运输途中的工位
            var status = EnumOrderBodyStatus.运输中.GetIndexInt();
            var workOrderDetailRepository = new BusWorkOrderDetailRepository();
            var workStationCodeList = workOrderDetailRepository.Where(t => t.State == status).ToList(t => t.StationCode);
            //删除运输途中的工位
            if (workStationCodeList.Count > 0)
            {
                for (var i = nextEquipmentList.Count - 1; i >= 0; i--)
                {
                    if (workStationCodeList.Contains(nextEquipmentList[i].WorkStationCode))
                    {
                        nextEquipmentList.RemoveAt(i);
                    }
                }
            }
            if (nextEquipmentList.Count() == 0)
            {
                return BllResultFactory.Create<List<Equipment>>(BllResultCode.Warning, null, "允许进入的工位正在运输中，暂时没有可去的工位。");
            }
            return BllResultFactory.Success<List<Equipment>>(nextEquipmentList);
        }


        #endregion

        #region 新版PLC操作共用方法

        /// <summary>
        /// 地址请求回复
        /// </summary>
        /// <param name="station">站台编码</param>
        /// <param name="plc">PLC</param>
        /// <param name="messageFlag">交互标志</param>
        /// <param name="loadStatus">装载状态</param>
        /// <param name="number">请求编码</param>
        /// <param name="barcode">托盘编码</param>
        /// <param name="weight">重</param>
        /// <param name="lenght">长</param>
        /// <param name="width">宽</param>
        /// <param name="height">高</param>
        /// <param name="address">前进地址</param>
        /// <param name="backup">备用字段</param>
        /// <returns></returns>
        public BllResult SendAddressReplyToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus, string number,string barcode, string weight, string lenght, string width, string height, string address, string backup)
        {
            return SendAddressReplyToPlc(station, plc, messageFlag, loadStatus, number, barcode, weight, lenght, width, height, address, backup, 0, 0, 0, 0);
        }


        /// <summary>
        /// 地址请求回复
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <param name="messageFlag"></param>
        /// <param name="loadStatus"></param>
        /// <param name="number"></param>
        /// <param name="taskId"></param>
        /// <param name="barcode"></param>
        /// <param name="address"></param>
        /// <param name="backup"></param>
        /// <param name="pipeMaterial"></param>
        /// <param name="pipeLength"></param>
        /// <param name="pipeDiameter"></param>
        /// <param name="pipeThickness"></param>
        /// <returns></returns>
        public BllResult SendAddressReplyToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus, string number,string barcode, string address, string backup, int pipeMaterial, decimal pipeLength, decimal pipeDiameter, decimal pipeThickness)
        {
            return SendAddressReplyToPlc(station, plc, messageFlag, loadStatus, number, barcode, "0", "0", "0", "0",
                                         address, backup, pipeMaterial, pipeLength, pipeDiameter, pipeThickness);
        }

        /// <summary>
        /// 地址请求回复
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <param name="message"></param>
        /// <param name="loadStatus"></param>
        /// <param name="number"></param>
        /// <param name="barcode"></param>
        /// <param name="weight"></param>
        /// <param name="lenght"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="address"></param>
        /// <param name="backup"></param>
        /// <returns></returns>
        public BllResult SendAddressReplyToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus, string number,
                                               string barcode, string weight, string lenght, string width, string height, string address, string backup,
                                               int pipeMaterial, decimal pipeLength, decimal pipeDiameter, decimal pipeThickness)
        {
            List<EquipmentProp> props = new List<EquipmentProp>();

            SetStationPropList(props, station, StationProps.WCSReplyLoadStatus, loadStatus.GetIndexString());
            SetStationPropList(props, station, StationProps.WCSReplyNumber, number);
            SetStationPropList(props, station, StationProps.WCSReplyBarcode, barcode);
            SetStationPropList(props, station, StationProps.WCSReplyWeight, weight);
            SetStationPropList(props, station, StationProps.WCSReplyLength, lenght);
            SetStationPropList(props, station, StationProps.WCSReplyWidth, width);
            SetStationPropList(props, station, StationProps.WCSReplyHeight, height);
            SetStationPropList(props, station, StationProps.WCSReplyAddress, address);
            SetStationPropList(props, station, StationProps.WCSReplyBackup, backup);
            SetStationPropList(props, station, StationProps.WCSReplyMaterial, pipeMaterial.ToString());
            SetStationPropList(props, station, StationProps.WCSReplyLength, Convert.ToInt32(pipeLength).ToString());
            SetStationPropList(props, station, StationProps.WCSReplyDiameter, Convert.ToInt32(pipeDiameter * 10).ToString());
            SetStationPropList(props, station, StationProps.WCSReplyThickness, Convert.ToInt32(pipeThickness * 10).ToString());

            // 清除的时候要最先清除报文，写入的时候要最后写入报文
            if (messageFlag == StationMessageFlag.Default)
            {
                SetStationPropList(props, station, StationProps.WCSReplyMessage, messageFlag.GetIndexString(), true);
            }
            else
            {
                SetStationPropList(props, station, StationProps.WCSReplyMessage, messageFlag.GetIndexString());
            }
            return plc.Writes(props);
        }


        /// <summary>
        /// 地址请求时，回退
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <param name="barcode"></param>
        public void SendBack(Equipment station, PLCCore plc, string barcode)
        {
            var result = SendAddressReplyToPlc(station, plc, StationMessageFlag.WCSAddressReply, StationLoadStatus.Default,
                                                station[StationProps.RequestNumber.ToString()].Value,
                                                barcode,
                                                station[StationProps.RequestWeight.ToString()].Value,
                                                station[StationProps.RequestLength.ToString()].Value,
                                                station[StationProps.RequestWidth.ToString()].Value,
                                                station[StationProps.RequestHeight.ToString()].Value,
                                                station.BackAddress, "0");
            //记录日志
            OnEquipmentExecuteLog(result.Code, station, result.Msg, result.ErrorCode);
            result = BllResultFactory.Success();
        }

        /// <summary>
        /// 地址请求时，回退
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <param name="barcode"></param>
        public void SendBack(Equipment station, PLCCore plc, string barcode, string backup)
        {
            var result = SendAddressReplyToPlc(station, plc, StationMessageFlag.WCSAddressReply, StationLoadStatus.Default,
                                                station[StationProps.RequestNumber.ToString()].Value,
                                                barcode,
                                                station[StationProps.RequestWeight.ToString()].Value,
                                                station[StationProps.RequestLength.ToString()].Value,
                                                station[StationProps.RequestWidth.ToString()].Value,
                                                station[StationProps.RequestHeight.ToString()].Value,
                                                station.BackAddress,
                                                backup);
            //记录日志
            OnEquipmentExecuteLog(result.Code, station, result.Msg, result.ErrorCode);
            result = BllResultFactory.Success();
        }


        /// <summary>
        /// 清除 到达信号
        /// </summary>
        public BllResult NewSendAckToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus, string barcode, int wcsProductType)
        {
            return NewSendAckToPlc(station, plc, messageFlag, loadStatus, barcode, wcsProductType, "0", "0", 0);
        }


        /// <summary>
        /// 实现ACK回复，包括地址到达和控制指令
        /// </summary>
        public BllResult NewSendAckToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus, string barcode, int productType, string backup, string number, int parameter)
        {
            List<EquipmentProp> props = new List<EquipmentProp>();

            SetStationPropList(props, station, StationProps.WCSACKLoadStatus, loadStatus.GetIndexString());
            SetStationPropList(props, station, StationProps.WCSACKNumber, number);
            SetStationPropList(props, station, StationProps.WCSACKBarcode, barcode);
            SetStationPropList(props, station, StationProps.WCSACKParameter, parameter.ToString());
            SetStationPropList(props, station, StationProps.WCSACKBackup, backup.ToString());
            SetStationPropList(props, station, StationProps.WCSACKProductType, productType.ToString());

            // 清除的时候要最先清除报文，写入的时候要最后写入报文
            if (messageFlag == StationMessageFlag.Default)
            {
                SetStationPropList(props, station, StationProps.WCSACKMessage, messageFlag.GetIndexString(), true);
            }
            else
            {
                SetStationPropList(props, station, StationProps.WCSACKMessage, messageFlag.GetIndexString());
            }
            return plc.Writes(props);
        }


        /// <summary>
        /// 实现ACK回复，包括地址到达和控制指令
        /// </summary>
        /// <param name="station"></param>
        /// <param name="plc"></param>
        /// <param name="messageFlag"></param>
        /// <param name="loadStatus"></param>
        /// <param name="number"></param>
        /// <param name="taskId"></param>
        /// <param name="barcode"></param>
        /// <param name="address"></param>
        /// <param name="backup"></param>
        /// <param name="requestProductType"></param>
        /// <param name="pipeMaterial1"></param>
        /// <param name="pipeLength1"></param>
        /// <param name="pipeDiameter1"></param>
        /// <param name="pipeThickness1"></param>
        /// <returns></returns>
        public BllResult SendAckToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus, string number, string barcode,string backup, int parameter, int pipeMaterial, decimal pipeLength, decimal pipeDiameter, decimal pipeThickness, decimal cutLength = 0)
        {
            List<EquipmentProp> props = new List<EquipmentProp>();

            SetStationPropList(props, station, StationProps.WCSACKLoadStatus, loadStatus.GetIndexString());
            SetStationPropList(props, station, StationProps.WCSACKNumber, number);
            SetStationPropList(props, station, StationProps.WCSACKBarcode, barcode);
            SetStationPropList(props, station, StationProps.WCSACKParameter, parameter.ToString());
            SetStationPropList(props, station, StationProps.WCSACKBackup, backup.ToString());
            SetStationPropList(props, station, StationProps.WCSACKMaterial, pipeMaterial.ToString());
            SetStationPropList(props, station, StationProps.WCSACKLength, Convert.ToInt32(pipeLength).ToString());
            SetStationPropList(props, station, StationProps.WCSACKDiameter, Convert.ToInt32(pipeDiameter * 10).ToString());
            SetStationPropList(props, station, StationProps.WCSACKThickness, Convert.ToInt32(pipeThickness * 10).ToString());
            SetStationPropList(props, station, StationProps.WCSACKCutLength, Convert.ToInt32(cutLength).ToString());

            // 清除的时候要最先清除报文，写入的时候要最后写入报文
            if (messageFlag == StationMessageFlag.Default)
            {
                SetStationPropList(props, station, StationProps.WCSACKMessage, messageFlag.GetIndexString(), true);
            }
            else
            {
                SetStationPropList(props, station, StationProps.WCSACKMessage, messageFlag.GetIndexString());
            }
            return plc.Writes(props);
        }

        /// <summary>
        /// 清除地址请求回复
        /// </summary>
        public BllResult NewSendAddressReplyToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus)
        {
            return NewSendAddressReplyToPlc(station, plc, messageFlag, loadStatus, "0", "0", "0", "0", "0", "0", 0, 0, 0);
        }



        /// <summary>
        /// 写入地址请求回复
        /// </summary>
        public BllResult NewSendAddressReplyToPlc(Equipment station, PLCCore plc, StationMessageFlag messageFlag, StationLoadStatus loadStatus,
                                               string barcode, string wcsProductType, string number, string address, string backup, string pipeMaterial, int lenght, int pipeDiameter, int pipeThickness)
        {
            List<EquipmentProp> props = new List<EquipmentProp>();

            SetStationPropList(props, station, StationProps.WCSReplyLoadStatus, loadStatus.GetIndexString());
            SetStationPropList(props, station, StationProps.WCSReplyNumber, number);
            SetStationPropList(props, station, StationProps.WCSReplyBarcode, barcode);
            SetStationPropList(props, station, StationProps.WCSReplyProductType, wcsProductType.ToString());
            SetStationPropList(props, station, StationProps.WCSReplyAddress, address);
            SetStationPropList(props, station, StationProps.WCSReplyBackup, backup);
            SetStationPropList(props, station, StationProps.WCSReplyMaterial, pipeMaterial.ToString());
            SetStationPropList(props, station, StationProps.WCSReplyLength, Convert.ToInt32(lenght).ToString());
            SetStationPropList(props, station, StationProps.WCSReplyDiameter, Convert.ToInt32(pipeDiameter * 10).ToString());
            SetStationPropList(props, station, StationProps.WCSReplyThickness, Convert.ToInt32(pipeThickness * 10).ToString());


            // 清除的时候要最先清除报文，写入的时候要最后写入报文
            if (messageFlag == StationMessageFlag.Default)
            {
                SetStationPropList(props, station, StationProps.WCSReplyMessage, messageFlag.GetIndexString(), true);
            }
            else
            {
                SetStationPropList(props, station, StationProps.WCSReplyMessage, messageFlag.GetIndexString());
            }
            return plc.Writes(props);
        }

        /// <summary>
        /// WCS发送控制指令给PLC，主动控制PLC
        /// </summary>
        /// <param name="station"></param>
        /// <param name=""></param>
        /// <param name="messageFlag"></param>
        /// <param name="number"></param>
        /// <param name="backup"></param>
        /// <returns></returns>
        public BllResult SendControlToPLC(Equipment station, PLCCore plc, StationMessageFlag messageFlag, string controlType, string number, string barcode, string backup,string material,string numberb)
        {
            var prop1 = station[StationProps.WCSControlMessage.ToString()];
            prop1.Value = messageFlag.GetIndexString();
            var prop6 = station[StationProps.WCSControlBarcode.ToString()];
            prop6.Value = material;
            var prop2 = station[StationProps.WCSControlType.ToString()];
            prop2.Value = controlType;
            var prop3 = station[StationProps.WCSControlMaterial.ToString()];
            prop3.Value = number;
            var prop4 = station[StationProps.WCSControlDiameter.ToString()];
            prop4.Value = barcode;
            var prop5 = station[StationProps.WCSControlThickness.ToString()];
            prop5.Value = backup;
            var prop7 = station[StationProps.WCSControlBackup.ToString()];
            prop7.Value = numberb;
            List<EquipmentProp> props = new List<EquipmentProp>() { prop1, prop2, prop3, prop4,prop5,prop6,prop7 };
            return plc.Writes(props);
        }


        /// <summary>
        /// WCS发送控制指令给PLC，主动控制PLC
        /// </summary>
        /// <param name="station"></param>
        /// <param name=""></param>
        /// <param name="messageFlag"></param>
        /// <param name="number"></param>
        /// <param name="backup"></param>
        /// <returns></returns>
        public BllResult SendControlToPLC(Equipment station, PLCCore plc, StationMessageFlag messageFlag, string controlType, string number, string barcode, string material, int length, decimal diameter, decimal thickness, string backup)
        {
            List<EquipmentProp> props = new List<EquipmentProp>();

            //SetStationPropList(props, station, StationProps.WCSControlMessage, messageFlag.GetIndexString());
            SetStationPropList(props, station, StationProps.WCSControlType, controlType);
            SetStationPropList(props, station, StationProps.WCSControlNumber, number);
            SetStationPropList(props, station, StationProps.WCSControlBarcode, barcode);
            SetStationPropList(props, station, StationProps.WCSControlMaterial, material);
            SetStationPropList(props, station, StationProps.WCSControlLength, Convert.ToInt32(length).ToString());
            SetStationPropList(props, station, StationProps.WCSControlDiameter, Convert.ToInt32(diameter * 10).ToString());
            SetStationPropList(props, station, StationProps.WCSControlThickness, Convert.ToInt32(thickness * 10).ToString());
            SetStationPropList(props, station, StationProps.WCSControlBackup, backup);


            // 清除的时候要最先清除报文，写入的时候要最后写入报文
            if (messageFlag == StationMessageFlag.Default)
            {
                SetStationPropList(props, station, StationProps.WCSControlMessage, messageFlag.GetIndexString(), true);
            }
            else
            {
                SetStationPropList(props, station, StationProps.WCSControlMessage, messageFlag.GetIndexString());
            }
            return plc.Writes(props);
        }

        /// <summary>
        /// 设置设备属性列表
        /// </summary>
        /// <param name="list">设备属性列表</param>
        /// <param name="station">设备</param>
        /// <param name="propKey">要设置的属性Key</param>
        /// <param name="propValue">要设置的属性值</param>
        /// <param name="insert">是否用Inset插入到列表，默认为Add方法</param>
        public void SetStationPropList(List<EquipmentProp> list, Equipment station, StationProps propKey, string propValue, bool insertFirst = false)
        {
            var propItem = station[propKey.ToString()];
            if (propItem != null && propValue != null)
            {
                propItem.Value = propValue;
                if (insertFirst)
                {
                    list.Insert(0, propItem);
                }
                else
                {
                    list.Add(propItem);
                }
            }
        }



        #endregion


        public static BllResult<BusAGVTask> CreateAGVTask(List<Equipment> allEquipments, BaseWorkStation fromStation, List<BaseWorkStation> toStationList, int productType, BusWorkOrderHead busWorkOrderHead, User user)
        {
            BusAGVTask busAGVTask = new BusAGVTask();
            BaseLocationRepository baseLocationRepository = new BaseLocationRepository();
            var transfer = (int)ZoneCode.Transfer;

            if (toStationList.Count < 1)
            {
                return BllResultFactory.Error<BusAGVTask>("生成任务失败，没有可以去的点位");
            }
            var toStationCode = toStationList.Select(u => u.WorkStationCode).ToList();
            var locations = baseLocationRepository.Where(u => (u.StationCode == fromStation.WorkStationCode || toStationCode.Contains(u.StationCode)) && u.ZoneCode == transfer).ToList();
            var fromPositions = locations.Where(u => u.StationCode == fromStation.WorkStationCode && u.ZoneCode == transfer).ToList();
            var toPositions = locations.Where(u => toStationCode.Contains(u.StationCode) && u.ZoneCode == transfer).ToList();
            try
            {
                busAGVTask.Keys = Guid.NewGuid();
                busAGVTask.TaskCode = Guid.NewGuid().ToString();
                busAGVTask.AgvCode = "";
                busAGVTask.AgvTaskType = AGVTypeEnum.Transport.GetIndexInt();
                busAGVTask.MaterialFrameCode = fromPositions[0].ContainerCode;
                busAGVTask.MaterialDistributeLoadCode = "";
                busAGVTask.WorkOrderCode = busWorkOrderHead.WorkOrderCode;
                busAGVTask.ProductHeaderCode = busWorkOrderHead.ProductHeaderCode;
                busAGVTask.StartPosition = fromPositions[0].LocationCode;
                busAGVTask.EndPosition = toPositions[0].LocationCode;
                busAGVTask.State = AGVStatusEnum.任务创建.GetIndexInt();
                busAGVTask.CreateTime = DateTime.Now;
                busAGVTask.CreateBy = user.UserName;

                return BllResultFactory.Success<BusAGVTask>(busAGVTask);
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create<BusAGVTask>(BllResultCode.Exception, busAGVTask, $"生成站台[{fromStation.WorkStationCode}][{fromStation.WorkStationName}]的桁车任务时候，发生异常：{ex.Message}", ErrorCodeConst.Exe_E0001.ToString());
            }
        }
        public static BllResult ExcuteRequestForAPI(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                //检查状态
                var result = WebApiService.EquipmentStutas();
                if (result.Data.mode.ToString() != "2")
                {
                    //设备不是联机无故障
                    return BllResultFactory.Error("激光切割设备不是联机切无故障状态");
                }
                return BllResultFactory.Success();
            }
            catch (Exception ex) 
            {
                return BllResultFactory.Error("激光设备初始化出错");
            }
        }

            }
}