代码回归

schangxiang@126.com

2024-09-05 09a12e1094e90fe83c5578de64b56e9237c60507

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/WorkPieceInfoManager.cs

@@ -178,18 +178,19 @@
                            //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                            if (!loginfo.WorkingProcedure.Equals("OP05"))
                            {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                info.QualityState = (int)QualityState.Suspected;
                                info.QualityState = (int)QualityStateEnum.Suspected;
                                info.QualityErrorInfo = $"工件二维码第一次出现的工序{loginfo.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                info.Remarks = $"工件二维码第一次出现的工序{loginfo.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                            }
                            else
                            {
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                            {//OP05工序
                                info.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                            info.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                            info.CreatedUserName = loginfo.MonitoringPoint;
                            SystemBussinessHelper.SetWorkPieceInfoMiddleForCreatedUserName(ref info, loginfo.DataCapturePointCname);
                            info.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            info = ParseQRCode(info);
                            isAddWorkPieceInfo = true;
@@ -202,19 +203,29 @@
                                return;
                            }
                        }
                        info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                        info.WorkingProcedureEndTime = null;
                        info.WorkPieceState = (int)WorkPieceState.WIP;
                        info.EquipmentID = loginfo.EquipmentID;
                        info.QualityStateUpdateUser = loginfo.UpdatedUserName;
                        info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
                        info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                        info.UpdatedUserName = loginfo.MonitoringPoint;
                        info.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        info.WorkPieceCurrentPosition = loginfo.WorkingProcedure;
                        info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                        info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                        info.Remarks = $"{info.WorkingProcedureCurrent}工件上线";
                        if ((info.WorkingProcedureCurrent.Equals("OP05") && isAddWorkPieceInfo == false))
                        {
                            //如果是OP05的，并且是 不需要新增 表WorkPieceInfo，那么就不需要更新表 WorkPieceInfo
                        }
                        else
                        {
                            info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                            info.WorkingProcedureEndTime = null;
                            info.WorkPieceState = (int)WorkPieceState.WIP;
                            info.EquipmentID = loginfo.EquipmentID;
                            info.QualityStateUpdateUser = loginfo.UpdatedUserName;
                            info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
                            info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                            info.UpdatedUserName = loginfo.MonitoringPoint;
                            SystemBussinessHelper.SetWorkPieceInfoMiddleForUpdateDataCapturePointCname(ref info, loginfo.DataCapturePointCname);
                            info.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);

                            info.WorkPieceCurrentPosition = loginfo.WorkingProcedure;
                            info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                            info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                            info.Remarks = $"{info.WorkingProcedureCurrent}工件上线";
                        }


                        //修复下 op35 同一个件 下线时间跟下一个上线时间一模一样的问题  【Editby shaocx,2024-08-27】
                        var isNeedAddNewProcess = true;
@@ -230,8 +241,18 @@
                            {
                                pro.EndTime = DateTimeHelper.GetDateTime();
                                pro.UpdatedUserName = loginfo.MonitoringPoint;
                                pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                                pro.UpdatedTime = DateTimeHelper.GetDateTime();
                                pro.Remarks = "又一次上线，更新结束时间";
                            }
                        }
                        //特殊处理OP05上线，因为他是根据文本列表内容上线的 【Editby shaocx,2024-09-03】
                        if (loginfo.WorkingProcedure.Equals("OP05"))
                        {
                            var op05Proccss = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure).FirstOrDefault();
                            if (op05Proccss != null)
                            {
                                isNeedAddNewProcess = false;//不需要新增了
                            }
                        }
                        if (isNeedAddNewProcess)
@@ -248,127 +269,141 @@

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

                            new_process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            new_process.CreatedUserName = loginfo.MonitoringPoint;
                            new_process.DataCapturePointCname = loginfo.DataCapturePointCname;
                            new_process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            new_process.UpdatedUserName = loginfo.MonitoringPoint;
                            new_process.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                            new_process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            new_process.OperationType = OperationType.生产.ToString();
                            new_process.Remarks = "";
                            new_process.MyRemarks = "读码上线时，每次扫描上线都插入追溯表";
                            if (loginfo.WorkingProcedure.Equals("OP05"))
                            {
                            {//特殊处理OP05工序
                                new_process.EndTime = new_process.StartTime;

                                //如果已经存在其他工序，那么就必须要按照其他工序的时间往前推数据 【Editby shaocx,2024-09-05】
                                var op05OtherProccss = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID).OrderBy(x => x.StartTime).FirstOrDefault();
                                if (op05OtherProccss != null)
                                {//说明有，那么时间就按照这个时间往前推
                                    var _time = op05OtherProccss.StartTime.AddHours(-1);
                                    new_process.StartTime = _time;
                                    new_process.EndTime = _time;
                                    new_process.CreatedTime = _time;
                                    new_process.UpdatedTime = _time;
                                }
                            }
                            db.WorkPieceProcess.Add(new_process);
                        }

                        //db.Database.AutoTransactionsEnabled = false;// 同一个SaveChanges默认事务， 关闭默认事务：... 好像不能用啊，后面再研究吧
                        if (isAddWorkPieceInfo)
                        {
                            db.WorkPieceInfo.Add(info);
                        }
                        else
                        {//不确定info是直接会修改还是需要再次查询，待测试
                         //info.Remarks = "修改，具体修改逻辑待定";
                        }

                        #region 判断是否跳序,或质量不符合 然后反馈PLC
                        if (IsFeedback.HasValue && IsFeedback.Value == (int)FeedbackMode.FeedbackPLC)
                        {
                            bool checkQualityInfoCompleteFlag = false;
                            bool plcFlag = true;//反馈给PLC的标记
                            string message = "";
                            checkQualityInfoCompleteFlag = WorkPieceInfoManager.CheckQualityInfoComplete(info, loginfo, type);

                            if (!checkQualityInfoCompleteFlag || info.QualityState != (int)QualityState.OK)
                            //db.Database.AutoTransactionsEnabled = false;// 同一个SaveChanges默认事务， 关闭默认事务：... 好像不能用啊，后面再研究吧
                            if (isAddWorkPieceInfo)
                            {
                                plcFlag = false;
                                message = !checkQualityInfoCompleteFlag ? "跳序，" : "";
                                message += info.QualityState != (int)QualityState.OK ? "质量不符合" : "";
                                db.WorkPieceInfo.Add(info);
                            }
                            ////反馈给PLC，（写入点待定）
                            //MessageModel fr = null;
                            //fr = plcService.WriteValuePoint("", "", plcFlag, PLCManger.GetTypeForString("bool"));
                            //if (fr.result)
                            //{
                            //    Log4NetHelper.WriteInfoLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 成功， 出现 {message}");
                            //}
                            //else
                            //{
                            //    Log4NetHelper.WriteErrorLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 失败， 出现 {message} ，失败原因：{fr.resMsg}");
                            //}
                            else
                            {//不确定info是直接会修改还是需要再次查询，待测试
                             //info.Remarks = "修改，具体修改逻辑待定";
                            }

                            //#region 反馈PLC
                            #region 判断是否跳序,或质量不符合 然后反馈PLC
                            if (IsFeedback.HasValue && IsFeedback.Value == (int)FeedbackMode.FeedbackPLC)
                            {
                                bool checkQualityInfoCompleteFlag = false;
                                bool plcFlag = true;//反馈给PLC的标记
                                string message = "";
                                checkQualityInfoCompleteFlag = WorkPieceInfoManager.CheckQualityInfoComplete(info, loginfo, type);

                            //bool checkQualityInfoCompleteFlag = false;
                            //bool plcFlag = true;//反馈给PLC的标记
                            //string message = "";
                            //checkQualityInfoCompleteFlag = WorkPieceInfoManager.CheckQualityInfoComplete(info, wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                if (!checkQualityInfoCompleteFlag || info.QualityState != (int)QualityStateEnum.OK)
                                {
                                    plcFlag = false;
                                    message = !checkQualityInfoCompleteFlag ? "跳序，" : "";
                                    message += info.QualityState != (int)QualityStateEnum.OK ? "质量不符合" : "";
                                }
                                ////反馈给PLC，（写入点待定）
                                //MessageModel fr = null;
                                //fr = plcService.WriteValuePoint("", "", plcFlag, PLCManger.GetTypeForString("bool"));
                                //if (fr.result)
                                //{
                                //    Log4NetHelper.WriteInfoLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 成功， 出现 {message}");
                                //}
                                //else
                                //{
                                //    Log4NetHelper.WriteErrorLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 失败， 出现 {message} ，失败原因：{fr.resMsg}");
                                //}

                            //if (!checkQualityInfoCompleteFlag || info.QualityState != (int)QualityState.OK)
                            //{
                            //    plcFlag = false;
                            //    message = !checkQualityInfoCompleteFlag ? "跳序，" : "";
                            //message += info.QualityState != (int)QualityState.OK ? "质量不符合" : "";
                            //}
                            ////反馈给PLC，（写入点待定）
                            //MessageModel fr = null;
                            //fr = plcService.WriteValuePoint("", "", plcFlag, PLCManger.GetTypeForString("bool"));
                            //if (fr.result)
                            //{
                            //    Log4NetHelper.WriteInfoLog(PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), $" 工件{wplog.WorkPieceID} {WorkingProcedure}工序反馈给PLC 成功， 出现 {message}");
                            //}
                            //else
                            //{
                            //    Log4NetHelper.WriteErrorLog(PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), $" 工件{wplog.WorkPieceID} {WorkingProcedure}工序反馈给PLC 失败， 出现 {message} ，失败原因：{fr.resMsg}");
                            //}
                            //#endregion
                                //#region 反馈PLC

                                //bool checkQualityInfoCompleteFlag = false;
                                //bool plcFlag = true;//反馈给PLC的标记
                                //string message = "";
                                //checkQualityInfoCompleteFlag = WorkPieceInfoManager.CheckQualityInfoComplete(info, wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));

                                //if (!checkQualityInfoCompleteFlag || info.QualityState != (int)QualityState.OK)
                                //{
                                //    plcFlag = false;
                                //    message = !checkQualityInfoCompleteFlag ? "跳序，" : "";
                                //message += info.QualityState != (int)QualityState.OK ? "质量不符合" : "";
                                //}
                                ////反馈给PLC，（写入点待定）
                                //MessageModel fr = null;
                                //fr = plcService.WriteValuePoint("", "", plcFlag, PLCManger.GetTypeForString("bool"));
                                //if (fr.result)
                                //{
                                //    Log4NetHelper.WriteInfoLog(PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), $" 工件{wplog.WorkPieceID} {WorkingProcedure}工序反馈给PLC 成功， 出现 {message}");
                                //}
                                //else
                                //{
                                //    Log4NetHelper.WriteErrorLog(PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), $" 工件{wplog.WorkPieceID} {WorkingProcedure}工序反馈给PLC 失败， 出现 {message} ，失败原因：{fr.resMsg}");
                                //}
                                //#endregion
                            }
                            else
                            {//读码完成若工件质量不符合或发生跳序，不用管设备是否把工件放过去，数采系统都不变更当前工序，反馈设备PLC工件不符合，
                             //若工序后续收集点收到相关工件信息再变更当前工序，  但质量信息不变

                                info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                            }
                            #endregion

                            #region 更新设备实时表

                            bool isAddEquipmentCurrentMonitor = false;
                            EquipmentCurrentMonitor equinfo = new EquipmentCurrentMonitor();
                            equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == loginfo.EquipmentID).FirstOrDefault();
                            if (equinfo == null || equinfo.Id < 1)
                            {//没有工件信息，不做更新
                                Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.WorkingProcedure} 没有获取到设备监控信息，现新增");
                                equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(loginfo);
                                equinfo.OnlineTime = DateTime.Now;
                                isAddEquipmentCurrentMonitor = true;
                            }
                            else
                            {//更新工件
                                equinfo.WorkPieceID = loginfo.WorkPieceID;
                                equinfo.UpdatedUserName = loginfo.MonitoringPoint;
                                equinfo.UpdatedTime = DateTime.Now;
                                equinfo.OnlineTime = DateTime.Now;
                            }
                            if (isAddEquipmentCurrentMonitor)
                            {
                                equinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                                db.EquipmentCurrentMonitor.Add(equinfo);
                            }
                            #endregion
                            //db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo));
                            db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
                            //UpdateKnifeToolLift(db, loginfo);//更新刀具寿命信息
                        }
                        else
                        {//读码完成若工件质量不符合或发生跳序，不用管设备是否把工件放过去，数采系统都不变更当前工序，反馈设备PLC工件不符合，
                         //若工序后续收集点收到相关工件信息再变更当前工序，  但质量信息不变

                            info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                        }
                        #endregion

                        #region 更新设备实时表

                        bool isAddEquipmentCurrentMonitor = false;
                        EquipmentCurrentMonitor equinfo = new EquipmentCurrentMonitor();
                        equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == loginfo.EquipmentID).FirstOrDefault();
                        if (equinfo == null || equinfo.Id < 1)
                        {//没有工件信息，不做更新
                            Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.WorkingProcedure} 没有获取到设备监控信息，现新增");
                            equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(loginfo);
                            equinfo.OnlineTime = DateTime.Now;
                            isAddEquipmentCurrentMonitor = true;
                        }
                        else
                        {//更新工件
                            equinfo.WorkPieceID = loginfo.WorkPieceID;
                            equinfo.UpdatedUserName = loginfo.MonitoringPoint;
                            equinfo.UpdatedTime = DateTime.Now;
                            equinfo.OnlineTime = DateTime.Now;
                        }
                        if (isAddEquipmentCurrentMonitor)
                        {
                            equinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            db.EquipmentCurrentMonitor.Add(equinfo);
                        }
                        #endregion
                        //db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo));
                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
                        //UpdateKnifeToolLift(db, loginfo);//更新刀具寿命信息
                    }
                    else
                    {
                        loginfo.Remarks = $"上线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                            loginfo.Remarks = $"上线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                            Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");

                        }
                    }
                }
                catch (Exception e)
@@ -538,18 +573,19 @@
                                //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                                if (!logMiddle.WorkingProcedure.Equals("OP05"))
                                {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                    pieceInfo.QualityState = (int)QualityState.Suspected;
                                    pieceInfo.QualityState = (int)QualityStateEnum.Suspected;
                                    pieceInfo.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                    pieceInfo.Remarks = $"工件二维码第一次出现的工序{logMiddle.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                                }
                                else
                                {
                                    pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                    pieceInfo.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                    pieceInfo.Remarks = "OP05新增工件信息";
                                }
                                pieceInfo.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                                pieceInfo.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                                pieceInfo.CreatedUserName = ResetUpdatedUserName(logMiddle);
                                SystemBussinessHelper.SetWorkPieceInfoMiddleForCreatedUserName(ref pieceInfo, logMiddle.DataCapturePointCname);
                                pieceInfo.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                                pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                                pieceInfo.WorkingProcedureEndTime = null;
@@ -606,6 +642,8 @@
                            #endregion
                            //UpdateKnifeToolLift(db, loginfo);//更新刀具寿命信息
                        }

                        pieceInfo.WorkingProcedureCurrent = logMiddle.WorkingProcedure;//更新当前工序  【Editby shaocx,2024-09-03】
                        pieceInfo.WorkPieceState = (int)WorkPieceState.WIP;//推出后和SPC抽检后 质量录入时状态修改回在制品
                        pieceInfo.EquipmentID = logMiddle.EquipmentID;
                        pieceInfo.QualityStateUpdateUser = logMiddle.UpdatedUserName;
@@ -613,17 +651,18 @@
                        pieceInfo.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                        pieceInfo.Remarks = $"{logMiddle.WorkingProcedure}质量检测完成修改";
                        pieceInfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                        SystemBussinessHelper.SetWorkPieceInfoMiddleForUpdateDataCapturePointCname(ref pieceInfo, logMiddle.DataCapturePointCname);
                        pieceInfo.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        if (!(pieceInfo.WorkingProcedureStartTime.HasValue && pieceInfo.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                        {//工序开始时间没有则赋值
                            pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                        }
                        pieceInfo.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
                        pieceInfo.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityStateEnum.OK : QualityStateEnum.NG);
                        //赋值不合格原因
                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);


                        if (!pieceInfo.QualityState.Equals(((int)QualityState.OK).ToString()))
                        if (!pieceInfo.QualityState.Equals(((int)QualityStateEnum.OK).ToString()))
                        {
                            pieceInfo.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格{pieceInfo.QualityState}";
                        }
@@ -680,10 +719,10 @@
                                    qualityData.OP30QualityStateCH3 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH3 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH3 == ((int)QualityState.NG).ToString())
                                    if (qualityData.OP30QualityStateCH3 == ((int)QualityStateEnum.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30涨断工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30涨断工位力矩大.ToString();
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30涨断工位力矩超差;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30涨断工位力矩超差.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }
@@ -694,10 +733,10 @@
                                    qualityData.OP30QualityStateCH4 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH4 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH4 == ((int)QualityState.NG).ToString())
                                    if (qualityData.OP30QualityStateCH4 == ((int)QualityStateEnum.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30预拧紧工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30预拧紧工位力矩大.ToString();
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30预拧紧工位力矩超差;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30预拧紧工位力矩超差.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }
@@ -708,10 +747,10 @@
                                    qualityData.OP30QualityStateCH5 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH5 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH5 == ((int)QualityState.NG).ToString())
                                    if (qualityData.OP30QualityStateCH5 == ((int)QualityStateEnum.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30终拧紧工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30终拧紧工位力矩大.ToString();
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30终拧紧工位力矩超差;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30终拧紧工位力矩超差.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }
@@ -722,10 +761,10 @@
                                    qualityData.OP30QualityStateCH6 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                                    qualityData.OP30QualityReceiveTimeCH6 = DateTimeHelper.GetDateTime();

                                    if (qualityData.OP30QualityStateCH6 == ((int)QualityState.NG).ToString())
                                    if (qualityData.OP30QualityStateCH6 == ((int)QualityStateEnum.NG).ToString())
                                    {
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30压衬套工位力矩大;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30压衬套工位力矩大.ToString();
                                        logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30压衬套工位力矩超差;
                                        logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30压衬套工位力矩超差.ToString();
                                        //赋值不合格原因
                                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
                                    }
@@ -760,7 +799,11 @@
                            qualityData.OP80QualityReceiveTime = DateTimeHelper.GetDateTime();
                        }

                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID && o.WorkingProcedureCurrent == pieceInfo.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID
                        //修正：查询的工序是当前线程的工序，而不是当前数据的工序 【Editby shaocx,2024-09-03】
                        //&& o.WorkingProcedureCurrent == pieceInfo.WorkingProcedureCurrent
                        && o.WorkingProcedureCurrent == logMiddle.WorkingProcedure
                        && 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 没有上线扫码枪，约定用测量完成信号当上线标记，所以上线需要修改的字段放这里
                         //上线是每次都插入
@@ -787,18 +830,22 @@

                            process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            process.CreatedUserName = ResetUpdatedUserName(logMiddle);
                            process.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            process.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.OperationType = OperationType.生产.ToString();
                            process.QualityDataInfoID = qualityData.Id;
                            process.Remarks = "";
                            process.MyRemarks = "质量检测完成时，如果找不到就新建";
                            db.WorkPieceProcess.Add(process);
                        }
                        else
                        {//其他的都只是修改
                            pro.QualityDataInfoID = qualityData.Id;
                            pro.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            pro.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();

                            //不再默认赋值为合格 【Editby shaocx,2024-08-16】
@@ -812,13 +859,13 @@
                            if (logMiddle.WorkingProcedure == "OP60")
                            {
                                pro.CreatedUserName = ResetUpdatedUserName(logMiddle);

                                pro.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            }
                        }

                        if (logMiddle.QualityType != null && logMiddle.QualityType.Equals(QualityType.SPC.ToString()))
                        {//SPC反馈，
                            if (logMiddle.QualityState != (int)QualityState.OK)
                            if (logMiddle.QualityState != (int)QualityStateEnum.OK)
                            {
                                //当某到工序检测到不合格工件时，从该工件加工完成时刻前指定时间起至报检不合格时间止，系统将该工件的最后加工工序在该时间段内加工的所有工件、正在加工的工件、该工序入口处的第一个工件全部标记为疑似状态，由人工复检工件并修改状态，并支持批量变更。
                                //答复：在线测量不需要走这个流程，只有SPC抽检才需要，需要把这时间段的工件全部置为疑似，哪怕是已完成工件
@@ -843,8 +890,8 @@
                }
                catch (Exception ex)
                {
                    loginfo2.Remarks = $"质量检测完成{logMiddle.WorkPieceID ?? "空"}更新数据异常{ex.Message}++{ex.StackTrace}";
                    Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控读码标记 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");
                    loginfo2.Remarks = $"质量检测完成,更新数据异常{ex.Message}";
                    Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}质量检测完成 工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：" + ex.Message, ex);
                }
                finally
                {
@@ -956,7 +1003,7 @@
                        cur_db_info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (cur_db_info == null || cur_db_info.WorkPieceID.Length < 1)
                        {//没有工件信息，不做更新
                            Log4NetHelper.WriteErrorLog(type, $"工件{loginfo.WorkPieceID} 工件推出工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新");
                            Log4NetHelper.WriteErrorLog(type, $"工件{loginfo.WorkPieceID} 工件推出NOOK工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新");
                            return;
                        }
                        else
@@ -990,8 +1037,10 @@
                            }
                            cur_db_info.WorkPieceState = (int)WorkPieceState.NOOKPush;
                            cur_db_info.UpdatedUserName = loginfo.MonitoringPoint;
                            SystemBussinessHelper.SetWorkPieceInfoMiddleForUpdateDataCapturePointCname(ref cur_db_info, loginfo.DataCapturePointCname);
                            cur_db_info.UpdatedTime = DateTime.Now;
                            cur_db_info.Remarks = "工件NOOK推出";
                            loginfo2.Remarks = cur_db_info.Remarks;
                            if (!(cur_db_info.WorkingProcedureStartTime.HasValue && cur_db_info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                            {
                                cur_db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
@@ -1005,8 +1054,8 @@
                        if (loginfo.WorkingProcedure.Equals("OP35"))
                        {//为了解决OP35的采集到的质量信息是OK还NOOK的情况，OP35 NOOK时更新质量信息
                            loginfo2.Remarks = $"OP35NOOK原质量信息{(cur_db_info.QualityState.HasValue ? cur_db_info.QualityState.Value.ToString() : "空")}";
                            cur_db_info.QualityState = (int)QualityState.NG;
                            if (!cur_db_info.QualityState.Equals(((int)QualityState.OK).ToString()))
                            cur_db_info.QualityState = (int)QualityStateEnum.NG;
                            if (!cur_db_info.QualityState.Equals(((int)QualityStateEnum.OK).ToString()))
                            {
                                cur_db_info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量NOOK采集数据不合格{cur_db_info.QualityState}";
                            }
@@ -1025,13 +1074,37 @@
                            }
                        }
                        //更新上一工序的结束时间
                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID
                        && o.WorkingProcedureCurrent == loginfo.WorkingProcedure && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro != null && pro.WorkPieceID.Length > 0)
                        {
                            pro.EndTime = DateTimeHelper.GetDateTime();
                            pro.Remarks = (pro.Remarks ?? "") + "NOOK结束";
                            pro.Remarks = "NOOK结束";
                            pro.UpdatedUserName = loginfo.MonitoringPoint;
                            pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                        }
                        else
                        {//如果找不到就新建 【Editby shaocx,2024-09-03】
                            WorkPieceProcess add_process = new WorkPieceProcess();
                            add_process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(cur_db_info);
                            QualityStateHelper.ResetQualityNoOkForNewProcess(ref add_process);
                            add_process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            add_process.StartTime = DateTimeHelper.GetDateTime().AddSeconds(-SystemBussinessHelper.MoNiTimeForWorkingProcedure(loginfo.WorkingProcedure));
                            add_process.EndTime = DateTimeHelper.GetDateTime();
                            //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                            add_process.QualityState = WorkPieceInfoManager.GetQualityStateValue(loginfo.QualityState);

                            add_process.CreatedUserName = loginfo.MonitoringPoint;
                            add_process.DataCapturePointCname = loginfo.DataCapturePointCname;
                            add_process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            add_process.UpdatedUserName = loginfo.MonitoringPoint;
                            add_process.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                            add_process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            add_process.OperationType = OperationType.生产.ToString();
                            add_process.Remarks = "NOOK结束";
                            add_process.MyRemarks = "NOOK结束时，如果找不到就新建";
                            db.WorkPieceProcess.Add(add_process);
                        }

                        QualityStateHelper.SetQualityStateForNoOk(ref cur_db_info, ref pro, ref qualityData);
@@ -1108,6 +1181,7 @@
                            }
                            cur_db_info.WorkPieceState = (int)WorkPieceState.SPCPush;
                            cur_db_info.UpdatedUserName = loginfo.MonitoringPoint;
                            SystemBussinessHelper.SetWorkPieceInfoMiddleForUpdateDataCapturePointCname(ref cur_db_info, loginfo.DataCapturePointCname);
                            cur_db_info.UpdatedTime = DateTime.Now;
                            cur_db_info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
                            if (!(cur_db_info.WorkingProcedureStartTime.HasValue && cur_db_info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
@@ -1120,6 +1194,7 @@
                            cur_db_info.WorkPieceCurrentPositionOrder = cur_db_info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                        }
                        cur_db_info.Remarks = "工件SPC抽检推出";
                        loginfo2.Remarks = cur_db_info.Remarks;

                        //更新上一工序的结束时间
                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure
@@ -1129,6 +1204,7 @@
                            pro.EndTime = DateTimeHelper.GetDateTime();
                            pro.Remarks = (pro.Remarks ?? "") + "SPC抽检结束";
                            pro.UpdatedUserName = loginfo.MonitoringPoint;
                            pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                        }
                        //每次SPC 都插入追溯表
@@ -1137,13 +1213,16 @@
                        QualityStateHelper.ResetQualityNoOkForNewProcess(ref process);
                        process.StartTime = DateTimeHelper.GetDateTime();
                        process.OperationType = OperationType.SPC.ToString();
                        process.QualityState = (int)QualityState.Suspected;
                        process.QualityState = (int)QualityStateEnum.Suspected;
                        process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                        process.CreatedUserName = loginfo.MonitoringPoint;
                        process.DataCapturePointCname = loginfo.DataCapturePointCname;
                        process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        process.UpdatedUserName = loginfo.MonitoringPoint;
                        process.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                        process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        process.Remarks = "工件SPC抽检推出";
                        process.MyRemarks = "SPC时，插入追溯表";
                        db.WorkPieceProcess.Add(process);


@@ -1210,7 +1289,7 @@
            {
                if (logMiddle.WorkingProcedure.Equals("OP70"))
                {
                    logMiddle.QualityState = (int)QualityState.OK; //如果是OP70，则默认是合格 【Editby shaocx,2024-06-25】
                    logMiddle.QualityState = (int)QualityStateEnum.OK; //如果是OP70，则默认是合格 【Editby shaocx,2024-06-25】
                }

                WorkPieceLog loginfo2 = new WorkPieceLog();
@@ -1222,61 +1301,65 @@
                    {

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

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

                        db_info.WorkingProcedureCurrent = logMiddle.WorkingProcedure;//赋值最新工序 【Editby shaocx,2024-09-03】
                        db_info.UpdatedUserName = logMiddle.MonitoringPoint;
                        SystemBussinessHelper.SetWorkPieceInfoMiddleForUpdateDataCapturePointCname(ref db_info, logMiddle.DataCapturePointCname);
                        db_info.UpdatedTime = DateTimeHelper.GetDateTime();
                        db_info.WorkingProcedureCompleted = db_info.WorkingProcedureCompleted + logMiddle.WorkingProcedure;//已完成工序
                        if (!(db_info.WorkingProcedureStartTime.HasValue && db_info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                        {//若一直没有工序开始时间，则赋值当前时间
                            info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                            db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                        }
                        info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
                        info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) / 2;
                        info.Remarks = $"{logMiddle.WorkingProcedure}工序完成";
                        db_info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
                        db_info.WorkPieceCurrentPositionOrder = db_info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) / 2;
                        db_info.Remarks = $"{logMiddle.WorkingProcedure}工序完成";
                        long op80id = 0;
                        if (logMiddle.WorkingProcedure.Equals("OP80"))
                        {
                            info.WorkPieceState = (int)WorkPieceState.FinishedProducts;
                            info.WorkPieceLastOfflineTime = DateTimeHelper.GetDateTime();
                            info.WorkPieceCurrentPosition = "OP80";
                            info.CompleteTime = DateTimeHelper.GetDateTime();
                            info.OP80NewCode = logMiddle.OP80NewCode;
                            db_info.WorkPieceState = (int)WorkPieceState.FinishedProducts;
                            db_info.WorkPieceLastOfflineTime = DateTimeHelper.GetDateTime();
                            db_info.WorkPieceCurrentPosition = "OP80";
                            db_info.CompleteTime = DateTimeHelper.GetDateTime();
                            db_info.OP80NewCode = logMiddle.OP80NewCode;

                            //质检数据改为 获取文件后修改 【Editby shaocx,2024-06-15】
                            /*
@@ -1316,15 +1399,17 @@
                                info.QualityErrorInfo = "";
                            }
                            //*/

                            loginfo2.Remarks = $"测量合格状态:{logMiddle.St3_Means_OK},称重状态:{logMiddle.St4_Weight_OK}";
                        }
                        else if (logMiddle.WorkingProcedure.Equals("OP30"))
                        {

                            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();
                            db_info.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityStateEnum.OK : QualityStateEnum.NG);
                            logMiddle.QualityState = db_info.QualityState;
                            db_info.QualityStateUpdateUser = logMiddle.UpdatedUserName;
                            db_info.QualityStateUpdateTime = logMiddle.UpdatedTime.Value.LocalDateTime;
                            db_info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();

                            var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                            if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
@@ -1332,79 +1417,84 @@
                                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.QualityStateUpdateUser = db_info.UpdatedUserName;
                            qualityData.QualityReceiveTime = db_info.UpdatedTime.Value.LocalDateTime;
                            qualityData.QualityStateUpdateMode = db_info.QualityStateUpdateMode;
                            qualityData.OP30QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
                            qualityData.OP30QualityReceiveTime = DateTimeHelper.GetDateTime();
                            loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{logMiddle.QualityStateStr ?? "空"}";
                            if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
                            if (!db_info.QualityState.Equals(((int)QualityStateEnum.OK).ToString()))
                            {
                                info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
                                db_info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
                            }
                            else
                            {
                                info.QualityErrorInfo = "";
                                db_info.QualityErrorInfo = "";
                            }
                        }
                        else
                        {
                            //这里修复OP10、OP40 因为PLC先推 SPC推出、再推 产品下线问题，导致 产品下线更新数据时，把SPC数据覆盖的问题 【Editby shaocx,2024-08-27】
                            var isAlow = SystemBussinessHelper.IsAllowUpdateWorkPieceStateToWip(info, db, logMiddle);
                            var isAlow = SystemBussinessHelper.IsAllowUpdateWorkPieceStateToWip(db_info, db, logMiddle);
                            if (isAlow)
                            {
                                info.WorkPieceState = (int)WorkPieceState.WIP;
                                db_info.WorkPieceState = (int)WorkPieceState.WIP;
                            }


                            if (info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= info.WorkingProcedurePlan.Length)
                            if (db_info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= db_info.WorkingProcedurePlan.Length)
                            {
                                info.WorkPieceCurrentPosition = info.WorkingProcedurePlan.Substring(info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure), 8);
                                db_info.WorkPieceCurrentPosition = db_info.WorkingProcedurePlan.Substring(db_info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure), 8);
                            }
                        }

                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.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 == db_info.WorkingProcedureCurrent
                        && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro == null || pro.WorkPieceID.Length < 1)
                        {
                            WorkPieceProcess process = new WorkPieceProcess();
                            process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
                            QualityStateHelper.ResetQualityNoOkForNewProcess(ref process);
                            process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            process.StartTime = DateTimeHelper.GetDateTime();
                            process.EndTime = DateTimeHelper.GetDateTime();
                            WorkPieceProcess add_process = new WorkPieceProcess();
                            add_process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(db_info);
                            QualityStateHelper.ResetQualityNoOkForNewProcess(ref add_process);
                            add_process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            add_process.StartTime = DateTimeHelper.GetDateTime().AddSeconds(-SystemBussinessHelper.MoNiTimeForWorkingProcedure(logMiddle.WorkingProcedure));
                            add_process.EndTime = DateTimeHelper.GetDateTime();
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {//OP80的质量数据是后来获取文件搞的
                             //质检数据，再考虑 另外两种状态  【Editby shaocx,2024-08-27】
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref info, ref process);
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref db_info, ref add_process);
                            }
                            else
                            {
                                //不再默认赋值为合格 【Editby shaocx,2024-08-16】
                                //process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                                process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
                                add_process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
                            }
                            process.CreatedUserName = logMiddle.MonitoringPoint;
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = logMiddle.MonitoringPoint;
                            process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.OperationType = OperationType.生产.ToString();
                            process.Remarks = "";
                            add_process.CreatedUserName = logMiddle.MonitoringPoint;
                            add_process.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            add_process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            add_process.UpdatedUserName = logMiddle.MonitoringPoint;
                            add_process.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            add_process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            add_process.OperationType = OperationType.生产.ToString();
                            add_process.Remarks = "";
                            add_process.MyRemarks = "工序完成时，如果找不到就新建";
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {
                                process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                                add_process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                            }
                            if (op80id > 0)
                            {
                                process.QualityDataInfoID = op80id;
                                add_process.QualityDataInfoID = op80id;
                            }
                            db.WorkPieceProcess.Add(process);
                            db.WorkPieceProcess.Add(add_process);
                        }
                        else
                        {
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {//OP80的质量数据是后来获取文件搞的
                             //质检数据，再考虑 另外两种状态  【Editby shaocx,2024-08-27】
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref info, ref pro);
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref db_info, ref pro);
                            }
                            if (op80id > 0)
                            {
@@ -1412,6 +1502,7 @@
                            }
                            pro.EndTime = DateTimeHelper.GetDateTime();
                            pro.UpdatedUserName = logMiddle.MonitoringPoint;
                            pro.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {
@@ -1425,9 +1516,9 @@

                        if (isAddWorkPieceInfo)
                        {
                            db.WorkPieceInfo.Add(info);
                            db.WorkPieceInfo.Add(db_info);
                        }
                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(db_info));
                    }
                    else
                    {
@@ -2405,10 +2496,10 @@
                //特殊逻辑：按照OP30的顺序判断
                if (logMiddle.QualityNoOk != null && qualityNoOk != null
                    && (
                      qualityNoOk == (int)QualityNoOkEnum.OP30压衬套工位力矩大
                      || qualityNoOk == (int)QualityNoOkEnum.OP30涨断工位力矩大
                      || qualityNoOk == (int)QualityNoOkEnum.OP30终拧紧工位力矩大
                      || qualityNoOk == (int)QualityNoOkEnum.OP30预拧紧工位力矩大
                      qualityNoOk == (int)QualityNoOkEnum.OP30压衬套工位力矩超差
                      || qualityNoOk == (int)QualityNoOkEnum.OP30涨断工位力矩超差
                      || qualityNoOk == (int)QualityNoOkEnum.OP30终拧紧工位力矩超差
                      || qualityNoOk == (int)QualityNoOkEnum.OP30预拧紧工位力矩超差
                    )
                    )
                {
@@ -2508,11 +2599,11 @@
        public static void SetLogMiddleForQuality(ref WorkPieceLogMiddle logMiddle)
        {

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

            //根据质量数据判断是否合格/不合格 【Editby shaocx,2024-06-25】
            QualityNoOkEnum? qualityNoOkEnum = null;
            QualityState qualityState = WorkPieceInfoManager.CalcQualityStateForOP(logMiddle, ref qualityNoOkEnum);
            QualityStateEnum qualityState = WorkPieceInfoManager.CalcQualityStateForOP(logMiddle, ref qualityNoOkEnum);
            logMiddle.QualityState = (int)qualityState;
            logMiddle.QualityStateStr = qualityState.ToString();
            if (qualityNoOkEnum != null)
@@ -2525,9 +2616,9 @@
        /// <summary>
        /// 计算OP 质量数据是否合格
        /// </summary>
        private static QualityState CalcQualityStateForOP(WorkPieceLogMiddle logMiddle, ref QualityNoOkEnum? qualityNoOkEnum)
        private static QualityStateEnum CalcQualityStateForOP(WorkPieceLogMiddle logMiddle, ref QualityNoOkEnum? qualityNoOkEnum)
        {
            QualityState qualityState = QualityState.Suspected;
            QualityStateEnum qualityState = QualityStateEnum.Suspected;
            if (logMiddle.WorkingProcedure == "OP60")
            {//合格/不合格由 WMS自行判断
                decimal _QualityOP60To1 = SystemHelper.GetDecimal(logMiddle.QualityOP60To1);
@@ -2555,24 +2646,24 @@

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

@@ -2659,25 +2750,25 @@
            }
            else if (logMiddle.WorkingProcedure == "OP10")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP10厚度超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP20")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP20小头孔直径超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
@@ -2685,35 +2776,35 @@
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityStateStr.Equals("OK"))
                {
                    qualityState = QualityState.OK;
                    qualityState = QualityStateEnum.OK;
                }
                else
                {
                    qualityState = QualityState.NG;
                    qualityState = QualityStateEnum.NG;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP35")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP35滚压力不合格;
                    qualityNoOkEnum = QualityNoOkEnum.OP35滚压力超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
            else if (logMiddle.WorkingProcedure == "OP40")
            {//合格/不合格由 QualityStateStr值判断
                if (logMiddle.QualityState == (int)QualityState.NG)
                if (logMiddle.QualityState == (int)QualityStateEnum.NG)
                {
                    qualityNoOkEnum = QualityNoOkEnum.OP40厚度超差;
                }
                else
                {
                    qualityState = QualityState.OK;
                    qualityState = QualityStateEnum.OK;
                }
                return qualityState;
            }
@@ -2730,17 +2821,17 @@
        {
            if (qualityState.HasValue == false)
            {
                return (int)QualityState.Suspected;
                return (int)QualityStateEnum.Suspected;
            }
            if (qualityState.Value == 1)
            {
                return (int)QualityState.OK;
                return (int)QualityStateEnum.OK;
            }
            if (qualityState.Value == 2)
            {
                return (int)QualityState.NG;
                return (int)QualityStateEnum.NG;
            }
            return (int)QualityState.Suspected;
            return (int)QualityStateEnum.Suspected;
        }