using HslCommunication.BasicFramework;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using iWare_SCADA_Model.MiddleModel;
using iWare_SCADA_Model.TableModel;
using log4net;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Data.Entity.Validation;
using System.Diagnostics;
//using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Web.UI.WebControls;
using System.Windows.Forms;
using static System.Windows.Forms.AxHost;

namespace iWare_SCADA_BusinessLogical.BLL
{
    public class WorkPieceInfoManager
    {
        //public static WorkPieceInfo GetWorkPieceInfo(string WorkPieceID)
        //{
        //    using (DbModel db = new DbModel())
        //    {
        //        //查询所有
        //        var query = db.WorkPieceInfo.Where(o => o.WorkPieceID == WorkPieceID).FirstOrDefault();
        //        return query;
        //    }
        //}


        //public static long InsertWorkPieceInfo(WorkPieceInfo workPiece)
        //{
        //    using (DbModel db = new DbModel())
        //    {
        //        db.WorkPieceInfo.Add(workPiece);
        //        db.SaveChanges();
        //        return workPiece.Id;
        //    }
        //}

        //public static WorkPieceLogMiddle GetAddWorkPieceLog(WorkPieceLogMiddle loginfo)
        //{
        //    loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
        //    return loginfo;
        //}

        /// <summary>
        /// 给WorkPieceLog主键等公共的的属性赋值
        /// </summary>
        /// <param name="loginfo"></param>
        /// <returns></returns>
        public static WorkPieceLog GetAddWorkPieceLog(WorkPieceLog loginfo)
        {
            loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            return loginfo;
        }
        public static WorkPieceLog GetAddWorkPieceLog1(WorkPieceLogMiddle loginfo)
        {
            loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            return loginfo;
        }
        /// <summary>
        /// 通过WorkPieceInfo   给WorkPieceInfoLog 属性赋值
        /// </summary>
        /// <param name="wpinfo"></param>
        /// <returns></returns>
        public static WorkPieceInfoLog GetAddWorkPieceInfoLog(WorkPieceInfo wpinfo)
        {
            WorkPieceInfoLog infolog = EntityPropHelper.Mapper<WorkPieceInfoLog, WorkPieceInfo>(wpinfo);
            infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            infolog.WorkPieceInfoID = wpinfo.Id;
            infolog.LogAddTime = DateTime.Now;
            return infolog;
        }
        /// <summary>
        /// 给QualityDataInfo主键等公共的的属性赋值
        /// </summary>
        /// <param name="loginfo"></param>
        /// <returns></returns>
        public static QualityDataInfo GetAddQualityDataInfo(QualityDataInfo qdinfo)
        {
            qdinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            return qdinfo;
        }
        /// <summary>
        /// 通过QualityDataInfo   给QualityDataInfoLog 属性赋值
        /// </summary>
        /// <param name="wpinfo"></param>
        /// <returns></returns>
        public static QualityDataInfoLog GetAddQualityDataInfoLog(QualityDataInfo qdinfo)
        {
            QualityDataInfoLog infolog = EntityPropHelper.Mapper<QualityDataInfoLog, QualityDataInfo>(qdinfo);
            infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            return infolog;
        }
        public static void test()
        {
            using (DbModel db = new DbModel())
            {
                //WorkPieceLogMiddle a = new WorkPieceLogMiddle();
                //a.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                //a.WorkPieceID="test01"+ new Random().Next(4).ToString();
                //a.QualityType = QualityType.SPC.ToString();

                //if(a.QualityType.Equals(QualityType.SPC.ToString()))
                //{
                //    a.Remarks = "SPC";
                //}
                //else
                //{
                //    a.Remarks = "AUTO";
                //}

                //WorkPieceLog b = new WorkPieceLog();
                //b.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                //b.WorkPieceID = "testxxx" + new Random().Next(0,1000).ToString();
                //b.QualityType = QualityType.SPC.ToString();
                //b.Remarks = "SPC insert into";
                //b.QualityState = 2;
                //b.QualityStateUpdateMode = "heheh";
                //db.WorkPieceLog.Add(b);


                //db.SaveChanges();

            }

        }
        /// <summary>
        /// 根据设备id更新刀具寿命信息（目前设定每生产一个工件，所有刀具寿命都会减1）
        /// </summary>
        /// <param name="db"></param>
        /// <param name="loginfo"></param>
        public static void UpdateKnifeToolLift(DbModel db, WorkPieceLog loginfo)
        {
            try
            {
                var info = db.KnifeToolEquipmentInfo.Where(o => o.EquipmentID.Equals(loginfo.EquipmentID)).ToList();
                foreach (var item in info)
                {
                    item.CurrentLife++;
                    item.UpdatedTime = DateTime.Now;
                }

            }
            catch (Exception ex)
            {
                loginfo.Remarks = $"{loginfo.WorkPieceID ?? "空"}刀具寿命更新数据异常{ex.Message}";

            }
        }

     
        public static WorkPieceLogMiddle QualityDataHand(WorkPieceLogMiddle loginfo, List<EquipmentQualityConfig> qcofig)
        {
            try
            {
                switch (loginfo.WorkingProcedure)
                {
                    case "OP10":
                        var cof = qcofig.Where(o => o.ParamColName.Equals("QualityOP10To1")).FirstOrDefault();
                        if (cof != null && cof.Id > 0)
                        {
                            double oldvalue = 0;
                            double StandardValue = 0;
                            var flag1 = double.TryParse(loginfo.QualityOP10To1, out oldvalue);
                            var flag2 = double.TryParse(cof.StandardValue, out StandardValue);
                            if (!flag1 || !flag2)
                            {
                                return loginfo;
                            }
                            loginfo.QualityOP10To1 = ((StandardValue + oldvalue * 1.0 / cof.DecimalPlaces).ToString());
                            //+(string.IsNullOrEmpty(cof.Unit) ? "" : cof.Unit)
                        }
                        break;
                    case "OP40":
                        var cofOP40 = qcofig.Where(o => o.ParamColName.Equals("QualityOP40To1")).FirstOrDefault();
                        if (cofOP40 != null && cofOP40.Id > 0)
                        {
                            double oldvalue = 0;
                            double StandardValue = 0;
                            var flag1 = double.TryParse(loginfo.QualityOP40To1, out oldvalue);
                            var flag2 = double.TryParse(cofOP40.StandardValue, out StandardValue);
                            if (!flag1 || !flag2)
                            {
                                return loginfo;
                            }
                            loginfo.QualityOP40To1 = ((StandardValue + oldvalue * 1.0 / cofOP40.DecimalPlaces).ToString());
                            //+(string.IsNullOrEmpty(cofOP40.Unit) ? "" : cofOP40.Unit)
                        }
                        break;
                    case "OP20":
                        var cofOP20 = qcofig.Where(o => o.ParamColName.Equals("QualityOP20To1")).FirstOrDefault();
                        if (cofOP20 != null && cofOP20.Id > 0)
                        {
                            double oldvalue = 0;
                            double StandardValue = 0;
                            var flag1 = double.TryParse(loginfo.QualityOP20To1, out oldvalue);
                            var flag2 = double.TryParse(cofOP20.StandardValue, out StandardValue);
                            if (!flag1 || !flag2)
                            {
                                return loginfo;
                            }
                            loginfo.QualityOP20To1 = ((StandardValue + oldvalue * 1.0 / cofOP20.DecimalPlaces).ToString());
                        }
                        break;
                    case "OP60":
                        var cofOP60to1 = qcofig.Where(o => o.ParamColName.Equals("QualityOP60To1")).FirstOrDefault();
                        if (cofOP60to1 != null && cofOP60to1.Id > 0)
                        {
                            double oldvalue = 0;
                            double StandardValue = 0;
                            var flag1 = double.TryParse(loginfo.QualityOP60To1, out oldvalue);
                            var flag2 = double.TryParse(cofOP60to1.StandardValue, out StandardValue);
                            if (!flag1 || !flag2)
                            {
                                return loginfo;
                            }
                            loginfo.QualityOP60To1 = ((StandardValue + oldvalue * 1.0 / cofOP60to1.DecimalPlaces).ToString());
                        }
                        var cofOP60to2 = qcofig.Where(o => o.ParamColName.Equals("QualityOP60To2")).FirstOrDefault();
                        if (cofOP60to2 != null && cofOP60to2.Id > 0)
                        {
                            double oldvalue = 0;
                            double StandardValue = 0;
                            var flag1 = double.TryParse(loginfo.QualityOP60To2, out oldvalue);
                            var flag2 = double.TryParse(cofOP60to2.StandardValue, out StandardValue);
                            if (!flag1 || !flag2)
                            {
                                return loginfo;
                            }
                            loginfo.QualityOP60To2 = ((StandardValue + oldvalue * 1.0 / (10 * cofOP60to2.DecimalPlaces)).ToString() + (string.IsNullOrEmpty(cofOP60to2.Unit) ? "" : cofOP60to2.Unit));
                        }
                        break;
                    default:
                        break;

                }
            }
            catch (Exception ex)
            {

            }
            return loginfo;
        }

     

        /// <summary>
        /// 赋值 修改人 【Editby shaocx,2024-07-05】
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <returns></returns>
        public static string ResetUpdatedUserName(WorkPieceLogMiddle logMiddle)
        {
            if (logMiddle.MonitoringPoint.Equals("OP1003"))
            {//因为OP10和OP40是一台机器，OP1003专门是OP40测量的。
                return "OP4003";
            }
            return logMiddle.MonitoringPoint;
        }

       
       


        public static void SetWorkingProcedureCurrentForOP10(WorkPieceInfo cur_db_info, ref string set_WorkingProcedureCurrent)
        {
            //截断字符串
            if (cur_db_info.WorkingProcedureCurrent.Length == 4)
            {
                try
                {
                    var bb = cur_db_info.WorkingProcedureCurrent.Substring(2, 2);
                    int ii = Convert.ToInt32(bb);
                    if (ii <= 10)
                    {
                        set_WorkingProcedureCurrent = "OP10";
                    }
                    else
                    {
                        set_WorkingProcedureCurrent = "OP40";
                    }
                }
                catch (Exception)
                {
                    set_WorkingProcedureCurrent = cur_db_info.WorkingProcedureCurrent;
                }
            }
            else
            {
                set_WorkingProcedureCurrent = cur_db_info.WorkingProcedureCurrent;
            }
        }

       
        public static void AlertMonitor(WorkPieceLog loginfo, LogType type)
        {

        }
        /// <summary>
        /// 设备告警监控（清洗液，切削液，刀具告警等）
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static void AlertMonitor(LogType type)
        {
            using (DbModel db = new DbModel())
            {
                bool isAddAlert = false;
                try
                {

                    var equipmentlist = db.EquipmentBaseInfo.Where(o => o.IsDeleted == false).ToList();
                    var alertlist = db.v_get_equipment_alert.Where(o => o.IsDeleted == false).ToList();
                    var knifetoolbase = db.KnifeToolBaseInfo.Where(o => o.IsDeleted == false).ToList();
                    var knifetoolinfo = db.KnifeToolEquipmentInfo.Where(o => o.IsDeleted == false).ToList();
                    //var knifelist = db.KnifeToolEquipmentInfo.GroupJoin(db.KnifeToolBaseInfo.Where(o => o.IsDeleted == false).ToList(), a => a.EquipmentID, b => b.EquipmentID, (a, b) => new { a,b})
                    //.SelectMany(ab => ab.b.DefaultIfEmpty(), (ab, b) => new { ab.a, b.KnifeToolChangeAlertThreshold,b.KnifeToolLife })
                    //.Where(o => o.a.IsDeleted == false)
                    //.ToList();
                    foreach (var item in equipmentlist)
                    {
                        try
                        {
                            var alert = alertlist.Where(o => o.EquipmentId.Equals(item.EquipmentId)).FirstOrDefault();
                            if (alert == null || alert.Id < 1)
                            {
                                alert = EntityPropHelper.Mapper<v_get_equipment_alert, EquipmentBaseInfo>(item);
                                isAddAlert = true;
                            }
                            //if(item.WorkingProcedure.Equals("OP70"))
                            {
                                if (item.Detergentchangetime.HasValue)
                                {
                                    if (item.Detergentchangetime.Value.AddDays(item.DetergentChangeAlertThreshold).Date <= DateTime.Now.Date)
                                    {//op70清洗液告警
                                        alert.IsAlertDetergent = true;
                                        alert.Detergentchangetime = item.Detergentchangetime;
                                        alert.DetergentChangeAlertThreshold = item.DetergentChangeAlertThreshold;
                                        alert.DetergentChangeCycle = item.DetergentChangeCycle;
                                        alert.DetergentDesc = $"设备【{item.EquipmentName}】清洗液最新更换时间为【{item.Detergentchangetime.Value}】，已达到告警阈值，请注意！";
                                    }
                                    else
                                    {
                                        alert.IsAlertDetergent = false;
                                        alert.DetergentDesc = "";
                                    }
                                }
                                else
                                {

                                    alert.IsAlertDetergent = false;
                                    alert.DetergentDesc = "";
                                }
                            }
                            //if (!item.WorkingProcedure.Equals("OP05")&& !item.WorkingProcedure.Equals("OP30") && !item.WorkingProcedure.Equals("OP70") && !item.WorkingProcedure.Equals("OP80"))
                            {
                                if (item.CuttingFluidChangeTime.HasValue)
                                {
                                    if (item.CuttingFluidChangeTime.Value.AddDays(item.CuttingFluidChangeAlertThreshold).Date <= DateTime.Now.Date)
                                    {//切削液告警
                                        alert.IsAlertCuttingFluid = true;
                                        alert.CuttingFluidChangeTime = item.CuttingFluidChangeTime;
                                        alert.CuttingFluidChangeAlertThreshold = item.CuttingFluidChangeAlertThreshold;
                                        alert.CuttingFluidDesc = $"设备【{item.EquipmentName}】切削液最新更换时间为【{item.CuttingFluidChangeTime.Value}】，已达到告警阈值，请注意！";
                                    }
                                    else
                                    {
                                        alert.IsAlertCuttingFluid = false;
                                        alert.CuttingFluidDesc = "";
                                    }
                                }
                                else
                                {
                                    alert.IsAlertCuttingFluid = false;
                                    alert.CuttingFluidDesc = "";
                                }
                            }
                            bool flag = false;
                            string desc = $"设备【{item.EquipmentName}】";
                            foreach (var knife in knifetoolinfo.Where(o => o.EquipmentID.Equals(item.EquipmentId)))
                            {
                                var list = knifetoolbase.Where(o => o.KnifeToolID.Equals(knife.KnifeToolID)).FirstOrDefault();
                                if (list != null)
                                {
                                    if ((knife.CurrentLife + list.KnifeToolChangeAlertThreshold) >= list.KnifeToolLife)
                                    {//刀具告警
                                        flag = true;
                                        alert.IsAlertKnifeTool = true;
                                        alert.KnifeToolChangeAlertThreshold = list.KnifeToolChangeAlertThreshold;
                                        desc += $"\r\n工位【{knife.Station}】上刀具【{knife.KnifeToolID}】计划寿命【{list.KnifeToolLife}】次，当前已使用寿命【{knife.CurrentLife}】次，已达到告警阈值，请注意！";
                                    }
                                }
                            }
                            if (!flag)
                            {//没有刀具告警
                                alert.IsAlertKnifeTool = false;
                                alert.KnifeToolDesc = "";
                            }
                            else
                            {
                                alert.IsAlertKnifeTool = true;
                                alert.KnifeToolDesc = desc;
                            }

                            EquipmentCurrentMonitor info = new EquipmentCurrentMonitor();
                            info = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == item.EquipmentId).FirstOrDefault();
                            if (info == null || info.Id < 1)
                            {//没有工件信息，不做更新
                                Log4NetHelper.WriteErrorLog(type, $"设备{item.EquipmentId} 计算告警{item.WorkingProcedure} 没有获取到设备监控信息！");
                            }
                            else
                            {
                                if (string.IsNullOrEmpty(info.Alertmsg))
                                {
                                    alert.IsAlert = false;
                                    alert.AlertDesc = "";
                                }
                                else
                                {
                                    alert.IsAlert = true;
                                    alert.AlertDesc = info.Alertmsg;
                                }
                            }
                            if (isAddAlert)
                            {
                                db.v_get_equipment_alert.Add(alert);
                            }
                        }
                        catch (Exception ex)
                        {

                            Log4NetHelper.WriteErrorLog(type, $" {item.EquipmentName}设备计算告警时异常：");
                        }
                    }
                }
                catch (Exception e)
                {
                    Log4NetHelper.WriteErrorLog(type, $" 设备告警监控（清洗液，切削液，刀具告警等） 计算时异常：{e.Message} {e.StackTrace}");
                }



                //db.WorkPieceLog.Add(loginfo2);//插入设备采集日志表
                db.SaveChanges();
            }
        }

        /// <summary>
        /// 设备监控
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static void EquipmentMonitor(WorkPieceLogMiddle loginfo, LogType type)
        {

            using (DbModel db = new DbModel())
            {
                var loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
                try
                {
                    bool isAddEquipmentCurrentMonitor = false;
                    EquipmentCurrentMonitor info = new EquipmentCurrentMonitor();
                    info = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == loginfo.EquipmentID).FirstOrDefault();
                    if (info == null || info.Id < 1)
                    {//没有工件信息，不做更新
                        Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.MonitoringPoint} 没有获取到设备监控信息，现新增");
                        info = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLogMiddle>(loginfo);
                        isAddEquipmentCurrentMonitor = true;
                    }
                    //最新设备状态
                    string State = "";
                    //OP20,OP30,OP35,OP50,OP60等等都不区分告警和message，但code都不会重复，所以本处就不需要判断告警类型了
                    var codelist = db.EquipmentFailureCode.Where(o => o.WorkingProcedure.Equals(loginfo.WorkingProcedure)).ToList();

                    #region 故障代码处理
                    List<long> Failueslist = new List<long>();
                    Failueslist.Add(loginfo.FailureType1);
                    Failueslist.Add(loginfo.FailureType2);
                    Failueslist.Add(loginfo.FailureType3);
                    Failueslist.Add(loginfo.FailureType4);
                    Failueslist.Add(loginfo.FailureType5);
                    Failueslist.Add(loginfo.FailureType6);
                    Failueslist.Add(loginfo.FailureType7);
                    Failueslist.Add(loginfo.FailureType8);
                    Failueslist.Add(loginfo.FailureType9);
                    Failueslist.Add(loginfo.FailureType10);
                    Failueslist.Add(loginfo.FailureType11);
                    Failueslist.Add(loginfo.FailureType12);
                    Failueslist.Add(loginfo.FailureType13);
                    Failueslist.Add(loginfo.FailureType14);
                    Failueslist.Add(loginfo.FailureType15);
                    Failueslist.Add(loginfo.FailureType16);
                    Failueslist.Add(loginfo.FailureType17);
                    Failueslist.Add(loginfo.FailureType18);
                    Failueslist.Add(loginfo.FailureType19);
                    Failueslist.Add(loginfo.FailureType20);
                    Failueslist.RemoveAll(o => o == 0);
                    string faultall = "";
                    string faultmsg = "";
                    int i = 1;
                    foreach (var failues in Failueslist)
                    {
                        faultall += (failues + "\r\n");
                        EquipmentFailureCode codeinfo = codelist.Where(o => o.Code == failues.ToString()).FirstOrDefault();
                        if (codeinfo != null && codeinfo.Code.Length > 0)
                        {
                            faultmsg += (i.ToString() + "." + (codeinfo.CodeDesc ?? codeinfo.Code) + "\r\n");
                        }
                        else
                        {
                            faultmsg += (i.ToString() + "." + failues.ToString() + "\r\n");
                        }
                        i++;
                    }
                    //var faultall = string.Join("\r\n", Failueslist.OrderBy(o=>o));
                    #endregion
                    #region 告警代码处理

                    List<long> Alertlist = new List<long>();
                    Alertlist.Add(loginfo.FailureMessage1);
                    Alertlist.Add(loginfo.FailureMessage2);
                    Alertlist.Add(loginfo.FailureMessage3);
                    Alertlist.Add(loginfo.FailureMessage4);
                    Alertlist.Add(loginfo.FailureMessage5);
                    Alertlist.Add(loginfo.FailureMessage6);
                    Alertlist.Add(loginfo.FailureMessage7);
                    Alertlist.Add(loginfo.FailureMessage8);
                    Alertlist.Add(loginfo.FailureMessage9);
                    Alertlist.Add(loginfo.FailureMessage10);
                    Alertlist.Add(loginfo.FailureMessage11);
                    Alertlist.Add(loginfo.FailureMessage12);
                    Alertlist.Add(loginfo.FailureMessage13);
                    Alertlist.Add(loginfo.FailureMessage14);
                    Alertlist.Add(loginfo.FailureMessage15);
                    Alertlist.Add(loginfo.FailureMessage16);
                    Alertlist.Add(loginfo.FailureMessage17);
                    Alertlist.Add(loginfo.FailureMessage18);
                    Alertlist.Add(loginfo.FailureMessage19);
                    Alertlist.Add(loginfo.FailureMessage20);
                    Alertlist.RemoveAll(o => o == 0);
                    string alertall = "";
                    string warnmsg = "";
                    i = 1;
                    foreach (var alert in Alertlist)
                    {
                        alertall += (alert + "\r\n");
                        var codeinfo = codelist.Where(o => o.Code == alert.ToString()).FirstOrDefault();
                        if (codeinfo != null && codeinfo.Code.Length > 0)
                        {
                            warnmsg += (i.ToString() + "." + (codeinfo.CodeDesc ?? codeinfo.Code) + "\r\n");
                        }
                        else
                        {
                            warnmsg += (i.ToString() + "." + alert.ToString() + "\r\n");
                        }
                        i++;
                    }
                    #endregion
                    //var alertall = string.Join("\r\n", Alertlist.OrderBy(o=>o));


                    EquipmentWorkingLog infolog = new EquipmentWorkingLog();
                    infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                    infolog.LogAddTime = DateTimeHelper.GetDateTime();
                    infolog.WorkPieceLogID = loginfo2.Id;
                    infolog.EquipmentID = info.EquipmentID;
                    bool isAddEquipmentWorkingLog = false;

                    bool isStatechange = false;

                    #region 设备状态处理

                    //故障》警告》其他
                    if (loginfo.IsCloseAlert)
                    {//故障
                        info.AlertTime = info.AlertTime ?? DateTime.Now;
                        info.FailureType = "";
                        info.WarnType = "";
                        info.Alertmsg = faultmsg;//这个需要代码对应字典维护信息才知道
                        info.FailureType = faultall;
                        State = ((int)EnumEquipmentCurrentStateDisplay.故障).ToString();


                        //infolog.FailureStartTime = DateTimeHelper.GetDateTime();
                        //infolog.FailureType = faultall;
                        //infolog.FailureMsg = faultmsg;
                        if (loginfo.IsMessage)
                        {
                            info.WarnTime = info.WarnTime ?? DateTime.Now;
                            info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
                            info.WarnType = alertall;
                        }
                    }
                    //else if (loginfo.IsMessage)
                    //{//警告
                    //    info.AlertTime = null;
                    //    info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
                    //    info.FailureType = "";

                    //    info.WarnTime = info.WarnTime ?? DateTime.Now;
                    //    info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
                    //    info.WarnType = alertall;

                    //    //infolog.WarnStartTime = DateTimeHelper.GetDateTime();
                    //    //infolog.WarnType = alertall;
                    //    //infolog.Warnmsg = warnmsg;
                    //    State = ((int)EnumEquipmentCurrentStateDisplay.警告).ToString();
                    //}
                    else
                    {//告警结束，获取有告警的数据，然后关闭他
                        info.AlertTime = null;
                        info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
                        info.FailureType = "";
                        info.WarnType = "";
                        info.WarnTime = null;
                        info.Warnmsg = "";
                        if (loginfo.IsMessage)
                        {//警告会覆盖下面的状态，先不用警告了
                            info.WarnTime = info.WarnTime ?? DateTime.Now;
                            info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
                            info.WarnType = alertall;
                        }
                        if (info.EquipmentCurrentState == null || (!info.EquipmentCurrentState.Equals(((int)EnumEquipmentCurrentStateDisplay.离线).ToString())))
                        {//如果设备状态为离线，则此处不需要判断任何信息
                            if (loginfo.IsNormalProduction && !loginfo.LackMaterial && !loginfo.FullMaterial)
                            {//自动运行状态+不缺料+不堵料
                                State = ((int)EnumEquipmentCurrentStateDisplay.生产).ToString();
                            }
                            else if (loginfo.IsNormalProduction && loginfo.FullMaterial)
                            {//自动运行状态+下料道满料 =  完成 （就是有生产出来但没有出设备）
                                State = ((int)EnumEquipmentCurrentStateDisplay.完成).ToString();
                            }
                            //else if (loginfo.IsNormalProduction && loginfo.LackMaterial)
                            //{//其他状态全算待机
                            //    State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
                            //}
                            else
                            {//其他状态全算待机
                                State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(State) && State != info.EquipmentCurrentState)
                    {//只有状态出现变化才变更,状态变更，肯定有新的一条数据

                        //状态变更，获取旧状态的信息，若有则更新(准确的说，只要没有结束时间的设备状态都需要更新结束时间，以便于插入新的数据)
                        var equlogState = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
                        && o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue && (o.EquipmentStateEndTime == null || o.EquipmentStateEndTime == DateTime.MinValue)
                        //&& o.EquipmentState== info.EquipmentCurrentState
                        )
                            .OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();

                        if (equlogState != null)
                        {
                            equlogState.MonitoringPoint = loginfo.MonitoringPoint;
                            equlogState.EquipmentStateEndTime = DateTimeHelper.GetDateTime();
                        }

                        info.UpdatedUserName = loginfo.MonitoringPoint;
                        info.UpdatedTime = DateTime.Now;
                        info.EquipmentCurrentState = State;

                        //状态变更，需要更新原来的，肯定会插入新的
                        infolog.EquipmentState = State;
                        infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
                        infolog.WorkingProcedure = loginfo.WorkingProcedure;
                        infolog.MonitoringPoint = loginfo.MonitoringPoint;
                        infolog.Remarks = "告警信息出现变更3";
                        infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(State)).ToString()}\r\n";
                        isAddEquipmentWorkingLog = true;
                        isStatechange = true;
                    }
                    #endregion

                    //1.有故障则是故障状态， 有故障信息+告警信息
                    //2.没有故障有告警则是告警状态，有告警信息
                    //3.即没故障，也没告警，则是其他状态

                    //查找是否有未结束的故障
                    var equlogFailure = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
                    && o.FailureStartTime != null && o.FailureStartTime != DateTime.MinValue && (o.FailureEndTime == null || o.FailureEndTime == DateTime.MinValue))
                        .OrderByDescending(o => o.FailureStartTime).FirstOrDefault();
                    if (loginfo.IsCloseAlert)
                    {//有故障标志位，设备状态若有变更则肯定有新增，此处直接更新即可
                     //有故障标志位，设备状态若没有更新，有故障，也不会插入新的（有故障设备状态变更肯定是变成故障）
                        infolog.FailureStartTime = DateTimeHelper.GetDateTime();
                        infolog.FailureType = faultall;
                        infolog.FailureMsg = faultmsg;
                        infolog.WorkingProcedure = loginfo.WorkingProcedure;
                        infolog.MonitoringPoint = loginfo.MonitoringPoint;
                        infolog.Remarks = "故障信息出现变更1";
                        infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + "故障信息变更\r\n";
                    }
                    else
                    {
                        if (equlogFailure != null)
                        {//故障关闭的
                            equlogFailure.MonitoringPoint = loginfo.MonitoringPoint;
                            equlogFailure.FailureEndTime = DateTimeHelper.GetDateTime();
                        }
                    }

                    //查找是否有未结束的告警
                    var equlogalert = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
                    && o.WarnStartTime != null && o.WarnStartTime != DateTime.MinValue && (o.WarnEndTime == null || o.WarnEndTime == DateTime.MinValue))
                        .OrderByDescending(o => o.WarnStartTime).FirstOrDefault();
                    if (loginfo.IsMessage)
                    {//若有告警，如果有设备状态变更，肯定插入，此处只修改即可
                     //若有告警，如果设备状态没有变更，有告警，也不插入新的（问题：当状态没有更改，如一直是故障，但告警信息有变化，怎么办  ps：此处先不管）
                        infolog.WarnStartTime = DateTimeHelper.GetDateTime();
                        infolog.WarnType = alertall;
                        infolog.Warnmsg = warnmsg;
                        infolog.WorkingProcedure = loginfo.WorkingProcedure;
                        infolog.MonitoringPoint = loginfo.MonitoringPoint;
                        infolog.Remarks = "告警信息出现变更2";
                        infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + "告警信息变更\r\n";
                    }
                    else
                    {
                        if (equlogalert != null)
                        {//故障关闭的
                            equlogalert.MonitoringPoint = loginfo.MonitoringPoint;
                            equlogalert.WarnEndTime = DateTimeHelper.GetDateTime();
                        }
                    }
                    #region 原来的代码，以后删掉

                    //EquipmentWorkingLog infolog =new EquipmentWorkingLog();
                    //infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                    //infolog.LogAddTime = DateTimeHelper.GetDateTime();
                    //infolog.WorkPieceLogID = loginfo2.Id;
                    //infolog.EquipmentID = info.EquipmentID;
                    //bool isAddEquipmentWorkingLog = false;
                    //if (loginfo.ischeckAlertStatus)
                    //{//告警状态发生变更
                    //    //说明是一个新告警，需要更新设备监控表
                    //    //查找未结束的告警
                    //    var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID 
                    //    && o.FailureStartTime != null && o.FailureStartTime != DateTime.MinValue)
                    //        .OrderByDescending(o=>o.FailureStartTime).FirstOrDefault();
                    //    if (loginfo.IsCloseAlert)
                    //    {
                    //        if (equlog == null|| (equlog.FailureEndTime!=null&& equlog.FailureEndTime > DateTime.MinValue))
                    //        {
                    //            info.AlertTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                    //            infolog.FailureStartTime = DateTimeHelper.GetDateTime();
                    //            infolog.FailureType = faultall;
                    //            infolog.FailureMsg = faultmsg;
                    //            infolog.WorkingProcedure = loginfo.WorkingProcedure;
                    //            infolog.MonitoringPoint = loginfo.MonitoringPoint;
                    //            infolog.Remarks = "故障信息出现变更1";
                    //            infolog.UpdateDesc = (infolog.UpdateDesc??"")+"故障信息变更\r\n";
                    //            isAddEquipmentWorkingLog =true;
                    //        }
                    //    }
                    //    else
                    //    {
                    //        if (equlog != null && (equlog.FailureEndTime == null || equlog.FailureEndTime <= DateTime.MinValue))
                    //        {//告警关闭的，若没有告警信息，不用管
                    //            equlog.MonitoringPoint = loginfo.MonitoringPoint;
                    //            equlog.FailureEndTime = DateTimeHelper.GetDateTime();
                    //        }

                    //    }
                    //}
                    //if (loginfo.ischeckMessageStatus)
                    //{//告警状态发生变更
                    //    //说明是一个新告警，需要更新设备监控表
                    //    //查找未结束的告警
                    //    var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID 
                    //    && o.WarnStartTime != null && o.WarnStartTime != DateTime.MinValue).OrderByDescending(o => o.WarnStartTime).FirstOrDefault();
                    //    if (loginfo.IsMessage)
                    //    {
                    //        if (equlog == null || (equlog.WarnEndTime != null && equlog.WarnEndTime > DateTime.MinValue))
                    //        {
                    //            info.WarnTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                    //            infolog.WarnStartTime = DateTimeHelper.GetDateTime();
                    //            infolog.WarnType = alertall;
                    //            infolog.Warnmsg = warnmsg;
                    //            infolog.WorkingProcedure = loginfo.WorkingProcedure;
                    //            infolog.MonitoringPoint = loginfo.MonitoringPoint;
                    //            infolog.Remarks = "告警信息出现变更2";
                    //            infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + "告警信息变更\r\n";
                    //            isAddEquipmentWorkingLog = true;
                    //        }
                    //    }
                    //    else
                    //    {
                    //        if (equlog != null && (equlog.WarnEndTime == null || equlog.WarnEndTime <= DateTime.MinValue))
                    //        {//告警关闭的，若没有告警信息，不用管
                    //            equlog.MonitoringPoint = loginfo.MonitoringPoint;
                    //            equlog.WarnEndTime = DateTimeHelper.GetDateTime();
                    //        }

                    //    }
                    //}
                    ////故障》警告》其他
                    //if (loginfo.IsCloseAlert)
                    //{//故障
                    //    info.AlertTime = info.AlertTime??DateTime.Now;
                    //    info.FailureType = "";
                    //    info.WarnType = "";
                    //    info.Alertmsg = faultmsg;//这个需要代码对应字典维护信息才知道
                    //    info.FailureType = faultall;
                    //    State = ((int)EnumEquipmentCurrentStateDisplay.故障).ToString();


                    //    infolog.FailureStartTime = DateTimeHelper.GetDateTime();
                    //    infolog.FailureType = faultall;
                    //    infolog.FailureMsg = faultmsg;
                    //    if (loginfo.IsMessage)
                    //    {
                    //        info.WarnTime = info.WarnTime ?? DateTime.Now;
                    //        info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
                    //        info.WarnType = alertall;
                    //    }
                    //}
                    //else if(loginfo.IsMessage)
                    //{//警告
                    //    info.AlertTime = null;
                    //    info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
                    //    info.FailureType = "";

                    //    info.WarnTime = info.WarnTime ?? DateTime.Now;
                    //    info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
                    //    info.WarnType = alertall;

                    //    infolog.WarnStartTime = DateTimeHelper.GetDateTime();
                    //    infolog.WarnType = alertall;
                    //    infolog.Warnmsg = warnmsg;
                    //    State = ((int)EnumEquipmentCurrentStateDisplay.警告).ToString();
                    //}
                    //else
                    //{//告警结束，获取有告警的数据，然后关闭他
                    //    info.AlertTime = null;
                    //    info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
                    //    info.FailureType = "";
                    //    info.WarnType = "";
                    //    info.WarnTime = null;
                    //    info.Warnmsg = "";
                    //    if (loginfo.IsNormalProduction&& loginfo.LackMaterial)
                    //    {
                    //        State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
                    //    }
                    //    else if(loginfo.IsNormalProduction && !loginfo.LackMaterial)
                    //    {
                    //        State = ((int)EnumEquipmentCurrentStateDisplay.生产).ToString();
                    //    }
                    //    else if(loginfo.IsNormalProduction && loginfo.FullMaterial)
                    //    {//正常生产+下料道满料 =  完成 （就是有生产出来但没有出设备）
                    //        State = ((int)EnumEquipmentCurrentStateDisplay.完成).ToString();
                    //    }
                    //    else
                    //    {//理论上不可能走到这，只是避免空值
                    //        State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
                    //    }
                    //}
                    //if (!string.IsNullOrEmpty(State) && State != info.EquipmentCurrentState)
                    //{//只有状态出现变化才变更
                    //    info.UpdatedUserName = loginfo.MonitoringPoint;
                    //    info.UpdatedTime = DateTime.Now;
                    //    info.EquipmentCurrentState = State;

                    //    var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
                    //    && o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();

                    //    if (equlog != null && (equlog.EquipmentStateEndTime == null || equlog.EquipmentStateEndTime <= DateTime.MinValue))
                    //    {
                    //        equlog.MonitoringPoint = loginfo.MonitoringPoint;
                    //        equlog.EquipmentStateEndTime = DateTimeHelper.GetDateTime();

                    //    }
                    //    //状态变更，需要更新原来的，并插入新的
                    //    infolog.EquipmentState = State;
                    //    infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
                    //    infolog.WorkingProcedure = loginfo.WorkingProcedure;
                    //    infolog.MonitoringPoint = loginfo.MonitoringPoint;
                    //    infolog.Remarks = "告警信息出现变更3";
                    //    infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(State)).ToString()}\r\n";
                    //    isAddEquipmentWorkingLog = true;
                    //}
                    ////info.Remarks = $"{loginfo.WorkingProcedure}工序告警";
                    #endregion
                    if (isAddEquipmentCurrentMonitor)
                    {
                        info.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                        db.EquipmentCurrentMonitor.Add(info);
                    }
                    if (isAddEquipmentWorkingLog)
                    {
                        db.EquipmentWorkingLog.Add(infolog);
                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = $"{loginfo2.MonitoringPoint}设备监控更新数据异常{e.Message}.{e.StackTrace}";
                    Log4NetHelper.WriteErrorLog(type, $"{loginfo2.MonitoringPoint}设备监控更新数据异常{e.Message}.{e.StackTrace}");
                }

                //db.WorkPieceLog.Add(loginfo2);//插入设备采集日志表
                db.SaveChanges();
            }
        }


        /// <summary>
        /// 心跳监控
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static void EquipmentBeartBeatMonitor(WorkPieceLogMiddle loginfo, LogType type)
        {

            using (DbModel db = new DbModel())
            {
                bool isAddEquipmentCurrentMonitor = false;
                EquipmentCurrentMonitor info = new EquipmentCurrentMonitor();
                info = db.EquipmentCurrentMonitor.Where(o => o.WorkingProcedure == loginfo.WorkingProcedure).FirstOrDefault();
                if (info == null)
                {//没有工件信息，不做更新
                    Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.MonitoringPoint} 没有获取到设备监控信息，现新增");
                    info = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLogMiddle>(loginfo);
                    isAddEquipmentCurrentMonitor = true;
                    info.EquipmentCurrentState = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
                    info.IsDeleted = false;
                }
                string state = "";


                EquipmentWorkingLog infolog = new EquipmentWorkingLog();
                infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                infolog.LogAddTime = DateTimeHelper.GetDateTime();
                infolog.WorkPieceLogID = loginfo.Id;
                infolog.EquipmentID = info.EquipmentID;
                bool isAddEquipmentWorkingLog = false;

                if (!loginfo.IsConnect)
                {//最新状态为离线
                    state = ((int)EnumEquipmentCurrentStateDisplay.离线).ToString();
                    info.EquipmentCurrentState = state;
                    info.UpdatedUserName = loginfo.MonitoringPoint;
                    info.UpdatedTime = DateTime.Now;
                    info.Alertmsg = "设备离线";
                    info.AlertTime = DateTimeHelper.GetDateTime();
                    info.FailureType = "";

                    //若没有离线的信息，则新增一条
                    var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
                    && o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue && (o.EquipmentStateEndTime == null || o.EquipmentStateEndTime == DateTime.MinValue)
                    && o.EquipmentState.Equals(state)
                    ).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();

                    if (equlog == null)
                    {
                        infolog.EquipmentState = state;
                        infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
                        infolog.WorkingProcedure = loginfo.WorkingProcedure;
                        infolog.MonitoringPoint = loginfo.MonitoringPoint;
                        infolog.Remarks = "离线";
                        infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(state)).ToString()}\r\n";
                        isAddEquipmentWorkingLog = true;
                    }
                    //若有非离线的状态数据，则更新
                    var equlog2 = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
                && o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue && (o.EquipmentStateEndTime == null || o.EquipmentStateEndTime == DateTime.MinValue)
                && !o.EquipmentState.Equals(state)
                ).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
                    if (equlog2 != null)
                    {
                        equlog2.MonitoringPoint = loginfo.MonitoringPoint;
                        equlog2.EquipmentStateEndTime = DateTimeHelper.GetDateTime();
                    }

                }
                else
                {//最新状态为开机
                    if (((int)EnumEquipmentCurrentStateDisplay.离线).ToString() == info.EquipmentCurrentState)
                    {//只有离线状态，才能变成开机
                        state = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
                        info.EquipmentCurrentState = state;
                        info.UpdatedUserName = loginfo.MonitoringPoint;
                        info.UpdatedTime = DateTime.Now;
                        info.Alertmsg = "";
                        info.AlertTime = null;

                        //有离线的数据，则更新
                        var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
                        && o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue && (o.EquipmentStateEndTime == null || o.EquipmentStateEndTime == DateTime.MinValue)
                        && o.EquipmentState.Equals(((int)EnumEquipmentCurrentStateDisplay.离线).ToString())
                        ).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
                        if (equlog != null)
                        {
                            equlog.MonitoringPoint = loginfo.MonitoringPoint;
                            equlog.EquipmentStateEndTime = DateTimeHelper.GetDateTime();

                        }
                        //离线变开机，肯定会插入一条
                        infolog.EquipmentState = state;
                        infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
                        infolog.WorkingProcedure = loginfo.WorkingProcedure;
                        infolog.MonitoringPoint = loginfo.MonitoringPoint;
                        infolog.Remarks = "开机";
                        infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(state)).ToString()}\r\n";
                        isAddEquipmentWorkingLog = true;
                    }
                }
                if (isAddEquipmentWorkingLog)
                {
                    db.EquipmentWorkingLog.Add(infolog);
                }
                if (isAddEquipmentCurrentMonitor)
                {
                    info.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                    db.EquipmentCurrentMonitor.Add(info);
                }

                db.SaveChanges();
            }
        }

        public static void ThreadMonitor(ThreadStatusMonitorMiddle threadinfo)
        {
            ThreadMonitor(EntityPropHelper.Mapper<ThreadStatusMonitor, ThreadStatusMonitorMiddle>(threadinfo));
            try
            {
                SystemValue.UpdateMainList(threadinfo);

            }
            catch (Exception ex)
            {

            }
        }
        public static void ThreadMonitor(ThreadStatusMonitor threadinfo)
        {
            try
            {
                using (DbModel db = new DbModel())
                {
                    var info = db.ThreadStatusMonitor.Where(o => o.Threadcode == threadinfo.Threadcode).FirstOrDefault();
                    if (info == null || info.Id == 0)
                    {//没有工件信息，不做更新
                        threadinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                        threadinfo.CreatedTime = DateTimeHelper.GetDateTime();
                        threadinfo.CreatedUserName = threadinfo.Threadcode;
                        db.ThreadStatusMonitor.Add(threadinfo);

                    }
                    else
                    {//更新表WorkPieceInfo
                        info.Remarks = threadinfo.Remarks;
                        info.ErrorMsg = threadinfo.ErrorMsg;
                        info.Threadendtime = DateTimeHelper.GetDateTime();//每次都更新
                        info.ThreadId = threadinfo.ThreadId;
                        info.ThreadFrequency = threadinfo.ThreadFrequency;
                        info.UpdatedTime = DateTimeHelper.GetDateTime();
                        info.UpdatedUserName = threadinfo.Threadcode;
                        info.Threadlastmodifytime = threadinfo.Threadlastmodifytime > DateTime.MinValue ? threadinfo.Threadlastmodifytime : info.Threadlastmodifytime;//如果有传参则更新
                                                                                                                                                                      //if (info.Threadstatue==1)
                                                                                                                                                                      //{
                                                                                                                                                                      //    info.Threadlastmodifytime = DateTimeHelper.GetDateTime();//最新跑到数据
                                                                                                                                                                      //}
                    }
                    db.SaveChanges();
                }

            }
            catch (Exception ex)
            {

            }
        }

        #region 业务方法

        /// <summary>
        ///  【质量数据更新专用】 dict中前面一个是原对象，后面一个是目标对象
        /// </summary>
        /// <param name="WorkingProcedure"></param>
        /// <returns></returns>
        public static Dictionary<string, string> GetQualityDataInfoUpdate(WorkPieceLogMiddle logMiddle, string WorkingProcedure = "", string MonitoringPoint = "")
        {
            Dictionary<string, string> dict = new Dictionary<string, string>();

            dict.Add("QualityState", "QualityState");
            dict.Add("EquipmentID", "EquipmentID");
            dict.Add("WorkingProcedure", "WorkingProcedure");
            dict.Add("QualityStateUpdateMode", "QualityStateUpdateMode");
            dict.Add("QualityStateUpdateUser", "QualityStateUpdateUser");
            dict.Add("OfflineTime", "OfflineTime");

            switch (WorkingProcedure)
            {
                case "OP10":
                    dict.Add("QualityOP10To1", "QualityOP10To1");

                    dict.Add("QualityNoOk", "QualityNoOk_OP10");
                    dict.Add("QualityNoOkReason", "QualityNoOkReason_OP10");
                    break;
                case "OP20":
                    dict.Add("QualityOP20To1", "QualityOP20To1");

                    dict.Add("QualityNoOk", "QualityNoOk_OP20");
                    dict.Add("QualityNoOkReason", "QualityNoOkReason_OP20");
                    break;
                case "OP30":
                    dict.Add("QualityNoOk", "QualityNoOk_OP30");
                    dict.Add("QualityNoOkReason", "QualityNoOkReason_OP30");

                    switch (MonitoringPoint)
                    {
                        case "OP3002CH3":
                            dict.Add("QualityOP30To1", "QualityOP30To1");
                            break;
                        case "OP3002CH4":
                            dict.Add("QualityOP30To2", "QualityOP30To2");
                            dict.Add("QualityOP30To8", "QualityOP30To8");
                            break;
                        case "OP3002CH5":
                            dict.Add("QualityOP30To3", "QualityOP30To3");
                            dict.Add("QualityOP30To4", "QualityOP30To4");
                            dict.Add("QualityOP30To5", "QualityOP30To5");
                            dict.Add("QualityOP30To9", "QualityOP30To9");
                            dict.Add("QualityOP30To10", "QualityOP30To10");
                            dict.Add("QualityOP30To11", "QualityOP30To11");
                            break;
                        case "OP3002CH6":
                            dict.Add("QualityOP30To6", "QualityOP30To6");
                            dict.Add("QualityOP30To7", "QualityOP30To7");
                            break;
                        default:
                            break;
                    }
                    break;
                case "OP35":
                    dict.Add("QualityOP35To1", "QualityOP35To1");
                    dict.Add("QualityOP35To2", "QualityOP35To2");

                    dict.Add("QualityNoOk", "QualityNoOk_OP35");
                    dict.Add("QualityNoOkReason", "QualityNoOkReason_OP35");

                    break;
                case "OP40":
                    dict.Add("QualityOP40To1", "QualityOP40To1");

                    dict.Add("QualityNoOk", "QualityNoOk_OP40");
                    dict.Add("QualityNoOkReason", "QualityNoOkReason_OP40");
                    break;
                case "OP60":
                    dict.Add("QualityOP60To1", "QualityOP60To1");
                    dict.Add("QualityOP60To2", "QualityOP60To2");

                    dict.Add("QualityNoOk", "QualityNoOk_OP60");
                    dict.Add("QualityNoOkReason", "QualityNoOkReason_OP60");

                    break;
                case "OP70":
                    dict.Add("QualityOP70To1", "QualityOP70To1");
                    dict.Add("QualityOP70To2", "QualityOP70To2");
                    dict.Add("QualityOP70To3", "QualityOP70To3");
                    break;
                case "OP80":
                    //dict.Add("OP80NewCode", "OP80NewCode");
                    dict.Add("QualityOP80To1", "QualityOP80To1");
                    dict.Add("QualityOP80To2", "QualityOP80To2");
                    dict.Add("QualityOP80To3", "QualityOP80To3");
                    dict.Add("QualityOP80To4", "QualityOP80To4");
                    dict.Add("QualityOP80To5", "QualityOP80To5");
                    dict.Add("QualityOP80To6", "QualityOP80To6");
                    dict.Add("QualityOP80To7", "QualityOP80To7");
                    dict.Add("QualityOP80To8", "QualityOP80To8");
                    dict.Add("QualityOP80To9", "QualityOP80To9");
                    dict.Add("QualityOP80To10", "QualityOP80To10");

                    //新增 【Editby shaocx,2024-06-16】
                    dict.Add("QualityOP80_Houdu", "QualityOP80_Houdu");
                    dict.Add("QualityOP80_ZXJ", "QualityOP80_ZXJ");
                    dict.Add("QualityOP80_DTKYZD", "QualityOP80_DTKYZD");
                    dict.Add("QualityOP80_XTSMYD", "QualityOP80_XTSMYD");
                    dict.Add("QualityOP80_XTXMYD", "QualityOP80_XTXMYD");
                    dict.Add("QualityOP80_D_TKZJ", "QualityOP80_D_TKZJ");
                    dict.Add("QualityOP80_D_S_X", "QualityOP80_D_S_X");
                    dict.Add("QualityOP80_D_S_Y", "QualityOP80_D_S_Y");
                    dict.Add("QualityOP80_D_X_X", "QualityOP80_D_X_X");
                    dict.Add("QualityOP80_D_X_Y", "QualityOP80_D_X_Y");
                    dict.Add("QualityOP80_X_TKZJ", "QualityOP80_X_TKZJ");
                    dict.Add("QualityOP80_X_S_X", "QualityOP80_X_S_X");
                    dict.Add("QualityOP80_X_S_Y", "QualityOP80_X_S_Y");
                    dict.Add("QualityOP80_X_X_X", "QualityOP80_X_X_X");
                    dict.Add("QualityOP80_X_X_Y", "QualityOP80_X_X_Y");


                    dict.Add("QualityNoOk", "QualityNoOk_OP80");
                    dict.Add("QualityNoOkReason", "QualityNoOkReason_OP80");

                    break;
                default:
                    break;
            }
            return dict;
        }

        /// <summary>
        ///  【工件或工序数据数据更新专用】 dict中前面一个是原对象，后面一个是目标对象
        /// </summary>
        /// <param name="WorkingProcedure"></param>
        /// <returns></returns>
        public static Dictionary<string, string> GetWorkPieceInfoUpdateForQualityNoOk(WorkPieceLogMiddle loginfo)
        {
            Dictionary<string, string> dict = new Dictionary<string, string>();

            //if (loginfo.QualityState != null)
            //{
            //    QualityState qualityState;
            //    bool isRight = Enum.TryParse<QualityState>(loginfo.QualityState.ToString(), out qualityState);
            //    if (isRight && (qualityState == QualityState.NG || qualityState == QualityState.Suspected))
            //    {

            //    }
            //}

            dict.Add("QualityNoOk", "QualityNoOk");
            dict.Add("QualityNoOkReason", "QualityNoOkReason");

            return dict;
        }

        public static void SetQualityNoOk_WorkPieceInfo(WorkPieceLogMiddle logMiddle, ref WorkPieceInfo pieceInfo)
        {
            if (!IsWirteQualityNoOk(logMiddle, pieceInfo.QualityNoOk)) return;

            pieceInfo.QualityNoOk = logMiddle.QualityNoOk;
            pieceInfo.QualityNoOkReason = logMiddle.QualityNoOkReason;
        }
        public static void SetQualityNoOk_WorkPieceProcess(WorkPieceLogMiddle logMiddle, ref WorkPieceProcess pieceProcess)
        {
            if (!IsWirteQualityNoOk(logMiddle, pieceProcess.QualityNoOk)) return;

            pieceProcess.QualityNoOk = logMiddle.QualityNoOk;
            pieceProcess.QualityNoOkReason = logMiddle.QualityNoOkReason;
        }

        /// <summary>
        /// 是否需要重写 NOOK原因
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <param name="pieceInfo"></param>
        /// <returns></returns>
        public static bool IsWirteQualityNoOk(WorkPieceLogMiddle logMiddle, int? qualityNoOk)
        {
            if (logMiddle.WorkingProcedure == (WorkingProcedureForHMI.OP30).ToString())
            {
                //特殊逻辑：按照OP30的顺序判断
                if (logMiddle.QualityNoOk != null && qualityNoOk != null
                    && (
                      qualityNoOk == (int)QualityNoOkEnum.OP30压衬套工位力矩超差
                      || qualityNoOk == (int)QualityNoOkEnum.OP30涨断工位力矩超差
                      || qualityNoOk == (int)QualityNoOkEnum.OP30终拧紧工位力矩超差
                      || qualityNoOk == (int)QualityNoOkEnum.OP30预拧紧工位力矩超差
                    )
                    )
                {
                    if ((int)logMiddle.QualityNoOk > (int)qualityNoOk)
                    {//不需要重新赋值
                        return false;
                    }
                }
            }

            return true;
        }


        /// <summary>
        /// 判断是否跳序
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static bool CheckQualityInfoComplete(WorkPieceInfo info, WorkPieceLog loginfo, LogType type)
        {
            //判断是否跳序
            if (info == null || info.WorkPieceID.Length < 1)
            {
                Log4NetHelper.WriteErrorLog(type, $"校验工件信息{loginfo.WorkPieceID}工序是否跳序时，传入工件信息异常");
                return true;//没取到工件信息，不做判断是否跳序
            }
            else
            {
                try
                {
                    string wproStr = info.WorkingProcedureCurrent + loginfo.WorkingProcedure;
                    if (wproStr.Length != 8)
                    {
                        Log4NetHelper.WriteErrorLog(type, $"校验工件{info.WorkPieceID}  {loginfo.WorkingProcedure}工序 是否跳序时，工序拼接有问题长度不为8位:{wproStr}");
                        return true;//工序拼接有问题
                    }
                    if (!ConfigHelper.GetConfigString("WorkingProcedureAllStr").Contains(wproStr))
                    {
                        Log4NetHelper.WriteErrorLog(type, $"校验工件{info.WorkPieceID}  {loginfo.WorkingProcedure}工序 出现跳序，请设备注意:{wproStr}");
                        return false;
                    }

                }
                catch (Exception ex)
                {
                    Log4NetHelper.WriteErrorLog(type, $"校验工件{info.WorkPieceID}  {loginfo.WorkingProcedure}工序 是否跳序时出现异常", ex);
                }
            }
            return true;

            //using (var trans = db.Database.BeginTransaction())
            //{ }

            //var conStr = @"server=localhost;Database=EFDBO1;User ID=sa;Password=123456;"; 
            //using (var connection = new SqlConnection(conStr))
            //{
            //    connection.Open();
            //    using (var scope = new Transactionscope())
            //    {

            //        //AD0.Net
            //        var command = connection.CreateCommand();
            //        command.CommandText = "DELETE FROM T_RoleInfor";
            //        command.ExecuteNonQuery();
            //        //综合提交
            //        scope.complete();
            //    }
            //}
        }
        /// <summary>
        ///         解析二维码

        /// </summary>
        /// <param name="loginfo"></param>
        /// <returns></returns>
        public static WorkPieceInfo ParseQRCode(WorkPieceInfo loginfo)
        {
            if (string.IsNullOrEmpty(loginfo.WorkPieceID) || loginfo.WorkPieceID.Length != 22)
            {
                return loginfo;
            }
            loginfo.WorkPieceIDTo1 = loginfo.WorkPieceID.Substring(0, 2);
            loginfo.WorkPieceIDTo2 = loginfo.WorkPieceID.Substring(2, 4);
            loginfo.WorkPieceIDTo3 = loginfo.WorkPieceID.Substring(6, 6);
            loginfo.WorkPieceIDTo4 = loginfo.WorkPieceID.Substring(12, 2);
            loginfo.WorkPieceIDTo5 = loginfo.WorkPieceID.Substring(14, 4);
            loginfo.WorkPieceIDTo6 = loginfo.WorkPieceID.Substring(18, 2);
            loginfo.WorkPieceIDTo7 = loginfo.WorkPieceID.Substring(20, 2);
            return loginfo;
        }

        /// <summary>
        /// 设置中间变量的质量数据
        /// </summary>
        /// <param name="logMiddle"></param>
        public static void SetLogMiddleForQuality(ref WorkPieceLogMiddle logMiddle)
        {

            logMiddle.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityStateEnum.OK : QualityStateEnum.NG);

            //根据质量数据判断是否合格/不合格 【Editby shaocx,2024-06-25】
            QualityNoOkEnum? qualityNoOkEnum = null;
            QualityStateEnum qualityState = WorkPieceInfoManager.CalcQualityStateForOP(logMiddle, ref qualityNoOkEnum);
            logMiddle.QualityState = (int)qualityState;
            logMiddle.QualityStateStr = qualityState.ToString();
            if (qualityNoOkEnum != null)
            {
                logMiddle.QualityNoOk = (int)qualityNoOkEnum;
                logMiddle.QualityNoOkReason = qualityNoOkEnum.ToString();
            }
        }

        /// <summary>
        /// 计算OP 质量数据是否合格
        /// </summary>
        private static QualityStateEnum CalcQualityStateForOP(WorkPieceLogMiddle logMiddle, ref QualityNoOkEnum? qualityNoOkEnum)
        {
            QualityStateEnum qualityState = QualityStateEnum.Suspected;
            if (logMiddle.WorkingProcedure == "OP60")
            {//合格/不合格由 WMS自行判断
                decimal _QualityOP60To1 = SystemHelper.GetDecimal(logMiddle.QualityOP60To1);
                decimal _QualityOP60To2 = SystemHelper.GetDecimal(logMiddle.QualityOP60To2);
                var isPass_QualityOP60To1 = false;
                var isPass_QualityOP60To2 = false;


                if (_QualityOP60To1 >= (decimal)53.018 && _QualityOP60To1 <= (decimal)53.030)
                {
                    isPass_QualityOP60To1 = true;
                }
                else
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP60大头孔直径超差;
                }
                if (_QualityOP60To2 >= (decimal)22.005 && _QualityOP60To2 <= (decimal)22.011)
                {
                    isPass_QualityOP60To2 = true;
                }
                else
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP60小头孔直径超差;
                }

                if (isPass_QualityOP60To1 && isPass_QualityOP60To2)
                {
                    qualityState = QualityStateEnum.OK;
                }
                else
                {
                    qualityState = QualityStateEnum.NG;
                }
                if (_QualityOP60To1 == 0 || _QualityOP60To2 == 0)
                {
                    qualityState = QualityStateEnum.Suspected;
                    return qualityState;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP80")
            {//合格/不合格由 OP80 判断，QualityState 和 QualityStateStr 都在调用当前方法前 写入值了
                if (logMiddle.QualityState == (int)QualityStateEnum.OK)
                {
                    qualityState = QualityStateEnum.OK;
                    return qualityState;
                }

                decimal _QualityOP80_D_TKZJ = SystemHelper.GetDecimal(logMiddle.QualityOP80_D_TKZJ);
                if (!(_QualityOP80_D_TKZJ >= (decimal)53.018 && _QualityOP80_D_TKZJ <= (decimal)53.03))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80大头孔直径超差;
                }

                decimal _QualityOP80_X_TKZJ = SystemHelper.GetDecimal(logMiddle.QualityOP80_X_TKZJ);
                if (!(_QualityOP80_X_TKZJ >= (decimal)22.005 && _QualityOP80_X_TKZJ <= (decimal)22.011))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔直径超差;
                }

                decimal _QualityOP80_ZXJ = SystemHelper.GetDecimal(logMiddle.QualityOP80_ZXJ);
                if (!(_QualityOP80_ZXJ >= (decimal)144.475 && _QualityOP80_ZXJ <= (decimal)144.525))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80中心距超差;
                }

                decimal _QualityOP80_DTKYZD = SystemHelper.GetDecimal(logMiddle.QualityOP80_DTKYZD);
                if (!(_QualityOP80_DTKYZD >= (decimal)0 && _QualityOP80_DTKYZD <= (decimal)0.005))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80大头孔圆柱度超差;
                }

                decimal _QualityOP80_XTSMYD = SystemHelper.GetDecimal(logMiddle.QualityOP80_XTSMYD);
                if (!(_QualityOP80_XTSMYD >= (decimal)0 && _QualityOP80_XTSMYD <= (decimal)0.003))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔圆度上面超差;
                }

                decimal _QualityOP80_XTXMYD = SystemHelper.GetDecimal(logMiddle.QualityOP80_XTXMYD);
                if (!(_QualityOP80_XTXMYD >= (decimal)0 && _QualityOP80_XTXMYD <= (decimal)0.003))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔圆度下面超差;
                }

                decimal _QualityOP80To4 = SystemHelper.GetDecimal(logMiddle.QualityOP80To4);
                if (!(_QualityOP80To4 >= (decimal)(-0.075) && _QualityOP80To4 <= (decimal)0.075))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔平行度弯曲超差;
                }

                decimal _QualityOP80To5 = SystemHelper.GetDecimal(logMiddle.QualityOP80To5);
                if (!(_QualityOP80To5 >= (decimal)(-0.2) && _QualityOP80To5 <= (decimal)0.2))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔平行度扭曲超差;
                }

                decimal _QualityOP80To6 = SystemHelper.GetDecimal(logMiddle.QualityOP80To6);
                if (!(_QualityOP80To6 >= (decimal)0 && _QualityOP80To6 <= (decimal)0.04))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80大头孔垂直度超差;
                }

                decimal _QualityOP80To10 = SystemHelper.GetDecimal(logMiddle.QualityOP80To10);
                if (!(_QualityOP80To10 >= (decimal)0 && _QualityOP80To10 <= (decimal)0.04))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头孔垂直度超差;
                }

                decimal _QualityOP80_Houdu = SystemHelper.GetDecimal(logMiddle.QualityOP80_Houdu);
                if (!(_QualityOP80_Houdu >= (decimal)21.80 && _QualityOP80_Houdu <= (decimal)21.85))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80厚度超差;
                }

                decimal _QualityOP80To1 = SystemHelper.GetDecimal(logMiddle.QualityOP80To1);
                if (!(_QualityOP80To1 >= (decimal)364 && _QualityOP80To1 <= (decimal)385))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80大头端重量超差;
                }

                decimal _QualityOP80To2 = SystemHelper.GetDecimal(logMiddle.QualityOP80To2);
                if (!(_QualityOP80To2 >= (decimal)143 && _QualityOP80To2 <= (decimal)155))
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP80小头端重量超差;
                }


                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP10")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP10厚度超差;
                }
                else
                {
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP20")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP20小头孔直径超差;
                }
                else
                {
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP30")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityStateStr.Equals("OK"))
                {
                    qualityState = QualityStateEnum.OK;
                }
                else
                {
                    qualityState = QualityStateEnum.NG;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP35")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP35滚压力超差;
                }
                else
                {
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP40")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP40厚度超差;
                }
                else
                {
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
            return qualityState;
        }


        /// <summary>
        /// 获取质量状态值
        /// </summary>
        /// <param name="qualityState"></param>
        /// <returns></returns>
        public static int GetQualityStateValue(int? qualityState)
        {
            if (qualityState.HasValue == false)
            {
                return (int)QualityStateEnum.Suspected;
            }
            if (qualityState.Value == 1)
            {
                return (int)QualityStateEnum.OK;
            }
            if (qualityState.Value == 2)
            {
                return (int)QualityStateEnum.NG;
            }
            return (int)QualityStateEnum.Suspected;
        }


        #endregion
    }
}