DF22001YiQi.git

			@@ -41,7 +41,7 @@
			return workPiece.Id;
			}
			}


			public static WorkPieceLogMiddle GetAddWorkPieceLog(WorkPieceLogMiddle loginfo)
			{
			loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			@@ -140,15 +140,16 @@
			try
			{
			var info = db.KnifeToolEquipmentInfo.Where(o => o.EquipmentID.Equals(loginfo.EquipmentID)).ToList();
			foreach(var item in info)
			foreach (var item in info)
			{
			item.CurrentLife++;
			item.UpdatedTime= DateTime.Now;
			item.UpdatedTime = DateTime.Now;
			}

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

			}
			}
			@@ -157,7 +158,7 @@
			/// 读取二维码时逻辑
			/// 校验工件是否跳序，质量是否合格
			/// </summary>
			public static void ReadQRcode(WorkPieceLog loginfo, LogType type,PLCService plcService, int? IsFeedback)
			public static void ReadQRcode(WorkPieceLog loginfo, LogType type, PLCService plcService, int? IsFeedback)
			{//此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
			using (DbModel db = new DbModel())
			{
			@@ -181,7 +182,7 @@
			}
			else
			{
			info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
			info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
			info.Remarks = "OP05新增工件信息";
			}
			info.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
			@@ -193,7 +194,7 @@
			}
			else
			{
			if(info.WorkingProcedureCurrent.Equals("OP05"))
			if (info.WorkingProcedureCurrent.Equals("OP05"))
			{
			loginfo.Remarks = (loginfo.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"} OP05工序重复读取了";
			return;
			@@ -211,9 +212,9 @@
			info.WorkPieceCurrentPosition = loginfo.WorkingProcedure;
			info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
			info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
			info.Remarks = info.Remarks??""+$"{info.WorkingProcedureCurrent}工件上线";
			info.Remarks = info.Remarks ?? "" + $"{info.WorkingProcedureCurrent}工件上线";

			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();
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && !o.OperationType.Equals("SPC") && (o.EndTime == null \|\| o.EndTime <= DateTime.MinValue)).OrderByDescending(o => o.StartTime).FirstOrDefault();
			if (pro != null && pro.WorkPieceID.Length > 1)
			{
			pro.EndTime = DateTimeHelper.GetDateTime();
			@@ -225,7 +226,16 @@
			WorkPieceProcess process = new WorkPieceProcess();
			process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
			process.StartTime = DateTimeHelper.GetDateTime();
			process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;

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

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

			process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			process.CreatedUserName = loginfo.MonitoringPoint;
			process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			@@ -318,14 +328,14 @@
			{//没有工件信息，不做更新
			Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.WorkingProcedure} 没有获取到设备监控信息，现新增");
			equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(loginfo);
			equinfo.OnlineTime=DateTime.Now;
			equinfo.OnlineTime = DateTime.Now;
			isAddEquipmentCurrentMonitor = true;
			}
			else
			{//更新工件
			equinfo.WorkPieceID = loginfo.WorkPieceID;
			equinfo.UpdatedUserName = loginfo.MonitoringPoint;
			equinfo.UpdatedTime = DateTime.Now;
			equinfo.UpdatedTime = DateTime.Now;
			equinfo.OnlineTime = DateTime.Now;
			}
			if (isAddEquipmentCurrentMonitor)
			@@ -345,7 +355,7 @@

			}
			}
			catch(Exception e)
			catch (Exception e)
			{
			loginfo.Remarks = (loginfo.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			}
			@@ -393,7 +403,7 @@
			{
			return loginfo;
			}
			loginfo.QualityOP40To1 = ((StandardValue + oldvalue*1.0/ cofOP40.DecimalPlaces).ToString());
			loginfo.QualityOP40To1 = ((StandardValue + oldvalue * 1.0 / cofOP40.DecimalPlaces).ToString());
			//+(string.IsNullOrEmpty(cofOP40.Unit) ? "" : cofOP40.Unit)
			}
			break;
			@@ -409,7 +419,7 @@
			{
			return loginfo;
			}
			loginfo.QualityOP20To1 = ((StandardValue + oldvalue * 1.0 / cofOP20.DecimalPlaces).ToString());
			loginfo.QualityOP20To1 = ((StandardValue + oldvalue * 1.0 / cofOP20.DecimalPlaces).ToString());
			}
			break;
			case "OP60":
			@@ -445,7 +455,7 @@

			}
			}
			catch(Exception ex)
			catch (Exception ex)
			{

			}
			@@ -455,9 +465,9 @@
			/// <summary>
			/// 质量检测完成
			/// </summary>
			/// <param name="loginfo"></param>
			/// <param name="logMiddle"></param>
			/// <param name="type"></param>
			public static void QualityInfoComplete(WorkPieceLogMiddle loginfo, LogType type)
			public static void QualityInfoComplete(WorkPieceLogMiddle logMiddle, LogType type)
			{
			//此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
			//插入质量相关表QualityDataInfo
			@@ -467,79 +477,79 @@

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

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


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

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

			#region 更新设备实时表

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

			}
			}

			if (loginfo.QualityType!=null&& loginfo.QualityType.Equals(QualityType.SPC.ToString()))
			if (logMiddle.QualityType != null && logMiddle.QualityType.Equals(QualityType.SPC.ToString()))
			{//SPC反馈，
			if (loginfo.QualityState != (int)QualityState.OK)
			if (logMiddle.QualityState != (int)QualityState.OK)
			{
			//当某到工序检测到不合格工件时，从该工件加工完成时刻前指定时间起至报检不合格时间止，系统将该工件的最后加工工序在该时间段内加工的所有工件、正在加工的工件、该工序入口处的第一个工件全部标记为疑似状态，由人工复检工件并修改状态，并支持批量变更。
			//答复：在线测量不需要走这个流程，只有SPC抽检才需要，需要把这时间段的工件全部置为疑似，哪怕是已完成工件
			@@ -705,34 +774,117 @@
			//时间段结束时间：抽检工件质量结果出现后的时间
			//抽检工件工序扫描枪外入口处的第一个工件也把质量状态置为疑似
			//（每一工序SPC抽检是设置的固定的，比如200抽4，状态置为疑似时若工件还在设备内，会继续生产完毕后排出）

			//目前这块逻辑放到了 WebAPI中了

			}

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

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

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

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

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


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

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

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

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

			/// <summary>
			/// 工件推出NOOK
			/// </summary>
			@@ -781,9 +933,11 @@
			info.WorkingProcedureCompleted = info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
			info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
			}
			if(loginfo.WorkingProcedure.Equals("OP35"))
			QualityDataInfo qualityData = null;
			qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
			if (loginfo.WorkingProcedure.Equals("OP35"))
			{//为了解决OP35的采集到的质量信息是OK还NOOK的情况，OP35 NOOK时更新质量信息
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"OP35NOOK原质量信息{(info.QualityState.HasValue? info.QualityState.Value.ToString():"空")}";
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"OP35NOOK原质量信息{(info.QualityState.HasValue ? info.QualityState.Value.ToString() : "空")}";
			info.QualityState = (int)QualityState.NG;
			if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
			{
			@@ -795,7 +949,7 @@
			}
			loginfo.QualityState = info.QualityState;

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

			if (qualityData != null)
			{
			qualityData.OP35QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
			@@ -813,6 +967,8 @@
			pro.UpdatedTime = DateTimeHelper.GetDateTime();
			}

			QualityStateHelper.SetQualityStateForNoOk(ref info, ref pro, ref qualityData);

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

			}
			@@ -826,7 +982,7 @@
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			}



			db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
			db.SaveChanges();
			@@ -845,8 +1001,9 @@
			{
			WorkPieceLog loginfo2 = new WorkPieceLog();
			loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
			try {
			if ((loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
			try
			{
			if ((loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
			//\|\| !((loginfo.WorkingProcedure.Equals("OP10") \|\| loginfo.WorkingProcedure.Equals("OP40")) && loginfo.Remarks.Length > 0)
			)
			{
			@@ -860,7 +1017,7 @@
			}
			else
			{//更新表WorkPieceInfo
			if(loginfo.WorkingProcedure.Equals("OP10"))
			if (loginfo.WorkingProcedure.Equals("OP10"))
			{
			info.WorkPieceCurrentPosition = info.WorkingProcedureCurrent + "SPC";
			//var WorkingProcedure = (loginfo.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
			@@ -888,8 +1045,8 @@
			info.Remarks = "工件SPC抽检推出";

			//更新上一工序的结束时间
			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)
			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抽检结束";
			@@ -907,7 +1064,7 @@
			process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.UpdatedUserName = loginfo.MonitoringPoint;
			process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.Remarks = "工件SPC抽检推出";
			process.Remarks = "工件SPC抽检推出";
			db.WorkPieceProcess.Add(process);


			@@ -928,98 +1085,109 @@
			db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
			db.SaveChanges();
			}


			}
			}
			/// <summary>
			/// 工序完成
			/// </summary>
			/// <param name="loginfo"></param>
			/// <param name="logMiddle"></param>
			/// <param name="type"></param>
			public static void WorkingProcedureComplete(WorkPieceLogMiddle loginfo, LogType type)
			public static void WorkingProcedureComplete(WorkPieceLogMiddle logMiddle, LogType type)
			{

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

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

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

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

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

			//质检数据改为获取文件后修改【Editby shaocx,2024-06-15】
			/*
			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 == loginfo.WorkPieceID).FirstOrDefault();
			var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
			if (qualityData == null \|\| qualityData.WorkPieceID.Length < 1 \|\| qualityData.WorkingProcedure.Length < 1)
			{//插入QualityDataInfo表
			qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(loginfo);
			qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
			db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
			}
			//修改QualityDataInfo表 //重复收到质量信息，会覆盖之前的
			EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(loginfo, qualityData, GetQualityDataInfoUpdate(loginfo.WorkingProcedure, loginfo.MonitoringPoint));//指定修改字段
			EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(logMiddle, qualityData, GetQualityDataInfoUpdate(logMiddle, logMiddle.WorkingProcedure, logMiddle.MonitoringPoint));//指定修改字段

			//质检数据改为获取文件后修改【Editby shaocx,2024-06-15】
			/*
			qualityData.QualityStateUpdateUser = info.UpdatedUserName;
			qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
			qualityData.QualityStateUpdateMode = info.QualityStateUpdateMode;
			@@ -1036,31 +1204,32 @@
			{
			info.QualityErrorInfo = "";
			}
			//*/
			}
			else if(loginfo.WorkingProcedure.Equals("OP30"))
			else if (logMiddle.WorkingProcedure.Equals("OP30"))
			{

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

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

			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == info.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o=>o.StartTime).FirstOrDefault();
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID && o.WorkingProcedureCurrent == info.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			if (pro == null \|\| pro.WorkPieceID.Length < 1)
			{
			WorkPieceProcess process = new WorkPieceProcess();
			@@ -1084,14 +1253,26 @@
			process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			process.StartTime = DateTimeHelper.GetDateTime();
			process.EndTime = DateTimeHelper.GetDateTime();
			process.QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value : (int)QualityState.OK;
			process.CreatedUserName = loginfo.MonitoringPoint;
			if (logMiddle.WorkingProcedure.Equals("OP80"))
			{//OP80的质量数据是后来获取文件搞的
			}
			else
			{
			//不再默认赋值为合格【Editby shaocx,2024-08-16】
			//process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
			process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
			}
			process.CreatedUserName = logMiddle.MonitoringPoint;
			process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.UpdatedUserName = loginfo.MonitoringPoint;
			process.UpdatedUserName = logMiddle.MonitoringPoint;
			process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.OperationType = OperationType.生产.ToString();
			process.Remarks = "";
			if(op80id>0)
			if (logMiddle.WorkingProcedure.Equals("OP80"))
			{
			process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
			}
			if (op80id > 0)
			{
			process.QualityDataInfoID = op80id;
			}
			@@ -1104,8 +1285,15 @@
			pro.QualityDataInfoID = op80id;
			}
			pro.EndTime = DateTimeHelper.GetDateTime();
			pro.UpdatedUserName = loginfo.MonitoringPoint;
			pro.UpdatedUserName = logMiddle.MonitoringPoint;
			pro.UpdatedTime = DateTimeHelper.GetDateTime();
			if (logMiddle.WorkingProcedure.Equals("OP80"))
			{
			if (pro.GetQcDataFlag != 0)
			{
			pro.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
			}
			}
			}


			@@ -1117,14 +1305,14 @@
			}
			else
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"下线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
			Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工序下线读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"下线完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
			Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序下线读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

			}
			}
			catch (Exception e)
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{logMiddle.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			}
			db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
			db.SaveChanges();
			@@ -1144,25 +1332,26 @@
			using (DbModel db = new DbModel())
			{
			bool isAddAlert = false;
			try {
			try
			{

			var equipmentlist = db.EquipmentBaseInfo.Where(o=>o.IsDeleted==false).ToList();
			var equipmentlist = db.EquipmentBaseInfo.Where(o => o.IsDeleted == false).ToList();
			var alertlist = db.v_get_equipment_alert.Where(o => o.IsDeleted == false).ToList();
			var knifetoolbase = db.KnifeToolBaseInfo.Where(o => o.IsDeleted == false).ToList();
			var knifetoolinfo= db.KnifeToolEquipmentInfo.Where(o => o.IsDeleted == false).ToList();
			var knifetoolinfo = db.KnifeToolEquipmentInfo.Where(o => o.IsDeleted == false).ToList();
			//var knifelist = db.KnifeToolEquipmentInfo.GroupJoin(db.KnifeToolBaseInfo.Where(o => o.IsDeleted == false).ToList(), a => a.EquipmentID, b => b.EquipmentID, (a, b) => new { a,b})
			//.SelectMany(ab => ab.b.DefaultIfEmpty(), (ab, b) => new { ab.a, b.KnifeToolChangeAlertThreshold,b.KnifeToolLife })
			//.Where(o => o.a.IsDeleted == false)
			//.ToList();
			//.SelectMany(ab => ab.b.DefaultIfEmpty(), (ab, b) => new { ab.a, b.KnifeToolChangeAlertThreshold,b.KnifeToolLife })
			//.Where(o => o.a.IsDeleted == false)
			//.ToList();
			foreach (var item in equipmentlist)
			{
			try
			{
			var alert = alertlist.Where(o => o.EquipmentId.Equals(item.EquipmentId)).FirstOrDefault();
			if (alert==null\|\|alert.Id<1)
			if (alert == null \|\| alert.Id < 1)
			{
			alert = EntityPropHelper.Mapper<v_get_equipment_alert, EquipmentBaseInfo>(item);
			isAddAlert=true;
			isAddAlert = true;
			}
			//if(item.WorkingProcedure.Equals("OP70"))
			{
			@@ -1191,7 +1380,7 @@
			}
			//if (!item.WorkingProcedure.Equals("OP05")&& !item.WorkingProcedure.Equals("OP30") && !item.WorkingProcedure.Equals("OP70") && !item.WorkingProcedure.Equals("OP80"))
			{
			if(item.CuttingFluidChangeTime.HasValue)
			if (item.CuttingFluidChangeTime.HasValue)
			{
			if (item.CuttingFluidChangeTime.Value.AddDays(item.CuttingFluidChangeAlertThreshold).Date <= DateTime.Now.Date)
			{//切削液告警
			@@ -1214,10 +1403,10 @@
			}
			bool flag = false;
			string desc = $"设备【{item.EquipmentName}】";
			foreach (var knife in knifetoolinfo.Where(o=>o.EquipmentID.Equals(item.EquipmentId)))
			foreach (var knife in knifetoolinfo.Where(o => o.EquipmentID.Equals(item.EquipmentId)))
			{
			var list = knifetoolbase.Where(o => o.KnifeToolID.Equals(knife.KnifeToolID)).FirstOrDefault();
			if(list!=null)
			if (list != null)
			{
			if ((knife.CurrentLife + list.KnifeToolChangeAlertThreshold) >= list.KnifeToolLife)
			{//刀具告警
			@@ -1228,7 +1417,7 @@
			}
			}
			}
			if(!flag)
			if (!flag)
			{//没有刀具告警
			alert.IsAlertKnifeTool = false;
			alert.KnifeToolDesc = "";
			@@ -1247,7 +1436,7 @@
			}
			else
			{
			if(string.IsNullOrEmpty(info.Alertmsg))
			if (string.IsNullOrEmpty(info.Alertmsg))
			{
			alert.IsAlert = false;
			alert.AlertDesc = "";
			@@ -1262,7 +1451,8 @@
			{
			db.v_get_equipment_alert.Add(alert);
			}
			}catch(Exception ex)
			}
			catch (Exception ex)
			{

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





			//db.WorkPieceLog.Add(loginfo2);//插入设备采集日志表
			db.SaveChanges();
			@@ -1335,9 +1525,9 @@
			string faultmsg = "";
			int i = 1;
			foreach (var failues in Failueslist)
			{
			{
			faultall += (failues + "\r\n");
			EquipmentFailureCode codeinfo = codelist.Where(o => o.Code == failues.ToString()).FirstOrDefault();
			EquipmentFailureCode codeinfo = codelist.Where(o => o.Code == failues.ToString()).FirstOrDefault();
			if (codeinfo != null && codeinfo.Code.Length > 0)
			{
			faultmsg += (i.ToString() + "." + (codeinfo.CodeDesc ?? codeinfo.Code) + "\r\n");
			@@ -1377,13 +1567,13 @@
			string alertall = "";
			string warnmsg = "";
			i = 1;
			foreach(var alert in Alertlist)
			foreach (var alert in Alertlist)
			{
			alertall+=(alert+"\r\n");
			var codeinfo=codelist.Where(o => o.Code == alert.ToString()).FirstOrDefault();
			if(codeinfo!=null&&codeinfo.Code.Length>0)
			alertall += (alert + "\r\n");
			var codeinfo = codelist.Where(o => o.Code == alert.ToString()).FirstOrDefault();
			if (codeinfo != null && codeinfo.Code.Length > 0)
			{
			warnmsg += (i.ToString()+"."+(codeinfo.CodeDesc ?? codeinfo.Code) + "\r\n");
			warnmsg += (i.ToString() + "." + (codeinfo.CodeDesc ?? codeinfo.Code) + "\r\n");
			}
			else
			{
			@@ -1456,7 +1646,7 @@
			info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
			info.WarnType = alertall;
			}
			if (info.EquipmentCurrentState==null\|\|(!info.EquipmentCurrentState.Equals(((int)EnumEquipmentCurrentStateDisplay.离线).ToString())))
			if (info.EquipmentCurrentState == null \|\| (!info.EquipmentCurrentState.Equals(((int)EnumEquipmentCurrentStateDisplay.离线).ToString())))
			{//如果设备状态为离线，则此处不需要判断任何信息
			if (loginfo.IsNormalProduction && !loginfo.LackMaterial && !loginfo.FullMaterial)
			{//自动运行状态+不缺料+不堵料
			@@ -1504,7 +1694,7 @@
			infolog.Remarks = "告警信息出现变更3";
			infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(State)).ToString()}\r\n";
			isAddEquipmentWorkingLog = true;
			isStatechange=true;
			isStatechange = true;
			}
			#endregion

			@@ -1538,7 +1728,7 @@

			//查找是否有未结束的告警
			var equlogalert = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
			&& o.WarnStartTime != null && o.WarnStartTime != DateTime.MinValue && (o.WarnEndTime == null\|\| o.WarnEndTime == DateTime.MinValue))
			&& o.WarnStartTime != null && o.WarnStartTime != DateTime.MinValue && (o.WarnEndTime == null \|\| o.WarnEndTime == DateTime.MinValue))
			.OrderByDescending(o => o.WarnStartTime).FirstOrDefault();
			if (loginfo.IsMessage)
			{//若有告警，如果有设备状态变更，肯定插入，此处只修改即可
			@@ -1722,13 +1912,13 @@
			info.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			db.EquipmentCurrentMonitor.Add(info);
			}
			if(isAddEquipmentWorkingLog)
			if (isAddEquipmentWorkingLog)
			{
			db.EquipmentWorkingLog.Add(infolog);
			}
			}
			catch (Exception e)
			{
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"{loginfo2.MonitoringPoint}设备监控更新数据异常{e.Message}.{e.StackTrace}";
			Log4NetHelper.WriteErrorLog(type, $"{loginfo2.MonitoringPoint}设备监控更新数据异常{e.Message}.{e.StackTrace}");
			}
			@@ -1777,13 +1967,13 @@
			info.UpdatedUserName = loginfo.MonitoringPoint;
			info.UpdatedTime = DateTime.Now;
			info.Alertmsg = "设备离线";
			info.AlertTime= DateTimeHelper.GetDateTime();
			info.AlertTime = DateTimeHelper.GetDateTime();
			info.FailureType = "";

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

			if (equlog == null)
			@@ -1810,7 +2000,7 @@
			}
			else
			{//最新状态为开机
			if(((int)EnumEquipmentCurrentStateDisplay.离线).ToString() == info.EquipmentCurrentState)
			if (((int)EnumEquipmentCurrentStateDisplay.离线).ToString() == info.EquipmentCurrentState)
			{//只有离线状态，才能变成开机
			state = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
			info.EquipmentCurrentState = state;
			@@ -1821,7 +2011,7 @@

			//有离线的数据，则更新
			var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
			&& o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue&& (o.EquipmentStateEndTime == null \|\| o.EquipmentStateEndTime == DateTime.MinValue)
			&& o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue && (o.EquipmentStateEndTime == null \|\| o.EquipmentStateEndTime == DateTime.MinValue)
			&& o.EquipmentState.Equals(((int)EnumEquipmentCurrentStateDisplay.离线).ToString())
			).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
			if (equlog != null)
			@@ -1874,13 +2064,13 @@
			using (DbModel db = new DbModel())
			{
			var info = db.ThreadStatusMonitor.Where(o => o.Threadcode == threadinfo.Threadcode).FirstOrDefault();
			if (info == null \|\| info.Id==0)
			if (info == null \|\| info.Id == 0)
			{//没有工件信息，不做更新
			threadinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			threadinfo.CreatedTime= DateTimeHelper.GetDateTime();
			threadinfo.CreatedTime = DateTimeHelper.GetDateTime();
			threadinfo.CreatedUserName = threadinfo.Threadcode;
			db.ThreadStatusMonitor.Add(threadinfo);


			}
			else
			{//更新表WorkPieceInfo
			@@ -1901,7 +2091,7 @@
			}

			}
			catch(Exception ex)
			catch (Exception ex)
			{

			}
			@@ -1910,11 +2100,11 @@
			#region 业务方法

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

			@@ -1929,11 +2119,20 @@
			{
			case "OP10":
			dict.Add("QualityOP10To1", "QualityOP10To1");

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

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

			switch (MonitoringPoint)
			{
			case "OP3002CH3":
			@@ -1962,13 +2161,24 @@
			case "OP35":
			dict.Add("QualityOP35To1", "QualityOP35To1");
			dict.Add("QualityOP35To2", "QualityOP35To2");

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

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

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

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

			break;
			case "OP70":
			dict.Add("QualityOP70To1", "QualityOP70To1");
			@@ -1987,11 +2197,103 @@
			dict.Add("QualityOP80To8", "QualityOP80To8");
			dict.Add("QualityOP80To9", "QualityOP80To9");
			dict.Add("QualityOP80To10", "QualityOP80To10");

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


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

			break;
			default:
			break;
			}
			return dict;
			}

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

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

			// }
			//}

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

			return dict;
			}

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

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

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

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

			return true;
			}


			@@ -2053,13 +2355,13 @@
			}
			/// <summary>
			/// 解析二维码


			/// </summary>
			/// <param name="loginfo"></param>
			/// <returns></returns>
			public static WorkPieceInfo ParseQRCode(WorkPieceInfo loginfo)
			{
			if(string.IsNullOrEmpty(loginfo.WorkPieceID)\|\| loginfo.WorkPieceID.Length!=22)
			if (string.IsNullOrEmpty(loginfo.WorkPieceID) \|\| loginfo.WorkPieceID.Length != 22)
			{
			return loginfo;
			}
			@@ -2072,6 +2374,250 @@
			loginfo.WorkPieceIDTo7 = loginfo.WorkPieceID.Substring(20, 2);
			return loginfo;
			}

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


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


			#endregion
			}
			}