DF22001YiQi.git

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


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

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

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

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

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


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

			process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;

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

			process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			process.CreatedUserName = loginfo.MonitoringPoint;
			process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.UpdatedUserName = loginfo.MonitoringPoint;
			process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.OperationType = OperationType.生产.ToString();
			process.Remarks = "";
			//特殊处理OP05上线，因为他是根据文本列表内容上线的【Editby shaocx,2024-09-03】
			if (loginfo.WorkingProcedure.Equals("OP05"))
			{
			process.EndTime = process.StartTime;
			}
			db.WorkPieceProcess.Add(process);

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

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

			if (!checkQualityInfoCompleteFlag \|\| info.QualityState != (int)QualityState.OK)
			var op05Proccss = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure).FirstOrDefault();
			if (op05Proccss != null)
			{
			plcFlag = false;
			message = !checkQualityInfoCompleteFlag ? "跳序，" : "";
			message += info.QualityState != (int)QualityState.OK ? "质量不符合" : "";
			isNeedAddNewProcess = false;//不需要新增了
			}
			////反馈给PLC，（写入点待定）
			//MessageModel fr = null;
			//fr = plcService.WriteValuePoint("", "", plcFlag, PLCManger.GetTypeForString("bool"));
			//if (fr.result)
			//{
			// Log4NetHelper.WriteInfoLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 成功，出现 {message}");
			//}
			//else
			//{
			// Log4NetHelper.WriteErrorLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 失败，出现 {message} ，失败原因：{fr.resMsg}");
			//}

			//#region 反馈PLC

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

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

			info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
			}
			#endregion

			#region 更新设备实时表

			bool isAddEquipmentCurrentMonitor = false;
			EquipmentCurrentMonitor equinfo = new EquipmentCurrentMonitor();
			equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == loginfo.EquipmentID).FirstOrDefault();
			if (equinfo == null \|\| equinfo.Id < 1)
			{//没有工件信息，不做更新
			Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.WorkingProcedure} 没有获取到设备监控信息，现新增");
			equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(loginfo);
			equinfo.OnlineTime = DateTime.Now;
			isAddEquipmentCurrentMonitor = true;
			}
			else
			{//更新工件
			equinfo.WorkPieceID = loginfo.WorkPieceID;
			equinfo.UpdatedUserName = loginfo.MonitoringPoint;
			equinfo.UpdatedTime = DateTime.Now;
			equinfo.OnlineTime = DateTime.Now;
			}
			if (isAddEquipmentCurrentMonitor)
			if (isNeedAddNewProcess)
			{
			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.Remarks ?? "") + $"上线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
			Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
			//每次扫描上线都插入追溯表
			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 ? "质量不符合" : "";
			}
			////反馈给PLC，（写入点待定）
			//MessageModel fr = null;
			//fr = plcService.WriteValuePoint("", "", plcFlag, PLCManger.GetTypeForString("bool"));
			//if (fr.result)
			//{
			// Log4NetHelper.WriteInfoLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 成功，出现 {message}");
			//}
			//else
			//{
			// Log4NetHelper.WriteErrorLog(type, $" 工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序反馈给PLC 失败，出现 {message} ，失败原因：{fr.resMsg}");
			//}

			//#region 反馈PLC

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

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

			info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
			}
			#endregion

			#region 更新设备实时表

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

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

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

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

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

			throw;
			}



			}

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

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

			@@ -491,18 +573,19 @@
			//EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
			if (!logMiddle.WorkingProcedure.Equals("OP05"))
			{//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
			pieceInfo.QualityState = (int)QualityState.Suspected;
			pieceInfo.QualityState = (int)QualityStateEnum.Suspected;
			pieceInfo.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
			pieceInfo.Remarks = $"工件二维码第一次出现的工序{logMiddle.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
			}
			else
			{
			pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值
			pieceInfo.QualityState = (int)QualityStateEnum.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
			pieceInfo.Remarks = "OP05新增工件信息";
			}
			pieceInfo.WorkPieceinitOnlineTime = DateTimeHelper.GetDateTime();
			pieceInfo.WorkingProcedurePlan = ConfigHelper.GetConfigString("WorkingProcedureAllStr") ?? "OP05OP10OP20OP30OP35OP40OP50OP60OP70OP80";
			pieceInfo.CreatedUserName = logMiddle.MonitoringPoint;
			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;
			@@ -513,7 +596,7 @@
			}
			else
			{
			loginfo2.Remarks = loginfo2.Remarks ?? "" + $"\|工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新";
			loginfo2.Remarks = $"\|工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新";
			Log4NetHelper.WriteErrorLog(type, $"工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新");
			return;
			}
			@@ -547,7 +630,7 @@
			else
			{//更新工件
			equinfo.WorkPieceID = logMiddle.WorkPieceID;
			equinfo.UpdatedUserName = logMiddle.MonitoringPoint;
			equinfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
			equinfo.UpdatedTime = DateTime.Now;
			equinfo.OnlineTime = DateTime.Now;
			}
			@@ -559,24 +642,27 @@
			#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 = pieceInfo.Remarks ?? "" + $"{logMiddle.WorkingProcedure}质量检测完成修改";
			pieceInfo.UpdatedUserName = logMiddle.MonitoringPoint;
			pieceInfo.Remarks = $"{logMiddle.WorkingProcedure}质量检测完成修改";
			pieceInfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
			SystemBussinessHelper.SetWorkPieceInfoMiddleForUpdateDataCapturePointCname(ref pieceInfo, logMiddle.DataCapturePointCname);
			pieceInfo.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			if (!(pieceInfo.WorkingProcedureStartTime.HasValue && pieceInfo.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
			{//工序开始时间没有则赋值
			pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
			}
			pieceInfo.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") \|\| logMiddle.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
			pieceInfo.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") \|\| logMiddle.QualityStateStr.Equals("0K")) ? QualityStateEnum.OK : QualityStateEnum.NG);
			//赋值不合格原因
			SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);


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

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

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

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

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

			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID && o.WorkingProcedureCurrent == pieceInfo.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID
			//修正：查询的工序是当前线程的工序，而不是当前数据的工序【Editby shaocx,2024-09-03】
			//&& o.WorkingProcedureCurrent == pieceInfo.WorkingProcedureCurrent
			&& o.WorkingProcedureCurrent == logMiddle.WorkingProcedure
			&& o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			if (pro == null \|\| pro.WorkPieceID.Length < 1 \|\| logMiddle.MonitoringPoint.Equals("OP1002") \|\| logMiddle.MonitoringPoint.Equals("OP1003") \|\| logMiddle.MonitoringPoint.Contains("OP2002"))
			{// OP10 没有上线扫码枪，约定用测量完成信号当上线标记，所以上线需要修改的字段放这里
			//上线是每次都插入
			//上线是每次都插入

			WorkPieceProcess process_05 = WorkPieceProcessHelper.CreateWorkPieceProcessForOP05(logMiddle, db, pieceInfo);
			if (process_05 != null)
			{//创建OP05工序，当没有05工序时,才创建【Editby shaocx,2024-08-29】
			db.WorkPieceProcess.Add(process_05);
			}

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

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


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

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

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

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

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

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

			if (logMiddle.QualityType != null && logMiddle.QualityType.Equals(QualityType.SPC.ToString()))
			{//SPC反馈，
			if (logMiddle.QualityState != (int)QualityState.OK)
			if (logMiddle.QualityState != (int)QualityStateEnum.OK)
			{
			//当某到工序检测到不合格工件时，从该工件加工完成时刻前指定时间起至报检不合格时间止，系统将该工件的最后加工工序在该时间段内加工的所有工件、正在加工的工件、该工序入口处的第一个工件全部标记为疑似状态，由人工复检工件并修改状态，并支持批量变更。
			//答复：在线测量不需要走这个流程，只有SPC抽检才需要，需要把这时间段的工件全部置为疑似，哪怕是已完成工件
			@@ -773,24 +883,107 @@
			}
			else
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量检测完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
			loginfo2.Remarks = $"质量检测完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
			Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序监控读码标记读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");

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

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

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

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


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

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

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

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

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

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

			if (qualityData != null)
			{
			qualityData.OP35QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
			@@ -862,27 +1074,53 @@
			}
			}
			//更新上一工序的结束时间
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID
			&& o.WorkingProcedureCurrent == loginfo.WorkingProcedure && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			if (pro != null && pro.WorkPieceID.Length > 0)
			{
			pro.EndTime = DateTimeHelper.GetDateTime();
			pro.Remarks = (pro.Remarks ?? "") + "NOOK结束";
			pro.Remarks = "NOOK结束";
			pro.UpdatedUserName = loginfo.MonitoringPoint;
			pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
			pro.UpdatedTime = DateTimeHelper.GetDateTime();
			}
			else
			{//如果找不到就新建【Editby shaocx,2024-09-03】
			WorkPieceProcess add_process = new WorkPieceProcess();
			add_process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(cur_db_info);
			QualityStateHelper.ResetQualityNoOkForNewProcess(ref add_process);
			add_process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			add_process.StartTime = DateTimeHelper.GetDateTime().AddSeconds(-SystemBussinessHelper.MoNiTimeForWorkingProcedure(loginfo.WorkingProcedure));
			add_process.EndTime = DateTimeHelper.GetDateTime();
			//不再默认赋值为合格【Editby shaocx,2024-08-16】
			add_process.QualityState = WorkPieceInfoManager.GetQualityStateValue(loginfo.QualityState);

			db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
			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 = (loginfo2.Remarks ?? "") + $"工件NOOK推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
			loginfo2.Remarks = $"工件NOOK推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
			Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件NOOK推出读码标记读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
			}
			}
			catch (Exception e)
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			loginfo2.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			}


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


			info.WorkingProcedureCompleted = info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
			info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
			cur_db_info.WorkingProcedureCompleted = cur_db_info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
			cur_db_info.WorkPieceCurrentPositionOrder = cur_db_info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
			}
			info.Remarks = "工件SPC抽检推出";
			cur_db_info.Remarks = "工件SPC抽检推出";
			loginfo2.Remarks = cur_db_info.Remarks;

			//更新上一工序的结束时间
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure
			&& o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			if (pro != null && pro.WorkPieceID.Length > 0)
			{
			pro.EndTime = DateTimeHelper.GetDateTime();
			pro.Remarks = (pro.Remarks ?? "") + "SPC抽检结束";
			pro.UpdatedUserName = loginfo.MonitoringPoint;
			pro.UpdateDataCapturePointCname = loginfo.DataCapturePointCname;
			pro.UpdatedTime = DateTimeHelper.GetDateTime();
			}
			//每次SPC 都插入追溯表
			WorkPieceProcess process = new WorkPieceProcess();
			process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
			process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(cur_db_info);
			QualityStateHelper.ResetQualityNoOkForNewProcess(ref process);
			process.StartTime = DateTimeHelper.GetDateTime();
			process.OperationType = OperationType.SPC.ToString();
			process.QualityState = (int)QualityState.Suspected;
			process.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(info));
			db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(cur_db_info));
			}
			else
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"工件SPC抽检推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
			loginfo2.Remarks = $"工件SPC抽检推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
			Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件SPC抽检推出读码标记读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
			}
			}
			catch (Exception e)
			{
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			loginfo2.Remarks = $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
			}
			finally
			{
			@@ -990,6 +1246,37 @@

			}
			}


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

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

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

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

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

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

			//质检数据改为获取文件后修改【Editby shaocx,2024-06-15】
			/*
			@@ -1078,6 +1369,7 @@
			info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
			info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
			//*/


			var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
			if (qualityData == null \|\| qualityData.WorkPieceID.Length < 1 \|\| qualityData.WorkingProcedure.Length < 1)
			@@ -1107,15 +1399,17 @@
			info.QualityErrorInfo = "";
			}
			//*/

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

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

			var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
			if (qualityData == null \|\| qualityData.WorkPieceID.Length < 1 \|\| qualityData.WorkingProcedure.Length < 1)
			@@ -1123,69 +1417,92 @@
			qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
			db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
			}
			qualityData.QualityStateUpdateUser = info.UpdatedUserName;
			qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
			qualityData.QualityStateUpdateMode = info.QualityStateUpdateMode;
			qualityData.QualityStateUpdateUser = db_info.UpdatedUserName;
			qualityData.QualityReceiveTime = db_info.UpdatedTime.Value.LocalDateTime;
			qualityData.QualityStateUpdateMode = db_info.QualityStateUpdateMode;
			qualityData.OP30QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
			qualityData.OP30QualityReceiveTime = DateTimeHelper.GetDateTime();
			loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{logMiddle.QualityStateStr ?? "空"}";
			if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
			if (!db_info.QualityState.Equals(((int)QualityStateEnum.OK).ToString()))
			{
			info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
			db_info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
			}
			else
			{
			info.QualityErrorInfo = "";
			db_info.QualityErrorInfo = "";
			}
			}
			else
			{
			info.WorkPieceState = (int)WorkPieceState.WIP;
			if (info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= info.WorkingProcedurePlan.Length)
			//这里修复OP10、OP40 因为PLC先推 SPC推出、再推产品下线问题，导致产品下线更新数据时，把SPC数据覆盖的问题【Editby shaocx,2024-08-27】
			var isAlow = SystemBussinessHelper.IsAllowUpdateWorkPieceStateToWip(db_info, db, logMiddle);
			if (isAlow)
			{
			info.WorkPieceCurrentPosition = info.WorkingProcedurePlan.Substring(info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure), 8);
			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 == info.WorkingProcedureCurrent && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID
			&& o.WorkingProcedureCurrent == db_info.WorkingProcedureCurrent
			&& o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
			if (pro == null \|\| pro.WorkPieceID.Length < 1)
			{
			WorkPieceProcess process = new WorkPieceProcess();
			process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
			process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			process.StartTime = DateTimeHelper.GetDateTime();
			process.EndTime = DateTimeHelper.GetDateTime();
			WorkPieceProcess add_process = new WorkPieceProcess();
			add_process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(db_info);
			QualityStateHelper.ResetQualityNoOkForNewProcess(ref add_process);
			add_process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
			add_process.StartTime = DateTimeHelper.GetDateTime().AddSeconds(-SystemBussinessHelper.MoNiTimeForWorkingProcedure(logMiddle.WorkingProcedure));
			add_process.EndTime = DateTimeHelper.GetDateTime();
			if (logMiddle.WorkingProcedure.Equals("OP80"))
			{//OP80的质量数据是后来获取文件搞的
			//质检数据，再考虑另外两种状态【Editby shaocx,2024-08-27】
			QualityStateHelper.SetQualityStateForOP80(logMiddle, ref db_info, ref add_process);
			}
			else
			{
			process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;
			//不再默认赋值为合格【Editby shaocx,2024-08-16】
			//process.QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
			add_process.QualityState = WorkPieceInfoManager.GetQualityStateValue(logMiddle.QualityState);
			}
			process.CreatedUserName = logMiddle.MonitoringPoint;
			process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.UpdatedUserName = logMiddle.MonitoringPoint;
			process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			process.OperationType = OperationType.生产.ToString();
			process.Remarks = "";
			add_process.CreatedUserName = logMiddle.MonitoringPoint;
			add_process.DataCapturePointCname = logMiddle.DataCapturePointCname;
			add_process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			add_process.UpdatedUserName = logMiddle.MonitoringPoint;
			add_process.UpdateDataCapturePointCname = logMiddle.DataCapturePointCname;
			add_process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
			add_process.OperationType = OperationType.生产.ToString();
			add_process.Remarks = "";
			add_process.MyRemarks = "工序完成时，如果找不到就新建";
			if (logMiddle.WorkingProcedure.Equals("OP80"))
			{
			process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
			add_process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
			}
			if (op80id > 0)
			{
			process.QualityDataInfoID = op80id;
			add_process.QualityDataInfoID = op80id;
			}
			db.WorkPieceProcess.Add(process);
			db.WorkPieceProcess.Add(add_process);
			}
			else
			{
			if (logMiddle.WorkingProcedure.Equals("OP80"))
			{//OP80的质量数据是后来获取文件搞的
			//质检数据，再考虑另外两种状态【Editby shaocx,2024-08-27】
			QualityStateHelper.SetQualityStateForOP80(logMiddle, ref 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"))
			{
			@@ -1199,20 +1516,20 @@

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

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

			@@ -2153,13 +2470,47 @@

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

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

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

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

			return true;
			}


			@@ -2248,9 +2599,11 @@
			public static void SetLogMiddleForQuality(ref WorkPieceLogMiddle logMiddle)
			{

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

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

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

			@@ -2396,34 +2749,62 @@
			return qualityState;
			}
			else if (logMiddle.WorkingProcedure == "OP10")
			{
			if (logMiddle.QualityState == (int)QualityState.NG)
			{//合格/不合格由 QualityStateStr值判断
			if (logMiddle.QualityState == (int)QualityStateEnum.NG)
			{
			qualityNoOkEnum = QualityNoOkEnum.OP10厚度超差;
			}
			else
			{
			qualityState = QualityStateEnum.OK;
			}
			return qualityState;
			}
			else if (logMiddle.WorkingProcedure == "OP20")
			{
			if (logMiddle.QualityState == (int)QualityState.NG)
			{//合格/不合格由 QualityStateStr值判断
			if (logMiddle.QualityState == (int)QualityStateEnum.NG)
			{
			qualityNoOkEnum = QualityNoOkEnum.OP20小头孔直径超差;
			}
			else
			{
			qualityState = QualityStateEnum.OK;
			}
			return qualityState;
			}
			else if (logMiddle.WorkingProcedure == "OP30")
			{//合格/不合格由 QualityStateStr值判断
			if (logMiddle.QualityStateStr.Equals("OK"))
			{
			qualityState = QualityStateEnum.OK;
			}
			else
			{
			qualityState = QualityStateEnum.NG;
			}
			return qualityState;
			}
			else if (logMiddle.WorkingProcedure == "OP35")
			{
			if (logMiddle.QualityState == (int)QualityState.NG)
			{//合格/不合格由 QualityStateStr值判断
			if (logMiddle.QualityState == (int)QualityStateEnum.NG)
			{
			qualityNoOkEnum = QualityNoOkEnum.OP35滚压力不合格;
			qualityNoOkEnum = QualityNoOkEnum.OP35滚压力超差;
			}
			else
			{
			qualityState = QualityStateEnum.OK;
			}
			return qualityState;
			}
			else if (logMiddle.WorkingProcedure == "OP40")
			{
			if (logMiddle.QualityState == (int)QualityState.NG)
			{//合格/不合格由 QualityStateStr值判断
			if (logMiddle.QualityState == (int)QualityStateEnum.NG)
			{
			qualityNoOkEnum = QualityNoOkEnum.OP40厚度超差;
			}
			else
			{
			qualityState = QualityStateEnum.OK;
			}
			return qualityState;
			}
			@@ -2431,6 +2812,29 @@
			}


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


			#endregion
			}
			}