高翔 / ECS-ZJHX · Files

using Hh.Mes.Common.Json;
using HHECS.Application.Enums;
using HHECS.Application.Error;
using HHECS.Application.Service;
using HHECS.BLL.EquipmentExcute.Machine;
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.Repository;
using HHECS.EquipmentExcute.CacheShelf;
using HHECS.Executor.EquipmentHandler;
using HHECS.Executor.EquipmentHandler.Machine;
using HHECS.Executor.EquipmentHandler.Truss;
using HHECS.Infrastructure.CommonHelper;
using HHECS.Infrastructure.Enums;
using HHECS.Infrastructure.Notice;
using HHECS.Model.Dtos;
using HHECS.Model.Entities;
using HHECS.Model.Enums;
using HHHECS.Model.Enums;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using static FreeSql.Internal.GlobalFilter;

namespace HHECS.Executor
{
    /// <summary>
    /// 执行类，此类请使用单例模式并调用inti方法
    /// </summary>
    public class EquipmentExecutor
    {
        #region 属性

        /// <summary>
        /// 设备执行时，触发日志记录
        /// 交由前台程序自己实现，比如WPF客户端记录到日志控件
        /// </summary>
        public event Action<object, EquipmentExecuteLogEventArgs> EquipmentExecuteLog;

        /// <summary>
        /// 为true表示停止，为false表示执行
        /// </summary>
        private bool stop = true;

        /// <summary>
        /// 是否可执行
        /// </summary>
        public bool CanExcute { get; private set; } = false;

        /// <summary>
        /// 设备服务类
        /// </summary>
        public ExecuteService ExcuteService { get; set; } = new ExecuteService();

        public List<TrussExcute> TrussExcutes { get; private set; } = new List<TrussExcute>();

        public List<StationExecute> StationExecutes { get; private set; } = new List<StationExecute>();

        //public List<MarkingExcute> MarkingExcutes { get; set; } = new List<MarkingExcute>();


        public string WarehouseCode { get; }

        /// <summary>
        /// 所有设备
        /// </summary>
        public List<Equipment> Equipments { get; set; }

        /// <summary>
        /// 任务服务
        /// </summary>
        private TaskService taskService = new TaskService();

        /// <summary>
        /// PLC访问类
        /// </summary>
        public PLCCore PLC { get; set; }

        /// <summary>
        /// 是否在执行中
        /// </summary>
        public bool IsExecuting
        {
            get { return CanExcute && !stop; }
        }

        /// <summary>
        /// 默认延迟100
        /// </summary>
        public int Delay { get; set; } = 100;


        /// <summary>
        /// 当前执行的用户
        /// 可传递一个WCS用户
        /// </summary>
        public User User { get; set; }

        /// <summary>
        /// 执行监控类
        /// </summary>
        public List<TaskExcutorModel> TaskExcutes { get; set; } = new List<TaskExcutorModel>();

        #endregion
        


        /// <summary>
        /// 执行线程
        /// </summary>
        private void Excuting()
        {
            //todo:自定义设备分组，这里以仓库下的PLCIP分组为例
            var groups = Equipments.GroupBy(t => new { t.WarehouseCode, t.IP }).ToList();
            foreach (var item in groups)
            {
                TaskExcutorModel taskExcutorModelMonitor = new TaskExcutorModel();
                taskExcutorModelMonitor.Code = $"执行标记：{item.Key}";
                taskExcutorModelMonitor.EquipmentCodes = item.ToList().Select(t => t.Code).Aggregate((a, b) => a + "," + b);
                taskExcutorModelMonitor.ExcuteTask = Task.Factory.StartNew(async () =>
                {
                    Stopwatch stopwatch = new Stopwatch();
                    while (true)
                    {
                        //TestExcute(item.Key.IP);
                        await Task.Delay(Delay);
                        stopwatch.Restart();
                        if (CanExcute && !stop)
                        {
                            var result = Excute(item.ToList(), item.Key.IP);
                            EquipmentExecuteLog?.Invoke(this, new EquipmentExecuteLogEventArgs(result.Code, null, result.Exception, result.Msg, result.ErrorCode));
                        }
                        stopwatch.Stop();
                        taskExcutorModelMonitor.Time = stopwatch.ElapsedMilliseconds;
                    }
                }, TaskCreationOptions.LongRunning).Unwrap();
                TaskExcutes.Add(taskExcutorModelMonitor);
            }

            //设备报警,按收集报警的时间点计算
            TaskExcutorModel taskExcutorModel = new TaskExcutorModel();
            taskExcutorModel.Code = $"执行标记：辅助线程";
            taskExcutorModel.ExcuteTask = Task.Factory.StartNew(async () =>
            {
                //默认，只有在设备启动开始后，才会
                Stopwatch stopwatch = new Stopwatch();
                while (true)
                {
                    //await Task.Delay(60000);
                    await Task.Delay(6000);
                    stopwatch.Restart();
                    if (!stop && CanExcute)
                    {
                        //CallPipe(Equipments);
                        //CollectData();
                        //EquipmentCommon.EquipmentAlarmGenerate(Equipments);
                        //EquipmentCommon.EquipmentStatusRecordGenerate(Equipments);


                        //EquipmentCommon.DataUpd(Equipments);


                        //OPCUA设备采集
                        //SendDataToOPCUA.ConnectOPCUA();
                        //大族激光采集数据
                        //SendDataToMarking.SendData();
                    }
                    EquipmentCommon.EquipmentAlarmAutoEndAsync();
                    //EquipmentCommon.EquipmentStatusAutoEnd();
                    stopwatch.Stop();
                    taskExcutorModel.Time = stopwatch.ElapsedMilliseconds;
                }
            }, TaskCreationOptions.LongRunning).Unwrap();
            TaskExcutes.Add(taskExcutorModel);
            //TaskExcutorModel taskExcutorModel1 = new TaskExcutorModel();
            //taskExcutorModel1.Code = $"执行标记：激光切割线程";
            //taskExcutorModel1.ExcuteTask = Task.Factory.StartNew(async () =>
            //{
            //    //默认，只有在设备启动开始后，才会
            //    Stopwatch stopwatch = new Stopwatch();
            //    while (true)
            //    {
            //        //await Task.Delay(60000);
            //        await Task.Delay(6000);
            //        stopwatch.Restart();
            //        if (!stop && CanExcute)
            //        {

            //            //CallPipe(Equipments);
            //            //CollectData();
            //            EquipmentCommon.CutEquipmentTaskAssign();
            //            //EquipmentCommon.EquipmentStatusRecordGenerate(Equipments);


            //            //EquipmentCommon.DataUpd(Equipments);


            //            //OPCUA设备采集
            //            //SendDataToOPCUA.ConnectOPCUA();
            //            //大族激光采集数据
            //            //SendDataToMarking.SendData();
            //        }
            //        //EquipmentCommon.EquipmentAlarmAutoEndAsync();
            //        //EquipmentCommon.EquipmentStatusAutoEnd();
            //        //EquipmentCommon.CutEquipmentTaskAssign();
            //        stopwatch.Stop();
            //        taskExcutorModel1.Time = stopwatch.ElapsedMilliseconds;
            //    }
            //}, TaskCreationOptions.LongRunning).Unwrap();
            //TaskExcutes.Add(taskExcutorModel1);

            //TaskExcutorModel taskExcutorMode2 = new TaskExcutorModel();
            //taskExcutorModel.Code = $"执行标记：测长设备线程";
            //taskExcutorModel.ExcuteTask = Task.Factory.StartNew(async () =>
            //{
            //    //获取此程序为那个设备的测长设备
            //    string linecode = ConfigurationManager.AppSettings["LineCode"];
            //    string equipmentcode = ConfigurationManager.AppSettings["EquipmentCode"];
            //    var equipment = Equipments.Where(t => t.Code == equipmentcode).First();
            //    if (equipment == null)
            //    {
                    
            //    }

            //}, TaskCreationOptions.LongRunning).Unwrap();
            //TaskExcutes.Add(taskExcutorMode2);
        }


        /// <summary>
        /// todo:每个分组设备的具体执行,单次运行
        /// </summary>
        /// <param name="equipments"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        private BllResult Excute(List<Equipment> equipments, string ip)
        {
            try
            {
                #region 检查是否连接正常
                if (equipments.Any(t => t.Code == "MiT_Cut"))
                {
                    StationExecute.ExcuteRequestForAPI(equipments.FirstOrDefault(t => t.Code == "MiT_Cut"), Equipments, PLC, User);
                    return BllResultFactory.Success();
                }
                //注意此处使用过滤后的tempEquipments
                List<Equipment> tempEquipments = equipments;
                if (PLC == null)
                {
                    return BllResultFactory.Error($"PLC为空", ErrorCodeConst.PLC_E0001.ToString());
                }
                if (!PLC.GetConnectStatus(ip).Success)
                {
                    PLC.DisConnect(ip);
                    var result2 = PLC.Connect(ip);
                    if (!result2.Success)
                    {
                        return BllResultFactory.Error($"重新连接打开IP为{ip}的PLC连接失败：{result2.Msg}；请检查网络是否断开", ErrorCodeConst.PLC_E0001.ToString());
                    }
                }

                #endregion

                #region PLC心跳是否正常

                var heartbeat = tempEquipments.Find(t => t.EquipmentType.Code == EquipmentTypeConst.PLCHeartbeat.ToString() && t.IP == ip);
                if (heartbeat == null)
                {
                    return BllResultFactory.Error($"IP为{ip}的PLC没有配置心跳连接");
                }
                //var readProp = heartbeat.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == PLCHeartProps.PLCWrite.ToString());
                //由于蒋昱宏要求心跳一直+1，于是改为读取写入的心跳然后+1，如果溢出就变成-32767，然后再继续加
                var prop = heartbeat.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == PLCHeartProps.WCSWrite.ToString());
                var readResult = PLC.Reads(prop);
                //readResult.Success= true;
                if (readResult.Success)
                {
                    //回复一个
                    //var prop = heartbeat.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == PLCHeartProps.WCSWrite.ToString());
                    var heartValue = Convert.ToInt32(prop.Value);
                    heartValue = heartValue >= 32000 ? 1 : heartValue + 1;
                    prop.Value = heartValue.ToString();
                    PLC.Write(prop);
                }
                else
                {
                    //如果读取不到PLC，就把对应的设备实体得属性值清空
                    var equipmentPropsTemp = tempEquipments.Where(t => t.IP == heartbeat.IP).SelectMany(t => t.EquipmentProps);
                    foreach (var item in equipmentPropsTemp)
                    {
                        item.Value = "";
                    }
                    //表示心跳断开,排除其IP对应的设备
                    tempEquipments = tempEquipments.Where(t => t.IP != heartbeat.IP).ToList();
                }
                //无可用设备时，结束处理
                if (tempEquipments.Count == 0)
                {
                    return BllResultFactory.Error($"IP为{ip}的PLC心跳断开，请检查网络情况");
                }

                #endregion
                #region 注释PLC心跳是否正常

                //var heartbeat = tempEquipments.Find(t => t.EquipmentType.Code == EquipmentTypeConst.PLCHeartbeat.ToString() && t.IP == ip);
                //if (heartbeat == null)
                //{
                //    return BllResultFactory.Error($"IP为{ip}的PLC没有配置心跳连接", ErrorCodeConst.PLC_E0004.ToString());
                //}
                //var heartProp = heartbeat.EquipmentProps.Find(t => t.EquipmentTypePropTemplateCode == PLCHeartProps.WCSWrite.ToString());
                //var plcResult = PLC.Reads(heartProp);
                //if (!plcResult.Success)
                //{
                //    return BllResultFactory.Error($"IP为{ip}的PLC心跳读取失败，原因：{plcResult.Msg}", ErrorCodeConst.PLC_E0001.ToString());
                //}
                ////如果是0就写1，否则就写0
                //heartProp.Value = heartProp.Value == "0" ? "1" : "0";
                //plcResult = PLC.Writes(heartProp);
                //if (!plcResult.Success)
                //{
                //    return BllResultFactory.Error($"IP为{ip}的PLC心跳写入失败，原因：{plcResult.Msg}", ErrorCodeConst.PLC_E0002.ToString());
                //}

                ////无可用设备时，结束处理，由于现在是一个PLC一个处理方法，所以心跳失败，直接方法就不处理了
                //if (tempEquipments.Count == 0)
                //{
                //    return BllResultFactory.Error($"IP为{ip}的PLC心跳断开，请检查网络情况", ErrorCodeConst.PLC_E0001.ToString());
                //}

                #endregion

                //读取所有地址值
                //foreach (var tempEquipment in tempEquipments)
                //{
                //    var ss = tempEquipment.EquipmentProps
                //                                  .Where(a => a.EquipmentTypePropTemplate.PropType == EquipmentPropType.ECSReadAddress.ToString() ||
                //                                               a.EquipmentTypePropTemplate.PropType == EquipmentPropType.ECSWriteAddress.ToString() ||
                //                                               a.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCAlarmAddress.ToString() ||
                //                                               a.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCCollectionAddress.ToString())
                //                                  .ToArray();
                //    var result = PLC.Reads(ss);
                //}
                var readEquipments = tempEquipments.SelectMany(t => t.EquipmentProps)
                                                   .Where(a => a.EquipmentTypePropTemplate.PropType == EquipmentPropType.ECSReadAddress.ToString() ||
                                                                a.EquipmentTypePropTemplate.PropType == EquipmentPropType.ECSWriteAddress.ToString() ||
                                                                a.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCAlarmAddress.ToString() ||
                                                                a.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCCollectionAddress.ToString())
                                                   .ToArray();
                var result = PLC.Reads(readEquipments);
                //result.Success = true;
                if (!result.Success)
                {
                    return BllResultFactory.Error($"读取IP为{ip}的PLC地址错误：{result.Msg}，如果此问题一直存在，请检查数据地址或网络配置", ErrorCodeConst.PLC_E0001.ToString());
                }

                //更新到数据库中（按需）
                //采集有线电表数据
                //List<BusCollectionResult> busCollectionResults = new List<BusCollectionResult>();
                //BusCollectionResultRepository busCollectionResultRepository = new BusCollectionResultRepository();
                //var collectDatas = readEquipments.Where(t => t.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCCollectionAddress.ToString()).ToList();
                //if (collectDatas.Count > 0)
                //{
                //    foreach (var collection in collectDatas)
                //    {
                //        BusCollectionResult busCollectionResult = new BusCollectionResult();
                //        busCollectionResult.Keys = Guid.NewGuid();
                //        busCollectionResult.Value = collection.Value;
                //        busCollectionResult.ExternalEquipmentCode = collection.EquipmentId.ToString();
                //        busCollectionResult.CommandCode = collection.EquipmentTypePropTemplateCode;
                //        busCollectionResult.Status = 10;
                //        busCollectionResult.Remark = collection.Remark;
                //        busCollectionResult.CreateTime = DateTime.Now;
                //        busCollectionResults.Add(busCollectionResult);
                //    }
                //    var ids = collectDatas.Select(t => t.EquipmentId.ToString()).Distinct().ToList();
                //    var deleteIds = busCollectionResultRepository.Where(t => ids.Contains(t.ExternalEquipmentCode)).ToList();
                //    if (deleteIds.Count > 0)
                //    {
                //        DALHelper.GetFreeSql().Delete<BusCollectionResult>().Where(t => ids.Contains(t.ExternalEquipmentCode)).ExecuteAffrows();
                //    }
                //    using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                //    {
                //        try
                //        {

                //            busCollectionResultRepository.UnitOfWork = uw;

                //            busCollectionResultRepository.Insert(busCollectionResults);
                //            uw.Commit();
                //        }
                //        catch (Exception ex)
                //        {
                //            uw?.Rollback();
                //        }
                //    }
                //}

                #region 桁架处理

                //if (tempEquipments.Exists(t => t.EquipmentType.Code == EquipmentTypeConst.Truss.ToString()))
                //{
                //    TrussExcutes.ForEach(t =>
                //    {
                //        t.Excute(tempEquipments.Where(a => a.EquipmentType.Id == t.EquipmentType.Id).ToList(), Equipments, PLC, User);
                //    });
                //}

                #endregion

                #region 站台、设备 处理
                StationExecutes.ForEach(t =>
                {
                    t.Excute(tempEquipments.Where(a => a.EquipmentType.Id == t.EquipmentType.Id).ToList(), Equipments, PLC, User);
                });
                #endregion              

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

        /// <summary>
        /// 初始化
        /// </summary>
        /// <returns></returns>
        public BllResult Init(List<string> LineCodes)
        {
            var origin = ConfigurationManager.AppSettings["Origin"];
            var referer = ConfigurationManager.AppSettings["Referer"];
            var sendNoneGoodsPointsUrl = ConfigurationManager.AppSettings["SendNoneGoodsPointsUrl"];
            var convertResult = int.TryParse(ConfigurationManager.AppSettings["TimeSpace"], out int timeSpace);
            if (!convertResult)
            {
                return BllResultFactory.Error($"获取配置文件请求上料等待时间出错");
            }

            var result = ExcuteService.InitPLC(LineCodes);
            if (!result.Success)
            {
                result.Msg = $"初始化PLC失败：{result.Msg}";
                return result;
            }
            PLC = result.Data;

            var result2 = ExcuteService.InitEquipment(LineCodes);
            if (!result2.Success)
            {
                result2.Msg = $"初始化设备出错：{result2.Msg}";
                return result2;
            }
            Equipments = result2.Data;

            //组合处理类
            Equipments.Select(t => t.EquipmentType).Distinct().ToList().ForEach(t =>
            {
                #region 标注物流的设备类
                //if (t.Code == EquipmentTypeConst.Truss.ToString())
                //{
                //    var truss = new TrussNormalExcute(Equipments.Select(t => t.EquipmentType).Where(t => t.Code == EquipmentTypeConst.Truss.ToString()).First());
                //    truss.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    truss.TaskRecord += Exc_TaskRecord;
                //    TrussExcutes.Add(truss);
                //}
                #endregion

                #region MES项目的设备类

                //if (t.Code == EquipmentTypeConst.FrontStationFitup.ToString())
                //{
                //    var frontStationFitup = new FrontStationFitup(t, origin, referer, sendNoneGoodsPointsUrl);
                //    frontStationFitup.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    frontStationFitup.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(frontStationFitup);
                //}
                //if (t.Code == EquipmentTypeConst.BackStationFitup.ToString())
                //{
                //    var backStationFitup = new BackStationFitup(t, origin, referer, sendNoneGoodsPointsUrl);
                //    backStationFitup.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    backStationFitup.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(backStationFitup);
                //}
                //if (t.Code == EquipmentTypeConst.PrecentrumJoint.ToString())
                //{
                //    var precentrumJoint = new PrecentrumJoint(t, origin, referer, sendNoneGoodsPointsUrl);
                //    precentrumJoint.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    precentrumJoint.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(precentrumJoint);
                //}
                //if (t.Code == EquipmentTypeConst.ClosureHeadWeld.ToString())
                //{
                //    var closureHeadWeld = new ClosureHeadWeld(t, origin, referer, sendNoneGoodsPointsUrl);
                //    closureHeadWeld.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    closureHeadWeld.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(closureHeadWeld);
                //}
                //if (t.Code == EquipmentTypeConst.BackConeJoint.ToString())
                //{
                //    var backConeJoint = new BackConeJoint(t, origin, referer, sendNoneGoodsPointsUrl);
                //    backConeJoint.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    backConeJoint.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(backConeJoint);
                //}
                //if (t.Code == EquipmentTypeConst.VerticalFitup.ToString())
                //{
                //    var VerticalFitup = new VerticalFitup(t, origin, referer, sendNoneGoodsPointsUrl);
                //    VerticalFitup.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    VerticalFitup.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(VerticalFitup);
                //}
                //if (t.Code == EquipmentTypeConst.InsideWeld.ToString())
                //{
                //    var insideWeld = new InsideWeld(t, origin, referer, sendNoneGoodsPointsUrl);
                //    insideWeld.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    insideWeld.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(insideWeld);
                //}
                //if (t.Code == EquipmentTypeConst.VaneFitup.ToString())
                //{
                //    var vaneFitup = new VaneFitup(t, origin, referer, sendNoneGoodsPointsUrl);
                //    vaneFitup.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    vaneFitup.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(vaneFitup);
                //}
                //if (t.Code == EquipmentTypeConst.VaneWeld.ToString())
                //{
                //    var vaneWeld = new VaneWeld(t, origin, referer, sendNoneGoodsPointsUrl);
                //    vaneWeld.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    vaneWeld.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(vaneWeld);
                //}
                //if (t.Code == EquipmentTypeConst.BackCone1StitchWelding.ToString())
                //{
                //    var backCone1StitchWelding = new BackCone1StitchWelding(t, origin, referer, sendNoneGoodsPointsUrl);
                //    backCone1StitchWelding.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    backCone1StitchWelding.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(backCone1StitchWelding);
                //}
                //if (t.Code == EquipmentTypeConst.LongitudinalWelding.ToString())
                //{
                //    var longitudinalWelding = new LongitudinalWelding(t, origin, referer, sendNoneGoodsPointsUrl);
                //    longitudinalWelding.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    longitudinalWelding.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(longitudinalWelding);
                //}
                if (t.Code == EquipmentTypeConst.Cut.ToString())
                {
                    var cutExcute = new CutExcute(t);
                    cutExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    cutExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(cutExcute);
                }
                //if (t.Code == EquipmentTypeConst.Bevel.ToString())
                //{
                //    var bevelExcute = new BevelExcute(t, origin, referer, sendNoneGoodsPointsUrl);
                //    bevelExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    bevelExcute.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(bevelExcute);
                //}
                if (t.Code == EquipmentTypeConst.Marking.ToString())
                {
                    var printExcute = new PrintExcute(t);
                    printExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    printExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(printExcute);
                }
                if (t.Code == EquipmentTypeConst.Measure.ToString())
                {
                    var MeasureExcute = new MeasureExcute(t);
                    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    MeasureExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(MeasureExcute);
                }
                //if (t.Code == EquipmentTypeConst.Other.ToString())
                //{
                //    var MeasureExcute = new MeasureExcute(t);
                //    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    MeasureExcute.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(MeasureExcute);
                //}
                if (t.Code == EquipmentTypeConst.Laser.ToString())
                {
                    var MeasureExcute = new PrintExcuteCX(t);
                    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    MeasureExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(MeasureExcute);
                }
                if (t.Code == EquipmentTypeConst.Polish.ToString())
                {
                    var MeasureExcute = new PolishExcute(t);
                    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    MeasureExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(MeasureExcute);
                }
                if (t.Code == EquipmentTypeConst.FitUp.ToString())
                {
                    var MeasureExcute = new FitUpExcute(t);
                    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    MeasureExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(MeasureExcute);
                }
                if (t.Code == EquipmentTypeConst.StationForConveyor.ToString())
                {
                    var MeasureExcute = new ConveyingExcute(t);
                    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    MeasureExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(MeasureExcute);
                }
                if (t.Code == EquipmentTypeConst.Weld.ToString())
                {
                    var MeasureExcute = new WeldExcute(t);
                    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                    MeasureExcute.TaskRecord += Exc_TaskRecord;
                    StationExecutes.Add(MeasureExcute);
                }
                //if (t.Code == EquipmentTypeConst.Weld.ToString())
                //{
                //    var MeasureExcute = new WeldExcute(t);
                //    MeasureExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    MeasureExcute.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(MeasureExcute);
                //}

                //if (t.Code == EquipmentTypeConst.Weld.ToString())
                //{
                //    var weldExcute = new WeldExcute(t);
                //    weldExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    weldExcute.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(weldExcute);
                //}
                //if (t.Code == EquipmentTypeConst.FitUp.ToString())
                //{
                //    var fitUpExcute = new FitUpExcute(t);
                //    fitUpExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    fitUpExcute.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(fitUpExcute);
                //}
                //if (t.Code == EquipmentTypeConst.StationForConveyor.ToString())
                //{
                //    var stationForConveyorExcute = new StationForConveyorExcute(t);
                //    stationForConveyorExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    stationForConveyorExcute.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(stationForConveyorExcute);
                //}
                //if (t.Code == EquipmentTypeConst.Other.ToString())
                //{
                //    var otherExcute = new OtherExcute(t, origin, referer, sendNoneGoodsPointsUrl);
                //    otherExcute.EquipmentExecuteLog += Exc_EquipmentExecuteLog;
                //    otherExcute.TaskRecord += Exc_TaskRecord;
                //    StationExecutes.Add(otherExcute);
                //}
                #endregion
            });
            CanExcute = true;
            Excuting();
            //初始化PLC长连接的时候，可能会失败，Excute中read或是write的时候，就会开启短链接，照样可以跑，但是长连接失败要提示出来。
            return BllResultFactory.Success(result.Msg);
        }

        /// <summary>
        /// 记录任务流转
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Exc_TaskRecord(object arg1, TaskRecordEventArgs arg2)
        {
            taskService.RecordTask(arg2.TaskId, arg2.Equipment, arg2.Description);
        }

        /// <summary>
        /// 记录设备执行，继续触发事件，交由具体实现类
        /// todo:考虑将此日志录入到数据库中方便查找
        /// </summary>
        /// <param name="arg1"></param>
        /// <param name="arg2"></param>
        /// <exception cref="NotImplementedException"></exception>
        private void Exc_EquipmentExecuteLog(object arg1, EquipmentExecuteLogEventArgs arg2)
        {
            EquipmentExecuteLog?.Invoke(arg1, arg2);
        }

        /// <summary>
        /// 开启执行
        /// </summary>
        public BllResult StartExcute()
        {
            if (!CanExcute)
            {
                return BllResultFactory.Error("未初始化成功，启动失败");
            }
            stop = false;
            return BllResultFactory.Success();
        }

        /// <summary>
        /// 关闭执行
        /// </summary>
        public BllResult StopExcute()
        {
            stop = true;
            return BllResultFactory.Success();
        }



        /// <summary>
        /// 处理逻辑
        /// </summary>
        BllResult TestExcute(string ip)
        {
            try
            {
                if (ip != "192.168.1.21")
                {
                    return BllResultFactory.Success();
                }
                List<Equipment> tempEquipments = new List<Equipment>();
                EquipmentType equipmentType = new EquipmentType();
                //RobotGripperExcute robotGripperExcute = new RobotGripperExcute(equipmentType, new ExcuteService(), new WMSService(), new LocationService(), new TaskService(), new BllService());
                List<Equipment> equipments = new List<Equipment>();
                var ss = Equipments.FirstOrDefault(u => u.EquipmentTypeId == 17);
                equipments.Add(ss);

                Equipment equipment = new Equipment();
                equipment = equipments[0];
                var collectDatas = equipment.EquipmentProps.Where(t => t.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCCollectionAddress.ToString());
                foreach (var collectData in collectDatas)
                {
                    collectData.Value = "1";
                }
                List<BusCollectionResult> busCollectionResults = new List<BusCollectionResult>();
                var collectDatass = equipment.EquipmentProps.Where(t => t.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCCollectionAddress.ToString());
                foreach (var collection in collectDatass)
                {
                    BusCollectionResult busCollectionResult = new BusCollectionResult();
                    busCollectionResult.Keys = Guid.NewGuid();
                    busCollectionResult.Value = collection.Value;
                    busCollectionResult.ExternalEquipmentCode = collection.EquipmentId.ToString();
                    busCollectionResult.CommandCode = collection.EquipmentTypePropTemplateCode;
                    busCollectionResult.Status = 10;
                    busCollectionResult.Remark = collection.Remark;
                    busCollectionResult.CreateTime = DateTime.Now;
                    busCollectionResults.Add(busCollectionResult);
                }
                BusCollectionResultRepository busCollectionResultRepository = new BusCollectionResultRepository();
                busCollectionResultRepository.Insert(busCollectionResults);
                //equipment.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == StationProps.OperationModel.ToString()).Value = "5";
                //equipment.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == StationProps.TotalError.ToString()).Value = "1";
                //equipment.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == StationProps.ControlMessage.ToString()).Value = "3";
                //equipment.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == StationProps.WCSACKMessage.ToString()).Value = "0";
                //equipment.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == StationProps.ACKLocation1.ToString()).Value = "1";
                //equipment.EquipmentProps.FirstOrDefault(t => t.EquipmentTypePropTemplateCode == StationProps.ACKLocation2.ToString()).Value = "1";
                //robotGripperExcute.Excute(equipments, Equipments, PLC, WarehouseCode, User);


                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Exception, ex, $"程序处理出现异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 保存设备采集的数据
        /// </summary>
        BllResult CollectData()
        {
            try
            {
                //采集数据结果
                List<BusCollectionResult> busCollectionResults = new List<BusCollectionResult>();
                BusCollectionResultRepository busCollectionResultRepository = new BusCollectionResultRepository();
                var collectDatas = Equipments.SelectMany(t => t.EquipmentProps).Where(t => t.EquipmentTypePropTemplate.PropType == EquipmentPropType.PLCCollectionAddress.ToString()).ToList();
                if (collectDatas.Count > 0)
                {
                    foreach (var collection in collectDatas)
                    {
                        BusCollectionResult busCollectionResult = new BusCollectionResult();
                        busCollectionResult.Keys = Guid.NewGuid();
                        busCollectionResult.Value = collection.Value;
                        busCollectionResult.ExternalEquipmentCode = collection.EquipmentId.ToString();
                        busCollectionResult.CommandCode = collection.EquipmentTypePropTemplateCode;
                        busCollectionResult.Status = 10;
                        busCollectionResult.Remark = collection.Remark;
                        busCollectionResult.CreateTime = DateTime.Now;
                        busCollectionResults.Add(busCollectionResult);
                    }
                    var ids = collectDatas.Select(t => t.EquipmentId.ToString()).Distinct().ToList();
                    //如果已经采集了设备的数据，就清空后再插入新数据
                    var deleteIds = busCollectionResultRepository.Where(t => ids.Contains(t.ExternalEquipmentCode)).ToList();
                    if (deleteIds.Count > 0)
                    {
                        DALHelper.GetFreeSql().Delete<BusCollectionResult>().Where(t => ids.Contains(t.ExternalEquipmentCode)).ExecuteAffrows();
                    }
                    using (var uw = DALHelper.GetFreeSql().CreateUnitOfWork())
                    {
                        try
                        {
                            busCollectionResultRepository.UnitOfWork = uw;
                            busCollectionResultRepository.Insert(busCollectionResults);
                            uw.Commit();
                        }
                        catch (Exception ex)
                        {
                            uw?.Rollback();
                        }
                    }
                }

                return BllResultFactory.Success();
            }
            catch (Exception ex)
            {
                return BllResultFactory.Create(BllResultCode.Exception, ex, $"程序处理出现异常：{ex.Message}");
            }
        }



        private BllResult CallPipe(List<Equipment> Equipments)
        {
            try
            {
                //如果存在一个大于初始小于切割完成的，就说明有切割方案正在执行
                //行走方案中存在未完成的数据也是有数据正在执行
                //检查设备是否联机无故障 允许放货，空闲
                var cut = Equipments.FirstOrDefault(t => t.EquipmentType.Code == EquipmentTypeConst.CutBevel.ToString());
                if (cut == null)
                {
                    return BllResultFactory.Success();
                }
                var OperationModel = cut[StationProps.OperationModel.ToString()];
                var TotalError = cut[StationProps.TotalError.ToString()];
                var AllowEntry = cut[StationProps.AllowEntry.ToString()];
                var Status = cut[StationProps.Status.ToString()];
                if (OperationModel.Value != OperationModelFlag.Online.GetIndexString() || TotalError.Value != TotalErrorFlag.Normal.GetIndexString() || AllowEntry.Value != StationAllowEntry.Allow.GetIndexString() || Status.Value != EquipmentStatus.空闲.GetIndexString())
                {
                    return BllResultFactory.Success();
                }
                var cutPlanHeadRepository = new CutPlanHeadRepository();
                var cutPlanHeads = cutPlanHeadRepository.Where(t => t.State < (int)CutPlanHeadState.切割完成).ToList();
                if (cutPlanHeads.Any(t => t.State > (int)CutPlanHeadState.初始))
                {
                    return BllResultFactory.Success();
                }
                var cutOrPrintPlanRepository = DALHelper.GetFreeSql().GetRepository<CutOrPrintPlan>();
                var cutOrPrintPlans = cutOrPrintPlanRepository.Where(t => t.State == 0).ToList();
                if (cutOrPrintPlans.Any())
                {
                    NoticeBus.Notice($"呼叫长管失败，新增计划中存在为未完成的计划", Level.Error);
                    return BllResultFactory.Success();
                }
                var cutPlanHeadList = cutPlanHeads.Where(t => t.State == (int)CutPlanHeadState.初始).OrderByDescending(t => t.Level).ToList();
                if (!cutPlanHeadList.Any())
                {
                    return BllResultFactory.Success();
                }
                var sysDictDataRepository = DALHelper.GetFreeSql().GetRepository<SysDictData>();
                var sysDictData = sysDictDataRepository.Where(t => t.DictType == "GetUrl" && t.DictLabel == "CallPipe").First();
                if (sysDictData == null)
                {
                    NoticeBus.Notice($"因为中控系统字典中未设置管材叫料地址！请在中控系统字典中设置！", Level.Error);
                    return BllResultFactory.Error($"因为中控系统字典中未设置管材叫料地址！请在中控系统字典中设置！");
                }
                //调用接口叫料
                CommonService commonService = new CommonService();
                var sendData = new { MaterialCode = cutPlanHeadList[0].MaterialCode };
                //var result = commonService.PostJson<object>("SendNoneGoodsPoints:上传库位编码", callMaterialUrl, sendData, origin, referer).Result;
                //var result = commonService.PostJson<object>("SendNoneGoodsPoints:上传库位编码", callMaterialUrl, sendData).Result;
                var result = commonService.HttpMan2(sysDictData.DictValue, sendData, "CallPipe:管材切割叫料");
                if (result.Code != 200)
                {
                    cutPlanHeadList[0].Level = 0;
                    cutPlanHeadRepository.Update(cutPlanHeadList[0]);
                    NoticeBus.Notice($"处理设备[{cut.Name}]工位[{cut.WorkStationId}]，向wcs叫料失败！原因【{result.Message}】！", Level.Error);
                    return BllResultFactory.Success($"处理设备[{cut.Name}]工位[{cut.WorkStationId}]，向wcs叫料失败！原因【{result.Message}】！");
                }
                cutPlanHeadList[0].LotNo = result.Result.Batch.Value;
                cutPlanHeadList[0].State = (int)CutPlanHeadState.下料开始;
                cutPlanHeadList[0].DischargeStartTime = DateTime.Now;
                cutPlanHeadRepository.Update(cutPlanHeadList[0]);
                NoticeBus.Notice($"处理设备[{cut.Name}]工位[{cut.WorkStationId}]，向wcs叫料成功！", Level.Success);
                return BllResultFactory.Success($"处理设备[{cut.Name}]工位[{cut.WorkStationId}]，向wcs叫料物料编码{cutPlanHeadList[0].MaterialCode}成功！");
            }
            catch (Exception ex)
            {
                NoticeBus.Notice($"呼叫管材出现异常，原因：{ex.Message}", Level.Error);
                return BllResultFactory.Exception(ex, $"呼叫管材出现异常，原因：{ex.Message}");
            }

        }
    }
}