整理代码

schangxiang@126.com

2024-09-06 05f2a20bb792169bf7b8a101af8718b96449f55a

整理代码

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/Important/QualityInfoCompleteManager.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,444 @@
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWare_SCADA_BusinessLogical.BLL.Important
{
    public class QualityInfoCompleteManager
    {
        /// <summary>
        /// è´¨é‡æ£€æµ‹å®Œæˆ
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <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

            using (DbModel db = new DbModel())
            {

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

                    if (logMiddle.WorkPieceID.Length == 22)
                    {//获取到的工件号异常
                        WorkPieceInfo pieceInfo = new WorkPieceInfo();
                        pieceInfo = db.WorkPieceInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                        if (pieceInfo == null || pieceInfo.WorkPieceID.Length < 1)
                        {//没有工件信息，不做更新
                            if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
                            {//OP10 æ²¡æœ‰ä¸Šçº¿æ‰«ç æžªï¼Œçº¦å®šç”¨æµ‹é‡å®Œæˆä¿¡å·å½“上线标记
                                pieceInfo = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLogMiddle>(logMiddle);
                                //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                                if (!logMiddle.WorkingProcedure.Equals("OP05"))
                                {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                    pieceInfo.QualityState = (int)QualityStateEnum.Suspected;
                                    pieceInfo.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                    pieceInfo.Remarks = $"工件二维码第一次出现的工序{logMiddle.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                                }
                                else
                                {
                                    pieceInfo.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                    pieceInfo.Remarks = "OP05新增工件信息";
                                }
                                pieceInfo.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                                pieceInfo.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                                pieceInfo.CreatedUserName = WorkPieceInfoManager.ResetUpdatedUserName(logMiddle);
                                SystemBussinessHelper.SetWorkPieceInfoMiddleForCreatedUserName(ref pieceInfo, logMiddle.DataCapturePointCname);
                                pieceInfo.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                                pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();//
                                pieceInfo.WorkingProcedureEndTime = null;
                                pieceInfo = WorkPieceInfoManager.ParseQRCode(pieceInfo);
                                isAddWorkPieceInfo = true;


                            }
                            else
                            {
                                loginfo2.Remarks = $"|工件{logMiddle.WorkPieceID} è´¨é‡æ£€æµ‹å®Œæˆå·¥åº{logMiddle.MonitoringPoint} æ²¡æœ‰èŽ·å–到工件信息不做更新";
                                Log4NetHelper.WriteErrorLog(type, $"工件{logMiddle.WorkPieceID} è´¨é‡æ£€æµ‹å®Œæˆå·¥åº{logMiddle.MonitoringPoint} æ²¡æœ‰èŽ·å–到工件信息不做更新");
                                return;
                            }
                        }
                        if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
                        {// OP10 æ²¡æœ‰ä¸Šçº¿æ‰«ç æžªï¼Œçº¦å®šç”¨æµ‹é‡å®Œæˆä¿¡å·å½“上线标记，所以上线需要修改的字段放这里

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

                            #region æ›´æ–°è®¾å¤‡å®žæ—¶è¡¨

                            bool isAddEquipmentCurrentMonitor = false;
                            EquipmentCurrentMonitor equinfo = new EquipmentCurrentMonitor();
                            equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == logMiddle.EquipmentID).FirstOrDefault();
                            if (equinfo == null || equinfo.Id < 1)
                            {//没有工件信息，不做更新
                                Log4NetHelper.WriteErrorLog(type, $"设备{logMiddle.EquipmentID} å‘Šè­¦ç›‘控{logMiddle.WorkingProcedure} æ²¡æœ‰èŽ·å–到设备监控信息，现新增");
                                equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(logMiddle);
                                equinfo.OnlineTime = DateTime.Now;
                                isAddEquipmentCurrentMonitor = true;
                            }
                            else
                            {//更新工件
                                equinfo.WorkPieceID = logMiddle.WorkPieceID;
                                equinfo.UpdatedUserName = WorkPieceInfoManager.ResetUpdatedUserName(logMiddle);
                                equinfo.UpdatedTime = DateTime.Now;
                                equinfo.OnlineTime = DateTime.Now;
                            }
                            if (isAddEquipmentCurrentMonitor)
                            {
                                equinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                                db.EquipmentCurrentMonitor.Add(equinfo);
                            }
                            #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;
                        pieceInfo.QualityStateUpdateTime = logMiddle.UpdatedTime.Value.LocalDateTime;
                        pieceInfo.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
                        pieceInfo.Remarks = $"{logMiddle.WorkingProcedure}质量检测完成修改";
                        pieceInfo.UpdatedUserName = WorkPieceInfoManager.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")) ? QualityStateEnum.OK : QualityStateEnum.NG);
                        //赋值不合格原因
                        WorkPieceInfoManager.SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);


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

                        #region æ ¹æ®æ ‡å‡†å€¼æ›´æ–°æœ€æ–°è´¨é‡æ•°æ®ï¼ˆOP10/OP40/OP20/OP60）
                        var qcofig = db.EquipmentQualityConfig.Where(o => o.WorkingProcedure.Equals(logMiddle.WorkingProcedure) && o.ParamType != 1 && o.IsDeleted == false).ToList();
                        if (qcofig.Count > 0)
                        {
                            WorkPieceInfoManager.QualityDataHand(logMiddle, qcofig);
                        }
                        #endregion


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

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

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

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

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

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

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

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

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

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

                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == 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 æ²¡æœ‰ä¸Šçº¿æ‰«ç æžªï¼Œçº¦å®šç”¨æµ‹é‡å®Œæˆä¿¡å·å½“上线标记，所以上线需要修改的字段放这里
                         //上线是每次都插入

                            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();

                            //不再默认赋值为合格 ã€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】
                            //赋值不合格原因
                            WorkPieceInfoManager.SetQualityNoOk_WorkPieceProcess(logMiddle, ref process);

                            process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                            process.CreatedUserName = WorkPieceInfoManager.ResetUpdatedUserName(logMiddle);
                            process.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            process.UpdatedUserName = WorkPieceInfoManager.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 = WorkPieceInfoManager.ResetUpdatedUserName(logMiddle);
                            pro.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
                            pro.UpdatedTime = DateTimeHelper.GetDateTime();

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

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

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

                        if (logMiddle.QualityType != null && logMiddle.QualityType.Equals(QualityType.SPC.ToString()))
                        {//SPC反馈，
                            if (logMiddle.QualityState != (int)QualityStateEnum.OK)
                            {
                                //当某到工序检测到不合格工件时，从该工件加工完成时刻前指定时间起至报检不合格时间止，系统将该工件的最后加工工序在该时间段内加工的所有工件、正在加工的工件、该工序入口处的第一个工件全部标记为疑似状态，由人工复检工件并修改状态，并支持批量变更。
                                //答复：在线测量不需要走这个流程，只有SPC抽检才需要，需要把这时间段的工件全部置为疑似，哪怕是已完成工件
                                //时间段起始时间：抽检工件生产时间前一SPC抽检时间
                                //时间段结束时间：抽检工件质量结果出现后的时间
                                //抽检工件工序扫描枪外入口处的第一个工件 ä¹ŸæŠŠè´¨é‡çŠ¶æ€ç½®ä¸ºç–‘ä¼¼
                                //（每一工序SPC抽检是设置的固定的，比如200抽4，状态置为疑似时若工件还在设备内，会继续生产完毕后排出）
                                //目前这块逻辑放到了 WebAPI中了

                            }

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

                    }
                }
                catch (Exception ex)
                {
                    loginfo2.Remarks = $"质量检测完成,更新数据异常{ex.Message}";
                    Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}质量检测完成 å·¥ä»¶ç æ•°æ®[{logMiddle.WorkPieceID ?? "空"}]时异常：" + ex.Message, ex);
                }
                finally
                {
                    loginfo2.Remarks = $"质量：{logMiddle.QualityStateStr ?? "空"}";
                    db.WorkPieceLog.Add(WorkPieceInfoManager.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(WorkPieceInfoManager.GetAddQualityDataInfoLog(qualityData));//插入日志

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

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

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/Important/ReadQRcodeManager.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,276 @@
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
using System.Collections.Generic;
using System.Data.Entity.Validation;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWare_SCADA_BusinessLogical.BLL.Important
{
    public class ReadQRcodeManager
    {
        /// <summary>
        /// è¯»å–二维码时逻辑
        /// æ ¡éªŒå·¥ä»¶æ˜¯å¦è·³åºï¼Œè´¨é‡æ˜¯å¦åˆæ ¼
        /// </summary>
        public static void ReadQRcode(WorkPieceLog loginfo, LogType type, PLCService plcService, int? IsFeedback)
        {//此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
            using (DbModel db = new DbModel())
            {
                try
                {
                    bool isAddWorkPieceInfo = false;
                    if (loginfo.WorkPieceID.Length == 22)
                    {
                        WorkPieceInfo info = new WorkPieceInfo();
                        info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (info == null || info.WorkPieceID.Length < 1)
                        {//插入WorkPieceInfo表
                            loginfo = CommonManager.Instance.GetWorkPieceID(loginfo, type);
                            info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLog>(loginfo);
                            //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                            if (!loginfo.WorkingProcedure.Equals("OP05"))
                            {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                info.QualityState = (int)QualityStateEnum.Suspected;
                                info.QualityErrorInfo = $"工件二维码第一次出现的工序{loginfo.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                info.Remarks = $"工件二维码第一次出现的工序{loginfo.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                            }
                            else
                            {//OP05工序
                                info.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                            info.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                            info.CreatedUserName = loginfo.MonitoringPoint;
                            info.WorkingProcedureCurrent = loginfo.WorkingProcedure;//工序赋值
                            SystemBussinessHelper.SetWorkPieceInfoMiddleForCreatedUserName(ref info, loginfo.DataCapturePointCname);
                            info.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            info = WorkPieceInfoManager.ParseQRCode(info);
                            isAddWorkPieceInfo = true;
                        }
                        else
                        {
                            //存在 è¡¨ WorkPieceInfo有，但是 WorkPieceProcess这个工序不存在的情况 ã€Editby shaocx,2024-09-06】
                            //if (info.WorkingProcedureCurrent.Equals("OP05"))
                            //{
                            //    loginfo.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"} OP05工序重复读取了";
                            //    return;
                            //}
                        }
                        if ((loginfo.WorkingProcedure.Equals("OP05") && isAddWorkPieceInfo == false))
                        {//存在 è¡¨ WorkPieceInfo有，但是 WorkPieceProcess这个工序不存在的情况
                            //如果是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;

                        //特殊处理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;//不需要新增了
                            }
                        }
                        else
                        {
                            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)
                            {
                                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 = "又一次上线，更新结束时间";
                                }
                            }
                        }
                        if (isNeedAddNewProcess)
                        {
                            //每次扫描上线都插入追溯表
                            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 = WorkPieceInfoManager.GetQualityStateValue(info.QualityState);

                            if (new_process.WorkingProcedureCurrent == WorkingProcedureForHMI.OP70.ToString())
                            { //特殊处理OP70，因为OP70没有测量，默认合格 [Editby shaocx,2024-07-03]
                                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)QualityStateEnum.OK)
                            {
                                plcFlag = false;
                                message = !checkQualityInfoCompleteFlag ? "跳序，" : "";
                                message += info.QualityState != (int)QualityStateEnum.OK ? "质量不符合" : "";
                            }
                            
                        }
                        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(WorkPieceInfoManager.GetAddWorkPieceInfoLog(info));
                        //UpdateKnifeToolLift(db, loginfo);//更新刀具寿命信息
                    }
                    else
                    {
                        loginfo.Remarks = $"上线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记 è¯»å–工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception e)
                {
                    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);

                    //保存数据库的异常捕捉 [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;
                    }



                }

            }
        }
    }
}

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/Important/WorkPiecePushOffManager.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,159 @@
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWare_SCADA_BusinessLogical.BLL.Important
{
    public class WorkPiecePushOffManager
    {
        /// <summary>
        /// å·¥ä»¶æŽ¨å‡ºNOOK
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static void WorkPiecePushOff(WorkPieceLogMiddle loginfo, LogType type)
        {
            using (DbModel db = new DbModel())
            {
                WorkPieceLog loginfo2 = new WorkPieceLog();
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
                try
                {
                    if (loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
                    {
                        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} å·¥ä»¶æŽ¨å‡ºNOOK工序{loginfo.WorkingProcedure} æ²¡æœ‰èŽ·å–到工件信息不做更新");
                            return;
                        }
                        else
                        {//更新表WorkPieceInfo
                            if (loginfo.WorkingProcedure.Equals("OP10"))
                            {
                                /*
                                info.WorkPieceCurrentPosition = info.WorkingProcedureCurrent + "NOOK";
                                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")
                                {
                                    WorkPieceInfoManager.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
                            {
                                cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "NOOK";
                            }
                            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();
                            }
                            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 = $"OP35NOOK原质量信息{(cur_db_info.QualityState.HasValue ? cur_db_info.QualityState.Value.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}";
                            }
                            else
                            {
                                cur_db_info.QualityErrorInfo = "";
                            }
                            loginfo.QualityState = cur_db_info.QualityState;


                            if (qualityData != null)
                            {
                                qualityData.OP35QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                                qualityData.OP35QualityReceiveTime = DateTimeHelper.GetDateTime();
                                db.QualityDataInfoLog.Add(WorkPieceInfoManager.GetAddQualityDataInfoLog(qualityData));
                            }
                        }
                        //更新上一工序的结束时间
                        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 = "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);

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

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


                db.WorkPieceLog.Add(WorkPieceInfoManager.GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                db.SaveChanges();
            }

        }
    }
}

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/Important/WorkPieceSPCPushOffManager.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,132 @@
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWare_SCADA_BusinessLogical.BLL.Important
{
    public class WorkPieceSPCPushOffManager
    {
        /// <summary>
        /// å·¥ä»¶SPC抽检推出
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static void WorkPieceSPCPushOff(WorkPieceLogMiddle loginfo, LogType type)
        {

            using (DbModel db = new DbModel())
            {
                WorkPieceLog loginfo2 = new WorkPieceLog();
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
                try
                {
                    if ((loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
                        //|| !((loginfo.WorkingProcedure.Equals("OP10") || loginfo.WorkingProcedure.Equals("OP40")) && loginfo.Remarks.Length > 0)
                        )
                    {
                        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} æ²¡æœ‰èŽ·å–到工件信息不做更新");
                            return;
                        }
                        else
                        {//更新表WorkPieceInfo
                            if (loginfo.WorkingProcedure.Equals("OP10"))
                            {
                                //修复 é”™è¯¯è®°å½•æˆOP05的问题 ã€Editby shaocx,2024-08-26】
                                var set_WorkingProcedureCurrent = "";
                                if (cur_db_info.WorkingProcedureCurrent != "OP10" && cur_db_info.WorkingProcedureCurrent != "OP40")
                                {
                                    WorkPieceInfoManager.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
                            {
                                cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "SPC";
                            }
                            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")))
                            {
                                cur_db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                            }


                            cur_db_info.WorkingProcedureCompleted = cur_db_info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
                            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
                        && 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>(cur_db_info);
                        QualityStateHelper.ResetQualityNoOkForNewProcess(ref process);
                        process.StartTime = DateTimeHelper.GetDateTime();
                        process.OperationType = OperationType.SPC.ToString();
                        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);


                        db.WorkPieceInfoLog.Add(WorkPieceInfoManager.GetAddWorkPieceInfoLog(cur_db_info));
                    }
                    else
                    {
                        loginfo2.Remarks = $"工件SPC抽检推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件SPC抽检推出读码标记 è¯»å–工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }
                finally
                {
                    db.WorkPieceLog.Add(WorkPieceInfoManager.GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                    db.SaveChanges();
                }

            }
        }

    }
}

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/Important/WorkingProcedureCompleteManager.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,272 @@
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWare_SCADA_BusinessLogical.BLL.Important
{
    public class WorkingProcedureCompleteManager
    {
        /// <summary>
        /// å·¥åºå®Œæˆ
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <param name="type"></param>
        public static void WorkingProcedureComplete(WorkPieceLogMiddle logMiddle, LogType type)
        {

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

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

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

                        bool isAddWorkPieceInfo = false;
                        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);
                            db_info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLog>(logMiddle);
                            //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                            if (!logMiddle.WorkingProcedure.Equals("OP05"))
                            {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                db_info.QualityState = (int)QualityStateEnum.Suspected;
                                db_info.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                db_info.Remarks = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                            }
                            else
                            {
                                db_info.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                db_info.Remarks = "OP05新增工件信息";
                            }
                            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 = WorkPieceInfoManager.ParseQRCode(db_info);
                            isAddWorkPieceInfo = true;
                        }
                        if (logMiddle.WorkingProcedure.Equals("OP10"))
                        {
                            //var WorkingProcedure = (loginfo.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
                            loginfo2.WorkingProcedure = db_info.WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
                            logMiddle.WorkingProcedure = db_info.WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                        }

                        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")))
                        {//若一直没有工序开始时间，则赋值当前时间
                            db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                        }
                        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"))
                        {
                            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】
                            /*
                            info.QualityState = (int)((loginfo.QualityStateStr.Equals("OK") || loginfo.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
                            loginfo.QualityState = info.QualityState;
                            info.QualityStateUpdateUser = loginfo.UpdatedUserName;
                            info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
                            info.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)
                            {//插入QualityDataInfo表
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                                db.QualityDataInfo.Add(WorkPieceInfoManager.GetAddQualityDataInfo(qualityData));
                            }
                            //修改QualityDataInfo表 //重复收到质量信息，会覆盖之前的
                            EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(logMiddle, qualityData, WorkPieceInfoManager.GetQualityDataInfoUpdate(logMiddle, logMiddle.WorkingProcedure, logMiddle.MonitoringPoint));//指定修改字段

                            //质检数据改为 èŽ·å–文件后修改 ã€Editby shaocx,2024-06-15】
                            /*
                            qualityData.QualityStateUpdateUser = info.UpdatedUserName;
                            qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
                            qualityData.QualityStateUpdateMode = info.QualityStateUpdateMode;
                            qualityData.OP80QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP80QualityReceiveTime = DateTimeHelper.GetDateTime();
                            qualityData.OP80QualityFilePath = loginfo.OP80QualityFilePath;
                            op80id = qualityData.Id;
                            loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{loginfo.QualityStateStr ?? "空"}";
                            if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
                            {
                                info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量采集数据不合格";
                            }
                            else
                            {
                                info.QualityErrorInfo = "";
                            }
                            //*/

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

                            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)
                            {//插入QualityDataInfo表
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                                db.QualityDataInfo.Add(WorkPieceInfoManager.GetAddQualityDataInfo(qualityData));
                            }
                            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 (!db_info.QualityState.Equals(((int)QualityStateEnum.OK).ToString()))
                            {
                                db_info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
                            }
                            else
                            {
                                db_info.QualityErrorInfo = "";
                            }
                        }
                        else
                        {
                            //这里修复OP10、OP40 å› ä¸ºPLC先推 SPC推出、再推 äº§å“ä¸‹çº¿é—®é¢˜ï¼Œå¯¼è‡´ äº§å“ä¸‹çº¿æ›´æ–°æ•°æ®æ—¶ï¼ŒæŠŠSPC数据覆盖的问题 ã€Editby shaocx,2024-08-27】
                            var isAlow = SystemBussinessHelper.IsAllowUpdateWorkPieceStateToWip(db_info, db, logMiddle);
                            if (isAlow)
                            {
                                db_info.WorkPieceState = (int)WorkPieceState.WIP;
                            }


                            if (db_info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= db_info.WorkingProcedurePlan.Length)
                            {
                                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 == db_info.WorkingProcedureCurrent
                        && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro == null || pro.WorkPieceID.Length < 1)
                        {
                            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 db_info, ref add_process);
                            }
                            else
                            {
                                //不再默认赋值为合格 ã€Editby shaocx,2024-08-16】
                                //process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                                add_process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
                            }
                            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"))
                            {
                                add_process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                            }
                            if (op80id > 0)
                            {
                                add_process.QualityDataInfoID = op80id;
                            }
                            db.WorkPieceProcess.Add(add_process);
                        }
                        else
                        {
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {//OP80的质量数据是后来获取文件搞的
                             //质检数据，再考虑 å¦å¤–两种状态  ã€Editby shaocx,2024-08-27】
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref db_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"))
                            {
                                if (pro.GetQcDataFlag != 0)
                                {
                                    pro.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                                }
                            }
                        }


                        if (isAddWorkPieceInfo)
                        {
                            db.WorkPieceInfo.Add(db_info);
                        }
                        db.WorkPieceInfoLog.Add(WorkPieceInfoManager.GetAddWorkPieceInfoLog(db_info));
                    }
                    else
                    {
                        loginfo2.Remarks = $"下线完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序下线 è¯»å–工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = $"读取二维码{logMiddle.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }
                db.WorkPieceLog.Add(WorkPieceInfoManager.GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                db.SaveChanges();
            }
        }
    }
}

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/BLL/WorkPieceInfoManager.cs

@@ -156,267 +156,7 @@
            }
        }

        /// <summary>
        /// è¯»å–二维码时逻辑
        /// æ ¡éªŒå·¥ä»¶æ˜¯å¦è·³åºï¼Œè´¨é‡æ˜¯å¦åˆæ ¼
        /// </summary>
        public static void ReadQRcode(WorkPieceLog loginfo, LogType type, PLCService plcService, int? IsFeedback)
        {//此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
            using (DbModel db = new DbModel())
            {
                try
                {
                    bool isAddWorkPieceInfo = false;
                    if (loginfo.WorkPieceID.Length == 22)
                    {
                        WorkPieceInfo info = new WorkPieceInfo();
                        info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
                        if (info == null || info.WorkPieceID.Length < 1)
                        {//插入WorkPieceInfo表
                            loginfo = CommonManager.Instance.GetWorkPieceID(loginfo, type);
                            info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLog>(loginfo);
                            //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                            if (!loginfo.WorkingProcedure.Equals("OP05"))
                            {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                info.QualityState = (int)QualityStateEnum.Suspected;
                                info.QualityErrorInfo = $"工件二维码第一次出现的工序{loginfo.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                info.Remarks = $"工件二维码第一次出现的工序{loginfo.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                            }
                            else
                            {//OP05工序
                                info.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                info.Remarks = "OP05新增工件信息";
                            }
                            info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
                            info.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
                            info.CreatedUserName = loginfo.MonitoringPoint;
                            info.WorkingProcedureCurrent = loginfo.WorkingProcedure;//工序赋值
                            SystemBussinessHelper.SetWorkPieceInfoMiddleForCreatedUserName(ref info, loginfo.DataCapturePointCname);
                            info.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
                            info = ParseQRCode(info);
                            isAddWorkPieceInfo = true;
                        }
                        else
                        {
                            //存在 è¡¨ WorkPieceInfo有，但是 WorkPieceProcess这个工序不存在的情况 ã€Editby shaocx,2024-09-06】
                            //if (info.WorkingProcedureCurrent.Equals("OP05"))
                            //{
                            //    loginfo.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"} OP05工序重复读取了";
                            //    return;
                            //}
                        }
                        if ((loginfo.WorkingProcedure.Equals("OP05") && isAddWorkPieceInfo == false))
                        {//存在 è¡¨ WorkPieceInfo有，但是 WorkPieceProcess这个工序不存在的情况
                            //如果是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;

                        //特殊处理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;//不需要新增了
                            }
                        }
                        else
                        {
                            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)
                            {
                                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 = "又一次上线，更新结束时间";
                                }
                            }
                        }
                        if (isNeedAddNewProcess)
                        {
                            //每次扫描上线都插入追溯表
                            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)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)QualityStateEnum.OK)
                            {
                                plcFlag = false;
                                message = !checkQualityInfoCompleteFlag ? "跳序，" : "";
                                message += info.QualityState != (int)QualityStateEnum.OK ? "质量不符合" : "";
                            }
                            
                        }
                        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 ?? "空"}]时异常：");

                    }
                }
                catch (Exception e)
                {
                    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);

                    //保存数据库的异常捕捉 [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;
                    }



                }

            }
        }
     
        public static WorkPieceLogMiddle QualityDataHand(WorkPieceLogMiddle loginfo, List<EquipmentQualityConfig> qcofig)
        {
            try
@@ -510,436 +250,7 @@
            return loginfo;
        }

        /// <summary>
        /// è´¨é‡æ£€æµ‹å®Œæˆ
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <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

            using (DbModel db = new DbModel())
            {

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

                    if (logMiddle.WorkPieceID.Length == 22)
                    {//获取到的工件号异常
                        WorkPieceInfo pieceInfo = new WorkPieceInfo();
                        pieceInfo = db.WorkPieceInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
                        if (pieceInfo == null || pieceInfo.WorkPieceID.Length < 1)
                        {//没有工件信息，不做更新
                            if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
                            {//OP10 æ²¡æœ‰ä¸Šçº¿æ‰«ç æžªï¼Œçº¦å®šç”¨æµ‹é‡å®Œæˆä¿¡å·å½“上线标记
                                pieceInfo = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLogMiddle>(logMiddle);
                                //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                                if (!logMiddle.WorkingProcedure.Equals("OP05"))
                                {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                    pieceInfo.QualityState = (int)QualityStateEnum.Suspected;
                                    pieceInfo.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                    pieceInfo.Remarks = $"工件二维码第一次出现的工序{logMiddle.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
                                }
                                else
                                {
                                    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;
                                pieceInfo = ParseQRCode(pieceInfo);
                                isAddWorkPieceInfo = true;


                            }
                            else
                            {
                                loginfo2.Remarks = $"|工件{logMiddle.WorkPieceID} è´¨é‡æ£€æµ‹å®Œæˆå·¥åº{logMiddle.MonitoringPoint} æ²¡æœ‰èŽ·å–到工件信息不做更新";
                                Log4NetHelper.WriteErrorLog(type, $"工件{logMiddle.WorkPieceID} è´¨é‡æ£€æµ‹å®Œæˆå·¥åº{logMiddle.MonitoringPoint} æ²¡æœ‰èŽ·å–到工件信息不做更新");
                                return;
                            }
                        }
                        if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
                        {// OP10 æ²¡æœ‰ä¸Šçº¿æ‰«ç æžªï¼Œçº¦å®šç”¨æµ‹é‡å®Œæˆä¿¡å·å½“上线标记，所以上线需要修改的字段放这里

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

                            #region æ›´æ–°è®¾å¤‡å®žæ—¶è¡¨

                            bool isAddEquipmentCurrentMonitor = false;
                            EquipmentCurrentMonitor equinfo = new EquipmentCurrentMonitor();
                            equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == logMiddle.EquipmentID).FirstOrDefault();
                            if (equinfo == null || equinfo.Id < 1)
                            {//没有工件信息，不做更新
                                Log4NetHelper.WriteErrorLog(type, $"设备{logMiddle.EquipmentID} å‘Šè­¦ç›‘控{logMiddle.WorkingProcedure} æ²¡æœ‰èŽ·å–到设备监控信息，现新增");
                                equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(logMiddle);
                                equinfo.OnlineTime = DateTime.Now;
                                isAddEquipmentCurrentMonitor = true;
                            }
                            else
                            {//更新工件
                                equinfo.WorkPieceID = logMiddle.WorkPieceID;
                                equinfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
                                equinfo.UpdatedTime = DateTime.Now;
                                equinfo.OnlineTime = DateTime.Now;
                            }
                            if (isAddEquipmentCurrentMonitor)
                            {
                                equinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
                                db.EquipmentCurrentMonitor.Add(equinfo);
                            }
                            #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;
                        pieceInfo.QualityStateUpdateTime = logMiddle.UpdatedTime.Value.LocalDateTime;
                        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")) ? QualityStateEnum.OK : QualityStateEnum.NG);
                        //赋值不合格原因
                        SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);


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

                        #region æ ¹æ®æ ‡å‡†å€¼æ›´æ–°æœ€æ–°è´¨é‡æ•°æ®ï¼ˆOP10/OP40/OP20/OP60）
                        var qcofig = db.EquipmentQualityConfig.Where(o => o.WorkingProcedure.Equals(logMiddle.WorkingProcedure) && o.ParamType != 1 && o.IsDeleted == false).ToList();
                        if (qcofig.Count > 0)
                        {
                            QualityDataHand(logMiddle, qcofig);
                        }
                        #endregion


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

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

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

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

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

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

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

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

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

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

                        var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == 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 æ²¡æœ‰ä¸Šçº¿æ‰«ç æžªï¼Œçº¦å®šç”¨æµ‹é‡å®Œæˆä¿¡å·å½“上线标记，所以上线需要修改的字段放这里
                         //上线是每次都插入

                            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();

                            //不再默认赋值为合格 ã€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 = 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】
                            //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 = ResetUpdatedUserName(logMiddle);
                                pro.DataCapturePointCname = logMiddle.DataCapturePointCname;
                            }
                        }

                        if (logMiddle.QualityType != null && logMiddle.QualityType.Equals(QualityType.SPC.ToString()))
                        {//SPC反馈，
                            if (logMiddle.QualityState != (int)QualityStateEnum.OK)
                            {
                                //当某到工序检测到不合格工件时，从该工件加工完成时刻前指定时间起至报检不合格时间止，系统将该工件的最后加工工序在该时间段内加工的所有工件、正在加工的工件、该工序入口处的第一个工件全部标记为疑似状态，由人工复检工件并修改状态，并支持批量变更。
                                //答复：在线测量不需要走这个流程，只有SPC抽检才需要，需要把这时间段的工件全部置为疑似，哪怕是已完成工件
                                //时间段起始时间：抽检工件生产时间前一SPC抽检时间
                                //时间段结束时间：抽检工件质量结果出现后的时间
                                //抽检工件工序扫描枪外入口处的第一个工件 ä¹ŸæŠŠè´¨é‡çŠ¶æ€ç½®ä¸ºç–‘ä¼¼
                                //（每一工序SPC抽检是设置的固定的，比如200抽4，状态置为疑似时若工件还在设备内，会继续生产完毕后排出）
                                //目前这块逻辑放到了 WebAPI中了

                            }

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

                    }
                }
                catch (Exception ex)
                {
                    loginfo2.Remarks = $"质量检测完成,更新数据异常{ex.Message}";
                    Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}质量检测完成 å·¥ä»¶ç æ•°æ®[{logMiddle.WorkPieceID ?? "空"}]时异常：" + ex.Message, ex);
                }
                finally
                {
                    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】
@@ -955,268 +266,8 @@
            return logMiddle.MonitoringPoint;
        }

        /// <summary>
        /// å·¥ä»¶æŽ¨å‡ºNOOK
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static void WorkPiecePushOff(WorkPieceLogMiddle loginfo, LogType type)
        {
            using (DbModel db = new DbModel())
            {
                WorkPieceLog loginfo2 = new WorkPieceLog();
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
                try
                {
                    if (loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
                    {
                        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} å·¥ä»¶æŽ¨å‡ºNOOK工序{loginfo.WorkingProcedure} æ²¡æœ‰èŽ·å–到工件信息不做更新");
                            return;
                        }
                        else
                        {//更新表WorkPieceInfo
                            if (loginfo.WorkingProcedure.Equals("OP10"))
                            {
                                /*
                                info.WorkPieceCurrentPosition = info.WorkingProcedureCurrent + "NOOK";
                                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
                            {
                                cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "NOOK";
                            }
                            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();
                            }
                            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 = $"OP35NOOK原质量信息{(cur_db_info.QualityState.HasValue ? cur_db_info.QualityState.Value.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}";
                            }
                            else
                            {
                                cur_db_info.QualityErrorInfo = "";
                            }
                            loginfo.QualityState = cur_db_info.QualityState;


                            if (qualityData != null)
                            {
                                qualityData.OP35QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                                qualityData.OP35QualityReceiveTime = DateTimeHelper.GetDateTime();
                                db.QualityDataInfoLog.Add(GetAddQualityDataInfoLog(qualityData));
                            }
                        }
                        //更新上一工序的结束时间
                        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 = "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);

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

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


                db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                db.SaveChanges();
            }

        }
        /// <summary>
        /// å·¥ä»¶SPC抽检推出
        /// </summary>
        /// <param name="loginfo"></param>
        /// <param name="type"></param>
        public static void WorkPieceSPCPushOff(WorkPieceLogMiddle loginfo, LogType type)
        {

            using (DbModel db = new DbModel())
            {
                WorkPieceLog loginfo2 = new WorkPieceLog();
                loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
                try
                {
                    if ((loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
                        //|| !((loginfo.WorkingProcedure.Equals("OP10") || loginfo.WorkingProcedure.Equals("OP40")) && loginfo.Remarks.Length > 0)
                        )
                    {
                        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} æ²¡æœ‰èŽ·å–到工件信息不做更新");
                            return;
                        }
                        else
                        {//更新表WorkPieceInfo
                            if (loginfo.WorkingProcedure.Equals("OP10"))
                            {
                                //修复 é”™è¯¯è®°å½•æˆ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
                            {
                                cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
                                cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "SPC";
                            }
                            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")))
                            {
                                cur_db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                            }


                            cur_db_info.WorkingProcedureCompleted = cur_db_info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
                            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
                        && 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>(cur_db_info);
                        QualityStateHelper.ResetQualityNoOkForNewProcess(ref process);
                        process.StartTime = DateTimeHelper.GetDateTime();
                        process.OperationType = OperationType.SPC.ToString();
                        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);


                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(cur_db_info));
                    }
                    else
                    {
                        loginfo2.Remarks = $"工件SPC抽检推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件SPC抽检推出读码标记 è¯»å–工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }
                finally
                {
                    db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                    db.SaveChanges();
                }

            }
        }
       
       


        public static void SetWorkingProcedureCurrentForOP10(WorkPieceInfo cur_db_info, ref string set_WorkingProcedureCurrent)
@@ -1248,264 +299,7 @@
            }
        }

        /// <summary>
        /// å·¥åºå®Œæˆ
        /// </summary>
        /// <param name="logMiddle"></param>
        /// <param name="type"></param>
        public static void WorkingProcedureComplete(WorkPieceLogMiddle logMiddle, LogType type)
        {

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

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

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

                        bool isAddWorkPieceInfo = false;
                        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);
                            db_info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLog>(logMiddle);
                            //EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
                            if (!logMiddle.WorkingProcedure.Equals("OP05"))
                            {//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
                                db_info.QualityState = (int)QualityStateEnum.Suspected;
                                db_info.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                                db_info.Remarks = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
                            }
                            else
                            {
                                db_info.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
                                db_info.Remarks = "OP05新增工件信息";
                            }
                            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 = db_info.WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
                            logMiddle.WorkingProcedure = db_info.WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
                        }

                        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")))
                        {//若一直没有工序开始时间，则赋值当前时间
                            db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
                        }
                        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"))
                        {
                            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】
                            /*
                            info.QualityState = (int)((loginfo.QualityStateStr.Equals("OK") || loginfo.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
                            loginfo.QualityState = info.QualityState;
                            info.QualityStateUpdateUser = loginfo.UpdatedUserName;
                            info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
                            info.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)
                            {//插入QualityDataInfo表
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                                db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
                            }
                            //修改QualityDataInfo表 //重复收到质量信息，会覆盖之前的
                            EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(logMiddle, qualityData, GetQualityDataInfoUpdate(logMiddle, logMiddle.WorkingProcedure, logMiddle.MonitoringPoint));//指定修改字段

                            //质检数据改为 èŽ·å–文件后修改 ã€Editby shaocx,2024-06-15】
                            /*
                            qualityData.QualityStateUpdateUser = info.UpdatedUserName;
                            qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
                            qualityData.QualityStateUpdateMode = info.QualityStateUpdateMode;
                            qualityData.OP80QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
                            qualityData.OP80QualityReceiveTime = DateTimeHelper.GetDateTime();
                            qualityData.OP80QualityFilePath = loginfo.OP80QualityFilePath;
                            op80id = qualityData.Id;
                            loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{loginfo.QualityStateStr ?? "空"}";
                            if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
                            {
                                info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量采集数据不合格";
                            }
                            else
                            {
                                info.QualityErrorInfo = "";
                            }
                            //*/

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

                            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)
                            {//插入QualityDataInfo表
                                qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
                                db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
                            }
                            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 (!db_info.QualityState.Equals(((int)QualityStateEnum.OK).ToString()))
                            {
                                db_info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
                            }
                            else
                            {
                                db_info.QualityErrorInfo = "";
                            }
                        }
                        else
                        {
                            //这里修复OP10、OP40 å› ä¸ºPLC先推 SPC推出、再推 äº§å“ä¸‹çº¿é—®é¢˜ï¼Œå¯¼è‡´ äº§å“ä¸‹çº¿æ›´æ–°æ•°æ®æ—¶ï¼ŒæŠŠSPC数据覆盖的问题 ã€Editby shaocx,2024-08-27】
                            var isAlow = SystemBussinessHelper.IsAllowUpdateWorkPieceStateToWip(db_info, db, logMiddle);
                            if (isAlow)
                            {
                                db_info.WorkPieceState = (int)WorkPieceState.WIP;
                            }


                            if (db_info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= db_info.WorkingProcedurePlan.Length)
                            {
                                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 == db_info.WorkingProcedureCurrent
                        && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
                        if (pro == null || pro.WorkPieceID.Length < 1)
                        {
                            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 db_info, ref add_process);
                            }
                            else
                            {
                                //不再默认赋值为合格 ã€Editby shaocx,2024-08-16】
                                //process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
                                add_process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
                            }
                            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"))
                            {
                                add_process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                            }
                            if (op80id > 0)
                            {
                                add_process.QualityDataInfoID = op80id;
                            }
                            db.WorkPieceProcess.Add(add_process);
                        }
                        else
                        {
                            if (logMiddle.WorkingProcedure.Equals("OP80"))
                            {//OP80的质量数据是后来获取文件搞的
                             //质检数据，再考虑 å¦å¤–两种状态  ã€Editby shaocx,2024-08-27】
                                QualityStateHelper.SetQualityStateForOP80(logMiddle, ref db_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"))
                            {
                                if (pro.GetQcDataFlag != 0)
                                {
                                    pro.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
                                }
                            }
                        }


                        if (isAddWorkPieceInfo)
                        {
                            db.WorkPieceInfo.Add(db_info);
                        }
                        db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(db_info));
                    }
                    else
                    {
                        loginfo2.Remarks = $"下线完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
                        Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序下线 è¯»å–工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

                    }
                }
                catch (Exception e)
                {
                    loginfo2.Remarks = $"读取二维码{logMiddle.WorkPieceID ?? "空"}更新数据异常{e.Message}";
                }
                db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
                db.SaveChanges();
            }
        }
       
        public static void AlertMonitor(WorkPieceLog loginfo, LogType type)
        {


 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandler/DataCaptureHandler_OP0506.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -63,7 +64,7 @@
                wplog.UpdatedTime = DateTimeHelper.GetDateTime();
                wplog.UpdatedUserName = DataCapturePointCode;
                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                WorkPiecePushOffManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));

                return;
            }

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandler/DataCaptureHandler_OP2001.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -110,7 +111,7 @@
                                    }
                                }
                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);
                                ReadQRcodeManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);


                                //判断是否跳序，上一工序质量是否合格

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandler/DataCaptureHandler_OP2003.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -110,7 +111,7 @@
                                    }
                                }
                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);
                                ReadQRcodeManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);


                                //判断是否跳序，上一工序质量是否合格

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandler/DataCaptureHandler_OP2004.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -13,7 +14,7 @@
    /// <summary>
    /// OP20SPC推出标记
    /// </summary>
    public class DataCaptureHandler_OP2004: DataCaptureHandler
    public class DataCaptureHandler_OP2004 : DataCaptureHandler
    {
        public static readonly DataCaptureHandler_OP2004 Instance = new DataCaptureHandler_OP2004();

@@ -101,7 +102,7 @@
                                wplog.MonitoringPoint = "OP2004";
                                foreach (var col in colConfig)
                                {
                                    switch(col.DbNumber+ col.Offset)
                                    switch (col.DbNumber + col.Offset)
                                    {
                                        case "":
                                            var valuecol = plcService.ReadValuePoint(col.DbNumber, col.Offset, PLCManger.GetTypeForString(col.DataCaptureColumnType));
@@ -110,7 +111,7 @@
                                    }
                                }
                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);
                                ReadQRcodeManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);


                                //判断是否跳序，上一工序质量是否合格

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandler/DataCaptureHandler_OP2005.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -110,7 +111,7 @@
                                    }
                                }
                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);
                                ReadQRcodeManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);


                                //判断是否跳序，上一工序质量是否合格

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandler/DataCaptureHandler_OP2006.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -109,7 +110,7 @@
                                    }
                                }
                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);
                                ReadQRcodeManager.ReadQRcode(wplog, LogType.PLCOP20, plcService, _dataCaptureConfig.IsFeedback);


                                //判断是否跳序，上一工序质量是否合格

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/DataCaptureHandler_01.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using iWare_SCADA_Model.MiddleModel;
@@ -197,7 +198,7 @@
                                SystemBussinessHelper.SetWorkPieceLogMiddleForCreatedUserName(ref wplog, wplog.MonitoringPoint, DataCapturePointCname);

                                //读取二维码后更新数据库
                                WorkPieceInfoManager.ReadQRcode(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), plcService, _dataCaptureConfig.IsFeedback);
                                ReadQRcodeManager.ReadQRcode(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), plcService, _dataCaptureConfig.IsFeedback);

                                threadStatusMonitor.Threadstatue = 1;


 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/DataCaptureHandler_02.cs

@@ -21,6 +21,7 @@
using Spire.Additions.Xps.Schema;
using log4net;
using static Org.BouncyCastle.Math.EC.ECCurve;
using iWare_SCADA_BusinessLogical.BLL.Important;

namespace iWare_SCADA_BusinessLogical
{
@@ -630,7 +631,7 @@


                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.QualityInfoComplete(logMiddle, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                QualityInfoCompleteManager.QualityInfoComplete(logMiddle, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                threadStatusMonitor.Threadstatue = 1;



 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/DataCaptureHandler_03.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using iWare_SCADA_Model.MiddleModel;
@@ -64,7 +65,7 @@
                wplog.UpdatedTime = DateTimeHelper.GetDateTime();
                wplog.UpdatedUserName = DataCapturePointCode;
                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                WorkPiecePushOffManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));

                return;
            }
@@ -153,13 +154,13 @@
                                {//op20会同时推出多件，所以特殊处理
                                    wplog.WorkPieceID = wplog.WorkPieceIDA;
                                    wplog.Remarks = "NOOK推出工件A";
                                    WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPiecePushOffManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    wplog.WorkPieceID = wplog.WorkPieceIDB;
                                    wplog.Remarks = "NOOK推出工件B";
                                    WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPiecePushOffManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    wplog.WorkPieceID = wplog.WorkPieceIDC;
                                    wplog.Remarks = "NOOK推出工件C";
                                    WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPiecePushOffManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    //wplog.WorkPieceID = wplog.WorkPieceIDD;
                                    //wplog.Remarks = "NOOK推出工件D";
                                    //WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
@@ -167,7 +168,7 @@
                                else
                                {
                                    //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                    WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPiecePushOffManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                }
                                threadStatusMonitor.Threadstatue = 1;


 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/DataCaptureHandler_04.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using iWare_SCADA_Model.MiddleModel;
@@ -63,7 +64,7 @@
                wplog.UpdatedTime = DateTimeHelper.GetDateTime();
                wplog.UpdatedUserName = DataCapturePointCode;
                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                WorkPieceInfoManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                WorkPieceSPCPushOffManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));

                return;
            }
@@ -153,24 +154,24 @@
                                {//op20,op50,op60 ä¼šåŒæ—¶æŽ¨å‡ºå¤šä»¶ï¼Œæ‰€ä»¥ç‰¹æ®Šå¤„理
                                    wplog.WorkPieceID = wplog.WorkPieceIDA;
                                    wplog.Remarks = "SPC推出工件A";
                                    WorkPieceInfoManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPieceSPCPushOffManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    wplog.WorkPieceID = wplog.WorkPieceIDB;
                                    wplog.Remarks = "SPC推出工件B";
                                    WorkPieceInfoManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPieceSPCPushOffManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    wplog.WorkPieceID = wplog.WorkPieceIDC;
                                    wplog.Remarks = "SPC推出工件C";
                                    WorkPieceInfoManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPieceSPCPushOffManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    if (_dataCaptureConfig.WorkingProcedure.Equals("OP60"))
                                    {
                                        wplog.WorkPieceID = wplog.WorkPieceIDD;
                                        wplog.Remarks = "SPC推出工件D";
                                        WorkPieceInfoManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                        WorkPieceSPCPushOffManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    }
                                }
                                else
                                {
                                    //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                    WorkPieceInfoManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                    WorkPieceSPCPushOffManager.WorkPieceSPCPushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                }
                                threadStatusMonitor.Threadstatue = 1;


 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/DataCaptureHandler_05.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using iWare_SCADA_Model.MiddleModel;
@@ -344,7 +345,7 @@
                                //*/

                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.WorkingProcedureComplete(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                WorkingProcedureCompleteManager.WorkingProcedureComplete(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                threadStatusMonitor.Threadstatue = 1;

                            }

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/DataCaptureHandler_06.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using iWare_SCADA_Model.MiddleModel;
@@ -65,7 +66,7 @@
                wplog.UpdatedTime = DateTimeHelper.GetDateTime();
                wplog.UpdatedUserName = DataCapturePointCode;
                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                WorkPieceInfoManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                WorkPiecePushOffManager.WorkPiecePushOff(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));

                return;
            }

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/DataCaptureHandler_OP0501.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -326,8 +327,8 @@
                                        {
                                            Log4NetHelper.WriteInfoLog(PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure),
                                                   $"{_dataCaptureConfig.WorkingProcedure}工序读取工控机中二维码信息,读取工件二维码:{item.WorkPieceID.ToString()}");
                                           
                                            WorkPieceInfoManager.ReadQRcode(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), null, _dataCaptureConfig.IsFeedback);

                                            ReadQRcodeManager.ReadQRcode(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), null, _dataCaptureConfig.IsFeedback);

                                            threadStatusMonitor.Threadstatue = 1;
                                        }

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/Special/DataCaptureHandler_OP1002.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using log4net;
@@ -172,7 +173,7 @@


                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.QualityInfoComplete(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                QualityInfoCompleteManager.QualityInfoComplete(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                threadStatusMonitor.Threadstatue = 1;



 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/Special/DataCaptureHandler_OP1003.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -170,7 +171,7 @@


                                //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
                                WorkPieceInfoManager.QualityInfoComplete(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                QualityInfoCompleteManager.QualityInfoComplete(wplog, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
                                threadStatusMonitor.Threadstatue = 1;
                            }
                            SystemValue.value_OP1003 = value.ToString();

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/Special/DataCaptureHandler_OP1004.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using System;
@@ -129,16 +130,16 @@
                                {
                                    Log4NetHelper.WriteInfoLog(PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), $" {DataCapturePointCode}工序1监控读码标记 è¯»å–工件码数据{wplog.WorkPieceID}推出原因[{wplog.OP10Flag}]");

                                    WorkPieceInfoManager.WorkPiecePushOff(wplog, LogType.PLCOP10);
                                    WorkPiecePushOffManager.WorkPiecePushOff(wplog, LogType.PLCOP10);
                                    threadStatusMonitor.Threadstatue = 1;
                                    wplog.Remarks =$"推出原因[{wplog.OP10Flag}]   NOOK";
                                    wplog.Remarks = $"推出原因[{wplog.OP10Flag}]   NOOK";
                                }
                                //else if (wplog.OP10Flag == 2 || wplog.OP10Flag == 3)
                                else
                                {
                                    Log4NetHelper.WriteInfoLog(PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure), $" {DataCapturePointCode}工序23监控读码标记 è¯»å–工件码数据{wplog.WorkPieceID}推出原因[{wplog.OP10Flag}]");

                                    WorkPieceInfoManager.WorkPieceSPCPushOff(wplog, LogType.PLCOP10);
                                    WorkPieceSPCPushOffManager.WorkPieceSPCPushOff(wplog, LogType.PLCOP10);
                                    wplog.Remarks = $"推出原因[{wplog.OP10Flag}]   SPC";
                                    threadStatusMonitor.Threadstatue = 1;
                                }

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/DataCaptureHandlerV2/Special/DataCaptureHandler_OP7009.cs

@@ -1,4 +1,5 @@
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using log4net;
@@ -159,7 +160,7 @@
                                foreach (var item in noFinishWorkPieceProcessList)
                                {
                                    wplog.WorkPieceID = item.WorkPieceID;
                                    WorkPieceInfoManager.QualityInfoCompleteForOP70(wplog, LogType.OP7009);
                                    QualityInfoCompleteManager.QualityInfoCompleteForOP70(wplog, LogType.OP7009);
                                    // threadStatusMonitor.Threadstatue = 1;
                                }
                            }

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_BusinessLogical/iWare_SCADA_BusinessLogical.csproj

@@ -80,6 +80,11 @@
    <Compile Include="BLL\CommonManager.cs" />
    <Compile Include="BLL\DataCaptureColumnDictManager.cs" />
    <Compile Include="BLL\DataCaptureConfigManager.cs" />
    <Compile Include="BLL\Important\QualityInfoCompleteManager.cs" />
    <Compile Include="BLL\Important\ReadQRcodeManager.cs" />
    <Compile Include="BLL\Important\WorkingProcedureCompleteManager.cs" />
    <Compile Include="BLL\Important\WorkPiecePushOffManager.cs" />
    <Compile Include="BLL\Important\WorkPieceSPCPushOffManager.cs" />
    <Compile Include="BLL\SystemValue.cs" />
    <Compile Include="BLL\WorkPieceInfoManager.cs" />
    <Compile Include="BLL\WorkPieceLogManager.cs" />

 DataCapture/iWare_SCADA_DataCapture/iWare_SCADA_Test/UnitTest1.cs

@@ -1,5 +1,6 @@
using iWare_SCADA_BusinessLogical;
using iWare_SCADA_BusinessLogical.BLL;
using iWare_SCADA_BusinessLogical.BLL.Important;
using iWare_SCADA_BusinessLogical.Utils;
using iWare_SCADA_Model;
using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -147,7 +148,7 @@
            WorkPieceInfoManager.SetLogMiddleForQuality(ref logMiddle);

            //更新WorkPieceInfo表以及插入WorkPieceLog表和WorkPieceInfoLog表
            WorkPieceInfoManager.QualityInfoComplete(logMiddle, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));
            QualityInfoCompleteManager.QualityInfoComplete(logMiddle, PLCManger.GetLogTypeForWorkingProcedure(WorkingProcedure));


            string cc = "";