高翔 / ECS-ZJHX · Files


using HHECS.Application.Enums;
using HHECS.Application.Service;
using HHECS.BLL.EquipmentExcute.Marking;
using HHECS.BllModel;
using HHECS.Communication;
using HHECS.Communication.PLC;
using HHECS.Dal;
using HHECS.Dal.Repository;
using HHECS.DAL.Repository;
using HHECS.Executor.EquipmentHandler;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Model.Entities;
using HHECS.Model.Enums;
using HHECS.Model.Enums.Machine;
using HHHECS.Model.Enums;
using NPOI.SS.Formula.Functions;
using NPOI.SS.UserModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace HHECS.BLL.EquipmentExcute.Machine
{
    /// <summary>
    /// 焊接
    /// </summary>
    public class CutExcute : StationExecute
    {
        public CutExcute(EquipmentType equipmentType) : base(equipmentType)
        {
        }
        public int toadd = 1008;//添加全局变量

        /// <summary>
        /// 执行上料完成
        /// 注意：allEquipments引用所有设备，此为共享应用
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public override BllResult ExcuteArrive(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            // int count = 0;//记录管段数量
            var arriveBarcode = station[StationProps.ArriveBarcode.ToString()];
            var number = station[StationProps.ArriveRealAddress.ToString()];
            var baseMaterialRepository = new BaseMaterialRepository();
            var cutPlanHeadRepository = new CutPlanHeadRepository();
            var busWorkOrderHeadRepository = new BusWorkOrderHeadRepository();
            var cutPlandDilt = new CutPlanDetailRepository();
            var cutPlanHeads = cutPlanHeadRepository.Where(t => t.State == (int)CutPlanHeadState.下料完成 && t.LineCode == station.LineCode && t.Id.ToString() == arriveBarcode.Value).ToList();
            if (cutPlanHeads.Count != 1)
            {
                var msg = cutPlanHeads.Count > 1 ? $"{cutPlanHeads.Count}条未使用的" : $"没有找到已经到达的管材";
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】位置到达失败，切割方案存在{msg}");
            }
            //if (cutPlanHeads[0].OddmentsLength != 0)
            //{
            //    count = 1;
            //}
            cutPlanHeads[0].State = (int)CutPlanHeadState.切割开始;
            cutPlanHeads[0].CutStartTime = DateTime.Now;
            cutPlanHeads[0].DischargeEndTime = DateTime.Now; 
            cutPlanHeads[0].measureEndTime = DateTime.Now;
            var material = baseMaterialRepository.Where(t => t.MaterialCode == cutPlanHeads[0].MaterialCode).First();
            if (material == null)
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，没有找到物料");
            }
            using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
            {
                try
                {
                    cutPlanHeadRepository.UnitOfWork = uw;
                    cutPlandDilt.UnitOfWork = uw;
                    cutPlanHeadRepository.Update(cutPlanHeads[0]);
                    var detalitask = cutPlandDilt.Where(t => t.HeadKeys == cutPlanHeads[0].Keys).ToList();
                    //foreach (var item in detalitask)
                    //{
                    //    item.CutState = (int)CutPlanDetailState.切割开始;
                    //    item.UpdateTime = DateTime.Now;
                    //}
                    //cutPlandDilt.Update(detalitask);
                    //count = count +detalitask.Count;
                    BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ArriveReply, number.Value, cutPlanHeads[0].Id.ToString(), detalitask.Count().ToString(), 0, material.TypesPlcCode, cutPlanHeads[0].Pipelength, material.Diameter, material.Thickness);
                    if (sendResult.Success)
                    {
                        uw.Commit();
                        return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】切割设备【{station.Name}】位置到达成功，库存批次码【{cutPlanHeads[0].Id}】信息写入设备成功");
                    }
                    else
                    {
                        uw.Rollback();
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】切割设备【{station.Name}】位置到达失败，库存批次码【{cutPlanHeads[0].Id}】信息写入设备失败，原因：{sendResult.Msg}");
                    }
                }
                catch (Exception ex)
                {
                    uw.Rollback();
                    return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】切割的设备【{station.Name}】位置到达的时候，处理库存id【{cutPlanHeads[0].Id}】信息发生异常，原因：{ex.Message}");
                }
            }
        }



        /// </summary>
        /// 切割请求
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public override 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 ExcuteCut(station, allEquipments, plc, user);
                } 
                else if (controlType.Value == PLCControlType.获取管段信息.GetIndexString())
                {
                    return GetExcuteBarocdeValue(station, allEquipments, plc, user)
                       .ConfigureAwait(false)
                      .GetAwaiter()
                      .GetResult(); ;
                } 
                else
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】执行PLC发给WCS的控制指令失败，任务类型【{controlType.Value}】没有做对应的处理！");
                }
            }
            else
            {
                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】执行PLC发给WCS的控制指令失败，设备属性中不存在任务类型【ControlType】");
            }
        }

        public async Task<BllResult> GetExcuteBarocdeValue(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                var Barcode = station[StationProps.ControlBarcode.ToString()];//整根任务码
                var baseMaterialRepository = new BaseMaterialRepository();
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlandDilt = new CutPlanDetailRepository();
                var cutplan = new CutPlanHead();
                var cutpland = new CutPlanDetail();

                // 查询任务列表
                var cutPlanTask = cutPlanHeadRepository.Where(t => t.State == (int)CutPlanHeadState.下料完成
                                                              && t.LineCode == station.LineCode
                                                              && t.Id.ToString() == Barcode.Value).ToList();

                // 修复逻辑漏洞：先判断Barcode是否为空
                if (string.IsNullOrEmpty(Barcode.Value))
                {
                    var msg = cutPlanTask.Count > 1 ? $"{cutPlanTask.Count}条未使用的" : $"没有找到已经到达的管材";
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】获取工件信息失败，切割方案{msg}");
                }
                else
                {
                    // 修复逻辑漏洞：先验证cutPlanTask非空，再使用cutPlanTask[0]
                    if (cutPlanTask == null || cutPlanTask.Count == 0)
                    {
                        return BllResultFactory.Error($"下发激光切割任务号失败，未找到任务号【{Barcode.Value}】对应的下料完成任务");
                    }

                    using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                    {
                        // 绑定工作单元到所有仓储
                        cutPlandDilt.UnitOfWork = uw;
                        cutPlanHeadRepository.UnitOfWork = uw;
                        baseMaterialRepository.UnitOfWork = uw;

                        // 先验证cutPlanTask[0]非空
                        var firstCutPlan = cutPlanTask[0];
                        if (firstCutPlan == null)
                        {
                            return BllResultFactory.Error($"下发激光切割任务号失败，任务列表第一个元素为空");
                        }

                        // 查询子任务和物料信息
                        var cutdlit = cutPlandDilt.Where(t => t.HeadKeys == firstCutPlan.Keys).ToList();
                        var material = baseMaterialRepository.Where(t => t.MaterialCode == firstCutPlan.MaterialCode).First();

                        // 验证物料信息非空
                        if (material == null)
                        {
                            return BllResultFactory.Error($"下发激光切割任务号失败，未找到物料编码【{firstCutPlan.MaterialCode}】对应的基础物料信息");
                        }

                        // 2. 修复核心问题：使用await正确等待异步任务完成
                        BllResult<object> result = await WebApiService.CutRecord(
                            firstCutPlan.Keys.ToString(),
                            firstCutPlan.Id.ToString(),
                            firstCutPlan.CodeFile,
                            "碳钢",
                            firstCutPlan.Pipelength,
                            material.Diameter,
                            material.Thickness
                        );

                        // 任务执行成功后，更新状态
                        if (result.Success)
                        {
                            // 更新主任务状态
                            firstCutPlan.State = (int)CutPlanDetailState.切割开始;
                            firstCutPlan.UpdateTime = DateTime.Now;

                            // 修复冗余时间判断：仅保留DateTime.MinValue判断
                            if (firstCutPlan.DischargeEndTime == DateTime.MinValue)
                            {
                                firstCutPlan.DischargeEndTime = DateTime.Now;
                            }
                            if (firstCutPlan.CutStartTime == DateTime.MinValue)
                            {
                                firstCutPlan.CutStartTime = DateTime.Now;
                            }

                            // 优化：若仓储支持单个实体更新，优先传入单个实例（更安全）
                            // 若仅支持集合更新，保留cutPlanTask即可
                            cutPlanHeadRepository.Update(firstCutPlan);
                            // cutPlanHeadRepository.Update(cutPlanTask); // 集合更新备用

                            // 更新子任务状态
                            foreach (var item in cutdlit)
                            {
                                item.CutState = (int)CutPlanDetailState.切割开始;
                                item.UpdateTime = DateTime.Now;
                            }
                            cutPlandDilt.Update(cutdlit);

                            // 发送PLC应答
                            BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK,
                                                                StationLoadStatus.ControlReply, "1", "0", "0",
                                                                PLCControlType.获取管段信息.GetIndexInt(), 0, 0, 0, 0, 0);

                            if (sendResult.Success)
                            {
                                uw.Commit(); // 事务提交，状态持久化
                                return BllResultFactory.Success($"下发激光切割任务号成功任务号{firstCutPlan.Id},路径{firstCutPlan.Extend1},材质{material.types},长度{firstCutPlan.Pipelength},管径{material.Diameter},壁厚{material.Thickness}");
                            }
                            else
                            {
                                uw.Rollback(); // 执行失败，回滚所有更新
                                return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】获取管件信息失败，回复切割完成信息写入PLC失败，原因：{sendResult.Msg}");
                            }
                        }
                        else
                        {
                            return BllResultFactory.Error($"下发激光切割任务号失败,请检查主任务id{firstCutPlan.Id}及基础数据，原因：{result.Msg}");
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // 建议添加日志记录，方便排查异常
                // LogHelper.Error(ex, $"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】获取管件信息异常");
                return BllResultFactory.Exception(ex, $"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】获取管件信息，发生异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 处理定长切割请求
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="stepTraceList"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public BllResult ExcuteCut(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                var Barcode = station[StationProps.ControlBarcode.ToString()];//整根任务码
                var baseMaterialRepository = new BaseMaterialRepository();
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlandDilt = new CutPlanDetailRepository();
                var busworkdilt = new BusWorkOrderDetailRepository();
                var cutplan = new CutPlanHead();
                var cutpland = new CutPlanDetail();

                if (string.IsNullOrEmpty(Barcode.Value))
                {
                    return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】获取切割明细条码{Barcode.Value}失败，切割方案{Barcode.Value}");
                }
                else
                {
                    using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                    {
                        var cutPlanTask = cutPlandDilt.Where(t => t.CutState == (int)CutPlanDetailState.切割开始 && t.BarCode.ToString() == Barcode.Value).OrderBy(t => t.CutLevel).ToList();
                        cutPlandDilt.UnitOfWork = uw;
                        busworkdilt.UnitOfWork = uw;
                        var busworkdi = busworkdilt.Where(t => t.BarCode == cutPlanTask[0].BarCode && t.OprSequenceCode == "Cut" /*&& t.State == 0*/).OrderByDescending(t => t.CreateTime).ToList();
                      
                        //var cutplande = cutPlandDilt.Where(t => t.HeadKeys == cutPlanTask[0].Keys && t.CutLevel == Convert.ToInt32(Tovalue.Value)).First();
                        if (cutPlanTask == null)
                        {
                            return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】切割指令查找失败，未找到切割指令对应的工单数据");
                        }
                        //小于800直接下料
                        if (cutPlanTask[0].Cuttinglength <= 800)
                        {
                            cutPlanTask[0].Extend2 = "切割下料";
                            cutPlanTask[0].CutEndTime = DateTime.Now;
                        }
                        cutPlanTask[0].CutState = (int)CutPlanDetailState.切割完成;
                        cutPlanTask[0].CutStartTime = DateTime.Now; 
                        cutPlanTask[0].UpdateTime = DateTime.Now;
                        if (busworkdi !=null && busworkdi.Count>0)
                        { 
                            busworkdi[0].ActualEndTime = DateTime.Now;
                            busworkdi[0].State = (int)CutPlanDetailState.切割完成;
                            busworkdilt.Update(busworkdi);
                        }
                        cutPlandDilt.Update(cutPlanTask);
                        //报工
                        Task.Run(() => {
                            WebApiService.SendCutProcess(busworkdi[0].BarCode, "55");
                        });
                        var pland = cutPlandDilt.Where(t => t.HeadKeys == cutPlanTask[0].HeadKeys && t.CutState == (int)CutPlanDetailState.切割开始).ToList();
                        var planheads = cutPlanHeadRepository.Where(t => t.Keys == cutPlanTask[0].HeadKeys && t.LineCode == station.LineCode).First();
                        if (pland.Count == 0)
                        {
                            cutPlanHeadRepository.UnitOfWork = uw;
                            var planhead = cutPlanHeadRepository.Where(t => t.Keys == cutPlanTask[0].HeadKeys && t.LineCode == station.LineCode).First();
                            planhead.State = (int)CutPlanHeadState.切割完成;
                            planhead.UpdateTime = DateTime.Now;
                            planhead.CutEndTime = DateTime.Now;
                            planhead.ActualEndTime = DateTime.Now;
                            cutPlanHeadRepository.Update(planhead);
                            BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", "0", "0", PLCControlType.切割指令.GetIndexInt(), 0, cutPlanTask[0].Cuttinglength, 0, 0, 0);
                            if (sendResult.Success)
                            {
                                WebApiService.SurpplusRecord(planhead.Id.ToString());
                                uw?.Commit();
                                return BllResultFactory.Success($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】切割指令写入PLC成功，回复管件id[{cutPlanTask[0].Id}]完成信息写入PLC成功！");
                            }
                            else
                            {
                                uw.Rollback();
                                return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】切割指令写入PLC失败，回复切割完成信息写入PLC失败失败，原因：{sendResult.Msg}");
                            }
                        }
                        
                        else
                        {
                            BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", "0", "0", PLCControlType.切割指令.GetIndexInt(), 0, cutPlanTask[0].Cuttinglength, 0, 0, 0);
                            if (sendResult.Success)
                            {
                                uw?.Commit();
                                return BllResultFactory.Success($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】切割指令写入PLC成功，管件id【{cutPlanTask[0].Id}】回复管件完成信息写入PLC成功！");
                            }
                            else
                            {
                                uw.Rollback();
                                return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】切割指令写入PLC失败，回复切割完成信息写入PLC失败失败，原因：{sendResult.Msg}");
                            }
                        }

                    }

                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Exception(ex, $"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】切割请求，发生异常：{ex.Message}");
            }
        }



        /// <summary>
        /// 执行地址请求，余料和废料不请求，切割机直接翻到切割下料台
        /// 注意：allEquipments引用所有设备，此为共享应用
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <returns></returns>
        public override BllResult ExcuteRequest(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                var arriveBarcode = station[StationProps.RequestBarcode.ToString()];
                var number = station[StationProps.ArriveRealAddress.ToString()];
                var baseMaterialRepository = new BaseMaterialRepository();
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlandDilt = new CutPlanDetailRepository();
                var BusWorkOrderDetail = new BusWorkOrderDetailRepository();
                //int gotoadd;
                //int gotadd;
                if (string.IsNullOrEmpty(arriveBarcode.Value))
                {
                    return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】下料条码{arriveBarcode.Value}为空请求失败，切割方案");
                }
                else
                {
                    var cutplandilt = cutPlandDilt.Where(t => t.Id.ToString() == arriveBarcode.Value).OrderByDescending(t => t.CreateTime).ToList();
                    var busworkdi = BusWorkOrderDetail.Where(t => t.BarCode == cutplandilt[0].BarCode && t.OprSequenceCode == "Cut" && t.State == 0).OrderByDescending(t => t.CreateTime).ToList();
                    if (cutplandilt == null)
                    {
                        return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，没有找到切割明细");
                    }
                    //cutplandilt[0].CutState = (int)CutPlanDetailState.切割完成;
                    var cutplanhead = cutPlanHeadRepository.Where(t => t.Keys == cutplandilt[0].HeadKeys).First();
                    if (cutplanhead == null)
                    {
                        return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，没有找到切割主表明细");
                    }
                    var materl = baseMaterialRepository.Where(t => t.MaterialCode == cutplanhead.MaterialCode).First();
                    if (materl == null)
                    {
                        return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，没有找到物料明细");
                    }
                    using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                    {
                        cutPlandDilt.UnitOfWork = uw;
                        BusWorkOrderDetail.UnitOfWork = uw;
                        //var planhead = cutPlanHeadRepository.Where(t => t.Keys == cutplandilt[0].HeadKeys).First();

                        //var busworkorderdetail = BusWorkOrderDetail.Where(t => t.BodyKeys == cutplandilt[0].WorkOrderDetailKeys && t.OprSequenceName == "弯管" && t.State!=100).First();//如果存在弯管的给目的地为弯管机
                        if (string.IsNullOrEmpty(cutplandilt[0].Extend2))
                        {
                            if (busworkdi.Count != 0)
                            {
                                busworkdi[0].State = 100;
                                busworkdi[0].UpdateTime = DateTime.Now;
                                BusWorkOrderDetail.Update(busworkdi);
                            }
                            //gotadd = Convert.ToInt32(cutplandilt[0].Extend2);
                            //cutplandilt[0].UpdateTime = DateTime.Now;
                            //cutplandilt[0].CutEndTime = DateTime.Now;
                            //cutPlandDilt.Update(cutplandilt);
                            var sendResult = SendAddressReplyToPlc(station, plc, StationMessageFlag.WCSAddressReply, StationLoadStatus.Default, "0", "0", "0", "0", "0", "0", "0", "0",0, cutplandilt[0].Cuttinglength, materl.Diameter, materl.Thickness);
                            if (sendResult.Success)
                            {
                                //WebApiService.Layingoff(cutplandilt[0].BarCode, gotadd.ToString());//告诉mes在哪下料
                                uw.Commit();
                                return BllResultFactory.Success($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求成功，工单id【{cutplandilt[0].Id}】信息写入设备成功,管段长度{cutplandilt[0].Cuttinglength},管径{materl.Diameter},壁厚{materl.Thickness}");
                            }
                            else
                            {
                                uw.Rollback();
                                return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，工单id【{cutplandilt[0].Id}】信息写入设备失败，原因：{sendResult.Msg}");
                            }
                        }
                        else
                        {
                            if (busworkdi.Count != 0)
                            {
                                busworkdi[0].State = 100;
                                busworkdi[0].UpdateTime = DateTime.Now;
                                busworkdi[0].StationCode = toadd.ToString();
                                BusWorkOrderDetail.Update(busworkdi);
                            }
                            //cutplandilt[0].Extend2 = toadd.ToString();
                            //cutplandilt[0].UpdateTime = DateTime.Now;
                            //cutplandilt[0].CutEndTime = DateTime.Now;
                            //cutPlandDilt.Update(cutplandilt);
                            var sendResult = SendAddressReplyToPlc(station, plc, StationMessageFlag.WCSAddressReply, StationLoadStatus.Default, "0", "0", "0", "0", "0", "0", "0", "0",0, cutplandilt[0].Cuttinglength, materl.Diameter, materl.Thickness);
                            if (sendResult.Success)
                            {
                                //WebApiService.Layingoff(cutplandilt[0].BarCode, toadd.ToString());//告诉mes在哪下料
                                uw.Commit();
                                return BllResultFactory.Success($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求成功，工单id【{cutplandilt[0].Id}】信息写入设备成功,管段长度{cutplandilt[0].Cuttinglength},管径{materl.Diameter},壁厚{materl.Thickness}");
                            }
                            else
                            {
                                uw.Rollback();
                                return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，工单id【{cutplandilt[0].Id}】信息写入设备失败，原因：{sendResult.Msg}");
                            }
                        }

                        //var pland = cutPlandDilt.Where(t => t.HeadKeys == cutplandilt[0].HeadKeys && t.CutState == (int)CutPlanDetailState.切割开始).ToList();
                        //if (pland.Count == 0)
                        //{
                        //    cutPlanHeadRepository.UnitOfWork = uw;
                        //    planhead.State = (int)CutPlanHeadState.切割完成;
                        //    planhead.UpdateTime = DateTime.Now;
                        //    cutPlanHeadRepository.Update(planhead);
                        //var sendResult = SendAddressReplyToPlc(station, plc, StationMessageFlag.WCSAddressReply, StationLoadStatus.Default, "0", "0", "0", cutplandilt[0].Cuttinglength.ToString(), "0", "0", toadd.ToString(), "0");
                        //if (sendResult.Success)
                        //{
                        //    WebApiService.SurpplusRecord(planhead.Id.ToString());
                        //    uw.Commit();
                        //    return BllResultFactory.Success($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求成功，工单id【{cutplandilt[0].Id}】信息写入设备成功,Mes请求余料信息{planhead.Keys}，主表id{planhead.Id}");
                        //}
                        //else
                        //{
                        //    uw.Rollback();
                        //    return BllResultFactory.Error($"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，工单id【{cutplandilt[0].Id}】信息写入设备失败，原因：{sendResult.Msg}");
                        //}
                        //}

                    }
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Exception(ex, $"处理切割工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，异常原因：{ex.Message}");
            }

        }


        //检查坡口运行长度是否超限
        public static List<Equipment> ChekBevelLength(Equipment station, List<Equipment> allEquipments, ref List<Equipment> bevelEquipments, CutPlanTaskRepository cutPlanTaskRepository)
        {
            var bevelEquipmentsCode = bevelEquipments.Select(t => t.Code).ToList();
            for (int i = bevelEquipments.Count - 1; i >= 0; i--)
            {
                var cutPlanTasks = cutPlanTaskRepository.Where(t => t.Status < 100 && t.Status > 0 && t.IsAuto && (bevelEquipmentsCode[i] == t.NowStation || bevelEquipmentsCode[i] == t.NextStation)).ToList();
                //工单长度是否超限
                if (cutPlanTasks.Any())
                {//安全范围则移除设备
                    if (cutPlanTasks[0].CuttingLength < bevelEquipments[i].ColumnIndex)//2000
                    {
                        bevelEquipments.RemoveAt(i);
                    }
                }
                else
                {//没有任务则移除设备
                    bevelEquipments.RemoveAt(i);
                }
            }
            return bevelEquipments;

        }

        public static BllResult<List<Equipment>> ChekEquipment(Equipment equipment, List<Equipment> allEquipments, CutPlanTask cutPlanTask, ref List<Equipment> nextStations, CutPlanTaskRepository cutPlanTaskRepository)
        {
            var msg = "";
            var equipmentsCode = nextStations.Select(t => t.Code).ToList();
            for (int i = nextStations.Count - 1; i >= 0; i--)
            {
                var cutPlanTasks = cutPlanTaskRepository.Where(t => t.Status < 100 && t.Status > 0 && t.IsAuto && (equipmentsCode[i] == t.NowStation || equipmentsCode[i] == t.NextStation)).ToList();
                if (cutPlanTasks.Any())
                {
                    msg += $"{nextStations[i].Code}工位存在任务{cutPlanTasks[0].Id}";
                    nextStations.RemoveAt(i);
                    continue;
                }
                if (cutPlanTask.CuttingLength > nextStations[i].ColumnIndex && nextStations[i].Code.Contains("Cache"))
                {
                    //缓存工位不能超过限制，坡口工位可以
                    msg += $"-{nextStations[i].Code}工位长度限制{nextStations[i].ColumnIndex}，长度为{cutPlanTask.CuttingLength}";
                    nextStations.RemoveAt(i);
                    continue;
                }
                var OperationModel = nextStations[i][StationProps.OperationModel.ToString()];
                var TotalError = nextStations[i][StationProps.TotalError.ToString()];
                var AllowEntry = nextStations[i][StationProps.AllowEntry.ToString()];
                if (OperationModel.Value != OperationModelFlag.Online.GetIndexString() || TotalError.Value != TotalErrorFlag.Normal.GetIndexString() || AllowEntry.Value != StationAllowEntry.Allow.GetIndexString())
                {
                    if (OperationModel.Value != OperationModelFlag.Online.GetIndexString())
                    {
                        msg += $"-{nextStations[i].Code}工位没有联机、";
                        nextStations.RemoveAt(i);
                        continue;

                    }
                    if (TotalError.Value != TotalErrorFlag.Normal.GetIndexString())
                    {
                        msg += $"-{nextStations[i].Code}工位没有无故障、";
                        nextStations.RemoveAt(i);
                        continue;

                    }
                    if (AllowEntry.Value != StationAllowEntry.Allow.GetIndexString())
                    {
                        msg += $"-{nextStations[i].Code}工位没有允许放货";
                        nextStations.RemoveAt(i);
                        continue;

                    }
                }

            }
            if (nextStations.Any())
            {
                return BllResultFactory.Success(nextStations);
            }
            else
            {
                return (BllResult<List<Equipment>>)BllResultFactory.Error<List<Equipment>>(msg);
            }


        }




    }
}