修复

schangxiang@126.com

2024-09-02 15662d05c2e2a8620cdabf9038c94f7b64a106d2

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/WorkPieceInfoManager.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.Utils;
using HslCommunication.BasicFramework;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using iWare_SCADA_Model.MiddleModel;
using iWare_SCADA_Model.TableModel;
@@ -7,6 +8,7 @@
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Data.Entity.Validation;
using System.Diagnostics;
//using System.Data.Entity.Infrastructure;
using System.Linq;
@@ -21,32 +23,32 @@
{
    public class WorkPieceInfoManager
    {
        public static WorkPieceInfo GetWorkPieceInfo(string WorkPieceID)
        {
            using (DbModel db = new DbModel())
            {
                //查询所有
                var query = db.WorkPieceInfo.Where(o => o.WorkPieceID == WorkPieceID).FirstOrDefault();
                return query;
            }
        }
        //public static WorkPieceInfo GetWorkPieceInfo(string WorkPieceID)
        //{
        //    using (DbModel db = new DbModel())
        //    {
        //        //查询所有
        //        var query = db.WorkPieceInfo.Where(o => o.WorkPieceID == WorkPieceID).FirstOrDefault();
        //        return query;
        //    }
        //}


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

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

        /// <summary>
        /// 给WorkPieceLog主键等公共的的属性赋值
@@ -149,7 +151,7 @@
            }
            catch (Exception ex)
            {
                loginfo.Remarks = (loginfo.Remarks ?? "") + $"{loginfo.WorkPieceID ?? "空"}刀具寿命更新数据异常{ex.Message}";
                loginfo.Remarks = $"{loginfo.WorkPieceID ?? "空"}刀具寿命更新数据异常{ex.Message}";

            }
        }
@@ -182,7 +184,7 @@
                            }
                            else
                            {
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
@@ -196,7 +198,7 @@
                        {
                            if (info.WorkingProcedureCurrent.Equals("OP05"))
                            {
                                loginfo.Remarks = (loginfo.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"} OP05工序重复读取了";
                                loginfo.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"} OP05工序重复读取了";
                                return;
                            }
                        }
@@ -212,40 +214,59 @@
                        info.WorkPieceCurrentPosition = loginfo.WorkingProcedure;
                        info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                        info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                        info.Remarks = info.Remarks ?? "" + $"{info.WorkingProcedureCurrent}工件上线";
                        info.Remarks = $"{info.WorkingProcedureCurrent}工件上线";

                        //修复下 op35 同一个件 下线时间跟下一个上线时间一模一样的问题  【Editby shaocx,2024-08-27】
                        var isNeedAddNewProcess = true;
                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && !o.OperationType.Equals("SPC") && (o.EndTime == null || o.EndTime <= DateTime.MinValue)).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro != null && pro.WorkPieceID.Length > 1)
                        {
                            pro.EndTime = DateTimeHelper.GetDateTime();
                            pro.UpdatedUserName = loginfo.MonitoringPoint;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                            pro.Remarks = (pro.Remarks ?? "") + "又一次上线，更新结束时间";
                            if (pro.WorkingProcedureCurrent == loginfo.WorkingProcedure)
                            {//表示工序相同
                                isNeedAddNewProcess = false;
                                pro.Remarks = "又一次上线，更新结束时间";
                            }
                            else
                            {
                                pro.EndTime = DateTimeHelper.GetDateTime();
                                pro.UpdatedUserName = loginfo.MonitoringPoint;
                                pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                                pro.UpdatedTime = DateTimeHelper.GetDateTime();
                                pro.Remarks = "又一次上线，更新结束时间";
                            }
                        }
                        //每次扫描上线都插入追溯表
                        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;

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

                        process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                        process.CreatedUserName = loginfo.MonitoringPoint;
                        process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        process.UpdatedUserName = loginfo.MonitoringPoint;
                        process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                        process.OperationType = OperationType.生产.ToString();
                        process.Remarks = "";
                        if (loginfo.WorkingProcedure.Equals("OP05"))
                        if (isNeedAddNewProcess)
                        {
                            process.EndTime = process.StartTime;
                            //每次扫描上线都插入追溯表
                            WorkPieceProcess new_process = new WorkPieceProcess();
                            new_process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
                            QualityStateHelper.ResetQualityNoOkForNewProcess(ref new_process);
                            new_process.StartTime = DateTimeHelper.GetDateTime();

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

                            if (new_process.WorkingProcedureCurrent == WorkingProcedureForHMI.OP70.ToString())
                            { //特殊处理OP70，因为OP70没有测量，默认合格 [Editby shaocx,2024-07-03]
                                new_process.QualityState = (int)QualityState.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 = "";
                            if (loginfo.WorkingProcedure.Equals("OP05"))
                            {
                                new_process.EndTime = new_process.StartTime;
                            }
                            db.WorkPieceProcess.Add(new_process);
                        }
                        db.WorkPieceProcess.Add(process);

                        //db.Database.AutoTransactionsEnabled = false;// 同一个SaveChanges默认事务， 关闭默认事务：... 好像不能用啊，后面再研究吧
                        if (isAddWorkPieceInfo)
@@ -348,20 +369,46 @@
                    }
                    else
                    {
                        loginfo.Remarks = (loginfo.Remarks ?? "") + $"上线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        loginfo.Remarks = $"上线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception e)
                {
                    loginfo.Remarks = (loginfo.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                    loginfo.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                    Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：", e);
                }
                finally
                {
                    loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                    db.WorkPieceLog.Add(loginfo);
                    db.SaveChanges();

                    //保存数据库的异常捕捉 [Editby shaocx,2024-08-29]
                    try
                    {
                        db.SaveChanges();
                    }
                    catch (DbEntityValidationException exception)
                    {
                        var errorMessages =
                            exception.EntityValidationErrors
                                .SelectMany(validationResult => validationResult.ValidationErrors)
                                .Select(m => m.ErrorMessage);
                        var fullErrorMessage = string.Join(", ", errorMessages);
                        var exceptionMessage = string.Concat(exception.Message, " 验证异常消息是：", fullErrorMessage);

                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}],保存数据库时异常：" + exceptionMessage, exception);

                        throw new DbEntityValidationException(exceptionMessage, exception.EntityValidationErrors);
                    }
                    catch (Exception)
                    {

                        throw;
                    }



                }

@@ -467,6 +514,9 @@
        /// <param name="type"></param>
        public static void QualityInfoComplete(WorkPieceLogMiddle logMiddle, LogType type)
        {
            //根据质量数据判断是否合格/不合格 【Editby shaocx,2024-06-25】
            WorkPieceInfoManager.SetLogMiddleForQuality(ref logMiddle);

            //此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
            //插入质量相关表QualityDataInfo

@@ -497,12 +547,12 @@
                                }
                                else
                                {
                                    pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                    pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                    pieceInfo.Remarks = "OP05新增工件信息";
                                }
                                pieceInfo.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                                pieceInfo.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                                pieceInfo.CreatedUserName = logMiddle.MonitoringPoint;
                                pieceInfo.CreatedUserName = ResetUpdatedUserName(logMiddle);
                                pieceInfo.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                                pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                                pieceInfo.WorkingProcedureEndTime = null;
@@ -513,7 +563,7 @@
                            }
                            else
                            {
                                loginfo2.Remarks = loginfo2.Remarks ?? "" + $"|工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新";
                                loginfo2.Remarks = $"|工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新";
                                Log4NetHelper.WriteErrorLog(type, $"工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新");
                                return;
                            }
@@ -547,7 +597,7 @@
                            else
                            {//更新工件
                                equinfo.WorkPieceID = logMiddle.WorkPieceID;
                                equinfo.UpdatedUserName = logMiddle.MonitoringPoint;
                                equinfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                                equinfo.UpdatedTime = DateTime.Now;
                                equinfo.OnlineTime = DateTime.Now;
                            }
@@ -564,8 +614,8 @@
                        pieceInfo.QualityStateUpdateUser = logMiddle.UpdatedUserName;
                        pieceInfo.QualityStateUpdateTime = logMiddle.UpdatedTime.Value.LocalDateTime;
                        pieceInfo.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                        pieceInfo.Remarks = pieceInfo.Remarks ?? "" + $"{logMiddle.WorkingProcedure}质量检测完成修改";
                        pieceInfo.UpdatedUserName = logMiddle.MonitoringPoint;
                        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")))
                        {//工序开始时间没有则赋值
@@ -716,20 +766,34 @@
                        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_05 = WorkPieceProcessHelper.CreateWorkPieceProcessForOP05(logMiddle, db, pieceInfo);
                            if (process_05 != null)
                            {//创建OP05工序，当没有05工序时,才创建 【Editby shaocx,2024-08-29】
                                db.WorkPieceProcess.Add(process_05);
                            }

                            WorkPieceProcess process = new WorkPieceProcess();
                            process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(pieceInfo);
                            QualityStateHelper.ResetQualityNoOkForNewProcess(ref process);
                            process.StartTime = DateTimeHelper.GetDateTime();
                            process.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.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 = logMiddle.MonitoringPoint;
                            process.CreatedUserName = ResetUpdatedUserName(logMiddle);
                            process.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = logMiddle.MonitoringPoint;
                            process.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            process.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.OperationType = OperationType.生产.ToString();
                            process.QualityDataInfoID = qualityData.Id;
@@ -739,17 +803,22 @@
                        else
                        {//其他的都只是修改
                            pro.QualityDataInfoID = qualityData.Id;
                            pro.UpdatedUserName = logMiddle.MonitoringPoint;
                            pro.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                            pro.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                            pro.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.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 (logMiddle.WorkingProcedure == "OP60")
                            {
                                pro.CreatedUserName = logMiddle.MonitoringPoint;

                                pro.CreatedUserName = ResetUpdatedUserName(logMiddle);
                                pro.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            }
                        }

@@ -773,24 +842,107 @@
                    }
                    else
                    {
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量检测完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        loginfo2.Remarks = $"质量检测完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控读码标记 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

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

        /// <summary>
        /// 质量检测完成-OP70专用
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <param name="type"></param>
        public static void QualityInfoCompleteForOP70(WorkPieceLogMiddle logMiddle, LogType type)
        {
            if (string.IsNullOrEmpty(logMiddle.QualityOP70To1) && string.IsNullOrEmpty(logMiddle.QualityOP70To2) && string.IsNullOrEmpty(logMiddle.QualityOP70To3))
            {
                Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控清洗机数据 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]获取的三个值都是空的，不处理返回");
                return;
            }
            using (DbModel db = new DbModel())
            {
                try
                {
                    bool isAdd = false;
                    if (logMiddle.WorkPieceID.Length == 22)
                    {
                        var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                        if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
                        {//插入QualityDataInfo表
                            isAdd = true;
                            qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                        }

                        qualityData.QualityStateUpdateUser = "OP7009";
                        qualityData.QualityReceiveTime = DateTime.Now;

                        //特殊处理OP70的质量数据
                        if (string.IsNullOrEmpty(qualityData.QualityOP70To1) && !string.IsNullOrEmpty(SystemHelper.GetStrForQualityOP70(logMiddle.QualityOP70To1)))
                        {
                            qualityData.QualityOP70To1 = logMiddle.QualityOP70To1;
                        }
                        if (string.IsNullOrEmpty(qualityData.QualityOP70To2) && !string.IsNullOrEmpty(SystemHelper.GetStrForQualityOP70(logMiddle.QualityOP70To2)))
                        {
                            qualityData.QualityOP70To2 = logMiddle.QualityOP70To2;
                        }
                        if (string.IsNullOrEmpty(qualityData.QualityOP70To3) && !string.IsNullOrEmpty(SystemHelper.GetStrForQualityOP70(logMiddle.QualityOP70To3)))
                        {
                            qualityData.QualityOP70To3 = logMiddle.QualityOP70To3;
                        }


                        db.QualityDataInfoLog.Add(GetAddQualityDataInfoLog(qualityData));//插入日志

                        if (isAdd)
                        {
                            db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
                        }
                        db.SaveChanges();//保存数据
                    }
                    else
                    {
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控清洗机数据 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception ex)
                {
                    Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控清洗机数据 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：", ex);
                }
                finally
                {
                }
            }
        }

        /// <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>
@@ -806,9 +958,9 @@
                {
                    if (loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
                    {
                        WorkPieceInfo info = new WorkPieceInfo();
                        info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (info == null || info.WorkPieceID.Length < 1)
                        WorkPieceInfo cur_db_info = new WorkPieceInfo();
                        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} 没有获取到工件信息不做更新");
                            return;
@@ -817,43 +969,61 @@
                        {//更新表WorkPieceInfo
                            if (loginfo.WorkingProcedure.Equals("OP10"))
                            {
                                /*
                                info.WorkPieceCurrentPosition = info.WorkingProcedureCurrent + "NOOK";
                                //var WorkingProcedure = (loginfo.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
                                loginfo2.WorkingProcedure = info.WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
                                loginfo.WorkingProcedure = info.WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                                //*/
                                //修复 错误记录成OP05的问题 【Editby shaocx,2024-08-26】
                                var set_WorkingProcedureCurrent = "";
                                if (cur_db_info.WorkingProcedureCurrent != "OP10" && cur_db_info.WorkingProcedureCurrent != "OP40")
                                {
                                    SetWorkingProcedureCurrentForOP10(cur_db_info, ref set_WorkingProcedureCurrent);
                                }
                                else
                                {
                                    set_WorkingProcedureCurrent = cur_db_info.WorkingProcedureCurrent;
                                }
                                cur_db_info.WorkingProcedureCurrent = set_WorkingProcedureCurrent;
                                cur_db_info.WorkPieceCurrentPosition = set_WorkingProcedureCurrent + "NOOK";
                                loginfo2.WorkingProcedure = set_WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
                                loginfo.WorkingProcedure = set_WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                            }
                            else
                            {
                                info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "NOOK";
                                cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "NOOK";
                            }
                            info.WorkPieceState = (int)WorkPieceState.NOOKPush;
                            info.UpdatedUserName = loginfo.MonitoringPoint;
                            info.UpdatedTime = DateTime.Now;
                            info.Remarks = "工件NOOK推出";
                            if (!(info.WorkingProcedureStartTime.HasValue && info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                            cur_db_info.WorkPieceState = (int)WorkPieceState.NOOKPush;
                            cur_db_info.UpdatedUserName = loginfo.MonitoringPoint;
                            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")))
                            {
                                info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                                cur_db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                            }
                            info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
                            info.WorkingProcedureCompleted = info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
                            info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                            cur_db_info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
                            cur_db_info.WorkingProcedureCompleted = cur_db_info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
                            cur_db_info.WorkPieceCurrentPositionOrder = cur_db_info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                        }
                        QualityDataInfo qualityData = null;
                        qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (loginfo.WorkingProcedure.Equals("OP35"))
                        {//为了解决OP35的采集到的质量信息是OK还NOOK的情况，OP35 NOOK时更新质量信息
                            loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"OP35NOOK原质量信息{(info.QualityState.HasValue ? info.QualityState.Value.ToString() : "空")}";
                            info.QualityState = (int)QualityState.NG;
                            if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
                            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()))
                            {
                                info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量NOOK采集数据不合格{info.QualityState}";
                                cur_db_info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量NOOK采集数据不合格{cur_db_info.QualityState}";
                            }
                            else
                            {
                                info.QualityErrorInfo = "";
                                cur_db_info.QualityErrorInfo = "";
                            }
                            loginfo.QualityState = info.QualityState;
                            loginfo.QualityState = cur_db_info.QualityState;

                            var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();

                            if (qualityData != null)
                            {
                                qualityData.OP35QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
@@ -868,21 +1038,24 @@
                            pro.EndTime = DateTimeHelper.GetDateTime();
                            pro.Remarks = (pro.Remarks ?? "") + "NOOK结束";
                            pro.UpdatedUserName = loginfo.MonitoringPoint;
                            pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                        }

                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
                        QualityStateHelper.SetQualityStateForNoOk(ref cur_db_info, ref pro, ref qualityData);

                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(cur_db_info));

                    }
                    else
                    {
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"工件NOOK推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        loginfo2.Remarks = $"工件NOOK推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件NOOK推出读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                    loginfo2.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }


@@ -909,9 +1082,9 @@
                        //|| !((loginfo.WorkingProcedure.Equals("OP10") || loginfo.WorkingProcedure.Equals("OP40")) && loginfo.Remarks.Length > 0)
                        )
                    {
                        WorkPieceInfo info = new WorkPieceInfo();
                        info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (info == null || info.WorkPieceID.Length < 1)
                        WorkPieceInfo cur_db_info = new WorkPieceInfo();
                        cur_db_info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (cur_db_info == null || cur_db_info.WorkPieceID.Length < 1)
                        {//没有工件信息，不做更新
                            loginfo2.Remarks = $"工件{loginfo.WorkPieceID} 工件SPC推出工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新";
                            Log4NetHelper.WriteErrorLog(type, $"工件{loginfo.WorkPieceID} 工件SPC推出工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新");
@@ -921,66 +1094,82 @@
                        {//更新表WorkPieceInfo
                            if (loginfo.WorkingProcedure.Equals("OP10"))
                            {
                                info.WorkPieceCurrentPosition = info.WorkingProcedureCurrent + "SPC";
                                //var WorkingProcedure = (loginfo.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
                                loginfo2.WorkingProcedure = info.WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
                                loginfo.WorkingProcedure = info.WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                                //修复 错误记录成OP05的问题 【Editby shaocx,2024-08-26】
                                var set_WorkingProcedureCurrent = "";
                                if (cur_db_info.WorkingProcedureCurrent != "OP10" && cur_db_info.WorkingProcedureCurrent != "OP40")
                                {
                                    SetWorkingProcedureCurrentForOP10(cur_db_info, ref set_WorkingProcedureCurrent);
                                }
                                else
                                {
                                    set_WorkingProcedureCurrent = cur_db_info.WorkingProcedureCurrent;
                                }
                                cur_db_info.WorkingProcedureCurrent = set_WorkingProcedureCurrent;
                                cur_db_info.WorkPieceCurrentPosition = set_WorkingProcedureCurrent + "SPC";
                                loginfo2.WorkingProcedure = set_WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
                                loginfo.WorkingProcedure = set_WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                            }
                            else
                            {
                                info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "SPC";
                                cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "SPC";
                            }
                            info.WorkPieceState = (int)WorkPieceState.SPCPush;
                            info.UpdatedUserName = loginfo.MonitoringPoint;
                            info.UpdatedTime = DateTime.Now;
                            info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
                            if (!(info.WorkingProcedureStartTime.HasValue && info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
                            cur_db_info.WorkPieceState = (int)WorkPieceState.SPCPush;
                            cur_db_info.UpdatedUserName = loginfo.MonitoringPoint;
                            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")))
                            {
                                info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                                cur_db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                            }


                            info.WorkingProcedureCompleted = info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
                            info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                            cur_db_info.WorkingProcedureCompleted = cur_db_info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
                            cur_db_info.WorkPieceCurrentPositionOrder = cur_db_info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
                        }
                        info.Remarks = "工件SPC抽检推出";
                        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 && 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 ?? "") + "SPC抽检结束";
                            pro.UpdatedUserName = loginfo.MonitoringPoint;
                            pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                        }
                        //每次SPC 都插入追溯表
                        WorkPieceProcess process = new WorkPieceProcess();
                        process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
                        process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(cur_db_info);
                        QualityStateHelper.ResetQualityNoOkForNewProcess(ref process);
                        process.StartTime = DateTimeHelper.GetDateTime();
                        process.OperationType = OperationType.SPC.ToString();
                        process.QualityState = (int)QualityState.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抽检推出";
                        db.WorkPieceProcess.Add(process);


                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(cur_db_info));
                    }
                    else
                    {
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"工件SPC抽检推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        loginfo2.Remarks = $"工件SPC抽检推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件SPC抽检推出读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                    loginfo2.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }
                finally
                {
@@ -990,6 +1179,37 @@

            }
        }


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

        /// <summary>
        /// 工序完成
        /// </summary>
@@ -1033,7 +1253,7 @@
                            }
                            else
                            {
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
                                info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();//WorkPieceInitOnlineTime
@@ -1078,6 +1298,7 @@
                            info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
                            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)
@@ -1140,7 +1361,14 @@
                        }
                        else
                        {
                            info.WorkPieceState = (int)WorkPieceState.WIP;
                            //这里修复OP10、OP40 因为PLC先推 SPC推出、再推 产品下线问题，导致 产品下线更新数据时，把SPC数据覆盖的问题 【Editby shaocx,2024-08-27】
                            var isAlow = SystemBussinessHelper.IsAllowUpdateWorkPieceStateToWip(info, db, logMiddle);
                            if (isAlow)
                            {
                                info.WorkPieceState = (int)WorkPieceState.WIP;
                            }


                            if (info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= info.WorkingProcedurePlan.Length)
                            {
                                info.WorkPieceCurrentPosition = info.WorkingProcedurePlan.Substring(info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure), 8);
@@ -1152,19 +1380,26 @@
                        {
                            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();
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {//OP80的质量数据是后来获取文件搞的
                             //质检数据，再考虑 另外两种状态  【Editby shaocx,2024-08-27】
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref info, ref process);
                            }
                            else
                            {
                                process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;
                                //不再默认赋值为合格 【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.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = logMiddle.MonitoringPoint;
                            process.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.OperationType = OperationType.生产.ToString();
                            process.Remarks = "";
@@ -1180,12 +1415,18 @@
                        }
                        else
                        {
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {//OP80的质量数据是后来获取文件搞的
                             //质检数据，再考虑 另外两种状态  【Editby shaocx,2024-08-27】
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref info, ref pro);
                            }
                            if (op80id > 0)
                            {
                                pro.QualityDataInfoID = op80id;
                            }
                            pro.EndTime = DateTimeHelper.GetDateTime();
                            pro.UpdatedUserName = logMiddle.MonitoringPoint;
                            pro.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {
@@ -1205,14 +1446,14 @@
                    }
                    else
                    {
                        loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"下线完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        loginfo2.Remarks = $"下线完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序下线 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{logMiddle.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                    loginfo2.Remarks = $"读取二维码{logMiddle.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }
                db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                db.SaveChanges();
@@ -1819,7 +2060,7 @@
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"{loginfo2.MonitoringPoint}设备监控更新数据异常{e.Message}.{e.StackTrace}";
                    loginfo2.Remarks = $"{loginfo2.MonitoringPoint}设备监控更新数据异常{e.Message}.{e.StackTrace}";
                    Log4NetHelper.WriteErrorLog(type, $"{loginfo2.MonitoringPoint}设备监控更新数据异常{e.Message}.{e.StackTrace}");
                }

@@ -2153,13 +2394,47 @@

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


@@ -2248,6 +2523,8 @@
        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);
@@ -2267,7 +2544,7 @@
        {
            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;
@@ -2306,8 +2583,8 @@
                }
                return qualityState;
            }
            if (logMiddle.WorkingProcedure == "OP80")
            {
            else if (logMiddle.WorkingProcedure == "OP80")
            {//合格/不合格由 OP80 判断，QualityState 和 QualityStateStr 都在调用当前方法前 写入值了
                if (logMiddle.QualityState == (int)QualityState.OK)
                {
                    qualityState = QualityState.OK;
@@ -2396,41 +2673,92 @@
                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
    }
}