1

schangxiang@126.com

2024-08-16 565a8a99d48cacf9ef1f3e749400eee78e21ce56

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/WorkPieceInfoManager.cs

@@ -182,7 +182,7 @@
                            }
                            else
                            {
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
@@ -226,7 +226,16 @@
                        WorkPieceProcess process = new WorkPieceProcess();
                        process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
                        process.StartTime = DateTimeHelper.GetDateTime();
                        process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;

                        //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                        //process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                        process.QualityState = GetQualityStateValue(info.QualityState);

                        if (process.WorkingProcedureCurrent == WorkingProcedureForHMI.OP70.ToString())
                        { //特殊处理OP70，因为OP70没有测量，默认合格 [Editby shaocx,2024-07-03]
                            process.QualityState = (int)QualityState.OK;//默认合格，OP70默认是合格
                        }

                        process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                        process.CreatedUserName = loginfo.MonitoringPoint;
                        process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
@@ -456,9 +465,9 @@
        /// <summary>
        /// 质量检测完成
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="logMiddle"></param>
        /// <param name="type"></param>
        public static void QualityInfoComplete(WorkPieceLogMiddle loginfo, LogType type)
        public static void QualityInfoComplete(WorkPieceLogMiddle logMiddle, LogType type)
        {
            //此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
            //插入质量相关表QualityDataInfo
@@ -468,79 +477,79 @@

                bool isAddWorkPieceInfo = false;
                WorkPieceLog loginfo2 = new WorkPieceLog();
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(logMiddle);
                try
                {

                    if (loginfo.WorkPieceID.Length == 22)
                    if (logMiddle.WorkPieceID.Length == 22)
                    {//获取到的工件号异常
                        WorkPieceInfo info = new WorkPieceInfo();
                        info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (info == null || info.WorkPieceID.Length < 1)
                        WorkPieceInfo pieceInfo = new WorkPieceInfo();
                        pieceInfo = db.WorkPieceInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                        if (pieceInfo == null || pieceInfo.WorkPieceID.Length < 1)
                        {//没有工件信息，不做更新
                            if (loginfo.MonitoringPoint.Equals("OP1002") || loginfo.MonitoringPoint.Equals("OP1003") || loginfo.MonitoringPoint.Contains("OP2002"))
                            if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
                            {//OP10 没有上线扫码枪，约定用测量完成信号当上线标记
                                info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLogMiddle>(loginfo);
                                pieceInfo = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLogMiddle>(logMiddle);
                                //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                                if (!loginfo.WorkingProcedure.Equals("OP05"))
                                if (!logMiddle.WorkingProcedure.Equals("OP05"))
                                {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                    info.QualityState = (int)QualityState.Suspected;
                                    info.QualityErrorInfo = $"工件二维码第一次出现的工序{loginfo.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                    info.Remarks = $"工件二维码第一次出现的工序{loginfo.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                                    pieceInfo.QualityState = (int)QualityState.Suspected;
                                    pieceInfo.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                    pieceInfo.Remarks = $"工件二维码第一次出现的工序{logMiddle.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                                }
                                else
                                {
                                    info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                    info.Remarks = "OP05新增工件信息";
                                    pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                    pieceInfo.Remarks = "OP05新增工件信息";
                                }
                                info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                                info.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                                info.CreatedUserName = loginfo.MonitoringPoint;
                                info.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                                info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                                info.WorkingProcedureEndTime = null;
                                info = ParseQRCode(info);
                                pieceInfo.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                                pieceInfo.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                                pieceInfo.CreatedUserName = ResetUpdatedUserName(logMiddle);
                                pieceInfo.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                                pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                                pieceInfo.WorkingProcedureEndTime = null;
                                pieceInfo = ParseQRCode(pieceInfo);
                                isAddWorkPieceInfo = true;


                            }
                            else
                            {
                                loginfo2.Remarks = loginfo2.Remarks ?? "" + $"|工件{loginfo.WorkPieceID} 质量检测完成工序{loginfo.MonitoringPoint} 没有获取到工件信息不做更新";
                                Log4NetHelper.WriteErrorLog(type, $"工件{loginfo.WorkPieceID} 质量检测完成工序{loginfo.MonitoringPoint} 没有获取到工件信息不做更新");
                                loginfo2.Remarks = loginfo2.Remarks ?? "" + $"|工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新";
                                Log4NetHelper.WriteErrorLog(type, $"工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新");
                                return;
                            }
                        }
                        if (loginfo.MonitoringPoint.Equals("OP1002") || loginfo.MonitoringPoint.Equals("OP1003") || loginfo.MonitoringPoint.Contains("OP2002"))
                        if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
                        {// OP10 没有上线扫码枪，约定用测量完成信号当上线标记，所以上线需要修改的字段放这里

                            if (loginfo.WorkingProcedure.Equals("OP10"))
                            if (logMiddle.WorkingProcedure.Equals("OP10"))
                            {
                                var WorkingProcedure = (loginfo.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
                                var WorkingProcedure = (logMiddle.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
                                loginfo2.WorkingProcedure = WorkingProcedure;//解决OP10，OP40同一个的问题
                                loginfo.WorkingProcedure = WorkingProcedure;//解决OP10，OP40同一个的问题
                                logMiddle.WorkingProcedure = WorkingProcedure;//解决OP10，OP40同一个的问题
                            }
                            info.WorkPieceCurrentPosition = loginfo.WorkingProcedure;
                            info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                            info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                            info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                            pieceInfo.WorkPieceCurrentPosition = logMiddle.WorkingProcedure;
                            pieceInfo.WorkPieceCurrentPositionOrder = pieceInfo.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) / 2;
                            pieceInfo.WorkingProcedureCurrent = logMiddle.WorkingProcedure;
                            pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();

                            #region 更新设备实时表

                            bool isAddEquipmentCurrentMonitor = false;
                            EquipmentCurrentMonitor equinfo = new EquipmentCurrentMonitor();
                            equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == loginfo.EquipmentID).FirstOrDefault();
                            equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == logMiddle.EquipmentID).FirstOrDefault();
                            if (equinfo == null || equinfo.Id < 1)
                            {//没有工件信息，不做更新
                                Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.WorkingProcedure} 没有获取到设备监控信息，现新增");
                                equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(loginfo);
                                Log4NetHelper.WriteErrorLog(type, $"设备{logMiddle.EquipmentID} 告警监控{logMiddle.WorkingProcedure} 没有获取到设备监控信息，现新增");
                                equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(logMiddle);
                                equinfo.OnlineTime = DateTime.Now;
                                isAddEquipmentCurrentMonitor = true;
                            }
                            else
                            {//更新工件
                                equinfo.WorkPieceID = loginfo.WorkPieceID;
                                equinfo.UpdatedUserName = loginfo.MonitoringPoint;
                                equinfo.WorkPieceID = logMiddle.WorkPieceID;
                                equinfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                                equinfo.UpdatedTime = DateTime.Now;
                                equinfo.OnlineTime = DateTime.Now;
                            }
@@ -552,91 +561,130 @@
                            #endregion
                            //UpdateKnifeToolLift(db, loginfo);//更新刀具寿命信息
                        }
                        info.WorkPieceState = (int)WorkPieceState.WIP;//推出后和SPC抽检后 质量录入时状态修改回在制品
                        info.EquipmentID = loginfo.EquipmentID;
                        info.QualityStateUpdateUser = loginfo.UpdatedUserName;
                        info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
                        info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                        info.Remarks = info.Remarks ?? "" + $"{loginfo.WorkingProcedure}质量检测完成修改";
                        info.UpdatedUserName = loginfo.MonitoringPoint;
                        info.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        if (!(info.WorkingProcedureStartTime.HasValue && info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                        pieceInfo.WorkPieceState = (int)WorkPieceState.WIP;//推出后和SPC抽检后 质量录入时状态修改回在制品
                        pieceInfo.EquipmentID = logMiddle.EquipmentID;
                        pieceInfo.QualityStateUpdateUser = logMiddle.UpdatedUserName;
                        pieceInfo.QualityStateUpdateTime = logMiddle.UpdatedTime.Value.LocalDateTime;
                        pieceInfo.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                        pieceInfo.Remarks = pieceInfo.Remarks ?? "" + $"{logMiddle.WorkingProcedure}质量检测完成修改";
                        pieceInfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                        pieceInfo.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        if (!(pieceInfo.WorkingProcedureStartTime.HasValue && pieceInfo.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                        {//工序开始时间没有则赋值
                            info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                            pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                        }
                        info.QualityState = (int)((loginfo.QualityStateStr.Equals("OK") || loginfo.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
                        pieceInfo.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
                        //赋值不合格原因
                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);

                        if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))

                        if (!pieceInfo.QualityState.Equals(((int)QualityState.OK).ToString()))
                        {
                            info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量采集数据不合格{info.QualityState}";
                            pieceInfo.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格{pieceInfo.QualityState}";
                        }
                        else
                        {
                            info.QualityErrorInfo = "";
                            pieceInfo.QualityErrorInfo = "";
                        }
                        loginfo.QualityState = info.QualityState;
                        logMiddle.QualityState = pieceInfo.QualityState;
                        if (isAddWorkPieceInfo)
                        {
                            db.WorkPieceInfo.Add(info);
                            db.WorkPieceInfo.Add(pieceInfo);
                        }

                        #region 根据标准值更新最新质量数据（OP10/OP40/OP20/OP60）
                        var qcofig = db.EquipmentQualityConfig.Where(o => o.WorkingProcedure.Equals(loginfo.WorkingProcedure) && o.ParamType != 1 && o.IsDeleted == false).ToList();
                        var qcofig = db.EquipmentQualityConfig.Where(o => o.WorkingProcedure.Equals(logMiddle.WorkingProcedure) && o.ParamType != 1 && o.IsDeleted == false).ToList();
                        if (qcofig.Count > 0)
                        {
                            QualityDataHand(loginfo, qcofig);
                            QualityDataHand(logMiddle, qcofig);
                        }
                        #endregion


                        var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                        if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
                        {//插入QualityDataInfo表
                            qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(loginfo);
                            qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                            db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
                        }
                        //修改QualityDataInfo表 //重复收到质量信息，会覆盖之前的
                        EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(loginfo, qualityData, GetQualityDataInfoUpdate(loginfo.WorkingProcedure, loginfo.MonitoringPoint));//指定修改字段
                        EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(logMiddle, qualityData, GetQualityDataInfoUpdate(logMiddle, logMiddle.WorkingProcedure, logMiddle.MonitoringPoint));//指定修改字段

                        qualityData.QualityStateUpdateUser = info.UpdatedUserName;
                        qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
                        qualityData.QualityStateUpdateMode = info.QualityStateUpdateMode;
                        if (loginfo.WorkingProcedure.Equals("OP10"))
                        qualityData.QualityStateUpdateUser = pieceInfo.UpdatedUserName;
                        qualityData.QualityReceiveTime = pieceInfo.UpdatedTime.Value.LocalDateTime;
                        qualityData.QualityStateUpdateMode = pieceInfo.QualityStateUpdateMode;
                        if (logMiddle.WorkingProcedure.Equals("OP10"))
                        {
                            qualityData.OP10QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP10QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP10QualityReceiveTime = DateTimeHelper.GetDateTime();
                        }
                        else if (loginfo.WorkingProcedure.Equals("OP20"))
                        else if (logMiddle.WorkingProcedure.Equals("OP20"))
                        {
                            //Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}质量信息【{loginfo.QualityStateStr ?? "空"}】" +
                            //    $"【{(loginfo.QualityState.HasValue? loginfo.QualityState.Value:999)}】【{(info.QualityState.HasValue ? info.QualityState.Value : 888)}】 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]");
                            qualityData.OP20QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP20QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP20QualityReceiveTime = DateTimeHelper.GetDateTime();
                            qualityData.OP20QualityFilePath = loginfo.OP20QualityFilePath;
                            qualityData.OP20QualityFilePath = logMiddle.OP20QualityFilePath;
                        }
                        else if (loginfo.WorkingProcedure.Equals("OP30"))
                        else if (logMiddle.WorkingProcedure.Equals("OP30"))
                        {
                            switch (loginfo.MonitoringPoint)
                            switch (logMiddle.MonitoringPoint)
                            {
                                case "OP3002CH3":
                                    qualityData.OP30QualityFilePathCH3 = loginfo.OP30QualityFilePathCH3;
                                    qualityData.OP30QualityStateCH3 = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityFilePathCH3 = logMiddle.OP30QualityFilePathCH3;
                                    qualityData.OP30QualityStateCH3 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH3 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH3 == ((int)QualityState.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30涨断工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30涨断工位力矩大.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }

                                    break;
                                case "OP3002CH4":
                                    qualityData.OP30QualityFilePathCH4 = loginfo.OP30QualityFilePathCH4;
                                    qualityData.OP30QualityStateCH4 = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityFilePathCH4 = logMiddle.OP30QualityFilePathCH4;
                                    qualityData.OP30QualityStateCH4 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH4 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH4 == ((int)QualityState.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30预拧紧工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30预拧紧工位力矩大.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }

                                    break;
                                case "OP3002CH5":
                                    qualityData.OP30QualityFilePathCH5 = loginfo.OP30QualityFilePathCH5;
                                    qualityData.OP30QualityStateCH5 = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityFilePathCH5 = logMiddle.OP30QualityFilePathCH5;
                                    qualityData.OP30QualityStateCH5 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH5 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH5 == ((int)QualityState.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30终拧紧工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30终拧紧工位力矩大.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }

                                    break;
                                case "OP3002CH6":
                                    qualityData.OP30QualityFilePathCH6 = loginfo.OP30QualityFilePathCH6;
                                    qualityData.OP30QualityStateCH6 = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityFilePathCH6 = logMiddle.OP30QualityFilePathCH6;
                                    qualityData.OP30QualityStateCH6 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH6 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH6 == ((int)QualityState.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30压衬套工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30压衬套工位力矩大.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }

                                    break;
                                default:
                                    break;
@@ -644,42 +692,51 @@
                            //qualityData.OP30QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            //qualityData.OP30QualityReceiveTime = DateTimeHelper.GetDateTime();
                        }
                        else if (loginfo.WorkingProcedure.Equals("OP35"))
                        else if (logMiddle.WorkingProcedure.Equals("OP35"))
                        {
                            qualityData.OP35QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP35QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP35QualityReceiveTime = DateTimeHelper.GetDateTime();
                        }
                        else if (loginfo.WorkingProcedure.Equals("OP40"))
                        else if (logMiddle.WorkingProcedure.Equals("OP40"))
                        {
                            qualityData.OP40QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP40QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP40QualityReceiveTime = DateTimeHelper.GetDateTime();
                        }
                        else if (loginfo.WorkingProcedure.Equals("OP60"))
                        else if (logMiddle.WorkingProcedure.Equals("OP60"))
                        {
                            qualityData.OP60QualityFilePath = loginfo.OP60QualityFilePath;
                            qualityData.OP60QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP60QualityFilePath = logMiddle.OP60QualityFilePath;
                            qualityData.OP60QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP60QualityReceiveTime = DateTimeHelper.GetDateTime();
                        }
                        else if (loginfo.WorkingProcedure.Equals("OP80"))
                        else if (logMiddle.WorkingProcedure.Equals("OP80"))
                        {
                            qualityData.OP80QualityFilePath = loginfo.OP80QualityFilePath;
                            qualityData.OP80QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP80QualityFilePath = logMiddle.OP80QualityFilePath;
                            qualityData.OP80QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP80QualityReceiveTime = DateTimeHelper.GetDateTime();
                        }

                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == info.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro == null || pro.WorkPieceID.Length < 1 || loginfo.MonitoringPoint.Equals("OP1002") || loginfo.MonitoringPoint.Equals("OP1003") || loginfo.MonitoringPoint.Contains("OP2002"))
                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID && o.WorkingProcedureCurrent == pieceInfo.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro == null || pro.WorkPieceID.Length < 1 || logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
                        {// OP10 没有上线扫码枪，约定用测量完成信号当上线标记，所以上线需要修改的字段放这里
                            //上线是每次都插入

                            WorkPieceProcess process = new WorkPieceProcess();
                            process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
                            process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(pieceInfo);
                            process.StartTime = DateTimeHelper.GetDateTime();
                            process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;

                            //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                            //process.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                            process.QualityState = WorkPieceInfoManager.GetQualityStateValue(pieceInfo.QualityState);


                            //记录质量不合格原因 【Editby shaocx,2024-06-26】
                            //赋值不合格原因
                            SetQualityNoOk_WorkPieceProcess(logMiddle, ref process);

                            process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            process.CreatedUserName = loginfo.MonitoringPoint;
                            process.CreatedUserName = ResetUpdatedUserName(logMiddle);
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = loginfo.MonitoringPoint;
                            process.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.OperationType = OperationType.生产.ToString();
                            process.QualityDataInfoID = qualityData.Id;
@@ -689,21 +746,27 @@
                        else
                        {//其他的都只是修改
                            pro.QualityDataInfoID = qualityData.Id;
                            pro.UpdatedUserName = loginfo.MonitoringPoint;
                            pro.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                            pro.QualityState = info.QualityState.HasValue ? info.QualityState.Value : 9;

                            //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                            //pro.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : 9;
                            pro.QualityState = WorkPieceInfoManager.GetQualityStateValue(pieceInfo.QualityState);

                            //赋值不合格原因
                            SetQualityNoOk_WorkPieceProcess(logMiddle, ref pro);

                            //TODO:判断如果是60工序，那么就要更新pro表的创建人为loginfo.MonitoringPoint 【Editby shaocx,2024-06-05】
                            if (loginfo.WorkingProcedure == "OP60")
                            if (logMiddle.WorkingProcedure == "OP60")
                            {
                                pro.CreatedUserName = loginfo.MonitoringPoint;
                                pro.CreatedUserName = ResetUpdatedUserName(logMiddle);

                            }
                        }

                        if (loginfo.QualityType != null && loginfo.QualityType.Equals(QualityType.SPC.ToString()))
                        if (logMiddle.QualityType != null && logMiddle.QualityType.Equals(QualityType.SPC.ToString()))
                        {//SPC反馈，
                            if (loginfo.QualityState != (int)QualityState.OK)
                            if (logMiddle.QualityState != (int)QualityState.OK)
                            {
                                //当某到工序检测到不合格工件时，从该工件加工完成时刻前指定时间起至报检不合格时间止，系统将该工件的最后加工工序在该时间段内加工的所有工件、正在加工的工件、该工序入口处的第一个工件全部标记为疑似状态，由人工复检工件并修改状态，并支持批量变更。
                                //答复：在线测量不需要走这个流程，只有SPC抽检才需要，需要把这时间段的工件全部置为疑似，哪怕是已完成工件
@@ -716,29 +779,44 @@
                            }

                        }
                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(pieceInfo));
                        db.QualityDataInfoLog.Add(GetAddQualityDataInfoLog(qualityData));//插入日志
                    }
                    else
                    {
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量检测完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工序监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量检测完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控读码标记 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception ex)
                {
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量检测完成{loginfo.WorkPieceID ?? "空"}更新数据异常{ex.Message}++{ex.StackTrace}";
                    Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工序监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量检测完成{logMiddle.WorkPieceID ?? "空"}更新数据异常{ex.Message}++{ex.StackTrace}";
                    Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控读码标记 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");
                }
                finally
                {
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{loginfo.QualityStateStr ?? "空"}";
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{logMiddle.QualityStateStr ?? "空"}";
                    db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                    db.SaveChanges();
                }
            }
        }

        /// <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;
        }

        /// <summary>
        /// 工件推出NOOK
        /// </summary>
@@ -941,76 +1019,82 @@
        /// <summary>
        /// 工序完成
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="logMiddle"></param>
        /// <param name="type"></param>
        public static void WorkingProcedureComplete(WorkPieceLogMiddle loginfo, LogType type)
        public static void WorkingProcedureComplete(WorkPieceLogMiddle logMiddle, LogType type)
        {

            using (DbModel db = new DbModel())
            {
                if (logMiddle.WorkingProcedure.Equals("OP70"))
                {
                    logMiddle.QualityState = (int)QualityState.OK; //如果是OP70，则默认是合格 【Editby shaocx,2024-06-25】
                }

                WorkPieceLog loginfo2 = new WorkPieceLog();
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(logMiddle);

                try
                {
                    if (loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
                    if (logMiddle.WorkPieceID != null && logMiddle.WorkPieceID.Trim('\0').Length == 22)
                    {

                        bool isAddWorkPieceInfo = false;
                        WorkPieceInfo info = new WorkPieceInfo();
                        info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        info = db.WorkPieceInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                        if (info == null || info.WorkPieceID.Length < 1)
                        {//没有工件信息，不做更新  （为了测试先先新增）
                            Log4NetHelper.WriteErrorLog(type, $"工件{loginfo.WorkPieceID} 工件推出工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新");
                            Log4NetHelper.WriteErrorLog(type, $"工件{logMiddle.WorkPieceID} 工件推出工序{logMiddle.WorkingProcedure} 没有获取到工件信息不做更新");
                            //db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo));//插入工件采集日志表
                            //db.SaveChanges();

                            loginfo2 = CommonManager.Instance.GetWorkPieceID(loginfo, type);
                            info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLog>(loginfo);
                            loginfo2 = CommonManager.Instance.GetWorkPieceID(logMiddle, type);
                            info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLog>(logMiddle);
                            //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                            if (!loginfo.WorkingProcedure.Equals("OP05"))
                            if (!logMiddle.WorkingProcedure.Equals("OP05"))
                            {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                info.QualityState = (int)QualityState.Suspected;
                                info.QualityErrorInfo = $"工件二维码第一次出现的工序{loginfo.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                info.Remarks = $"工件二维码第一次出现的工序{loginfo.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                info.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                info.Remarks = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                            }
                            else
                            {
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();//WorkPieceInitOnlineTime
                            info.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                            info.CreatedUserName = loginfo.MonitoringPoint;
                            info.CreatedUserName = logMiddle.MonitoringPoint;
                            info.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                            info.WorkingProcedureCurrent = logMiddle.WorkingProcedure;
                            info.WorkingProcedureEndTime = null;
                            info = ParseQRCode(info);
                            isAddWorkPieceInfo = true;
                        }
                        if (loginfo.WorkingProcedure.Equals("OP10"))
                        if (logMiddle.WorkingProcedure.Equals("OP10"))
                        {
                            //var WorkingProcedure = (loginfo.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
                            loginfo2.WorkingProcedure = info.WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
                            loginfo.WorkingProcedure = info.WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                            logMiddle.WorkingProcedure = info.WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                        }
                        info.UpdatedUserName = loginfo.MonitoringPoint;
                        info.UpdatedUserName = logMiddle.MonitoringPoint;
                        info.UpdatedTime = DateTimeHelper.GetDateTime();
                        info.WorkingProcedureCompleted = info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
                        info.WorkingProcedureCompleted = info.WorkingProcedureCompleted + logMiddle.WorkingProcedure;//已完成工序
                        if (!(info.WorkingProcedureStartTime.HasValue && info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                        {//若一直没有工序开始时间，则赋值当前时间
                            info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                        }
                        info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
                        info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                        info.Remarks = $"{loginfo.WorkingProcedure}工序完成";
                        info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) / 2;
                        info.Remarks = $"{logMiddle.WorkingProcedure}工序完成";
                        long op80id = 0;
                        if (loginfo.WorkingProcedure.Equals("OP80"))
                        if (logMiddle.WorkingProcedure.Equals("OP80"))
                        {
                            info.WorkPieceState = (int)WorkPieceState.FinishedProducts;
                            info.WorkPieceLastOfflineTime = DateTimeHelper.GetDateTime();
                            info.WorkPieceCurrentPosition = "OP80";
                            info.CompleteTime = DateTimeHelper.GetDateTime();
                            info.OP80NewCode = loginfo.OP80NewCode;
                            info.OP80NewCode = logMiddle.OP80NewCode;

                            //质检数据改为 获取文件后修改 【Editby shaocx,2024-06-15】
                            /*
@@ -1021,14 +1105,14 @@
                            info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                            //*/

                            var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                            var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                            if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
                            {//插入QualityDataInfo表
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(loginfo);
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                                db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
                            }
                            //修改QualityDataInfo表 //重复收到质量信息，会覆盖之前的
                            EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(loginfo, qualityData, GetQualityDataInfoUpdate(loginfo.WorkingProcedure, loginfo.MonitoringPoint));//指定修改字段
                            EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(logMiddle, qualityData, GetQualityDataInfoUpdate(logMiddle, logMiddle.WorkingProcedure, logMiddle.MonitoringPoint));//指定修改字段

                            //质检数据改为 获取文件后修改 【Editby shaocx,2024-06-15】
                            /*
@@ -1050,30 +1134,30 @@
                            }
                            //*/
                        }
                        else if (loginfo.WorkingProcedure.Equals("OP30"))
                        else if (logMiddle.WorkingProcedure.Equals("OP30"))
                        {

                            info.QualityState = (int)((loginfo.QualityStateStr.Equals("OK") || loginfo.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
                            loginfo.QualityState = info.QualityState;
                            info.QualityStateUpdateUser = loginfo.UpdatedUserName;
                            info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
                            info.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
                            logMiddle.QualityState = info.QualityState;
                            info.QualityStateUpdateUser = logMiddle.UpdatedUserName;
                            info.QualityStateUpdateTime = logMiddle.UpdatedTime.Value.LocalDateTime;
                            info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();

                            var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                            var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                            if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
                            {//插入QualityDataInfo表
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(loginfo);
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                                db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
                            }
                            qualityData.QualityStateUpdateUser = info.UpdatedUserName;
                            qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
                            qualityData.QualityStateUpdateMode = info.QualityStateUpdateMode;
                            qualityData.OP30QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP30QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP30QualityReceiveTime = DateTimeHelper.GetDateTime();
                            loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{loginfo.QualityStateStr ?? "空"}";
                            loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{logMiddle.QualityStateStr ?? "空"}";
                            if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
                            {
                                info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量采集数据不合格";
                                info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
                            }
                            else
                            {
@@ -1083,13 +1167,13 @@
                        else
                        {
                            info.WorkPieceState = (int)WorkPieceState.WIP;
                            if (info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) + 4 <= info.WorkingProcedurePlan.Length)
                            if (info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= info.WorkingProcedurePlan.Length)
                            {
                                info.WorkPieceCurrentPosition = info.WorkingProcedurePlan.Substring(info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure), 8);
                                info.WorkPieceCurrentPosition = info.WorkingProcedurePlan.Substring(info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure), 8);
                            }
                        }

                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == info.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID && o.WorkingProcedureCurrent == info.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro == null || pro.WorkPieceID.Length < 1)
                        {
                            WorkPieceProcess process = new WorkPieceProcess();
@@ -1097,16 +1181,24 @@
                            process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            process.StartTime = DateTimeHelper.GetDateTime();
                            process.EndTime = DateTimeHelper.GetDateTime();
                            process.QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value : (int)QualityState.OK;
                            process.CreatedUserName = loginfo.MonitoringPoint;
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {//OP80的质量数据是后来获取文件搞的
                            }
                            else
                            {
                                //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                                //process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                                process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
                            }
                            process.CreatedUserName = logMiddle.MonitoringPoint;
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = loginfo.MonitoringPoint;
                            process.UpdatedUserName = logMiddle.MonitoringPoint;
                            process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.OperationType = OperationType.生产.ToString();
                            process.Remarks = "";
                            if (loginfo.WorkingProcedure.Equals("OP80"))
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {
                                process.GetQcDataFlag = loginfo.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                                process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                            }
                            if (op80id > 0)
                            {
@@ -1121,13 +1213,13 @@
                                pro.QualityDataInfoID = op80id;
                            }
                            pro.EndTime = DateTimeHelper.GetDateTime();
                            pro.UpdatedUserName = loginfo.MonitoringPoint;
                            pro.UpdatedUserName = logMiddle.MonitoringPoint;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                            if (loginfo.WorkingProcedure.Equals("OP80"))
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {
                                if (pro.GetQcDataFlag != 0)
                                {
                                    pro.GetQcDataFlag = loginfo.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                                    pro.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                                }
                            }
                        }
@@ -1141,14 +1233,14 @@
                    }
                    else
                    {
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"下线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工序下线 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"下线完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序下线 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{logMiddle.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }
                db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                db.SaveChanges();
@@ -1936,11 +2028,11 @@
        #region 业务方法

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

@@ -1955,11 +2047,20 @@
            {
                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":
@@ -1988,13 +2089,24 @@
                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");
@@ -2013,11 +2125,103 @@
                    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;
        }


@@ -2098,6 +2302,250 @@
            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")) ? QualityState.OK : QualityState.NG);

            //根据质量数据判断是否合格/不合格 【Editby shaocx,2024-06-25】
            QualityNoOkEnum? qualityNoOkEnum = null;
            QualityState 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 QualityState CalcQualityStateForOP(WorkPieceLogMiddle logMiddle, ref QualityNoOkEnum? qualityNoOkEnum)
        {
            QualityState qualityState = QualityState.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 = QualityState.OK;
                }
                else
                {
                    qualityState = QualityState.NG;
                }
                if (_QualityOP60To1 == 0 || _QualityOP60To2 == 0)
                {
                    qualityState = QualityState.Suspected;
                    return qualityState;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP80")
            {//合格/不合格由 OP80 判断，QualityState 和 QualityStateStr 都在调用当前方法前 写入值了
                if (logMiddle.QualityState == (int)QualityState.OK)
                {
                    qualityState = QualityState.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)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP10厚度超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP20")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP20小头孔直径超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP30")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityStateStr.Equals("OK"))
                {
                    qualityState = QualityState.OK;
                }
                else
                {
                    qualityState = QualityState.NG;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP35")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP35滚压力不合格;
                }
                else
                {
                    qualityState = QualityState.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP40")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP40厚度超差;
                }
                else
                {
                    qualityState = QualityState.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)QualityState.Suspected;
            }
            if (qualityState.Value == 1)
            {
                return (int)QualityState.OK;
            }
            if (qualityState.Value == 2)
            {
                return (int)QualityState.NG;
            }
            return (int)QualityState.Suspected;
        }


        #endregion
    }
}