using iWare_SCADA_BusinessLogical.Utils;
|
using iWare_SCADA_Model;
|
using iWare_SCADA_Model.MiddleModel;
|
using iWare_SCADA_Model.TableModel;
|
using log4net;
|
using System;
|
using System.Collections.Concurrent;
|
using System.Collections.Generic;
|
using System.ComponentModel.DataAnnotations;
|
using System.Diagnostics;
|
//using System.Data.Entity.Infrastructure;
|
using System.Linq;
|
using System.Reflection;
|
using System.Text;
|
using System.Threading.Tasks;
|
using System.Web.UI.WebControls;
|
using System.Windows.Forms;
|
using static System.Windows.Forms.AxHost;
|
|
namespace iWare_SCADA_BusinessLogical.BLL
|
{
|
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 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;
|
}
|
|
/// <summary>
|
/// 给WorkPieceLog主键等公共的的属性赋值
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <returns></returns>
|
public static WorkPieceLog GetAddWorkPieceLog(WorkPieceLog loginfo)
|
{
|
loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
return loginfo;
|
}
|
public static WorkPieceLog GetAddWorkPieceLog1(WorkPieceLogMiddle loginfo)
|
{
|
loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
return loginfo;
|
}
|
/// <summary>
|
/// 通过WorkPieceInfo 给WorkPieceInfoLog 属性赋值
|
/// </summary>
|
/// <param name="wpinfo"></param>
|
/// <returns></returns>
|
public static WorkPieceInfoLog GetAddWorkPieceInfoLog(WorkPieceInfo wpinfo)
|
{
|
WorkPieceInfoLog infolog = EntityPropHelper.Mapper<WorkPieceInfoLog, WorkPieceInfo>(wpinfo);
|
infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
infolog.WorkPieceInfoID = wpinfo.Id;
|
infolog.LogAddTime = DateTime.Now;
|
return infolog;
|
}
|
/// <summary>
|
/// 给QualityDataInfo主键等公共的的属性赋值
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <returns></returns>
|
public static QualityDataInfo GetAddQualityDataInfo(QualityDataInfo qdinfo)
|
{
|
qdinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
return qdinfo;
|
}
|
/// <summary>
|
/// 通过QualityDataInfo 给QualityDataInfoLog 属性赋值
|
/// </summary>
|
/// <param name="wpinfo"></param>
|
/// <returns></returns>
|
public static QualityDataInfoLog GetAddQualityDataInfoLog(QualityDataInfo qdinfo)
|
{
|
QualityDataInfoLog infolog = EntityPropHelper.Mapper<QualityDataInfoLog, QualityDataInfo>(qdinfo);
|
infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
return infolog;
|
}
|
public static void test()
|
{
|
using (DbModel db = new DbModel())
|
{
|
//WorkPieceLogMiddle a = new WorkPieceLogMiddle();
|
//a.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
//a.WorkPieceID="test01"+ new Random().Next(4).ToString();
|
//a.QualityType = QualityType.SPC.ToString();
|
|
//if(a.QualityType.Equals(QualityType.SPC.ToString()))
|
//{
|
// a.Remarks = "SPC";
|
//}
|
//else
|
//{
|
// a.Remarks = "AUTO";
|
//}
|
|
//WorkPieceLog b = new WorkPieceLog();
|
//b.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
//b.WorkPieceID = "testxxx" + new Random().Next(0,1000).ToString();
|
//b.QualityType = QualityType.SPC.ToString();
|
//b.Remarks = "SPC insert into";
|
//b.QualityState = 2;
|
//b.QualityStateUpdateMode = "heheh";
|
//db.WorkPieceLog.Add(b);
|
|
|
//db.SaveChanges();
|
|
}
|
|
}
|
/// <summary>
|
/// 根据设备id更新刀具寿命信息（目前设定每生产一个工件，所有刀具寿命都会减1）
|
/// </summary>
|
/// <param name="db"></param>
|
/// <param name="loginfo"></param>
|
public static void UpdateKnifeToolLift(DbModel db, WorkPieceLog loginfo)
|
{
|
try
|
{
|
var info = db.KnifeToolEquipmentInfo.Where(o => o.EquipmentID.Equals(loginfo.EquipmentID)).ToList();
|
foreach (var item in info)
|
{
|
item.CurrentLife++;
|
item.UpdatedTime = DateTime.Now;
|
}
|
|
}
|
catch (Exception ex)
|
{
|
loginfo.Remarks = (loginfo.Remarks ?? "") + $"{loginfo.WorkPieceID ?? "空"}刀具寿命更新数据异常{ex.Message}";
|
|
}
|
}
|
|
/// <summary>
|
/// 读取二维码时逻辑
|
/// 校验工件是否跳序，质量是否合格
|
/// </summary>
|
public static void ReadQRcode(WorkPieceLog loginfo, LogType type, PLCService plcService, int? IsFeedback)
|
{//此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
|
using (DbModel db = new DbModel())
|
{
|
try
|
{
|
bool isAddWorkPieceInfo = false;
|
if (loginfo.WorkPieceID.Length == 22)
|
{
|
WorkPieceInfo info = new WorkPieceInfo();
|
info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
|
if (info == null || info.WorkPieceID.Length < 1)
|
{//插入WorkPieceInfo表
|
loginfo = CommonManager.Instance.GetWorkPieceID(loginfo, type);
|
info = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLog>(loginfo);
|
//EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
|
if (!loginfo.WorkingProcedure.Equals("OP05"))
|
{//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
|
info.QualityState = (int)QualityState.Suspected;
|
info.QualityErrorInfo = $"工件二维码第一次出现的工序{loginfo.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
|
info.Remarks = $"工件二维码第一次出现的工序{loginfo.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
|
}
|
else
|
{
|
info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
|
info.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 = ParseQRCode(info);
|
isAddWorkPieceInfo = true;
|
}
|
else
|
{
|
if (info.WorkingProcedureCurrent.Equals("OP05"))
|
{
|
loginfo.Remarks = (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}工件上线";
|
|
//修复下 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)
|
{
|
if (pro.WorkingProcedureCurrent == loginfo.WorkingProcedure)
|
{//表示工序相同
|
isNeedAddNewProcess = false;
|
pro.Remarks = (pro.Remarks ?? "") + "又一次上线，更新结束时间";
|
}
|
else
|
{
|
pro.EndTime = DateTimeHelper.GetDateTime();
|
pro.UpdatedUserName = loginfo.MonitoringPoint;
|
pro.UpdatedTime = DateTimeHelper.GetDateTime();
|
pro.Remarks = (pro.Remarks ?? "") + "又一次上线，更新结束时间";
|
}
|
}
|
if (isNeedAddNewProcess)
|
{
|
//每次扫描上线都插入追溯表
|
WorkPieceProcess new_process = new WorkPieceProcess();
|
new_process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
|
new_process.StartTime = DateTimeHelper.GetDateTime();
|
|
//不再默认赋值为合格 【Editby shaocx,2024-08-16】
|
//process.QualityState = info.QualityState.HasValue ? info.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
|
new_process.QualityState = GetQualityStateValue(info.QualityState);
|
|
if (new_process.WorkingProcedureCurrent == WorkingProcedureForHMI.OP70.ToString())
|
{ //特殊处理OP70，因为OP70没有测量，默认合格 [Editby shaocx,2024-07-03]
|
new_process.QualityState = (int)QualityState.OK;//默认合格，OP70默认是合格
|
}
|
|
new_process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
new_process.CreatedUserName = loginfo.MonitoringPoint;
|
new_process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
new_process.UpdatedUserName = loginfo.MonitoringPoint;
|
new_process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
new_process.OperationType = OperationType.生产.ToString();
|
new_process.Remarks = "";
|
if (loginfo.WorkingProcedure.Equals("OP05"))
|
{
|
new_process.EndTime = new_process.StartTime;
|
}
|
db.WorkPieceProcess.Add(new_process);
|
}
|
|
//db.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)
|
{
|
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(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.Remarks ?? "") + $"上线完成读取二维码{loginfo.WorkPieceID ?? "空"}异常";
|
Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}上线监控读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
|
|
}
|
}
|
catch (Exception e)
|
{
|
loginfo.Remarks = (loginfo.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
|
}
|
finally
|
{
|
loginfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
db.WorkPieceLog.Add(loginfo);
|
db.SaveChanges();
|
|
}
|
|
}
|
}
|
public static WorkPieceLogMiddle QualityDataHand(WorkPieceLogMiddle loginfo, List<EquipmentQualityConfig> qcofig)
|
{
|
try
|
{
|
switch (loginfo.WorkingProcedure)
|
{
|
case "OP10":
|
var cof = qcofig.Where(o => o.ParamColName.Equals("QualityOP10To1")).FirstOrDefault();
|
if (cof != null && cof.Id > 0)
|
{
|
double oldvalue = 0;
|
double StandardValue = 0;
|
var flag1 = double.TryParse(loginfo.QualityOP10To1, out oldvalue);
|
var flag2 = double.TryParse(cof.StandardValue, out StandardValue);
|
if (!flag1 || !flag2)
|
{
|
return loginfo;
|
}
|
loginfo.QualityOP10To1 = ((StandardValue + oldvalue * 1.0 / cof.DecimalPlaces).ToString());
|
//+(string.IsNullOrEmpty(cof.Unit) ? "" : cof.Unit)
|
}
|
break;
|
case "OP40":
|
var cofOP40 = qcofig.Where(o => o.ParamColName.Equals("QualityOP40To1")).FirstOrDefault();
|
if (cofOP40 != null && cofOP40.Id > 0)
|
{
|
double oldvalue = 0;
|
double StandardValue = 0;
|
var flag1 = double.TryParse(loginfo.QualityOP40To1, out oldvalue);
|
var flag2 = double.TryParse(cofOP40.StandardValue, out StandardValue);
|
if (!flag1 || !flag2)
|
{
|
return loginfo;
|
}
|
loginfo.QualityOP40To1 = ((StandardValue + oldvalue * 1.0 / cofOP40.DecimalPlaces).ToString());
|
//+(string.IsNullOrEmpty(cofOP40.Unit) ? "" : cofOP40.Unit)
|
}
|
break;
|
case "OP20":
|
var cofOP20 = qcofig.Where(o => o.ParamColName.Equals("QualityOP20To1")).FirstOrDefault();
|
if (cofOP20 != null && cofOP20.Id > 0)
|
{
|
double oldvalue = 0;
|
double StandardValue = 0;
|
var flag1 = double.TryParse(loginfo.QualityOP20To1, out oldvalue);
|
var flag2 = double.TryParse(cofOP20.StandardValue, out StandardValue);
|
if (!flag1 || !flag2)
|
{
|
return loginfo;
|
}
|
loginfo.QualityOP20To1 = ((StandardValue + oldvalue * 1.0 / cofOP20.DecimalPlaces).ToString());
|
}
|
break;
|
case "OP60":
|
var cofOP60to1 = qcofig.Where(o => o.ParamColName.Equals("QualityOP60To1")).FirstOrDefault();
|
if (cofOP60to1 != null && cofOP60to1.Id > 0)
|
{
|
double oldvalue = 0;
|
double StandardValue = 0;
|
var flag1 = double.TryParse(loginfo.QualityOP60To1, out oldvalue);
|
var flag2 = double.TryParse(cofOP60to1.StandardValue, out StandardValue);
|
if (!flag1 || !flag2)
|
{
|
return loginfo;
|
}
|
loginfo.QualityOP60To1 = ((StandardValue + oldvalue * 1.0 / cofOP60to1.DecimalPlaces).ToString());
|
}
|
var cofOP60to2 = qcofig.Where(o => o.ParamColName.Equals("QualityOP60To2")).FirstOrDefault();
|
if (cofOP60to2 != null && cofOP60to2.Id > 0)
|
{
|
double oldvalue = 0;
|
double StandardValue = 0;
|
var flag1 = double.TryParse(loginfo.QualityOP60To2, out oldvalue);
|
var flag2 = double.TryParse(cofOP60to2.StandardValue, out StandardValue);
|
if (!flag1 || !flag2)
|
{
|
return loginfo;
|
}
|
loginfo.QualityOP60To2 = ((StandardValue + oldvalue * 1.0 / (10 * cofOP60to2.DecimalPlaces)).ToString() + (string.IsNullOrEmpty(cofOP60to2.Unit) ? "" : cofOP60to2.Unit));
|
}
|
break;
|
default:
|
break;
|
|
}
|
}
|
catch (Exception ex)
|
{
|
|
}
|
return loginfo;
|
}
|
|
/// <summary>
|
/// 质量检测完成
|
/// </summary>
|
/// <param name="logMiddle"></param>
|
/// <param name="type"></param>
|
public static void QualityInfoComplete(WorkPieceLogMiddle logMiddle, LogType type)
|
{
|
//根据质量数据判断是否合格/不合格 【Editby shaocx,2024-06-25】
|
WorkPieceInfoManager.SetLogMiddleForQuality(ref logMiddle);
|
|
//此处同时插入了WorkPieceLog，WorkPieceInfoLog表，并新增或修改WorkPieceInfo表
|
//插入质量相关表QualityDataInfo
|
|
using (DbModel db = new DbModel())
|
{
|
|
bool isAddWorkPieceInfo = false;
|
WorkPieceLog loginfo2 = new WorkPieceLog();
|
loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(logMiddle);
|
try
|
{
|
|
if (logMiddle.WorkPieceID.Length == 22)
|
{//获取到的工件号异常
|
WorkPieceInfo pieceInfo = new WorkPieceInfo();
|
pieceInfo = db.WorkPieceInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
|
if (pieceInfo == null || pieceInfo.WorkPieceID.Length < 1)
|
{//没有工件信息，不做更新
|
if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
|
{//OP10 没有上线扫码枪，约定用测量完成信号当上线标记
|
pieceInfo = EntityPropHelper.Mapper<WorkPieceInfo, WorkPieceLogMiddle>(logMiddle);
|
//EntityPropHelper<WorkPieceLog, WorkPieceInfo>.CopyProp(loginfo, info, loginfo.GetWorkPieceInfoDict());
|
if (!logMiddle.WorkingProcedure.Equals("OP05"))
|
{//当工件二维码第一次出现的工序不是OP05，则设置为可疑状态
|
pieceInfo.QualityState = (int)QualityState.Suspected;
|
pieceInfo.QualityErrorInfo = $"工件二维码第一次出现的工序{logMiddle.MonitoringPoint}不是OP05,数据缺失,请确认情况并做相应处理！";
|
pieceInfo.Remarks = $"工件二维码第一次出现的工序{logMiddle.WorkingProcedure}不是OP05,数据缺失,请确认情况并做相应处理！";
|
}
|
else
|
{
|
pieceInfo.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
|
pieceInfo.Remarks = "OP05新增工件信息";
|
}
|
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 ?? "" + $"|工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新";
|
Log4NetHelper.WriteErrorLog(type, $"工件{logMiddle.WorkPieceID} 质量检测完成工序{logMiddle.MonitoringPoint} 没有获取到工件信息不做更新");
|
return;
|
}
|
}
|
if (logMiddle.MonitoringPoint.Equals("OP1002") || logMiddle.MonitoringPoint.Equals("OP1003") || logMiddle.MonitoringPoint.Contains("OP2002"))
|
{// OP10 没有上线扫码枪，约定用测量完成信号当上线标记，所以上线需要修改的字段放这里
|
|
if (logMiddle.WorkingProcedure.Equals("OP10"))
|
{
|
var WorkingProcedure = (logMiddle.MonitoringPoint.Equals("OP1002") ? "OP10" : "OP40");
|
loginfo2.WorkingProcedure = WorkingProcedure;//解决OP10，OP40同一个的问题
|
logMiddle.WorkingProcedure = WorkingProcedure;//解决OP10，OP40同一个的问题
|
}
|
pieceInfo.WorkPieceCurrentPosition = logMiddle.WorkingProcedure;
|
pieceInfo.WorkPieceCurrentPositionOrder = pieceInfo.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) / 2;
|
pieceInfo.WorkingProcedureCurrent = logMiddle.WorkingProcedure;
|
pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
|
|
#region 更新设备实时表
|
|
bool isAddEquipmentCurrentMonitor = false;
|
EquipmentCurrentMonitor equinfo = new EquipmentCurrentMonitor();
|
equinfo = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == logMiddle.EquipmentID).FirstOrDefault();
|
if (equinfo == null || equinfo.Id < 1)
|
{//没有工件信息，不做更新
|
Log4NetHelper.WriteErrorLog(type, $"设备{logMiddle.EquipmentID} 告警监控{logMiddle.WorkingProcedure} 没有获取到设备监控信息，现新增");
|
equinfo = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLog>(logMiddle);
|
equinfo.OnlineTime = DateTime.Now;
|
isAddEquipmentCurrentMonitor = true;
|
}
|
else
|
{//更新工件
|
equinfo.WorkPieceID = logMiddle.WorkPieceID;
|
equinfo.UpdatedUserName = ResetUpdatedUserName(logMiddle);
|
equinfo.UpdatedTime = DateTime.Now;
|
equinfo.OnlineTime = DateTime.Now;
|
}
|
if (isAddEquipmentCurrentMonitor)
|
{
|
equinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
db.EquipmentCurrentMonitor.Add(equinfo);
|
}
|
#endregion
|
//UpdateKnifeToolLift(db, loginfo);//更新刀具寿命信息
|
}
|
pieceInfo.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")))
|
{//工序开始时间没有则赋值
|
pieceInfo.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
|
}
|
pieceInfo.QualityState = (int)((logMiddle.QualityStateStr.Equals("OK") || logMiddle.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
|
//赋值不合格原因
|
SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
|
|
|
if (!pieceInfo.QualityState.Equals(((int)QualityState.OK).ToString()))
|
{
|
pieceInfo.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格{pieceInfo.QualityState}";
|
}
|
else
|
{
|
pieceInfo.QualityErrorInfo = "";
|
}
|
logMiddle.QualityState = pieceInfo.QualityState;
|
if (isAddWorkPieceInfo)
|
{
|
db.WorkPieceInfo.Add(pieceInfo);
|
}
|
|
#region 根据标准值更新最新质量数据（OP10/OP40/OP20/OP60）
|
var qcofig = db.EquipmentQualityConfig.Where(o => o.WorkingProcedure.Equals(logMiddle.WorkingProcedure) && o.ParamType != 1 && o.IsDeleted == false).ToList();
|
if (qcofig.Count > 0)
|
{
|
QualityDataHand(logMiddle, qcofig);
|
}
|
#endregion
|
|
|
var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
|
if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
|
{//插入QualityDataInfo表
|
qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
|
db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
|
}
|
//修改QualityDataInfo表 //重复收到质量信息，会覆盖之前的
|
EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(logMiddle, qualityData, GetQualityDataInfoUpdate(logMiddle, logMiddle.WorkingProcedure, logMiddle.MonitoringPoint));//指定修改字段
|
|
qualityData.QualityStateUpdateUser = pieceInfo.UpdatedUserName;
|
qualityData.QualityReceiveTime = pieceInfo.UpdatedTime.Value.LocalDateTime;
|
qualityData.QualityStateUpdateMode = pieceInfo.QualityStateUpdateMode;
|
if (logMiddle.WorkingProcedure.Equals("OP10"))
|
{
|
qualityData.OP10QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP10QualityReceiveTime = DateTimeHelper.GetDateTime();
|
}
|
else if (logMiddle.WorkingProcedure.Equals("OP20"))
|
{
|
//Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}质量信息【{loginfo.QualityStateStr ?? "空"}】" +
|
// $"【{(loginfo.QualityState.HasValue? loginfo.QualityState.Value:999)}】【{(info.QualityState.HasValue ? info.QualityState.Value : 888)}】 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]");
|
qualityData.OP20QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP20QualityReceiveTime = DateTimeHelper.GetDateTime();
|
qualityData.OP20QualityFilePath = logMiddle.OP20QualityFilePath;
|
}
|
else if (logMiddle.WorkingProcedure.Equals("OP30"))
|
{
|
switch (logMiddle.MonitoringPoint)
|
{
|
case "OP3002CH3":
|
qualityData.OP30QualityFilePathCH3 = logMiddle.OP30QualityFilePathCH3;
|
qualityData.OP30QualityStateCH3 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP30QualityReceiveTimeCH3 = DateTimeHelper.GetDateTime();
|
|
if (qualityData.OP30QualityStateCH3 == ((int)QualityState.NG).ToString())
|
{
|
logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30涨断工位力矩大;
|
logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30涨断工位力矩大.ToString();
|
//赋值不合格原因
|
SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
|
}
|
|
break;
|
case "OP3002CH4":
|
qualityData.OP30QualityFilePathCH4 = logMiddle.OP30QualityFilePathCH4;
|
qualityData.OP30QualityStateCH4 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP30QualityReceiveTimeCH4 = DateTimeHelper.GetDateTime();
|
|
if (qualityData.OP30QualityStateCH4 == ((int)QualityState.NG).ToString())
|
{
|
logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30预拧紧工位力矩大;
|
logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30预拧紧工位力矩大.ToString();
|
//赋值不合格原因
|
SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
|
}
|
|
break;
|
case "OP3002CH5":
|
qualityData.OP30QualityFilePathCH5 = logMiddle.OP30QualityFilePathCH5;
|
qualityData.OP30QualityStateCH5 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP30QualityReceiveTimeCH5 = DateTimeHelper.GetDateTime();
|
|
if (qualityData.OP30QualityStateCH5 == ((int)QualityState.NG).ToString())
|
{
|
logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30终拧紧工位力矩大;
|
logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30终拧紧工位力矩大.ToString();
|
//赋值不合格原因
|
SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
|
}
|
|
break;
|
case "OP3002CH6":
|
qualityData.OP30QualityFilePathCH6 = logMiddle.OP30QualityFilePathCH6;
|
qualityData.OP30QualityStateCH6 = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP30QualityReceiveTimeCH6 = DateTimeHelper.GetDateTime();
|
|
if (qualityData.OP30QualityStateCH6 == ((int)QualityState.NG).ToString())
|
{
|
logMiddle.QualityNoOk = (int)QualityNoOkEnum.OP30压衬套工位力矩大;
|
logMiddle.QualityNoOkReason = QualityNoOkEnum.OP30压衬套工位力矩大.ToString();
|
//赋值不合格原因
|
SetQualityNoOk_WorkPieceInfo(logMiddle, ref pieceInfo);
|
}
|
|
break;
|
default:
|
break;
|
}
|
//qualityData.OP30QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
|
//qualityData.OP30QualityReceiveTime = DateTimeHelper.GetDateTime();
|
}
|
else if (logMiddle.WorkingProcedure.Equals("OP35"))
|
{
|
qualityData.OP35QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP35QualityReceiveTime = DateTimeHelper.GetDateTime();
|
}
|
else if (logMiddle.WorkingProcedure.Equals("OP40"))
|
{
|
qualityData.OP40QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP40QualityReceiveTime = DateTimeHelper.GetDateTime();
|
}
|
else if (logMiddle.WorkingProcedure.Equals("OP60"))
|
{
|
qualityData.OP60QualityFilePath = logMiddle.OP60QualityFilePath;
|
qualityData.OP60QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP60QualityReceiveTime = DateTimeHelper.GetDateTime();
|
}
|
else if (logMiddle.WorkingProcedure.Equals("OP80"))
|
{
|
qualityData.OP80QualityFilePath = logMiddle.OP80QualityFilePath;
|
qualityData.OP80QualityState = logMiddle.QualityState.HasValue ? logMiddle.QualityState.Value.ToString() : "3";
|
qualityData.OP80QualityReceiveTime = DateTimeHelper.GetDateTime();
|
}
|
|
var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == logMiddle.WorkPieceID && 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>(pieceInfo);
|
process.StartTime = DateTimeHelper.GetDateTime();
|
|
//不再默认赋值为合格 【Editby shaocx,2024-08-16】
|
//process.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : (int)QualityState.OK;//默认合格，已处理
|
process.QualityState = WorkPieceInfoManager.GetQualityStateValue(pieceInfo.QualityState);
|
|
|
//记录质量不合格原因 【Editby shaocx,2024-06-26】
|
//赋值不合格原因
|
SetQualityNoOk_WorkPieceProcess(logMiddle, ref process);
|
|
process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
process.CreatedUserName = ResetUpdatedUserName(logMiddle);
|
process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
process.UpdatedUserName = ResetUpdatedUserName(logMiddle);
|
process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
process.OperationType = OperationType.生产.ToString();
|
process.QualityDataInfoID = qualityData.Id;
|
process.Remarks = "";
|
db.WorkPieceProcess.Add(process);
|
}
|
else
|
{//其他的都只是修改
|
pro.QualityDataInfoID = qualityData.Id;
|
pro.UpdatedUserName = ResetUpdatedUserName(logMiddle);
|
pro.UpdatedTime = DateTimeHelper.GetDateTime();
|
|
//不再默认赋值为合格 【Editby shaocx,2024-08-16】
|
//pro.QualityState = pieceInfo.QualityState.HasValue ? pieceInfo.QualityState.Value : 9;
|
pro.QualityState = WorkPieceInfoManager.GetQualityStateValue(pieceInfo.QualityState);
|
|
//赋值不合格原因
|
SetQualityNoOk_WorkPieceProcess(logMiddle, ref pro);
|
|
//TODO:判断如果是60工序，那么就要更新pro表的创建人为loginfo.MonitoringPoint 【Editby shaocx,2024-06-05】
|
if (logMiddle.WorkingProcedure == "OP60")
|
{
|
pro.CreatedUserName = ResetUpdatedUserName(logMiddle);
|
|
}
|
}
|
|
if (logMiddle.QualityType != null && logMiddle.QualityType.Equals(QualityType.SPC.ToString()))
|
{//SPC反馈，
|
if (logMiddle.QualityState != (int)QualityState.OK)
|
{
|
//当某到工序检测到不合格工件时，从该工件加工完成时刻前指定时间起至报检不合格时间止，系统将该工件的最后加工工序在该时间段内加工的所有工件、正在加工的工件、该工序入口处的第一个工件全部标记为疑似状态，由人工复检工件并修改状态，并支持批量变更。
|
//答复：在线测量不需要走这个流程，只有SPC抽检才需要，需要把这时间段的工件全部置为疑似，哪怕是已完成工件
|
//时间段起始时间：抽检工件生产时间前一SPC抽检时间
|
//时间段结束时间：抽检工件质量结果出现后的时间
|
//抽检工件工序扫描枪外入口处的第一个工件 也把质量状态置为疑似
|
//（每一工序SPC抽检是设置的固定的，比如200抽4，状态置为疑似时若工件还在设备内，会继续生产完毕后排出）
|
//目前这块逻辑放到了 WebAPI中了
|
|
}
|
|
}
|
db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(pieceInfo));
|
db.QualityDataInfoLog.Add(GetAddQualityDataInfoLog(qualityData));//插入日志
|
}
|
else
|
{
|
loginfo2.Remarks = (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 ?? "空"}]时异常：");
|
}
|
finally
|
{
|
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>
|
/// <param name="loginfo"></param>
|
/// <param name="type"></param>
|
public static void WorkPiecePushOff(WorkPieceLogMiddle loginfo, LogType type)
|
{
|
using (DbModel db = new DbModel())
|
{
|
WorkPieceLog loginfo2 = new WorkPieceLog();
|
loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
|
try
|
{
|
if (loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
|
{
|
WorkPieceInfo cur_db_info = new WorkPieceInfo();
|
cur_db_info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
|
if (cur_db_info == null || cur_db_info.WorkPieceID.Length < 1)
|
{//没有工件信息，不做更新
|
Log4NetHelper.WriteErrorLog(type, $"工件{loginfo.WorkPieceID} 工件推出工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新");
|
return;
|
}
|
else
|
{//更新表WorkPieceInfo
|
if (loginfo.WorkingProcedure.Equals("OP10"))
|
{
|
/*
|
info.WorkPieceCurrentPosition = info.WorkingProcedureCurrent + "NOOK";
|
loginfo2.WorkingProcedure = info.WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
|
loginfo.WorkingProcedure = info.WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
|
//*/
|
//修复 错误记录成OP05的问题 【Editby shaocx,2024-08-26】
|
var set_WorkingProcedureCurrent = "";
|
if (cur_db_info.WorkingProcedureCurrent != "OP10" && cur_db_info.WorkingProcedureCurrent != "OP40")
|
{
|
SetWorkingProcedureCurrentForOP10(cur_db_info, ref set_WorkingProcedureCurrent);
|
}
|
else
|
{
|
set_WorkingProcedureCurrent = cur_db_info.WorkingProcedureCurrent;
|
}
|
cur_db_info.WorkingProcedureCurrent = set_WorkingProcedureCurrent;
|
cur_db_info.WorkPieceCurrentPosition = set_WorkingProcedureCurrent + "NOOK";
|
loginfo2.WorkingProcedure = set_WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
|
loginfo.WorkingProcedure = set_WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
|
}
|
else
|
{
|
cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
|
cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "NOOK";
|
}
|
cur_db_info.WorkPieceState = (int)WorkPieceState.NOOKPush;
|
cur_db_info.UpdatedUserName = loginfo.MonitoringPoint;
|
cur_db_info.UpdatedTime = DateTime.Now;
|
cur_db_info.Remarks = "工件NOOK推出";
|
if (!(cur_db_info.WorkingProcedureStartTime.HasValue && cur_db_info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
|
{
|
cur_db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
|
}
|
cur_db_info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
|
cur_db_info.WorkingProcedureCompleted = cur_db_info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
|
cur_db_info.WorkPieceCurrentPositionOrder = cur_db_info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
|
}
|
QualityDataInfo qualityData = null;
|
qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
|
if (loginfo.WorkingProcedure.Equals("OP35"))
|
{//为了解决OP35的采集到的质量信息是OK还NOOK的情况，OP35 NOOK时更新质量信息
|
loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"OP35NOOK原质量信息{(cur_db_info.QualityState.HasValue ? cur_db_info.QualityState.Value.ToString() : "空")}";
|
cur_db_info.QualityState = (int)QualityState.NG;
|
if (!cur_db_info.QualityState.Equals(((int)QualityState.OK).ToString()))
|
{
|
cur_db_info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量NOOK采集数据不合格{cur_db_info.QualityState}";
|
}
|
else
|
{
|
cur_db_info.QualityErrorInfo = "";
|
}
|
loginfo.QualityState = cur_db_info.QualityState;
|
|
|
if (qualityData != null)
|
{
|
qualityData.OP35QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
|
qualityData.OP35QualityReceiveTime = DateTimeHelper.GetDateTime();
|
db.QualityDataInfoLog.Add(GetAddQualityDataInfoLog(qualityData));
|
}
|
}
|
//更新上一工序的结束时间
|
var pro = db.WorkPieceProcess.Where(o => o.WorkPieceID == loginfo.WorkPieceID && o.WorkingProcedureCurrent == loginfo.WorkingProcedure && o.OperationType == OperationType.生产.ToString()).OrderByDescending(o => o.StartTime).FirstOrDefault();
|
if (pro != null && pro.WorkPieceID.Length > 0)
|
{
|
pro.EndTime = DateTimeHelper.GetDateTime();
|
pro.Remarks = (pro.Remarks ?? "") + "NOOK结束";
|
pro.UpdatedUserName = loginfo.MonitoringPoint;
|
pro.UpdatedTime = DateTimeHelper.GetDateTime();
|
}
|
|
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 ?? "空"}异常";
|
Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件NOOK推出读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
|
}
|
}
|
catch (Exception e)
|
{
|
loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
|
}
|
|
|
db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
|
db.SaveChanges();
|
}
|
|
}
|
/// <summary>
|
/// 工件SPC抽检推出
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <param name="type"></param>
|
public static void WorkPieceSPCPushOff(WorkPieceLogMiddle loginfo, LogType type)
|
{
|
|
using (DbModel db = new DbModel())
|
{
|
WorkPieceLog loginfo2 = new WorkPieceLog();
|
loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
|
try
|
{
|
if ((loginfo.WorkPieceID != null && loginfo.WorkPieceID.Trim('\0').Length == 22)
|
//|| !((loginfo.WorkingProcedure.Equals("OP10") || loginfo.WorkingProcedure.Equals("OP40")) && loginfo.Remarks.Length > 0)
|
)
|
{
|
WorkPieceInfo cur_db_info = new WorkPieceInfo();
|
cur_db_info = db.WorkPieceInfo.Where(o => o.WorkPieceID == loginfo.WorkPieceID).FirstOrDefault();
|
if (cur_db_info == null || cur_db_info.WorkPieceID.Length < 1)
|
{//没有工件信息，不做更新
|
loginfo2.Remarks = $"工件{loginfo.WorkPieceID} 工件SPC推出工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新";
|
Log4NetHelper.WriteErrorLog(type, $"工件{loginfo.WorkPieceID} 工件SPC推出工序{loginfo.WorkingProcedure} 没有获取到工件信息不做更新");
|
return;
|
}
|
else
|
{//更新表WorkPieceInfo
|
if (loginfo.WorkingProcedure.Equals("OP10"))
|
{
|
//修复 错误记录成OP05的问题 【Editby shaocx,2024-08-26】
|
var set_WorkingProcedureCurrent = "";
|
if (cur_db_info.WorkingProcedureCurrent != "OP10" && cur_db_info.WorkingProcedureCurrent != "OP40")
|
{
|
SetWorkingProcedureCurrentForOP10(cur_db_info, ref set_WorkingProcedureCurrent);
|
}
|
else
|
{
|
set_WorkingProcedureCurrent = cur_db_info.WorkingProcedureCurrent;
|
}
|
cur_db_info.WorkingProcedureCurrent = set_WorkingProcedureCurrent;
|
cur_db_info.WorkPieceCurrentPosition = set_WorkingProcedureCurrent + "SPC";
|
loginfo2.WorkingProcedure = set_WorkingProcedureCurrent;//解决OP10，OP40同一个的问题
|
loginfo.WorkingProcedure = set_WorkingProcedureCurrent; //解决OP10，OP40同一个的问题
|
}
|
else
|
{
|
cur_db_info.WorkingProcedureCurrent = loginfo.WorkingProcedure;
|
cur_db_info.WorkPieceCurrentPosition = loginfo.WorkingProcedure + "SPC";
|
}
|
cur_db_info.WorkPieceState = (int)WorkPieceState.SPCPush;
|
cur_db_info.UpdatedUserName = loginfo.MonitoringPoint;
|
cur_db_info.UpdatedTime = DateTime.Now;
|
cur_db_info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
|
if (!(cur_db_info.WorkingProcedureStartTime.HasValue && cur_db_info.WorkingProcedureStartTime > DateTime.Parse("1900/01/01")))
|
{
|
cur_db_info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
|
}
|
|
|
cur_db_info.WorkingProcedureCompleted = cur_db_info.WorkingProcedureCompleted + loginfo.WorkingProcedure;//已完成工序
|
cur_db_info.WorkPieceCurrentPositionOrder = cur_db_info.WorkingProcedurePlan.IndexOf(loginfo.WorkingProcedure) / 2;
|
}
|
cur_db_info.Remarks = "工件SPC抽检推出";
|
|
//更新上一工序的结束时间
|
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.UpdatedTime = DateTimeHelper.GetDateTime();
|
}
|
//每次SPC 都插入追溯表
|
WorkPieceProcess process = new WorkPieceProcess();
|
process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(cur_db_info);
|
process.StartTime = DateTimeHelper.GetDateTime();
|
process.OperationType = OperationType.SPC.ToString();
|
process.QualityState = (int)QualityState.Suspected;
|
process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
process.CreatedUserName = loginfo.MonitoringPoint;
|
process.CreatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
process.UpdatedUserName = loginfo.MonitoringPoint;
|
process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
process.Remarks = "工件SPC抽检推出";
|
db.WorkPieceProcess.Add(process);
|
|
|
db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(cur_db_info));
|
}
|
else
|
{
|
loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"工件SPC抽检推出读取二维码{loginfo.WorkPieceID ?? "空"}异常";
|
Log4NetHelper.WriteErrorLog(type, $" {loginfo.WorkingProcedure}工件SPC抽检推出读码标记 读取工件码数据[{loginfo.WorkPieceID ?? "空"}]时异常：");
|
}
|
}
|
catch (Exception e)
|
{
|
loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{loginfo.WorkPieceID ?? "空"}更新数据异常{e.Message}";
|
}
|
finally
|
{
|
db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
|
db.SaveChanges();
|
}
|
|
}
|
}
|
|
|
public static void SetWorkingProcedureCurrentForOP10(WorkPieceInfo cur_db_info, ref string set_WorkingProcedureCurrent)
|
{
|
//截断字符串
|
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>
|
/// <param name="logMiddle"></param>
|
/// <param name="type"></param>
|
public static void WorkingProcedureComplete(WorkPieceLogMiddle logMiddle, LogType type)
|
{
|
|
using (DbModel db = new DbModel())
|
{
|
if (logMiddle.WorkingProcedure.Equals("OP70"))
|
{
|
logMiddle.QualityState = (int)QualityState.OK; //如果是OP70，则默认是合格 【Editby shaocx,2024-06-25】
|
}
|
|
WorkPieceLog loginfo2 = new WorkPieceLog();
|
loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(logMiddle);
|
|
try
|
{
|
if (logMiddle.WorkPieceID != null && logMiddle.WorkPieceID.Trim('\0').Length == 22)
|
{
|
|
bool isAddWorkPieceInfo = false;
|
WorkPieceInfo info = new WorkPieceInfo();
|
info = db.WorkPieceInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
|
if (info == null || 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);
|
//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,数据缺失,请确认情况并做相应处理！";
|
}
|
else
|
{
|
info.QualityState = (int)QualityState.OK;//此处需要注意，判断所有工序质量，然后再赋值 //默认合格，OP05默认是合格
|
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);
|
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同一个的问题
|
}
|
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")))
|
{//若一直没有工序开始时间，则赋值当前时间
|
info.WorkingProcedureStartTime = DateTimeHelper.GetDateTime();
|
}
|
info.WorkingProcedureEndTime = DateTimeHelper.GetDateTime();
|
info.WorkPieceCurrentPositionOrder = info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) / 2;
|
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;
|
|
//质检数据改为 获取文件后修改 【Editby shaocx,2024-06-15】
|
/*
|
info.QualityState = (int)((loginfo.QualityStateStr.Equals("OK") || loginfo.QualityStateStr.Equals("0K")) ? QualityState.OK : QualityState.NG);
|
loginfo.QualityState = info.QualityState;
|
info.QualityStateUpdateUser = loginfo.UpdatedUserName;
|
info.QualityStateUpdateTime = loginfo.UpdatedTime.Value.LocalDateTime;
|
info.QualityStateUpdateMode = QualityStateUpdateMode.Auto.ToString();
|
//*/
|
|
|
var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
|
if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
|
{//插入QualityDataInfo表
|
qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
|
db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
|
}
|
//修改QualityDataInfo表 //重复收到质量信息，会覆盖之前的
|
EntityPropHelper<WorkPieceLogMiddle, QualityDataInfo>.CopyProp(logMiddle, qualityData, GetQualityDataInfoUpdate(logMiddle, logMiddle.WorkingProcedure, logMiddle.MonitoringPoint));//指定修改字段
|
|
//质检数据改为 获取文件后修改 【Editby shaocx,2024-06-15】
|
/*
|
qualityData.QualityStateUpdateUser = info.UpdatedUserName;
|
qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
|
qualityData.QualityStateUpdateMode = info.QualityStateUpdateMode;
|
qualityData.OP80QualityState = loginfo.QualityState.HasValue ? loginfo.QualityState.Value.ToString() : "3";
|
qualityData.OP80QualityReceiveTime = DateTimeHelper.GetDateTime();
|
qualityData.OP80QualityFilePath = loginfo.OP80QualityFilePath;
|
op80id = qualityData.Id;
|
loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"质量：{loginfo.QualityStateStr ?? "空"}";
|
if (!info.QualityState.Equals(((int)QualityState.OK).ToString()))
|
{
|
info.QualityErrorInfo = $"{loginfo.WorkingProcedure}工序质量采集数据不合格";
|
}
|
else
|
{
|
info.QualityErrorInfo = "";
|
}
|
//*/
|
}
|
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();
|
|
var qualityData = db.QualityDataInfo.Where(o => o.WorkPieceID == logMiddle.WorkPieceID).FirstOrDefault();
|
if (qualityData == null || qualityData.WorkPieceID.Length < 1 || qualityData.WorkingProcedure.Length < 1)
|
{//插入QualityDataInfo表
|
qualityData = EntityPropHelper.Mapper<QualityDataInfo, WorkPieceLog>(logMiddle);
|
db.QualityDataInfo.Add(GetAddQualityDataInfo(qualityData));
|
}
|
qualityData.QualityStateUpdateUser = info.UpdatedUserName;
|
qualityData.QualityReceiveTime = info.UpdatedTime.Value.LocalDateTime;
|
qualityData.QualityStateUpdateMode = 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()))
|
{
|
info.QualityErrorInfo = $"{logMiddle.WorkingProcedure}工序质量采集数据不合格";
|
}
|
else
|
{
|
info.QualityErrorInfo = "";
|
}
|
}
|
else
|
{
|
//这里修复OP10、OP40 因为PLC先推 SPC推出、再推 产品下线问题，导致 产品下线更新数据时，把SPC数据覆盖的问题 【Editby shaocx,2024-08-27】
|
var isAlow = SystemBussinessHelper.IsAllowUpdateWorkPieceStateToWip(info, db, logMiddle);
|
if (isAlow)
|
{
|
info.WorkPieceState = (int)WorkPieceState.WIP;
|
}
|
|
|
if (info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure) + 4 <= info.WorkingProcedurePlan.Length)
|
{
|
info.WorkPieceCurrentPosition = info.WorkingProcedurePlan.Substring(info.WorkingProcedurePlan.IndexOf(logMiddle.WorkingProcedure), 8);
|
}
|
}
|
|
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();
|
process = EntityPropHelper.Mapper<WorkPieceProcess, WorkPieceInfo>(info);
|
process.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
process.StartTime = DateTimeHelper.GetDateTime();
|
process.EndTime = DateTimeHelper.GetDateTime();
|
if (logMiddle.WorkingProcedure.Equals("OP80"))
|
{//OP80的质量数据是后来获取文件搞的
|
//质检数据，再考虑 另外两种状态 【Editby shaocx,2024-08-27】
|
QualityStateHelper.SetQualityStateForOP80(logMiddle, ref info, ref process);
|
}
|
else
|
{
|
//不再默认赋值为合格 【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 = logMiddle.MonitoringPoint;
|
process.UpdatedTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
process.OperationType = OperationType.生产.ToString();
|
process.Remarks = "";
|
if (logMiddle.WorkingProcedure.Equals("OP80"))
|
{
|
process.GetQcDataFlag = logMiddle.GetQcDataFlag;//赋值标记 [Editby shaocx,2024-06-15]
|
}
|
if (op80id > 0)
|
{
|
process.QualityDataInfoID = op80id;
|
}
|
db.WorkPieceProcess.Add(process);
|
}
|
else
|
{
|
if (op80id > 0)
|
{
|
pro.QualityDataInfoID = op80id;
|
}
|
pro.EndTime = DateTimeHelper.GetDateTime();
|
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]
|
}
|
}
|
}
|
|
|
if (isAddWorkPieceInfo)
|
{
|
db.WorkPieceInfo.Add(info);
|
}
|
db.WorkPieceInfoLog.Add(GetAddWorkPieceInfoLog(info));
|
}
|
else
|
{
|
loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"下线完成读取二维码{logMiddle.WorkPieceID ?? "空"}异常";
|
Log4NetHelper.WriteErrorLog(type, $" {logMiddle.WorkingProcedure}工序下线 读取工件码数据[{logMiddle.WorkPieceID ?? "空"}]时异常：");
|
|
}
|
}
|
catch (Exception e)
|
{
|
loginfo2.Remarks = (loginfo2.Remarks ?? "") + $"读取二维码{logMiddle.WorkPieceID ?? "空"}更新数据异常{e.Message}";
|
}
|
db.WorkPieceLog.Add(GetAddWorkPieceLog(loginfo2));//插入工件采集日志表
|
db.SaveChanges();
|
}
|
}
|
public static void AlertMonitor(WorkPieceLog loginfo, LogType type)
|
{
|
|
}
|
/// <summary>
|
/// 设备告警监控（清洗液，切削液，刀具告警等）
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <param name="type"></param>
|
public static void AlertMonitor(LogType type)
|
{
|
using (DbModel db = new DbModel())
|
{
|
bool isAddAlert = false;
|
try
|
{
|
|
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 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();
|
foreach (var item in equipmentlist)
|
{
|
try
|
{
|
var alert = alertlist.Where(o => o.EquipmentId.Equals(item.EquipmentId)).FirstOrDefault();
|
if (alert == null || alert.Id < 1)
|
{
|
alert = EntityPropHelper.Mapper<v_get_equipment_alert, EquipmentBaseInfo>(item);
|
isAddAlert = true;
|
}
|
//if(item.WorkingProcedure.Equals("OP70"))
|
{
|
if (item.Detergentchangetime.HasValue)
|
{
|
if (item.Detergentchangetime.Value.AddDays(item.DetergentChangeAlertThreshold).Date <= DateTime.Now.Date)
|
{//op70清洗液告警
|
alert.IsAlertDetergent = true;
|
alert.Detergentchangetime = item.Detergentchangetime;
|
alert.DetergentChangeAlertThreshold = item.DetergentChangeAlertThreshold;
|
alert.DetergentChangeCycle = item.DetergentChangeCycle;
|
alert.DetergentDesc = $"设备【{item.EquipmentName}】清洗液最新更换时间为【{item.Detergentchangetime.Value}】，已达到告警阈值，请注意！";
|
}
|
else
|
{
|
alert.IsAlertDetergent = false;
|
alert.DetergentDesc = "";
|
}
|
}
|
else
|
{
|
|
alert.IsAlertDetergent = false;
|
alert.DetergentDesc = "";
|
}
|
}
|
//if (!item.WorkingProcedure.Equals("OP05")&& !item.WorkingProcedure.Equals("OP30") && !item.WorkingProcedure.Equals("OP70") && !item.WorkingProcedure.Equals("OP80"))
|
{
|
if (item.CuttingFluidChangeTime.HasValue)
|
{
|
if (item.CuttingFluidChangeTime.Value.AddDays(item.CuttingFluidChangeAlertThreshold).Date <= DateTime.Now.Date)
|
{//切削液告警
|
alert.IsAlertCuttingFluid = true;
|
alert.CuttingFluidChangeTime = item.CuttingFluidChangeTime;
|
alert.CuttingFluidChangeAlertThreshold = item.CuttingFluidChangeAlertThreshold;
|
alert.CuttingFluidDesc = $"设备【{item.EquipmentName}】切削液最新更换时间为【{item.CuttingFluidChangeTime.Value}】，已达到告警阈值，请注意！";
|
}
|
else
|
{
|
alert.IsAlertCuttingFluid = false;
|
alert.CuttingFluidDesc = "";
|
}
|
}
|
else
|
{
|
alert.IsAlertCuttingFluid = false;
|
alert.CuttingFluidDesc = "";
|
}
|
}
|
bool flag = false;
|
string desc = $"设备【{item.EquipmentName}】";
|
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 ((knife.CurrentLife + list.KnifeToolChangeAlertThreshold) >= list.KnifeToolLife)
|
{//刀具告警
|
flag = true;
|
alert.IsAlertKnifeTool = true;
|
alert.KnifeToolChangeAlertThreshold = list.KnifeToolChangeAlertThreshold;
|
desc += $"\r\n工位【{knife.Station}】上刀具【{knife.KnifeToolID}】计划寿命【{list.KnifeToolLife}】次，当前已使用寿命【{knife.CurrentLife}】次，已达到告警阈值，请注意！";
|
}
|
}
|
}
|
if (!flag)
|
{//没有刀具告警
|
alert.IsAlertKnifeTool = false;
|
alert.KnifeToolDesc = "";
|
}
|
else
|
{
|
alert.IsAlertKnifeTool = true;
|
alert.KnifeToolDesc = desc;
|
}
|
|
EquipmentCurrentMonitor info = new EquipmentCurrentMonitor();
|
info = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == item.EquipmentId).FirstOrDefault();
|
if (info == null || info.Id < 1)
|
{//没有工件信息，不做更新
|
Log4NetHelper.WriteErrorLog(type, $"设备{item.EquipmentId} 计算告警{item.WorkingProcedure} 没有获取到设备监控信息！");
|
}
|
else
|
{
|
if (string.IsNullOrEmpty(info.Alertmsg))
|
{
|
alert.IsAlert = false;
|
alert.AlertDesc = "";
|
}
|
else
|
{
|
alert.IsAlert = true;
|
alert.AlertDesc = info.Alertmsg;
|
}
|
}
|
if (isAddAlert)
|
{
|
db.v_get_equipment_alert.Add(alert);
|
}
|
}
|
catch (Exception ex)
|
{
|
|
Log4NetHelper.WriteErrorLog(type, $" {item.EquipmentName}设备计算告警时异常：");
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
Log4NetHelper.WriteErrorLog(type, $" 设备告警监控（清洗液，切削液，刀具告警等） 计算时异常：{e.Message} {e.StackTrace}");
|
}
|
|
|
|
//db.WorkPieceLog.Add(loginfo2);//插入设备采集日志表
|
db.SaveChanges();
|
}
|
}
|
|
/// <summary>
|
/// 设备监控
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <param name="type"></param>
|
public static void EquipmentMonitor(WorkPieceLogMiddle loginfo, LogType type)
|
{
|
|
using (DbModel db = new DbModel())
|
{
|
var loginfo2 = EntityPropHelper.Mapper<WorkPieceLog, WorkPieceLogMiddle>(loginfo);
|
try
|
{
|
bool isAddEquipmentCurrentMonitor = false;
|
EquipmentCurrentMonitor info = new EquipmentCurrentMonitor();
|
info = db.EquipmentCurrentMonitor.Where(o => o.EquipmentID == loginfo.EquipmentID).FirstOrDefault();
|
if (info == null || info.Id < 1)
|
{//没有工件信息，不做更新
|
Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.MonitoringPoint} 没有获取到设备监控信息，现新增");
|
info = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLogMiddle>(loginfo);
|
isAddEquipmentCurrentMonitor = true;
|
}
|
//最新设备状态
|
string State = "";
|
//OP20,OP30,OP35,OP50,OP60等等都不区分告警和message，但code都不会重复，所以本处就不需要判断告警类型了
|
var codelist = db.EquipmentFailureCode.Where(o => o.WorkingProcedure.Equals(loginfo.WorkingProcedure)).ToList();
|
|
#region 故障代码处理
|
List<long> Failueslist = new List<long>();
|
Failueslist.Add(loginfo.FailureType1);
|
Failueslist.Add(loginfo.FailureType2);
|
Failueslist.Add(loginfo.FailureType3);
|
Failueslist.Add(loginfo.FailureType4);
|
Failueslist.Add(loginfo.FailureType5);
|
Failueslist.Add(loginfo.FailureType6);
|
Failueslist.Add(loginfo.FailureType7);
|
Failueslist.Add(loginfo.FailureType8);
|
Failueslist.Add(loginfo.FailureType9);
|
Failueslist.Add(loginfo.FailureType10);
|
Failueslist.Add(loginfo.FailureType11);
|
Failueslist.Add(loginfo.FailureType12);
|
Failueslist.Add(loginfo.FailureType13);
|
Failueslist.Add(loginfo.FailureType14);
|
Failueslist.Add(loginfo.FailureType15);
|
Failueslist.Add(loginfo.FailureType16);
|
Failueslist.Add(loginfo.FailureType17);
|
Failueslist.Add(loginfo.FailureType18);
|
Failueslist.Add(loginfo.FailureType19);
|
Failueslist.Add(loginfo.FailureType20);
|
Failueslist.RemoveAll(o => o == 0);
|
string faultall = "";
|
string faultmsg = "";
|
int i = 1;
|
foreach (var failues in Failueslist)
|
{
|
faultall += (failues + "\r\n");
|
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");
|
}
|
else
|
{
|
faultmsg += (i.ToString() + "." + failues.ToString() + "\r\n");
|
}
|
i++;
|
}
|
//var faultall = string.Join("\r\n", Failueslist.OrderBy(o=>o));
|
#endregion
|
#region 告警代码处理
|
|
List<long> Alertlist = new List<long>();
|
Alertlist.Add(loginfo.FailureMessage1);
|
Alertlist.Add(loginfo.FailureMessage2);
|
Alertlist.Add(loginfo.FailureMessage3);
|
Alertlist.Add(loginfo.FailureMessage4);
|
Alertlist.Add(loginfo.FailureMessage5);
|
Alertlist.Add(loginfo.FailureMessage6);
|
Alertlist.Add(loginfo.FailureMessage7);
|
Alertlist.Add(loginfo.FailureMessage8);
|
Alertlist.Add(loginfo.FailureMessage9);
|
Alertlist.Add(loginfo.FailureMessage10);
|
Alertlist.Add(loginfo.FailureMessage11);
|
Alertlist.Add(loginfo.FailureMessage12);
|
Alertlist.Add(loginfo.FailureMessage13);
|
Alertlist.Add(loginfo.FailureMessage14);
|
Alertlist.Add(loginfo.FailureMessage15);
|
Alertlist.Add(loginfo.FailureMessage16);
|
Alertlist.Add(loginfo.FailureMessage17);
|
Alertlist.Add(loginfo.FailureMessage18);
|
Alertlist.Add(loginfo.FailureMessage19);
|
Alertlist.Add(loginfo.FailureMessage20);
|
Alertlist.RemoveAll(o => o == 0);
|
string alertall = "";
|
string warnmsg = "";
|
i = 1;
|
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)
|
{
|
warnmsg += (i.ToString() + "." + (codeinfo.CodeDesc ?? codeinfo.Code) + "\r\n");
|
}
|
else
|
{
|
warnmsg += (i.ToString() + "." + alert.ToString() + "\r\n");
|
}
|
i++;
|
}
|
#endregion
|
//var alertall = string.Join("\r\n", Alertlist.OrderBy(o=>o));
|
|
|
EquipmentWorkingLog infolog = new EquipmentWorkingLog();
|
infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
infolog.LogAddTime = DateTimeHelper.GetDateTime();
|
infolog.WorkPieceLogID = loginfo2.Id;
|
infolog.EquipmentID = info.EquipmentID;
|
bool isAddEquipmentWorkingLog = false;
|
|
bool isStatechange = false;
|
|
#region 设备状态处理
|
|
//故障》警告》其他
|
if (loginfo.IsCloseAlert)
|
{//故障
|
info.AlertTime = info.AlertTime ?? DateTime.Now;
|
info.FailureType = "";
|
info.WarnType = "";
|
info.Alertmsg = faultmsg;//这个需要代码对应字典维护信息才知道
|
info.FailureType = faultall;
|
State = ((int)EnumEquipmentCurrentStateDisplay.故障).ToString();
|
|
|
//infolog.FailureStartTime = DateTimeHelper.GetDateTime();
|
//infolog.FailureType = faultall;
|
//infolog.FailureMsg = faultmsg;
|
if (loginfo.IsMessage)
|
{
|
info.WarnTime = info.WarnTime ?? DateTime.Now;
|
info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
|
info.WarnType = alertall;
|
}
|
}
|
//else if (loginfo.IsMessage)
|
//{//警告
|
// info.AlertTime = null;
|
// info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
|
// info.FailureType = "";
|
|
// info.WarnTime = info.WarnTime ?? DateTime.Now;
|
// info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
|
// info.WarnType = alertall;
|
|
// //infolog.WarnStartTime = DateTimeHelper.GetDateTime();
|
// //infolog.WarnType = alertall;
|
// //infolog.Warnmsg = warnmsg;
|
// State = ((int)EnumEquipmentCurrentStateDisplay.警告).ToString();
|
//}
|
else
|
{//告警结束，获取有告警的数据，然后关闭他
|
info.AlertTime = null;
|
info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
|
info.FailureType = "";
|
info.WarnType = "";
|
info.WarnTime = null;
|
info.Warnmsg = "";
|
if (loginfo.IsMessage)
|
{//警告会覆盖下面的状态，先不用警告了
|
info.WarnTime = info.WarnTime ?? DateTime.Now;
|
info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
|
info.WarnType = alertall;
|
}
|
if (info.EquipmentCurrentState == null || (!info.EquipmentCurrentState.Equals(((int)EnumEquipmentCurrentStateDisplay.离线).ToString())))
|
{//如果设备状态为离线，则此处不需要判断任何信息
|
if (loginfo.IsNormalProduction && !loginfo.LackMaterial && !loginfo.FullMaterial)
|
{//自动运行状态+不缺料+不堵料
|
State = ((int)EnumEquipmentCurrentStateDisplay.生产).ToString();
|
}
|
else if (loginfo.IsNormalProduction && loginfo.FullMaterial)
|
{//自动运行状态+下料道满料 = 完成 （就是有生产出来但没有出设备）
|
State = ((int)EnumEquipmentCurrentStateDisplay.完成).ToString();
|
}
|
//else if (loginfo.IsNormalProduction && loginfo.LackMaterial)
|
//{//其他状态全算待机
|
// State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
|
//}
|
else
|
{//其他状态全算待机
|
State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
|
}
|
}
|
}
|
if (!string.IsNullOrEmpty(State) && State != info.EquipmentCurrentState)
|
{//只有状态出现变化才变更,状态变更，肯定有新的一条数据
|
|
//状态变更，获取旧状态的信息，若有则更新(准确的说，只要没有结束时间的设备状态都需要更新结束时间，以便于插入新的数据)
|
var equlogState = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
|
&& o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue && (o.EquipmentStateEndTime == null || o.EquipmentStateEndTime == DateTime.MinValue)
|
//&& o.EquipmentState== info.EquipmentCurrentState
|
)
|
.OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
|
|
if (equlogState != null)
|
{
|
equlogState.MonitoringPoint = loginfo.MonitoringPoint;
|
equlogState.EquipmentStateEndTime = DateTimeHelper.GetDateTime();
|
}
|
|
info.UpdatedUserName = loginfo.MonitoringPoint;
|
info.UpdatedTime = DateTime.Now;
|
info.EquipmentCurrentState = State;
|
|
//状态变更，需要更新原来的，肯定会插入新的
|
infolog.EquipmentState = State;
|
infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
|
infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
infolog.Remarks = "告警信息出现变更3";
|
infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(State)).ToString()}\r\n";
|
isAddEquipmentWorkingLog = true;
|
isStatechange = true;
|
}
|
#endregion
|
|
//1.有故障则是故障状态， 有故障信息+告警信息
|
//2.没有故障有告警则是告警状态，有告警信息
|
//3.即没故障，也没告警，则是其他状态
|
|
//查找是否有未结束的故障
|
var equlogFailure = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
|
&& o.FailureStartTime != null && o.FailureStartTime != DateTime.MinValue && (o.FailureEndTime == null || o.FailureEndTime == DateTime.MinValue))
|
.OrderByDescending(o => o.FailureStartTime).FirstOrDefault();
|
if (loginfo.IsCloseAlert)
|
{//有故障标志位，设备状态若有变更则肯定有新增，此处直接更新即可
|
//有故障标志位，设备状态若没有更新，有故障，也不会插入新的（有故障设备状态变更肯定是变成故障）
|
infolog.FailureStartTime = DateTimeHelper.GetDateTime();
|
infolog.FailureType = faultall;
|
infolog.FailureMsg = faultmsg;
|
infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
infolog.Remarks = "故障信息出现变更1";
|
infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + "故障信息变更\r\n";
|
}
|
else
|
{
|
if (equlogFailure != null)
|
{//故障关闭的
|
equlogFailure.MonitoringPoint = loginfo.MonitoringPoint;
|
equlogFailure.FailureEndTime = DateTimeHelper.GetDateTime();
|
}
|
}
|
|
//查找是否有未结束的告警
|
var equlogalert = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
|
&& o.WarnStartTime != null && o.WarnStartTime != DateTime.MinValue && (o.WarnEndTime == null || o.WarnEndTime == DateTime.MinValue))
|
.OrderByDescending(o => o.WarnStartTime).FirstOrDefault();
|
if (loginfo.IsMessage)
|
{//若有告警，如果有设备状态变更，肯定插入，此处只修改即可
|
//若有告警，如果设备状态没有变更，有告警，也不插入新的（问题：当状态没有更改，如一直是故障，但告警信息有变化，怎么办 ps：此处先不管）
|
infolog.WarnStartTime = DateTimeHelper.GetDateTime();
|
infolog.WarnType = alertall;
|
infolog.Warnmsg = warnmsg;
|
infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
infolog.Remarks = "告警信息出现变更2";
|
infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + "告警信息变更\r\n";
|
}
|
else
|
{
|
if (equlogalert != null)
|
{//故障关闭的
|
equlogalert.MonitoringPoint = loginfo.MonitoringPoint;
|
equlogalert.WarnEndTime = DateTimeHelper.GetDateTime();
|
}
|
}
|
#region 原来的代码，以后删掉
|
|
//EquipmentWorkingLog infolog =new EquipmentWorkingLog();
|
//infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
//infolog.LogAddTime = DateTimeHelper.GetDateTime();
|
//infolog.WorkPieceLogID = loginfo2.Id;
|
//infolog.EquipmentID = info.EquipmentID;
|
//bool isAddEquipmentWorkingLog = false;
|
//if (loginfo.ischeckAlertStatus)
|
//{//告警状态发生变更
|
// //说明是一个新告警，需要更新设备监控表
|
// //查找未结束的告警
|
// var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
|
// && o.FailureStartTime != null && o.FailureStartTime != DateTime.MinValue)
|
// .OrderByDescending(o=>o.FailureStartTime).FirstOrDefault();
|
// if (loginfo.IsCloseAlert)
|
// {
|
// if (equlog == null|| (equlog.FailureEndTime!=null&& equlog.FailureEndTime > DateTime.MinValue))
|
// {
|
// info.AlertTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
// infolog.FailureStartTime = DateTimeHelper.GetDateTime();
|
// infolog.FailureType = faultall;
|
// infolog.FailureMsg = faultmsg;
|
// infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
// infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
// infolog.Remarks = "故障信息出现变更1";
|
// infolog.UpdateDesc = (infolog.UpdateDesc??"")+"故障信息变更\r\n";
|
// isAddEquipmentWorkingLog =true;
|
// }
|
// }
|
// else
|
// {
|
// if (equlog != null && (equlog.FailureEndTime == null || equlog.FailureEndTime <= DateTime.MinValue))
|
// {//告警关闭的，若没有告警信息，不用管
|
// equlog.MonitoringPoint = loginfo.MonitoringPoint;
|
// equlog.FailureEndTime = DateTimeHelper.GetDateTime();
|
// }
|
|
// }
|
//}
|
//if (loginfo.ischeckMessageStatus)
|
//{//告警状态发生变更
|
// //说明是一个新告警，需要更新设备监控表
|
// //查找未结束的告警
|
// var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
|
// && o.WarnStartTime != null && o.WarnStartTime != DateTime.MinValue).OrderByDescending(o => o.WarnStartTime).FirstOrDefault();
|
// if (loginfo.IsMessage)
|
// {
|
// if (equlog == null || (equlog.WarnEndTime != null && equlog.WarnEndTime > DateTime.MinValue))
|
// {
|
// info.WarnTime = DateTime.SpecifyKind(DateTime.Now, DateTimeKind.Local);
|
// infolog.WarnStartTime = DateTimeHelper.GetDateTime();
|
// infolog.WarnType = alertall;
|
// infolog.Warnmsg = warnmsg;
|
// infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
// infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
// infolog.Remarks = "告警信息出现变更2";
|
// infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + "告警信息变更\r\n";
|
// isAddEquipmentWorkingLog = true;
|
// }
|
// }
|
// else
|
// {
|
// if (equlog != null && (equlog.WarnEndTime == null || equlog.WarnEndTime <= DateTime.MinValue))
|
// {//告警关闭的，若没有告警信息，不用管
|
// equlog.MonitoringPoint = loginfo.MonitoringPoint;
|
// equlog.WarnEndTime = DateTimeHelper.GetDateTime();
|
// }
|
|
// }
|
//}
|
////故障》警告》其他
|
//if (loginfo.IsCloseAlert)
|
//{//故障
|
// info.AlertTime = info.AlertTime??DateTime.Now;
|
// info.FailureType = "";
|
// info.WarnType = "";
|
// info.Alertmsg = faultmsg;//这个需要代码对应字典维护信息才知道
|
// info.FailureType = faultall;
|
// State = ((int)EnumEquipmentCurrentStateDisplay.故障).ToString();
|
|
|
// infolog.FailureStartTime = DateTimeHelper.GetDateTime();
|
// infolog.FailureType = faultall;
|
// infolog.FailureMsg = faultmsg;
|
// if (loginfo.IsMessage)
|
// {
|
// info.WarnTime = info.WarnTime ?? DateTime.Now;
|
// info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
|
// info.WarnType = alertall;
|
// }
|
//}
|
//else if(loginfo.IsMessage)
|
//{//警告
|
// info.AlertTime = null;
|
// info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
|
// info.FailureType = "";
|
|
// info.WarnTime = info.WarnTime ?? DateTime.Now;
|
// info.Warnmsg = warnmsg;//这个需要代码对应字典维护信息才知道
|
// info.WarnType = alertall;
|
|
// infolog.WarnStartTime = DateTimeHelper.GetDateTime();
|
// infolog.WarnType = alertall;
|
// infolog.Warnmsg = warnmsg;
|
// State = ((int)EnumEquipmentCurrentStateDisplay.警告).ToString();
|
//}
|
//else
|
//{//告警结束，获取有告警的数据，然后关闭他
|
// info.AlertTime = null;
|
// info.Alertmsg = "";//这个需要代码对应字典维护信息才知道
|
// info.FailureType = "";
|
// info.WarnType = "";
|
// info.WarnTime = null;
|
// info.Warnmsg = "";
|
// if (loginfo.IsNormalProduction&& loginfo.LackMaterial)
|
// {
|
// State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
|
// }
|
// else if(loginfo.IsNormalProduction && !loginfo.LackMaterial)
|
// {
|
// State = ((int)EnumEquipmentCurrentStateDisplay.生产).ToString();
|
// }
|
// else if(loginfo.IsNormalProduction && loginfo.FullMaterial)
|
// {//正常生产+下料道满料 = 完成 （就是有生产出来但没有出设备）
|
// State = ((int)EnumEquipmentCurrentStateDisplay.完成).ToString();
|
// }
|
// else
|
// {//理论上不可能走到这，只是避免空值
|
// State = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
|
// }
|
//}
|
//if (!string.IsNullOrEmpty(State) && State != info.EquipmentCurrentState)
|
//{//只有状态出现变化才变更
|
// info.UpdatedUserName = loginfo.MonitoringPoint;
|
// info.UpdatedTime = DateTime.Now;
|
// info.EquipmentCurrentState = State;
|
|
// var equlog = db.EquipmentWorkingLog.Where(o => o.EquipmentID == loginfo.EquipmentID
|
// && o.EquipmentStateStartTime != null && o.EquipmentStateStartTime != DateTime.MinValue).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
|
|
// if (equlog != null && (equlog.EquipmentStateEndTime == null || equlog.EquipmentStateEndTime <= DateTime.MinValue))
|
// {
|
// equlog.MonitoringPoint = loginfo.MonitoringPoint;
|
// equlog.EquipmentStateEndTime = DateTimeHelper.GetDateTime();
|
|
// }
|
// //状态变更，需要更新原来的，并插入新的
|
// infolog.EquipmentState = State;
|
// infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
|
// infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
// infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
// infolog.Remarks = "告警信息出现变更3";
|
// infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(State)).ToString()}\r\n";
|
// isAddEquipmentWorkingLog = true;
|
//}
|
////info.Remarks = $"{loginfo.WorkingProcedure}工序告警";
|
#endregion
|
if (isAddEquipmentCurrentMonitor)
|
{
|
info.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
db.EquipmentCurrentMonitor.Add(info);
|
}
|
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}");
|
}
|
|
//db.WorkPieceLog.Add(loginfo2);//插入设备采集日志表
|
db.SaveChanges();
|
}
|
}
|
|
|
/// <summary>
|
/// 心跳监控
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <param name="type"></param>
|
public static void EquipmentBeartBeatMonitor(WorkPieceLogMiddle loginfo, LogType type)
|
{
|
|
using (DbModel db = new DbModel())
|
{
|
bool isAddEquipmentCurrentMonitor = false;
|
EquipmentCurrentMonitor info = new EquipmentCurrentMonitor();
|
info = db.EquipmentCurrentMonitor.Where(o => o.WorkingProcedure == loginfo.WorkingProcedure).FirstOrDefault();
|
if (info == null)
|
{//没有工件信息，不做更新
|
Log4NetHelper.WriteErrorLog(type, $"设备{loginfo.EquipmentID} 告警监控{loginfo.MonitoringPoint} 没有获取到设备监控信息，现新增");
|
info = EntityPropHelper.Mapper<EquipmentCurrentMonitor, WorkPieceLogMiddle>(loginfo);
|
isAddEquipmentCurrentMonitor = true;
|
info.EquipmentCurrentState = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
|
info.IsDeleted = false;
|
}
|
string state = "";
|
|
|
EquipmentWorkingLog infolog = new EquipmentWorkingLog();
|
infolog.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
infolog.LogAddTime = DateTimeHelper.GetDateTime();
|
infolog.WorkPieceLogID = loginfo.Id;
|
infolog.EquipmentID = info.EquipmentID;
|
bool isAddEquipmentWorkingLog = false;
|
|
if (!loginfo.IsConnect)
|
{//最新状态为离线
|
state = ((int)EnumEquipmentCurrentStateDisplay.离线).ToString();
|
info.EquipmentCurrentState = state;
|
info.UpdatedUserName = loginfo.MonitoringPoint;
|
info.UpdatedTime = DateTime.Now;
|
info.Alertmsg = "设备离线";
|
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)
|
).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
|
|
if (equlog == null)
|
{
|
infolog.EquipmentState = state;
|
infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
|
infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
infolog.Remarks = "离线";
|
infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(state)).ToString()}\r\n";
|
isAddEquipmentWorkingLog = true;
|
}
|
//若有非离线的状态数据，则更新
|
var equlog2 = 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)
|
).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
|
if (equlog2 != null)
|
{
|
equlog2.MonitoringPoint = loginfo.MonitoringPoint;
|
equlog2.EquipmentStateEndTime = DateTimeHelper.GetDateTime();
|
}
|
|
}
|
else
|
{//最新状态为开机
|
if (((int)EnumEquipmentCurrentStateDisplay.离线).ToString() == info.EquipmentCurrentState)
|
{//只有离线状态，才能变成开机
|
state = ((int)EnumEquipmentCurrentStateDisplay.待机).ToString();
|
info.EquipmentCurrentState = state;
|
info.UpdatedUserName = loginfo.MonitoringPoint;
|
info.UpdatedTime = DateTime.Now;
|
info.Alertmsg = "";
|
info.AlertTime = null;
|
|
//有离线的数据，则更新
|
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(((int)EnumEquipmentCurrentStateDisplay.离线).ToString())
|
).OrderByDescending(o => o.EquipmentStateStartTime).FirstOrDefault();
|
if (equlog != null)
|
{
|
equlog.MonitoringPoint = loginfo.MonitoringPoint;
|
equlog.EquipmentStateEndTime = DateTimeHelper.GetDateTime();
|
|
}
|
//离线变开机，肯定会插入一条
|
infolog.EquipmentState = state;
|
infolog.EquipmentStateStartTime = DateTimeHelper.GetDateTime();
|
infolog.WorkingProcedure = loginfo.WorkingProcedure;
|
infolog.MonitoringPoint = loginfo.MonitoringPoint;
|
infolog.Remarks = "开机";
|
infolog.UpdateDesc = (infolog.UpdateDesc ?? "") + $"设备状态变更为{((EnumEquipmentCurrentStateDisplay)int.Parse(state)).ToString()}\r\n";
|
isAddEquipmentWorkingLog = true;
|
}
|
}
|
if (isAddEquipmentWorkingLog)
|
{
|
db.EquipmentWorkingLog.Add(infolog);
|
}
|
if (isAddEquipmentCurrentMonitor)
|
{
|
info.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
db.EquipmentCurrentMonitor.Add(info);
|
}
|
|
db.SaveChanges();
|
}
|
}
|
|
public static void ThreadMonitor(ThreadStatusMonitorMiddle threadinfo)
|
{
|
ThreadMonitor(EntityPropHelper.Mapper<ThreadStatusMonitor, ThreadStatusMonitorMiddle>(threadinfo));
|
try
|
{
|
SystemValue.UpdateMainList(threadinfo);
|
|
}
|
catch (Exception ex)
|
{
|
|
}
|
}
|
public static void ThreadMonitor(ThreadStatusMonitor threadinfo)
|
{
|
try
|
{
|
using (DbModel db = new DbModel())
|
{
|
var info = db.ThreadStatusMonitor.Where(o => o.Threadcode == threadinfo.Threadcode).FirstOrDefault();
|
if (info == null || info.Id == 0)
|
{//没有工件信息，不做更新
|
threadinfo.Id = Yitter.IdGenerator.YitIdHelper.NextId();
|
threadinfo.CreatedTime = DateTimeHelper.GetDateTime();
|
threadinfo.CreatedUserName = threadinfo.Threadcode;
|
db.ThreadStatusMonitor.Add(threadinfo);
|
|
}
|
else
|
{//更新表WorkPieceInfo
|
info.Remarks = threadinfo.Remarks;
|
info.ErrorMsg = threadinfo.ErrorMsg;
|
info.Threadendtime = DateTimeHelper.GetDateTime();//每次都更新
|
info.ThreadId = threadinfo.ThreadId;
|
info.ThreadFrequency = threadinfo.ThreadFrequency;
|
info.UpdatedTime = DateTimeHelper.GetDateTime();
|
info.UpdatedUserName = threadinfo.Threadcode;
|
info.Threadlastmodifytime = threadinfo.Threadlastmodifytime > DateTime.MinValue ? threadinfo.Threadlastmodifytime : info.Threadlastmodifytime;//如果有传参则更新
|
//if (info.Threadstatue==1)
|
//{
|
// info.Threadlastmodifytime = DateTimeHelper.GetDateTime();//最新跑到数据
|
//}
|
}
|
db.SaveChanges();
|
}
|
|
}
|
catch (Exception ex)
|
{
|
|
}
|
}
|
|
#region 业务方法
|
|
/// <summary>
|
/// 【质量数据更新专用】 dict中前面一个是原对象，后面一个是目标对象
|
/// </summary>
|
/// <param name="WorkingProcedure"></param>
|
/// <returns></returns>
|
public static Dictionary<string, string> GetQualityDataInfoUpdate(WorkPieceLogMiddle logMiddle, string WorkingProcedure = "", string MonitoringPoint = "")
|
{
|
Dictionary<string, string> dict = new Dictionary<string, string>();
|
|
dict.Add("QualityState", "QualityState");
|
dict.Add("EquipmentID", "EquipmentID");
|
dict.Add("WorkingProcedure", "WorkingProcedure");
|
dict.Add("QualityStateUpdateMode", "QualityStateUpdateMode");
|
dict.Add("QualityStateUpdateUser", "QualityStateUpdateUser");
|
dict.Add("OfflineTime", "OfflineTime");
|
|
switch (WorkingProcedure)
|
{
|
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":
|
dict.Add("QualityOP30To1", "QualityOP30To1");
|
break;
|
case "OP3002CH4":
|
dict.Add("QualityOP30To2", "QualityOP30To2");
|
dict.Add("QualityOP30To8", "QualityOP30To8");
|
break;
|
case "OP3002CH5":
|
dict.Add("QualityOP30To3", "QualityOP30To3");
|
dict.Add("QualityOP30To4", "QualityOP30To4");
|
dict.Add("QualityOP30To5", "QualityOP30To5");
|
dict.Add("QualityOP30To9", "QualityOP30To9");
|
dict.Add("QualityOP30To10", "QualityOP30To10");
|
dict.Add("QualityOP30To11", "QualityOP30To11");
|
break;
|
case "OP3002CH6":
|
dict.Add("QualityOP30To6", "QualityOP30To6");
|
dict.Add("QualityOP30To7", "QualityOP30To7");
|
break;
|
default:
|
break;
|
}
|
break;
|
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");
|
dict.Add("QualityOP70To2", "QualityOP70To2");
|
dict.Add("QualityOP70To3", "QualityOP70To3");
|
break;
|
case "OP80":
|
//dict.Add("OP80NewCode", "OP80NewCode");
|
dict.Add("QualityOP80To1", "QualityOP80To1");
|
dict.Add("QualityOP80To2", "QualityOP80To2");
|
dict.Add("QualityOP80To3", "QualityOP80To3");
|
dict.Add("QualityOP80To4", "QualityOP80To4");
|
dict.Add("QualityOP80To5", "QualityOP80To5");
|
dict.Add("QualityOP80To6", "QualityOP80To6");
|
dict.Add("QualityOP80To7", "QualityOP80To7");
|
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;
|
}
|
|
|
/// <summary>
|
/// 判断是否跳序
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <param name="type"></param>
|
public static bool CheckQualityInfoComplete(WorkPieceInfo info, WorkPieceLog loginfo, LogType type)
|
{
|
//判断是否跳序
|
if (info == null || info.WorkPieceID.Length < 1)
|
{
|
Log4NetHelper.WriteErrorLog(type, $"校验工件信息{loginfo.WorkPieceID}工序是否跳序时，传入工件信息异常");
|
return true;//没取到工件信息，不做判断是否跳序
|
}
|
else
|
{
|
try
|
{
|
string wproStr = info.WorkingProcedureCurrent + loginfo.WorkingProcedure;
|
if (wproStr.Length != 8)
|
{
|
Log4NetHelper.WriteErrorLog(type, $"校验工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序 是否跳序时，工序拼接有问题长度不为8位:{wproStr}");
|
return true;//工序拼接有问题
|
}
|
if (!ConfigHelper.GetConfigString("WorkingProcedureAllStr").Contains(wproStr))
|
{
|
Log4NetHelper.WriteErrorLog(type, $"校验工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序 出现跳序，请设备注意:{wproStr}");
|
return false;
|
}
|
|
}
|
catch (Exception ex)
|
{
|
Log4NetHelper.WriteErrorLog(type, $"校验工件{info.WorkPieceID} {loginfo.WorkingProcedure}工序 是否跳序时出现异常", ex);
|
}
|
}
|
return true;
|
|
//using (var trans = db.Database.BeginTransaction())
|
//{ }
|
|
//var conStr = @"server=localhost;Database=EFDBO1;User ID=sa;Password=123456;";
|
//using (var connection = new SqlConnection(conStr))
|
//{
|
// connection.Open();
|
// using (var scope = new Transactionscope())
|
// {
|
|
// //AD0.Net
|
// var command = connection.CreateCommand();
|
// command.CommandText = "DELETE FROM T_RoleInfor";
|
// command.ExecuteNonQuery();
|
// //综合提交
|
// scope.complete();
|
// }
|
//}
|
}
|
/// <summary>
|
/// 解析二维码
|
|
/// </summary>
|
/// <param name="loginfo"></param>
|
/// <returns></returns>
|
public static WorkPieceInfo ParseQRCode(WorkPieceInfo loginfo)
|
{
|
if (string.IsNullOrEmpty(loginfo.WorkPieceID) || loginfo.WorkPieceID.Length != 22)
|
{
|
return loginfo;
|
}
|
loginfo.WorkPieceIDTo1 = loginfo.WorkPieceID.Substring(0, 2);
|
loginfo.WorkPieceIDTo2 = loginfo.WorkPieceID.Substring(2, 4);
|
loginfo.WorkPieceIDTo3 = loginfo.WorkPieceID.Substring(6, 6);
|
loginfo.WorkPieceIDTo4 = loginfo.WorkPieceID.Substring(12, 2);
|
loginfo.WorkPieceIDTo5 = loginfo.WorkPieceID.Substring(14, 4);
|
loginfo.WorkPieceIDTo6 = loginfo.WorkPieceID.Substring(18, 2);
|
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
|
}
|
}
|
