高翔 / ECS-ZJHX · Files

using AutoMapper.Execution;
using FreeSql;
using HHECS.Application.Enums;
using HHECS.Application.Service;
using HHECS.BLL.EquipmentExcute.Marking;
using HHECS.BLL.Services;
using HHECS.BllModel;
using HHECS.Communication;
using HHECS.Communication.PLC;
using HHECS.Dal;
using HHECS.Dal.Repository;
using HHECS.DAL;
using HHECS.DAL.Repository;
using HHECS.Executor.EquipmentHandler;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Infrastructure.Enums;
using HHECS.Infrastructure.Notice;
using HHECS.Model.Entities;
using HHECS.Model.Enums;
using HHECS.Model.Enums.Machine;
using HHECS.Model.Enums.Warehouse;
using Microsoft.Data.SqlClient;
using NPOI.SS.Formula.Functions;
using NPOI.Util;
using Opc.Ua;
using System;
using System.Collections.Generic;
using System.Linq;
using static FreeSql.Internal.GlobalFilter;

namespace HHECS.BLL.EquipmentExcute.Machine
{
    /// <summary>
    /// 切割机处理类
    /// </summary>
    public class CutBevelExcute : StationExecute
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="timeSpace"></param>
        /// <param name="origin"></param>
        /// <param name="referer"></param>
        /// <param name="sendNoneGoodsPointsUrl"></param>
        public CutBevelExcute(EquipmentType equipmentType, string origin, string referer, string sendNoneGoodsPointsUrl) : base(equipmentType)
        {
            this.origin = origin;
            this.referer = referer;
            this.callMaterialUrl = sendNoneGoodsPointsUrl;
        }

        /// <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)
        {
            try
            {
                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 busWorkOrderDetailRepository = new BusWorkOrderDetailRepository();
                var cutPlanHeads = cutPlanHeadRepository.Where(t => t.State == (int)CutPlanHeadState.下料开始).ToList();
                if (cutPlanHeads.Count != 1)
                {
                    var msg = cutPlanHeads.Count > 1 ? $"{cutPlanHeads.Count}条未使用的" : $"没有找到已经到达的管材";
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】位置到达失败，切割方案存在{msg}");
                }
                cutPlanHeads[0].State = (int)CutPlanHeadState.下料完成;
                cutPlanHeads[0].DischargeEndTime = DateTime.Now;
                cutPlanHeads[0].measureEndTime = DateTime.Now;
                var result = ExcuteWalkPlan(station, allEquipments, plc, user);
                if (!result.Success)
                {
                    return BllResultFactory.Error(result.Msg);
                }
                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;
                        cutPlanHeadRepository.Update(cutPlanHeads[0]);

                        BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ArriveReply, number.Value, cutPlanHeads[0].LotNo, "1", 0, material.TypesPlcCode, cutPlanHeads[0].Pipelength, material.Diameter, material.Thickness);
                        if (sendResult.Success)
                        {
                            uw.Commit();
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】位置到达成功，库存批次码【{cutPlanHeads[0].LotNo}】信息写入设备成功");
                        }
                        else
                        {
                            uw.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】位置到达失败，库存批次码【{cutPlanHeads[0].LotNo}】信息写入设备失败，原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw.Rollback();
                        return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】位置到达的时候，处理库存id【{cutPlanHeads[0].LotNo}】信息发生异常，原因：{ex.Message}");
                    }
                }
            }
            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 address = station.GoAddress;
                var cutPlanDetail = new CutPlanDetail();
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlanDetailRepository = new CutPlanDetailRepository();
                var baseMaterialRepository = new BaseMaterialRepository();
                var busWorkOrderHeadRepository = new BusWorkOrderHeadRepository();
                var busWorkOrderDetailRepository = new BusWorkOrderDetailRepository();
                var workOrderHead = new BusWorkOrderHead();
                var requestBarcode = station[StationProps.RequestBarcode.ToString()];
                var requestNumber = station[StationProps.RequestNumber.ToString()];
                if (string.IsNullOrEmpty(requestBarcode.Value))
                {
                    var cutPlanHeads = cutPlanHeadRepository.Where(t => t.State == (int)CutPlanHeadState.切割开始).ToList();
                    if (cutPlanHeads.Count != 1)
                    {
                        var msg = cutPlanHeads.Count > 1 ? $"有{cutPlanHeads.Count}条已经开始切割的管材" : $"没有找到已经开始切割的管材";
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失，切割方案{msg}");
                    }
                    cutPlanDetail = cutPlanDetailRepository.Where(t => t.HeadKeys == cutPlanHeads[0].Keys && t.CutState == (int)CutPlanDetailState.切割开始).OrderBy(t => t.CutStartTime).First();

                }
                else
                {
                    var convertResult = int.TryParse(requestBarcode.Value, out int BarCode);
                    if (!convertResult)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，工序任务ID【{requestBarcode.Value}】转化为整数失败！");
                    }
                    if (BarCode < 1)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，工序任务ID【{requestBarcode.Value}】不能小于1！");
                    }
                    cutPlanDetail = cutPlanDetailRepository.Where(t => t.BarCode == BarCode.ToString()).First();
                    if (cutPlanDetail == null)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，没有找到切割明细");
                    }

                }
                workOrderHead = busWorkOrderHeadRepository.Where(t => t.WorkOrderCode == cutPlanDetail.IwpNo).First();
                if (workOrderHead == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】 地址请求失败，找不到工序任务ID【{cutPlanDetail.IwpNo}】的数据");
                }
                var cutPlanDetails = cutPlanDetailRepository.Where(t => t.HeadKeys == cutPlanDetail.HeadKeys && t.CutState < (int)CutPlanDetailState.切割完成).ToList();
                var cutPlanHead = cutPlanHeadRepository.Where(t => t.Keys == cutPlanDetail.HeadKeys).First();
                //如果当前切割方案关联的切割明细数据总数只有一条的情况，就说明是最后一条切割明细，则需要修改切割头的状态为切割完成
                if (cutPlanDetails.Count == 1)
                {
                    cutPlanHead.State = (int)CutPlanHeadState.切割完成;
                    cutPlanHead.UpdateBy = user.UserCode;
                    cutPlanHead.UpdateTime = DateTime.Now;
                    cutPlanHead.CutEndTime = DateTime.Now;
                    cutPlanHead.ActualEndTime = DateTime.Now;
                }
                var material = baseMaterialRepository.Where(t => t.MaterialCode == cutPlanHead.MaterialCode).First();
                if (material == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，没有找到物料");
                }
                var workOrderDetails = busWorkOrderDetailRepository.Where(t => t.HeadKeys == workOrderHead.Keys).ToList();
                var workOrderDetail = workOrderDetails.FirstOrDefault(t => t.BarCode == cutPlanDetail.BarCode && t.State == (int)EnumOrderBodyStatus.生产中);
                var nextOprSequenceCodeWorkOrderDetails = workOrderDetails.Where(t => t.BarCode == cutPlanDetail.BarCode && t.State == (int)EnumOrderBodyStatus.初始化).OrderBy(t => t.SerialNumber).ToList();

                var NextStationCode = allEquipments.Where(t => t.SelfAddress == station.GoAddress).FirstOrDefault();
                if (NextStationCode == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，下个设备{station.GoAddress}没有找到，请检查设备表的自身地址");
                }

                BllService bllService = new BllService();
                var dict = bllService.GetDictWithDetails(x => x.Code == "MixPipeLength", y => y.Code == station.LineCode);
                if (!dict.Success || dict.Data == null || dict.Data.DictDetails.Count == 0)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，因为WCS字典中未设置线体可以自动运输的最小管段长度！请在WCS字典中设置！");
                }
                var mixPipeLength = dict.Data.DictDetails[0].Value;

                cutPlanDetail.CutState = (int)CutPlanDetailState.切割完成;
                cutPlanDetail.UpdateBy = user.UserCode;
                cutPlanDetail.UpdateTime = DateTime.Now;
                cutPlanDetail.CutEndTime = DateTime.Now;

                workOrderDetail.StationCode = station.WorkStationCode;
                workOrderDetail.ActualEndTime = DateTime.Now;
                workOrderDetail.State = (int)EnumOrderBodyStatus.已完成;
                workOrderDetail.UpdateTime = DateTime.Now;
                workOrderDetail.UpdateBy = user.UserCode;

                nextOprSequenceCodeWorkOrderDetails[0].StationCode = NextStationCode.WorkStationCode;
                nextOprSequenceCodeWorkOrderDetails[0].EquipmentCode = NextStationCode.Code;
                nextOprSequenceCodeWorkOrderDetails[0].State = (int)EnumOrderBodyStatus.运输中;
                nextOprSequenceCodeWorkOrderDetails[0].UpdateTime = DateTime.Now;
                nextOprSequenceCodeWorkOrderDetails[0].UpdateBy = user.UserCode;

                //设置工序任务头
                var otherPipeOrder = workOrderDetails.Where(t => t.SerialNumber == workOrderDetail.SerialNumber && t.BarCode != workOrderDetail.BarCode && t.State < (int)EnumOrderBodyStatus.已完成).ToList();
                //判断是否为工单中的第一个单管，当前工位工序，只在第一个单管执行。下个工位工序，只在最后一个单管执行
                if (!otherPipeOrder.Any())
                {
                    workOrderHead.NextStationCode = NextStationCode.WorkStationCode;
                    workOrderHead.NextOprSequenceCode = nextOprSequenceCodeWorkOrderDetails[0].OprSequenceCode;
                    workOrderHead.UpdateTime = DateTime.Now;
                    workOrderHead.UpdateBy = user.UserCode;
                }

                //判断管子长度，如果管子大于等于线体运输最小长度才可以自动运输，否则就需翻到切割下料台，等人工搬运
                if (cutPlanDetail.Cuttinglength >= Convert.ToDecimal(mixPipeLength))
                {

                    address = station.GoAddress;
                }
                else
                {
                    if (string.IsNullOrWhiteSpace(station.OutAddress))
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，没有下料地址！");
                    }
                    var barCodeDistinct = workOrderDetails.Select(t => t.BarCode).Distinct().Count();
                    if (barCodeDistinct <= 1)
                    {
                        //工单中只有一个管段，并且是短管就直接结束工单
                        workOrderHead.State = (int)EnumWorkOrderStatus.已完成;
                    }
                    address = station.OutAddress;
                }

                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        if (cutPlanDetails.Count == 1)
                        {
                            cutPlanHeadRepository.UnitOfWork = uw;
                            cutPlanHeadRepository.Update(cutPlanHead);
                        }


                        cutPlanDetailRepository.UnitOfWork = uw;
                        cutPlanDetailRepository.Update(cutPlanDetail);

                        busWorkOrderHeadRepository.UnitOfWork = uw;
                        busWorkOrderHeadRepository.Update(workOrderHead);

                        busWorkOrderDetailRepository.UnitOfWork = uw;
                        busWorkOrderDetailRepository.Update(workOrderDetail);
                        busWorkOrderDetailRepository.Update(nextOprSequenceCodeWorkOrderDetails[0]);


                        var sendResult = SendAddressReplyToPlc(station, plc, StationMessageFlag.WCSAddressReply, StationLoadStatus.Default, requestNumber.Value,
                                                                cutPlanDetail.BarCode.ToString(), address, "0",
                                                                material.TypesPlcCode, cutPlanDetail.Cuttinglength, material.Diameter, material.Thickness);
                        if (sendResult.Success)
                        {
                            uw.Commit();
                            WebApiService.SendIWPTechnologylineProcess(workOrderHead.WorkOrderCode, cutPlanDetail.BarCode, (int)EnumCutHeadState.切割完成);
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求成功，管段编码【{cutPlanDetail.BarCode}】信息写入设备成功");
                        }
                        else
                        {
                            uw.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，管段编码【{cutPlanDetail.BarCode}】信息写入设备失败，原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw.Rollback();
                        return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】的设备【{station.Name}】地址请求失败，处理管段编码【{cutPlanDetail.BarCode}】信息发生异常，原因：{ex.Message}");
                    }
                }
            }
            catch (Exception ex)
            {
                return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，异常原因：{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 ExcuteWalk(station, allEquipments, plc, user);
                }
                //if (controlType.Value == PLCControlType.设备测长.GetIndexString())
                //{
                //    return ExcuteMeasure(station, allEquipments, plc, user);
                //}
                //if (controlType.Value == PLCControlType.获取管段数据.GetIndexString())
                //{
                //    return ExcuteBevel(station, allEquipments, plc, user);
                //}
                if (controlType.Value == PLCControlType.切割指令.GetIndexString())
                {
                    return ExcuteCut(station, allEquipments, plc, user);
                }
                else if (controlType.Value == PLCControlType.打印指令.GetIndexString())
                {
                    return ExcutePint(station, allEquipments, plc, user);
                }
                //else if (controlType.Value == PLCControlType.激光除锈.GetIndexString())
                //{
                //    return ExcuteDerusting(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>
        /// 处理定长切割请求
        /// </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 number = station[StationProps.ArriveRealAddress.ToString()];
                var sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                var sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "CutFlanConfig").First();
                if (sysDictData == null)
                {
                    return BllResultFactory.Error($"因为中控系统字典中未设置废料长度！请在中控系统字典中设置！");
                }
                var cuttingRemainLength = Convert.ToDecimal(sysDictData.DictValue);
                //1 第一次切割的时候按照工单顺序切，第二次按照已切工单的匹配的切割方案中的的数据
                //查询套料方案明细
                string cuttingLength;
                string str = DateTime.Now.ToShortDateString();
                DateTime time1 = Convert.ToDateTime(str + " 0:00:00");
                DateTime time2 = Convert.ToDateTime(str + " 23:59:59");
                var init = (int)EnumWorkOrderStatus.初始化;
                var cutPlanHeadInit = (int)CutPlanHeadState.初始;
                var cutPlanHeadStart = (int)CutPlanHeadState.切割开始;
                var cutPlanDetailStart = (int)CutPlanDetailState.切割开始;
                var cutPlanDetailInit = (int)CutPlanDetailState.初始;

                var busWorkOrderHeadRepository = new BusWorkOrderHeadRepository();
                var busWorkOrderDetailRepository = new BusWorkOrderDetailRepository();
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlanDetailRepository = new CutPlanDetailRepository();
                var baseMaterialRepository = new BaseMaterialRepository();
                //var cutPlanDetails = new List<CutPlanDetail>();
                var cutPlanDetail = new CutPlanDetail();
                var cutPlanHead = new CutPlanHead();
                var controlBarcode = station[StationProps.ControlBarcode.ToString()];
                //如果有套料明细ID就是管段打码请求，否则就是余料、废料打码请求
                if (!string.IsNullOrWhiteSpace(controlBarcode.Value))
                {
                    var convertResult = int.TryParse(controlBarcode.Value, out int cuttingDetailId);
                    if (!convertResult)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，工单明细ID【{controlBarcode.Value}】转化为整数失败！");
                    }
                    if (cuttingDetailId < 1)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，工单明细ID【{controlBarcode.Value}】不能小于1！");
                    }

                    //查询套料方案明细
                    cutPlanDetail = cutPlanDetailRepository.Where(x => x.BarCode == cuttingDetailId.ToString()).First();
                    if (cutPlanDetail == null)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，根据工单明细ID【{controlBarcode.Value}】找不到套料明细！");
                    }
                    //查询套料方案头
                    cutPlanHead = cutPlanHeadRepository.Where(t => t.Keys == cutPlanDetail.HeadKeys).First();
                    if (cutPlanHead == null)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，根据keys【{cutPlanDetail.HeadKeys}】未找到套料方案！");
                    }
                }
                else
                {
                    var cutPlanHeads = cutPlanHeadRepository.Where(t => t.State == cutPlanHeadStart).ToList();
                    if (!cutPlanHeads.Any())
                    {
                        cutPlanHeads = cutPlanHeadRepository.Where(t => t.State == (int)CutPlanHeadState.下料完成).OrderByDescending(t => t.Level).ToList();
                        if (!cutPlanHeads.Any())
                        {
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，没有找到切割方案头");
                        }
                    }
                    cutPlanHead = cutPlanHeads[0];
                    var cutPlanDetails = cutPlanDetailRepository.Where(t => t.HeadKeys == cutPlanHead.Keys && t.CutState < cutPlanDetailStart).OrderByDescending(t => t.CutLevel).ToList();
                    if (!cutPlanDetails.Any())
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，没有找到切割方案明细");

                    }
                    cutPlanDetail = cutPlanDetails[0];
                }
                //找到已经开始切割的头表
                cutPlanHead.State = cutPlanHeadStart;

                var material = baseMaterialRepository.Where(t => t.MaterialCode == cutPlanHead.MaterialCode).First();
                if (material == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，没有找到物料");
                }
                var workOrder = busWorkOrderHeadRepository.Where(t => t.WorkOrderCode == cutPlanDetail.IwpNo).First();
                if (workOrder == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，没有找到工单");
                }
                //工单中多个管段确认工单明细
                var cutWorkOrders = busWorkOrderDetailRepository.Where(t => t.HeadKeys == workOrder.Keys).OrderBy(t => t.SerialNumber).ToList();
                if (!cutWorkOrders.Any())
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，没有找到工单明细");
                }
                var cutWorkOrder = cutWorkOrders.Where(t => t.BarCode == cutPlanDetail.BarCode && t.State == (int)EnumOrderBodyStatus.初始化).OrderBy(t => t.SerialNumber).First();
                if (cutWorkOrder == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】切割请求失败，没有找到条码为{cutPlanDetail.BarCode}工单明细");
                }
                var otherPipeOrder = cutWorkOrders.Where(t => t.SerialNumber == cutWorkOrder.SerialNumber && t.BarCode != cutWorkOrder.BarCode && t.State > (int)EnumOrderBodyStatus.初始化).ToList();
                //判断是否为工单中的第一个单管，当前工位工序，只在第一个单管执行。下个工位工序，只在最后一个单管执行
                if (!otherPipeOrder.Any())
                {
                    //工单头，只有在第一根管材的时候才修改时间
                    workOrder.NowOprSequenceCode = cutWorkOrder.OprSequenceCode;
                    workOrder.NowStationCode = cutWorkOrder.StationCode;
                    workOrder.ActualStartTime = DateTime.Now;
                    workOrder.State = (int)EnumWorkOrderStatus.生产中;
                }
                workOrder.NextOprSequenceCode = "";
                workOrder.NextStationCode = "";
                workOrder.UpdateTime = DateTime.Now;
                workOrder.UpdateBy = user.UserCode;

                cutWorkOrder.State = (int)EnumOrderBodyStatus.生产中;
                cutWorkOrder.EquipmentCode = station.Code;
                cutWorkOrder.StationCode = station.Code;
                cutWorkOrder.ActualStartTime = DateTime.Now;
                cutWorkOrder.UpdateTime = DateTime.Now;
                cutWorkOrder.UpdateBy = user.UserCode;

                //只有第一个切割才更新头的时间
                var isFirst = cutPlanDetailRepository.Where(t => t.HeadKeys == cutPlanHead.Keys && t.CutState >= (int)CutPlanDetailState.切割开始).ToList();
                if (!isFirst.Any())
                {
                    cutPlanHead.ActualstartTime = DateTime.Now;
                    cutPlanHead.CutStartTime = DateTime.Now;
                    cutPlanHead.UpdateTime = DateTime.Now;
                    cutPlanHead.UpdateBy = user.UserCode;
                }

                cuttingLength = cutPlanDetail.Cuttinglength.ToString();
                cutPlanDetail.CutState = (int)CutPlanDetailState.切割开始;
                cutPlanDetail.CutStartTime = DateTime.Now;
                cutPlanDetail.UpdateTime = DateTime.Now;
                cutPlanDetail.UpdateBy = user.UserCode;

                #region 依据套料明细，增加在制品记录，并且把对应的切割信息发送给切割机
                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {

                        busWorkOrderHeadRepository.UnitOfWork = uw;
                        busWorkOrderDetailRepository.UnitOfWork = uw;
                        cutPlanHeadRepository.UnitOfWork = uw;
                        cutPlanDetailRepository.UnitOfWork = uw;

                        busWorkOrderHeadRepository.Update(workOrder);
                        busWorkOrderDetailRepository.Update(cutWorkOrder);
                        cutPlanHeadRepository.Update(cutPlanHead);
                        cutPlanDetailRepository.Update(cutPlanDetail);



                        var sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, number.Value,
                                                        cutPlanDetail.BarCode, "0", PLCControlType.切割指令.GetIndexInt(),
                                                        material.TypesPlcCode, cutPlanHead.Pipelength, material.Diameter, material.Thickness, cutPlanDetail.Cuttinglength);
                        if (sendResult.Success)
                        {
                            uw?.Commit();
                            WebApiService.SendIWPTechnologylineProcess(workOrder.WorkOrderCode, cutPlanDetail.BarCode, (int)EnumCutHeadState.切割进行);
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】切割请求成功，对管材【{cutPlanHead.LotNo}】开始执行切割工单明细ID【{cutPlanDetail.Id}】的【{cutPlanDetail.Cuttinglength}】毫米管段切割。");
                        }
                        else
                        {
                            uw?.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】切割请求失败，对管材【{cutPlanHead.LotNo}】开始执行切割工单明细ID【{cutPlanDetail.Id}】的【{cutPlanDetail.Cuttinglength}】毫米管段切割的时候，写入PLC失败，原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw.Rollback();
                        return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】设备【{station.Name}】切割请求发生异常，对管材【{cutPlanHead.LotNo}】开始执行切割工单明细ID【{cutPlanDetail.Id}】的【{cutPlanDetail.Cuttinglength}】毫米管段切割的时候产生异常，原因:{ex.Message}");
                    }
                }
                #endregion
            }
            catch (Exception ex)
            {
                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 ExcutePint(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                if (SendDataToMarking.markingFlag == MarkingFlagTocx.初始 || SendDataToMarking.markingFlag == MarkingFlagTocx.打标中)
                {
                    return BllResultFactory.Success();
                }
                string barcode = "";
                CutPlanHead cutPlanHead = null;
                CutPlanDetail cutPlanDetail = null;
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlanDetailRepository = new CutPlanDetailRepository();
                var cutOrPrintPlanRepository = new CutOrPrintPlanRepository();
                var number = station[StationProps.ArriveRealAddress.ToString()];
                var controlOtherBarcode = station[StationProps.ControlOtherBarcode.ToString()];
                var controlBarcode = station[StationProps.ControlBarcode.ToString()];
                //如果有套料明细ID就是管段打码请求，否则就是余料、废料打码请求
                if (!string.IsNullOrWhiteSpace(controlBarcode.Value))
                {
                    var convertResult = int.TryParse(controlBarcode.Value, out int cuttingDetailId);
                    if (!convertResult)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，工单明细ID【{controlBarcode.Value}】转化为整数失败！");
                    }
                    if (cuttingDetailId < 1)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，工单明细ID【{controlBarcode.Value}】不能小于1！");
                    }
                    //查询套料方案明细
                    cutPlanDetail = cutPlanDetailRepository.Where(x => x.BarCode == cuttingDetailId.ToString()).First();
                    if (cutPlanDetail == null)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，根据工单明细ID【{controlBarcode.Value}】找不到套料明细！");
                    }
                    //查询套料方案头
                    cutPlanHead = cutPlanHeadRepository.Where(t => t.Keys == cutPlanDetail.HeadKeys).First();
                    if (cutPlanHead == null)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，根据keys【{cutPlanDetail.HeadKeys}】未找到套料方案！");
                    }
                }
                else
                {
                    var prin = PLCControlType.打印指令.GetIndexInt();
                    var cutOrPrintPlans = cutOrPrintPlanRepository.Where(t => t.State == 100 && t.Control == 3).OrderByDescending(t => t.WalkTotal).ToList();
                    if (!cutOrPrintPlans.Any())
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，找不到行走方案！");
                    }
                    ///查询套料方案明细
                    cutPlanDetail = cutPlanDetailRepository.Where(x => x.BarCode == cutOrPrintPlans[0].BarCode).First();
                    if (cutPlanDetail == null)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，根据工单明细ID【{controlBarcode.Value}】找不到套料明细！");
                    }
                    ////查询套料方案头
                    cutPlanHead = cutPlanHeadRepository.Where(t => t.Keys == cutPlanDetail.HeadKeys).First();
                    if (cutPlanHead == null)
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，根据一件一码【{controlBarcode.Value}】未找到套料方案！");
                    }
                }

                if (cutPlanHead.State == CutPlanHeadState.切割完成.GetIndexInt())
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，一件一码【{cutPlanHead.LotNo}】对应的套料方案已经执行完成，请检查数据！");
                }

                //查询物料信息
                var materialRepository = new BaseMaterialRepository();
                var material = materialRepository.Where(x => x.MaterialCode == cutPlanHead.MaterialCode).First();
                if (material == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】打印请求失败，根据管材【{cutPlanHead.LotNo}】的套料计划的物料编码【{cutPlanHead.MaterialCode}】找不到物料信息！请检查基础数据！");
                }
                if (material.Diameter == 0 || material.Thickness == 0)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求失败，物料【{material.MaterialCode}】【{material.MaterialName}】的管径、壁厚参数不得为0，请检查基础数据！");
                }
                if (SendDataToMarking.markingFlag == MarkingFlagTocx.空闲)
                {
                    if (cutPlanDetail == null)
                    {
                        #region 余料发送打标机、废料直接响应PLC
                        var sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                        var sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "CuttingWasteLength").First();
                        if (sysDictData == null)
                        {
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求失败，因为中控系统字典中未设置废料长度！请在中控系统字典中设置！");
                        }
                        //剩余长度大于废料标准，就是余料需要打码，否则就是废料就不需要打码
                        if (cutPlanHead.OddmentsLength > Convert.ToDecimal(sysDictData.DictValue))
                        {
                            // 发送打标
                            var printResult = MarkingNormalExcute.PrintBarcode(cutPlanHead, material.Diameter);
                            if (printResult.Success)
                            {
                                return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求成功，给打标机发送条码【{cutPlanHead.OddmentsCode}】成功！");
                            }
                            else
                            {
                                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求失败，给打标机发送条码【{cutPlanHead.OddmentsCode}】失败，原因：{printResult.Msg}！");
                            }
                        }
                        else
                        {
                            // 告诉切割机，不用打标
                            BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, number.Value, "", "0", PrintFlag.WCS回复不需要打码.GetIndexInt(), material.TypesPlcCode, Convert.ToInt32(cutPlanHead.Pipelength), material.Diameter, material.Thickness, cutPlanDetail.Cuttinglength);
                            if (sendResult.Success)
                            {
                                return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求成功，WCS回复不需要打码！");
                            }
                            else
                            {
                                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求成功，WCS回复不需要打码，写入PLC失败失败，原因：{sendResult.Msg}！");
                            }
                        }
                        #endregion
                    }
                    else
                    {
                        #region 普通管段打码，如果管段状态是初始，那么就要修改套料状态再发送打码指令，否则就是多次打码，那就直接发送打码指令
                        // 管段的套料明细ID
                        barcode = cutPlanDetail.BarCode.ToString();

                        if (cutPlanDetail.CutState != CutPlanDetailState.初始.GetIndexInt())
                        {
                            var printResult = MarkingNormalExcute.PrintBarcode(cutPlanDetail, material.Diameter, cutPlanHead.LineCode);
                            if (printResult.Success)
                            {
                                return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求成功，给打标机发送条码【{cutPlanDetail.BarCode}】成功！");
                            }
                            else
                            {
                                return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求失败，给打标机发送条码【{cutPlanDetail.BarCode}】失败，原因：{printResult.Msg}");
                            }
                        }
                        else
                        {
                            using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                            {
                                try
                                {
                                    if (cutPlanHead.State == CutPlanHeadState.初始.GetIndexInt())
                                    {
                                        //cutPlanHeadRepository.UnitOfWork = uw;
                                        // 更新状态
                                        //cutPlanHead.State = CutPlanHeadState.激光打标.GetIndexInt();
                                        //更新套料计划头
                                        //cutPlanHeadRepository.Update(cutPlanHead);
                                    }
                                    if (cutPlanDetail.CutState == CutPlanDetailState.初始.GetIndexInt())
                                    {
                                        cutPlanDetailRepository.UnitOfWork = uw;
                                        // 更新状态
                                        cutPlanDetail.CutState = CutPlanDetailState.激光打标.GetIndexInt();
                                        //更新套料计划明细
                                        cutPlanDetailRepository.Update(cutPlanDetail);
                                    }
                                    // 发送打标机进行打标
                                    var printResult = MarkingNormalExcute.PrintBarcode(cutPlanDetail, material.Diameter, cutPlanHead.LineCode);
                                    if (printResult.Success)
                                    {
                                        // 发送回复确认打标成功
                                        uw?.Commit();
                                        return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求成功，给打标机发送条码【{cutPlanDetail.BarCode}】成功！");
                                    }
                                    else
                                    {
                                        uw?.Rollback();
                                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求失败，给打标机发送条码【{cutPlanDetail.BarCode}】失败，原因：{printResult.Msg}");
                                    }
                                }
                                catch (Exception ex)
                                {
                                    uw?.Rollback();
                                    return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求出现异常，异常原因：" + ex.Message);
                                }
                            }
                        }

                        #endregion
                    }
                }
                else if (SendDataToMarking.markingFlag == MarkingFlagTocx.打标完成)
                {
                    decimal cutLength = cutPlanDetail == null ? cutPlanHead.OddmentsLength : cutPlanDetail.Cuttinglength;
                    BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, number.Value, barcode, "0", PLCControlType.打印指令.GetIndexInt(), material.TypesPlcCode, cutPlanHead.Pipelength, material.Diameter, material.Thickness, cutLength);
                    if (sendResult.Success)
                    {
                        SendDataToMarking.markingFlag = MarkingFlagTocx.空闲;
                        SendDataToMarking.waitACK = false;
                        return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求成功，回复打标完成信息写入PLC成功！");
                    }
                    else
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】打印请求成功，回复打标完成信息写入PLC失败失败，原因：{sendResult.Msg}");
                    }
                }

                return BllResultFactory.Error();
            }
            catch (Exception ex)
            {
                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 ExcuteDerusting(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                if (SendDataToMarking.markingFlag == MarkingFlagTocx.初始 || SendDataToMarking.markingFlag == MarkingFlagTocx.打标中)
                {
                    return BllResultFactory.Success();
                }
                if (SendDataToMarking.markingFlag == MarkingFlagTocx.空闲)
                {
                    return MarkingNormalExcute.PrintDerusting();
                }
                else
                {
                    BllResult sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", "0", "0", PLCControlType.激光除锈.GetIndexInt(), 0, 0, 0, 0, 0);
                    if (sendResult.Success)
                    {
                        SendDataToMarking.markingFlag = MarkingFlagTocx.空闲;
                        SendDataToMarking.waitACK = false;
                        return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】除锈请求成功，回复除锈完成信息写入PLC成功！");
                    }
                    else
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】除锈请求成功，回复除锈完成信息写入PLC失败失败，原因：{sendResult.Msg}");
                    }
                }
            }
            catch (Exception ex)
            {
                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 ExcuteWalkPlan(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                //第一次切割所需的坡口长度（每个管段都需要头尾2端消耗长度）
                var sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                var sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "CutFlanConfig").First();
                if (sysDictData == null)
                {
                    return BllResultFactory.Error($"因为中控系统字典中未设置切割损耗长度！请在中控系统字典中设置！");
                }
                var a = Convert.ToDecimal(sysDictData.DictValue);

                //打码和管子一端的距离
                sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "PintLength").First();
                if (sysDictData == null)
                {
                    return BllResultFactory.Error($"因为中控系统字典中未设置初始打码长度！请在中控系统字典中设置！");
                }
                var b = Convert.ToDecimal(sysDictData.DictValue);

                //切割机和传感器的距离
                sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "EquipmentLength").First();
                if (sysDictData == null)
                {
                    return BllResultFactory.Error($"因为中控系统字典中未设置传感器和切割机的距离！请在中控系统字典中设置！");
                }
                var c = Convert.ToDecimal(sysDictData.DictValue);

                //打码机和传感器的距离
                sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "PrintLength").First();
                if (sysDictData == null)
                {
                    return BllResultFactory.Error($"因为中控系统字典中未设置打码机和传感器的距离！请在中控系统字典中设置！");
                }
                var d = Convert.ToDecimal(sysDictData.DictValue);

                //只能打一个码的长度
                sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "OnlyPrintLength").First();
                if (sysDictData == null)
                {
                    return BllResultFactory.Error($"因为中控系统字典中未设置只能打一个码的长度！请在中控系统字典中设置！");
                }
                var e = Convert.ToDecimal(sysDictData.DictValue);


                //首段坡口损耗
                sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                sysDictData = sysDictDataRepository.Where(t => t.DictType == "CutConfig" && t.DictLabel == "BevelLoss").First();
                if (sysDictData == null)
                {
                    return BllResultFactory.Error($"因为中控系统字典中未设置首段坡口损耗！请在中控系统字典中设置！");
                }
                var f = Convert.ToDecimal(sysDictData.DictValue);


                //每次累加完管段和磨损量的长度，每次打码的初始量
                decimal L = 0;
                //管段长度，初始为0
                var l = 0;

                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlanDetailRepository = new CutPlanDetailRepository();
                //CutOrPrintPlan cutOrPrintPlan=new CutOrPrintPlan();
                List<CutOrPrintPlan> cutOrPrintPlanList = new List<CutOrPrintPlan>();
                var cutPlanHead = cutPlanHeadRepository.Where(t => t.State == (int)CutPlanHeadState.下料开始).First();
                var cutPlanDetails = cutPlanDetailRepository.Where(t => t.HeadKeys == cutPlanHead.Keys).OrderByDescending(t => t.CutLevel).ToList();

                //每根长管第一次都要切割
                CutOrPrintPlan cutOrPrintPlan = new CutOrPrintPlan();
                cutOrPrintPlan.HeadKeys = cutPlanHead.Keys;
                cutOrPrintPlan.WalkTotal = L + c + f;
                cutOrPrintPlan.State = 0;
                cutOrPrintPlan.Control = (int)PLCControlType.首端坡口;
                cutOrPrintPlan.BarCode = cutPlanDetails[0].BarCode;
                cutOrPrintPlan.CreateBy = user.UserCode;
                cutOrPrintPlan.CreateTime = DateTime.Now;
                cutOrPrintPlanList.Add(cutOrPrintPlan);

                //初始长度加上首段坡口的损耗
                L += f;
                for (int i = 0; i < cutPlanDetails.Count; i++)
                {
                    l = (int)cutPlanDetails[i].Cuttinglength;
                    //每个管子需要2个打码和一个切割
                    CutOrPrintPlan cutOrPrintPlan1 = new CutOrPrintPlan();
                    cutOrPrintPlan1.HeadKeys = cutPlanHead.Keys;
                    cutOrPrintPlan1.WalkTotal = L + b + d;
                    cutOrPrintPlan1.State = 0;
                    cutOrPrintPlan1.Control = (int)PLCControlType.打印指令;
                    cutOrPrintPlan1.BarCode = cutPlanDetails[i].BarCode;
                    cutOrPrintPlan1.CreateBy = user.UserCode;
                    cutOrPrintPlan1.CreateTime = DateTime.Now;
                    cutOrPrintPlanList.Add(cutOrPrintPlan1);

                    if (cutPlanDetails[i].Cuttinglength >= e)
                    {
                        CutOrPrintPlan cutOrPrintPlan2 = new CutOrPrintPlan();
                        cutOrPrintPlan2.HeadKeys = cutPlanHead.Keys;
                        //1.3.标准件管段码（管段2端分别打码）1.4.成品管线管段码（管段1端打码）
                        cutOrPrintPlan2.WalkTotal = cutPlanDetails[i].Isendproduct == 0 ? L + l - b + d : L + b + b + d;
                        //cutOrPrintPlan2.WalkTotal = L + l - b + d;
                        cutOrPrintPlan2.State = 0;
                        cutOrPrintPlan2.Control = (int)PLCControlType.打印指令;
                        cutOrPrintPlan2.BarCode = cutPlanDetails[i].BarCode;
                        cutOrPrintPlan2.CreateBy = user.UserCode;
                        cutOrPrintPlan2.CreateTime = DateTime.Now;
                        cutOrPrintPlanList.Add(cutOrPrintPlan2);
                    }
                    //切割之前算一次损耗，把损耗长度预留在内
                    L += l + a;

                    CutOrPrintPlan cutOrPrintPlan3 = new CutOrPrintPlan();
                    cutOrPrintPlan3.HeadKeys = cutPlanHead.Keys;
                    cutOrPrintPlan3.WalkTotal = L + c;
                    cutOrPrintPlan3.State = 0;
                    cutOrPrintPlan3.Control = (int)PLCControlType.切割指令;
                    cutOrPrintPlan3.BarCode = cutPlanDetails[i].BarCode;
                    cutOrPrintPlan3.CreateBy = user.UserCode;
                    cutOrPrintPlan3.CreateTime = DateTime.Now;
                    cutOrPrintPlanList.Add(cutOrPrintPlan3);

                    //切割之后算一次损耗，把损耗长度预留在内
                    L += a;
                }
                #region 余料和废料处理
                //BllService bllService = new BllService();
                //var dict = bllService.GetDictWithDetails(x => x.Code == "MaxOddmentLength", y => y.Code == station.LineCode);
                //if (!dict.Success || dict.Data == null || dict.Data.DictDetails.Count == 0)
                //{
                //    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】地址请求失败，因为WCS字典中未设置线体可以自动运输的最小管段长度！请在WCS字典中设置！");
                //}
                //var mixPipeLength = dict.Data.DictDetails[0].Value;
                //if (cutPlanHead.Pipelength - L > Convert.ToDecimal(mixPipeLength))
                //{
                //    CutOrPrintPlan cutOrPrintPlan4 = new CutOrPrintPlan();
                //    cutOrPrintPlan4.HeadKeys = cutPlanHead.Keys;
                //    cutOrPrintPlan4.WalkTotal = L + b;
                //    cutOrPrintPlan4.State = 0;
                //    cutOrPrintPlan4.Control = (int)PLCControlType.打印指令;
                //    cutOrPrintPlan4.BarCode = cutPlanHead.OddmentsCode;
                //    cutOrPrintPlan4.CreateBy = user.UserCode;
                //    cutOrPrintPlan4.CreateTime = DateTime.Now;
                //    cutOrPrintPlanList.Add(cutOrPrintPlan4);

                //    CutOrPrintPlan cutOrPrintPlan5 = new CutOrPrintPlan();
                //    cutOrPrintPlan5.HeadKeys = cutPlanHead.Keys;
                //    cutOrPrintPlan5.WalkTotal = L + b + b;
                //    cutOrPrintPlan5.State = 0;
                //    cutOrPrintPlan5.Control = (int)PLCControlType.打印指令;
                //    cutOrPrintPlan5.BarCode = cutPlanHead.OddmentsCode;
                //    cutOrPrintPlan5.CreateBy = user.UserCode;
                //    cutOrPrintPlan5.CreateTime = DateTime.Now;
                //    cutOrPrintPlanList.Add(cutOrPrintPlan5);
                //}

                #endregion

                #region 没有余料和废料的处理
                //只有没有余料编码和余料长度的
                if (cutPlanHead.OddmentsLength == 0 && string.IsNullOrEmpty(cutPlanHead.OddmentsCode))
                {
                    //找到最后一个切割指令
                    var lastCutPlan = cutOrPrintPlanList.LastOrDefault(t => t.Control == (int)PLCControlType.切割指令);
                    lastCutPlan.Control = (int)PLCControlType.最后一段;
                    BusWorkOrderDetailRepository busWorkOrderDetailRepository = new BusWorkOrderDetailRepository();
                    var workOrderDetail=busWorkOrderDetailRepository.Where(t => t.BarCode == lastCutPlan.BarCode && t.WorkCenterCode == "CutBevel").ToList();
                    workOrderDetail[0].State = (int)EnumOrderBodyStatus.生产中;
                    busWorkOrderDetailRepository.Update(workOrderDetail);



                    //最后一段打码只能连续挨着打，不能一头一尾，应为管子长度为虚拟，以防打码到管子以外的地方
                    var lastPrintPlan = cutOrPrintPlanList.LastOrDefault(t => t.Control == (int)PLCControlType.打印指令);
                    var lastTwoPrintPlan = cutOrPrintPlanList.FirstOrDefault(t => t.Control == (int)PLCControlType.打印指令&& t.BarCode==lastPrintPlan.BarCode);
                    lastPrintPlan.WalkTotal = lastTwoPrintPlan.WalkTotal + b;
                    //cutOrPrintPlanList.Remove(lastCutPlan);
                }

                #endregion

                #region 根据长度排序和计算单次行走长度
                //冒泡排序
                for (int j = 0; j < cutOrPrintPlanList.Count - 1; j++)
                {
                    for (int i = 0; i < cutOrPrintPlanList.Count - 1; i++)
                    {
                        CutOrPrintPlan temp;
                        if (cutOrPrintPlanList[i].WalkTotal > cutOrPrintPlanList[i + 1].WalkTotal)
                        {
                            temp = cutOrPrintPlanList[i];
                            cutOrPrintPlanList[i] = cutOrPrintPlanList[i + 1];
                            cutOrPrintPlanList[i + 1] = temp;
                        }
                    }
                }
                //计算每个操作需要行走的距离
                for (int i = 0; i < cutOrPrintPlanList.Count; i++)
                {

                    if (i == 0)
                    {
                        cutOrPrintPlanList[i].Walk = cutOrPrintPlanList[i].WalkTotal;
                    }
                    else
                    {
                        cutOrPrintPlanList[i].Walk = cutOrPrintPlanList[i].WalkTotal - cutOrPrintPlanList[i - 1].WalkTotal;
                    }
                }
                #endregion

                CutOrPrintPlanRepository cutOrPrintPlanRepository = new CutOrPrintPlanRepository();
                cutOrPrintPlanRepository.Insert(cutOrPrintPlanList);


                return BllResultFactory.Success();


            }
            catch (Exception ex)
            {
                return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】设备【{station.Name}】计算切割打码行走任务，发生异常：{ex.Message}");
            } 
        }
        /// <summary>
        /// 发送测长数量
        /// </summary>
        /// <param name="station"></param>
        /// <param name="allEquipments"></param>
        /// <param name="plc"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public BllResult ExcuteMeasure(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                BaseLoaderTaskRepository baseLoaderRepository = new BaseLoaderTaskRepository();
                var baselodertask = baseLoaderRepository.Where(t => t.loaderStatus == (int)BaseLoaderTaskStatus.初始).OrderBy(t => t.materialCode).ToList();

                var isbaseloder = baselodertask.GroupBy(t => t.taskCode).ToList();
                if (isbaseloder.Count > 1)
                {
                    var msg = isbaseloder.Count > 1 ? $"存在不同测长计划" : $"没有找到可以测长的计划";
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】测长请求失败，{msg}");
                }
                if (isbaseloder.Count < 1)
                {
                    //直接回复电气完成
                    var sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0",
                                                      "0", "0", 0, 0, 0, 0, 0, 0);
                    if (sendResult.Success)
                    {
                        return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】测长请求执行完成");
                    }
                    else
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】测长请求执行完成失败，下发数据给PLC失败原因：{sendResult.Msg}");
                    }
                }
                baselodertask[0].loaderStatus = (int)BaseLoaderTaskStatus.测长上料中;
                baselodertask[0].updateTime = DateTime.Now;
                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        baseLoaderRepository.UnitOfWork = uw;
                        baseLoaderRepository.Update(baselodertask[0]);
                        var sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", baselodertask[0].taskCode.ToString(), baselodertask[0].feedbackNum, PLCControlType.设备测长.GetIndexInt(), 0, 0, 0, 0,0);
                        if (sendResult.Success)
                        {
                            uw?.Commit();
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】测长请求成功，条码{baselodertask[0].taskCode}，测长数量{baselodertask[0].loaderNum}");
                        }
                        else
                        {
                            uw?.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】测长请求失败，下发数据给PLC失败原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex )
                    {
                        uw.Rollback();
                        return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】设备【{station.Name}】测长请求失败,下发测长数据的时候发生异常：{ex.Message}");
                    }
                }
            }
            catch (Exception ex)
            {
                // uw.Rollback();
                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 ExcuteWalk(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                CutOrPrintPlanRepository cutOrPrintPlanRepository = new CutOrPrintPlanRepository();
                var cutOrPrintPlans = cutOrPrintPlanRepository.Where(t => t.State == 0).OrderBy(t => t.WalkTotal).ToList();
                var isNotOver = cutOrPrintPlans.GroupBy(t => t.HeadKeys).ToList();
                if (isNotOver.Count > 1)
                {
                    var msg = isNotOver.Count > 1 ? $"存在不同切割头的行走计划" : $"没有找到可以行走的计划";
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】行走请求失败，{msg}");

                }
                if (cutOrPrintPlans.Count < 1)
                {
                    //执行完成，直接告诉plc
                    var sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0",
                                                       "0", "0", 0, 0, 0, 0, 0, 0);
                    if (sendResult.Success)
                    {
                        return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】行走请求执行完成");
                    }
                    else
                    {
                        return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】行走请求执行完成失败，下发数据给PLC失败原因：{sendResult.Msg}");
                    }
                }
                cutOrPrintPlans[0].State = 100;
                cutOrPrintPlans[0].UpdateBy = user.UserCode;
                cutOrPrintPlans[0].UpdateTime = DateTime.Now;
                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        //cutOrPrintPlans[0].WalkTotal * 10
                        cutOrPrintPlanRepository.UnitOfWork = uw;
                        cutOrPrintPlanRepository.Update(cutOrPrintPlans[0]);
                        var sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", cutOrPrintPlans[0].BarCode, cutOrPrintPlans[0].Control.ToString(), PLCControlType.管段行走.GetIndexInt(), 0, 0, 0, 0, cutOrPrintPlans[0].Walk * 10);
                        if (sendResult.Success)
                        {
                            uw?.Commit();
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】行走请求成功，条码{cutOrPrintPlans[0].BarCode}，行走动作{cutOrPrintPlans[0].Control}，行走总长度{cutOrPrintPlans[0].WalkTotal}，行走长度{cutOrPrintPlans[0].Walk}");
                        }
                        else
                        {
                            uw?.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】行走请求失败，下发数据给PLC失败原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw.Rollback();
                        return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】设备【{station.Name}】行走请求失败,下发行走数据的时候发生异常：{ex.Message}");
                    }
                }



            }
            catch (Exception ex)
            {
                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 ExcuteBevel(Equipment station, List<Equipment> allEquipments, PLCCore plc, User user)
        {
            try
            {
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var materialRepository = new BaseMaterialRepository();
                CutOrPrintPlanRepository cutOrPrintPlanRepository = new CutOrPrintPlanRepository();
                var controlBarcode = station[StationProps.ControlBarcode.ToString()];
                var convertResult = int.TryParse(controlBarcode.Value, out int cuttingDetailId);
                var cutOrPrintPlans = cutOrPrintPlanRepository.Where(t => t.BarCode== cuttingDetailId.ToString() && t.Control == (int)PLCControlType.首端坡口).ToList();
                var cutPlanHeads = cutPlanHeadRepository.Where(t => t.Keys == cutOrPrintPlans[0].HeadKeys).ToList();
                var material = materialRepository.Where(x => x.MaterialCode == cutPlanHeads[0].MaterialCode).First();
                if (material == null)
                {
                    return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】的设备【{station.Name}】请求首端坡口失败，根据管材【{cutPlanHeads[0].LotNo}】的套料计划的物料编码【{cutPlanHeads[0].MaterialCode}】找不到物料信息！请检查基础数据！");
                }
                using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                {
                    try
                    {
                        var sendResult = SendAckToPlc(station, plc, StationMessageFlag.WCSPLCACK, StationLoadStatus.ControlReply, "0", "0", "0", cutOrPrintPlans[0].Control, material.TypesPlcCode, 0, material.Diameter, material.Thickness, 0);
                        if (sendResult.Success)
                        {
                            uw?.Commit();
                            return BllResultFactory.Success($"处理工位【{station.WorkStationCode}】设备【{station.Name}】请求首端坡口成功，条码{cutOrPrintPlans[0].BarCode}，管径{material.Diameter}，材质{material.TypesPlcCode}，壁厚{material.Thickness}");
                        }
                        else
                        {
                            uw?.Rollback();
                            return BllResultFactory.Error($"处理工位【{station.WorkStationCode}】设备【{station.Name}】请求首端坡口失败，下发数据给PLC失败原因：{sendResult.Msg}");
                        }
                    }
                    catch (Exception ex)
                    {
                        uw.Rollback();
                        return BllResultFactory.Exception(ex, $"处理工位【{station.WorkStationCode}】设备【{station.Name}】请求首端坡口失败,下发行走数据的时候发生异常：{ex.Message}");
                    }
                }



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