/// <summary>
/// 检查是否要HOLD批次。如果需要HOLD批次，则HOLD批次。
/// </summary>
/// <param name="dbtran">数据库事务对象。。</param>
/// <param name="lotKey">批次主键。</param>
/// <param name="stepKey">工步主键。</param>
/// <param name="shiftName">班别名称。</param>
/// <param name="shiftKey">班别主键。</param>
/// <param name="editor">编辑人。</param>
/// <param name="oprComputer">操作计算机名称。</param>
/// <param name="editTimeZone">编辑时间时区。</param>
/// <param name="action">动作名称。<see cref="COMMON_FIELDS.FIELD_ACTIVITY_TRACKIN"/>或者<see cref="COMMON_FIELDS.FIELD_ACTIVITY_TRACKOUT"/></param>
/// <returns>触发预设暂停的个数。0：没有批次被HOLD。>0：该批次被HOLD。</returns>
private int CheckAndUpdateFutureHold(DbTransaction dbtran, string lotKey, string stepKey,
string shiftName, string shiftKey,
string editor, string oprComputer, string editTimeZone, string action)
{
string sql = @"SELECT * FROM WIP_FUTUREHOLD
WHERE LOT_KEY=@lotKey AND STEP_KEY=@stepKey AND STATUS=1 AND ACTION_NAME=@action
ORDER BY EDIT_TIME DESC";
DbCommand dbCmd = db.GetSqlStringCommand(sql);
db.AddInParameter(dbCmd, "lotKey", DbType.String, lotKey);
db.AddInParameter(dbCmd, "stepKey", DbType.String, stepKey);
db.AddInParameter(dbCmd, "action", DbType.String, action);
DataSet dsFutureHold = db.ExecuteDataSet(dbCmd, dbtran);
int nRet = 0;
if (dsFutureHold != null && dsFutureHold.Tables.Count > 0 && dsFutureHold.Tables[0].Rows.Count > 0)
{
DataTable dtFutureHold = dsFutureHold.Tables[0];
DataRow drFutureHold = dtFutureHold.Rows[0];
string transactionKey = UtilHelper.GenerateNewKey(0);
string rcCodeKey = Convert.ToString(drFutureHold[WIP_FUTUREHOLD_FIELDS.FIELDS_REASON_CODE_KEY]);
string rcCodeName = Convert.ToString(drFutureHold[WIP_FUTUREHOLD_FIELDS.FIELDS_REASON_CODE]);
string comment = Convert.ToString(drFutureHold[WIP_FUTUREHOLD_FIELDS.FIELDS_REMARK]);
string opUser = Convert.ToString(drFutureHold[WIP_FUTUREHOLD_FIELDS.FIELDS_EDITOR]);
Hashtable htParams = new Hashtable();
htParams[POR_LOT_FIELDS.FIELD_LOT_KEY] = lotKey;
htParams[WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY] = transactionKey;
htParams[WIP_HOLD_RELEASE_FIELDS.FIELD_REASON_CODE_KEY] = rcCodeKey;
htParams[WIP_HOLD_RELEASE_FIELDS.FIELD_REASON_CODE_NAME] = rcCodeName;
htParams[WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY_COMMENT] = comment;
htParams[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_NAME] = shiftName;
htParams[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_KEY] = shiftKey;
htParams[WIP_TRANSACTION_FIELDS.FIELD_OPR_COMPUTER] = oprComputer;
htParams[WIP_TRANSACTION_FIELDS.FIELD_OPERATOR] = opUser;
htParams[WIP_TRANSACTION_FIELDS.FIELD_EDITOR] = opUser;
htParams[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY] = editTimeZone;
DataTable dtParams = SolarViewer.Hemera.Share.Common.CommonUtils.ParseToDataTable(htParams);
dtParams.TableName = TRANS_TABLES.TABLE_MAIN_DATA;
DataSet dsParams = new DataSet();
dsParams.Tables.Add(dtParams);
WipManagement.HoldLot(db, dbtran, dsParams);
sql = @"UPDATE WIP_FUTUREHOLD
SET STATUS=0,EDITOR=@editor,EDIT_TIME= GETDATE()
WHERE LOT_KEY=@lotKey AND STEP_KEY=@stepKey AND STATUS=1 AND ACTION_NAME=@action";
dbCmd = db.GetSqlStringCommand(sql);
db.AddInParameter(dbCmd, "lotKey", DbType.String, lotKey);
db.AddInParameter(dbCmd, "stepKey", DbType.String, stepKey);
db.AddInParameter(dbCmd, "action", DbType.String, action);
db.AddInParameter(dbCmd, "editor", DbType.String, editor);
nRet = db.ExecuteNonQuery(dbCmd, dbtran);
}
return(nRet);
}
/// <summary>
/// 批次终结操作。
/// </summary>
/// <param name="dsParams">包含批次终结数据的数据集。</param>
/// <returns>包含执行结果的数据集。</returns>
public DataSet TerminalLot(DataSet dsParams)
{
DateTime startTime = DateTime.Now;
DataSet dsReturn = new DataSet();
DbConnection dbConn = null;
DbTransaction dbTran = null;
try
{
dbConn = db.CreateConnection();
dbConn.Open();
//Create Transaction
dbTran = dbConn.BeginTransaction();
#region CheckExpired
if (dsParams.Tables.Contains(TRANS_TABLES.TABLE_PARAM))
{
DataTable dtParams = dsParams.Tables[TRANS_TABLES.TABLE_PARAM];
Hashtable htParams = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtParams);
string lotKey = htParams[POR_LOT_FIELDS.FIELD_LOT_KEY].ToString();
string strEditTime = htParams[POR_LOT_FIELDS.FIELD_EDIT_TIME].ToString();
KeyValuePair <string, string> kvp = new KeyValuePair <string, string>(POR_LOT_FIELDS.FIELD_LOT_KEY, lotKey);
List <KeyValuePair <string, string> > listCondition = new List <KeyValuePair <string, string> >();
listCondition.Add(kvp);
if (UtilHelper.CheckRecordExpired(db, POR_LOT_FIELDS.DATABASE_TABLE_NAME, listCondition, strEditTime))
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, COMMON_FIELDS.FIELD_COMMON_EDITTIME_EXP);
return(dsReturn);
}
}
#endregion
WipManagement.TerminalLot(db, dbTran, dsParams);
dbTran.Commit();
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, string.Empty);
}
catch (Exception ex)
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
LogService.LogError("TerminalLot Error: " + ex.Message);
dbTran.Rollback();
}
finally
{
dbConn.Close();
dbTran.Dispose();
dbConn.Dispose();
}
DateTime endTime = DateTime.Now;
LogService.LogInfo("TerminalLot Time: " + (endTime - startTime).TotalMilliseconds.ToString());
return(dsReturn);
}
/// <summary>
/// 批次出站或者重工操作更新设备信息。
/// </summary>
/// <param name="dbtran">数据库事务对象。</param>
/// <param name="dataset">包含批次出站数据的数据集对象。</param>
private void TrackOutOrReworkForEquipment(DbTransaction dbtran, DataSet dataset)
{
string lotKey = "", stepKey = "", userKey = "";
string equipmentKey = "";
if (dataset.Tables.Contains(TRANS_TABLES.TABLE_PARAM))
{
DataTable mainTable = dataset.Tables[TRANS_TABLES.TABLE_PARAM];
Hashtable hashData = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(mainTable);
lotKey = hashData[POR_LOT_FIELDS.FIELD_LOT_KEY].ToString();
stepKey = hashData[WIP_TRANSACTION_FIELDS.FIELD_STEP_KEY].ToString();
userKey = hashData[WIP_TRANSACTION_FIELDS.FIELD_EDITOR].ToString();
}
if (dataset.Tables.Contains(EMS_EQUIPMENTS_FIELDS.DATABASE_TABLE_NAME))
{
DataTable equTable = dataset.Tables[EMS_EQUIPMENTS_FIELDS.DATABASE_TABLE_NAME];
Hashtable equHashData = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(equTable);
equipmentKey = equHashData[EMS_EQUIPMENTS_FIELDS.FIELD_EQUIPMENT_KEY].ToString();
}
WipManagement.TrackOutForEquipment(lotKey, stepKey, equipmentKey, userKey, dbtran);
}
/// <summary>
/// 进行批次报废操作。
/// </summary>
/// <param name="dsParams">
/// 包含批次报废数据信息的数据集对象。
/// 必须包含名称为<see cref=" TRANS_TABLES.TABLE_PARAM"/>的数据表，用于存储批次主信息的数据。
/// 包含名称为<see cref=" WIP_SCRAP_FIELDS.DATABASE_TABLE_NAME"/>的数据表（可选），用于存储批次报废的数据。
/// </param>
/// <returns>包含执行结果的数据集。</returns>
public DataSet LotLossBonus(DataSet dsParams)
{
System.DateTime startTime = System.DateTime.Now;
DataSet dsReturn = new DataSet();
DbConnection dbConn = null;
DbTransaction dbTran = null;
string lotKey = string.Empty, editor = string.Empty, editTimeZone = string.Empty, qty = string.Empty;
try
{
dbConn = db.CreateConnection();
dbConn.Open();
//Create Transaction
dbTran = dbConn.BeginTransaction();
#region CheckExpired 检查记录是否过期。防止重复修改。
if (dsParams.Tables.Contains(TRANS_TABLES.TABLE_PARAM))
{
DataTable dtParams = dsParams.Tables[TRANS_TABLES.TABLE_PARAM];
Hashtable htParams = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtParams);
lotKey = htParams[POR_LOT_FIELDS.FIELD_LOT_KEY].ToString();
qty = htParams[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT].ToString();
editor = htParams[WIP_TRANSACTION_FIELDS.FIELD_EDITOR].ToString();
editTimeZone = htParams[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY].ToString();
string strEditTime = htParams[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIME].ToString();
KeyValuePair <string, string> kvp = new KeyValuePair <string, string>(POR_LOT_FIELDS.FIELD_LOT_KEY, lotKey);
List <KeyValuePair <string, string> > listCondition = new List <KeyValuePair <string, string> >();
listCondition.Add(kvp);
//如果记录过期，当前编辑时间<数据库中的记录编辑时间。结束方法执行。
if (UtilHelper.CheckRecordExpired(db, POR_LOT_FIELDS.DATABASE_TABLE_NAME, listCondition, strEditTime))
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, COMMON_FIELDS.FIELD_COMMON_EDITTIME_EXP);
return(dsReturn);
}
}
#endregion
//进行报废数据收集。
WipManagement.SetLossBonus(db, dbTran, dsParams);
//更新批次数量。
string sql = string.Format(@"UPDATE POR_LOT
SET QUANTITY='{0}',EDITOR='{1}',EDIT_TIME=GETDATE(),EDIT_TIMEZONE='{2}'
WHERE LOT_KEY='{3}'",
qty.PreventSQLInjection(),
editor.PreventSQLInjection(),
editTimeZone.PreventSQLInjection(),
lotKey.PreventSQLInjection());
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
dbTran.Commit();
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "");
}
catch (Exception ex)
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
LogService.LogError("LotLossBonus Error: " + ex.Message);
dbTran.Rollback();
}
finally
{
dbConn.Close();
}
System.DateTime endTime = System.DateTime.Now;
LogService.LogInfo("LotLossBonus Time: " + (endTime - startTime).TotalMilliseconds.ToString());
return(dsReturn);
}
/// <summary>
/// 执行批次进站作业。
/// </summary>
/// <param name="dsParams">
/// 数据集对象。包含名称为<see cref="TRANS_TABLES.TABLE_PARAM"/>的数据表。
/// 数据表中必须包含两个列"name"和"value"。列name存放哈希表的键名，列value存放哈希表键对应的键值。</param>
/// <returns>
/// 包含执行结果的数据集。
/// 0：成功。-1或1：失败。 2：需要进行数据采集。
/// </returns>
public DataSet TrackInLot(DataSet dsParams)
{
DateTime startTime = DateTime.Now;
DataSet dsReturn = new DataSet();
string sql = "";
DbConnection dbconn = null;
DbTransaction dbtran = null;
string lotKey = "",
lineKey = "",
workOrderKey = "",
stepKey = "",
quantityIn = "",
user = "",
editTime = "",
lotNumber = "",
strEquKey = "",
strEquStateKey = "",
strOperationKey = "",
strIsBatch = "",
maxQuantity = "",
inProductQuantity = "",
isAutoTrackOut = string.Empty,
oprLine = string.Empty,
shiftName = string.Empty,
lineName = string.Empty,
editTimeZone = string.Empty,
shiftKey = string.Empty,
operateCompName = string.Empty;
try
{
dbconn = db.CreateConnection();
dbconn.Open();
//Create Transaction
dbtran = dbconn.BeginTransaction();
//如果数据集中包含TRANS_TABLES.TABLE_PARAM的数据表
if (dsParams.Tables.Contains(TRANS_TABLES.TABLE_PARAM))
{
DataTable dtParams = dsParams.Tables[TRANS_TABLES.TABLE_PARAM];
Hashtable htParams = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtParams);
lotKey = htParams[POR_LOT_FIELDS.FIELD_LOT_KEY].ToString();
lotNumber = htParams[POR_LOT_FIELDS.FIELD_LOT_NUMBER].ToString();
lineKey = htParams[WIP_TRANSACTION_FIELDS.FIELD_LINE_KEY].ToString();
workOrderKey = htParams[WIP_TRANSACTION_FIELDS.FIELD_WORK_ORDER_KEY].ToString();
stepKey = htParams[WIP_TRANSACTION_FIELDS.FIELD_STEP_KEY].ToString();
quantityIn = htParams[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_IN].ToString();
user = htParams[WIP_TRANSACTION_FIELDS.FIELD_EDITOR].ToString();
editTime = htParams[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIME].ToString();
editTimeZone = htParams[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY].ToString();
oprLine = htParams[WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE].ToString();
shiftName = htParams[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_NAME].ToString();
lineName = htParams[POR_LOT_FIELDS.FIELD_LINE_NAME].ToString();
shiftKey = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_KEY]);
operateCompName = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_OPR_COMPUTER]);
}
#region 检查记录是否过期。
KeyValuePair <string, string> kvp = new KeyValuePair <string, string>(POR_LOT_FIELDS.FIELD_LOT_KEY, lotKey);
List <KeyValuePair <string, string> > listCondition = new List <KeyValuePair <string, string> >();
listCondition.Add(kvp);
//判断数据是否过期，如果过期，则返回执行结果为“数据已过期。”，结束方法执行。
if (UtilHelper.CheckRecordExpired(db, POR_LOT_FIELDS.DATABASE_TABLE_NAME, listCondition, editTime))
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, 1, "数据已过期");
return(dsReturn);
}
#endregion
DateTime dtCurrent = UtilHelper.GetSysdate(db);
#region 检查设备
//如果数据集合中包含EMS_EQUIPMENTS_FIELDS.DATABASE_TABLE_NAME数据表对象。
if (dsParams.Tables.Contains(EMS_EQUIPMENTS_FIELDS.DATABASE_TABLE_NAME))
{
DataTable equDataTable = dsParams.Tables[EMS_EQUIPMENTS_FIELDS.DATABASE_TABLE_NAME];
Hashtable equHashData = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(equDataTable);
strEquKey = equHashData[EMS_EQUIPMENTS_FIELDS.FIELD_EQUIPMENT_KEY].ToString();
strOperationKey = equHashData[POR_ROUTE_OPERATION_VER_FIELDS.FIELD_ROUTE_OPERATION_VER_KEY].ToString();
//如果设备主键有值。
if (strEquKey != "" && strEquKey.Length > 0)
{
sql = @"SELECT a.ISBATCH,a.EQUIPMENT_STATE_KEY,a.MAXQUANTITY ,b.EQUIPMENT_STATE_TYPE,b.EQUIPMENT_STATE_NAME
FROM EMS_EQUIPMENTS a
LEFT JOIN EMS_EQUIPMENT_STATES b ON a.EQUIPMENT_STATE_KEY=b.EQUIPMENT_STATE_KEY
WHERE EQUIPMENT_KEY='" + strEquKey.PreventSQLInjection() + "'";
DataSet dsEqu = db.ExecuteDataSet(CommandType.Text, sql);//查询设备
//如果有数据。
if (dsEqu.Tables[0].Rows.Count > 0)
{
strIsBatch = Convert.ToString(dsEqu.Tables[0].Rows[0][EMS_EQUIPMENTS_FIELDS.FIELD_ISBATCH]); //设备是否是批处理设备。
strEquStateKey = Convert.ToString(dsEqu.Tables[0].Rows[0][EMS_EQUIPMENTS_FIELDS.FIELD_EQUIPMENT_STATE_KEY]); //设备状态。
maxQuantity = Convert.ToString(dsEqu.Tables[0].Rows[0][EMS_EQUIPMENTS_FIELDS.FIELD_MAXQUANTITY]); //最大数量。
string strEquStateName = Convert.ToString(dsEqu.Tables[0].Rows[0][EMS_EQUIPMENT_STATES_FIELDS.FIELD_EQUIPMENT_STATE_NAME]); //设备状态名称。
string strEquStateType = Convert.ToString(dsEqu.Tables[0].Rows[0][EMS_EQUIPMENT_STATES_FIELDS.FIELD_EQUIPMENT_STATE_TYPE]); //设备状态类型。
#region 检查设备状态
//如果设备状态不是“待产”
if (strEquStateType != "LOST")
{
//如果设备状态是“在产”
if (strEquStateType == "RUN")
{
//如果是批处理设备。
if (strIsBatch == "1")
{
//获取设备在产数量。
sql = @"SELECT ISNULL(SUM(T.QUANTITY),0) AS INQUANTITY
FROM EMS_LOT_EQUIPMENT T
WHERE T.EQUIPMENT_KEY = '" + strEquKey + "' AND T.END_TIMESTAMP IS NULL";
DataSet dsLotEqu = db.ExecuteDataSet(CommandType.Text, sql);
if (dsLotEqu.Tables[0].Rows.Count > 0 && !string.IsNullOrEmpty(maxQuantity))//获取设备在产数量成功
{
inProductQuantity = dsLotEqu.Tables[0].Rows[0]["inQuantity"].ToString();
//在产数量>设备的最大数量，结束方法执行。
if (Convert.ToInt32(inProductQuantity) + Convert.ToInt32(quantityIn) > Convert.ToInt32(maxQuantity))
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "${res:SolarViewer.Hemera.Modules.Wip.WipEngine.Msg.BigThenMaxQuantity}");
return(dsReturn);
}
}
}
else
{
//如果不是批处理设备，结束方法执行。
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "${res:SolarViewer.Hemera.Modules.Wip.WipEngine.Msg.BatchIsFalse}");
return(dsReturn);
}
}
else
{
//如果设备状态不是在产，结束方法执行。
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "${res:SolarViewer.Hemera.Modules.Wip.WipEngine.Msg.EquipmentCanNotUser}");
return(dsReturn);
}
}
#endregion
}
else//获取设备数据失败。
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "${res:SolarViewer.Hemera.Modules.Wip.WipEngine.Msg.GetEquipmentError}");
return(dsReturn);
}
}
}
#endregion
//批次进站，更新批次数据，插入批次进站操作记录。
WipManagement.TrackInLot(db, dbtran, dsParams);
//设备主键不为空。
if (strEquKey != "")
{
//批次和设备进行关联。
WipManagement.TrackInForEquipment(lotKey, Convert.ToInt32(quantityIn), strOperationKey, stepKey, strEquKey, user, dbtran);
}
#region 检查自动合批
//工步主键不为空。
if (stepKey != "")
{
string isLastStep = "";
string isAutoMerge = "";
int maxBoxQuantity = -1;
DataSet dsStepUda = GetStepUda(stepKey);
//如果获取到工步自定义属性数据。
if (dsStepUda.Tables[0].Rows.Count > 0)
{
//遍历工序的自定义属性。
for (int i = 0; i < dsStepUda.Tables[0].Rows.Count; i++)
{
string szAttriName = dsStepUda.Tables[0].Rows[i][POR_ROUTE_STEP_ATTR_FIELDS.FIELD_ATTRIBUTE_NAME].ToString();
string szAttriValue = dsStepUda.Tables[0].Rows[i][POR_ROUTE_STEP_ATTR_FIELDS.FIELD_ATTRIBUTE_VALUE].ToString();
//是否是最后一个工步。
if (szAttriName == "IsLastStep")
{
isLastStep = szAttriValue;
}
//是否自动合批。
if (szAttriName == "AutoMerge")
{
isAutoMerge = szAttriValue;
}
//箱子最大数量。
if (szAttriName == "MaxBoxQuantity" && !int.TryParse(szAttriValue, out maxBoxQuantity))
{
maxBoxQuantity = -1;
}
//是否自动出站。
if (szAttriName == "AutoTrackOut")
{
isAutoTrackOut = szAttriValue;
}
}
if (isAutoMerge.ToLower() == "true")//进行自动合批
{
AutoMerge(db, dbtran, lotKey, workOrderKey, stepKey, lineKey,
quantityIn, maxBoxQuantity, 4, user, false, oprLine, shiftName);
}
}
}
#endregion
#region 检查自动出站
//自动出站
if (isAutoTrackOut.ToLower() == "true")
{
DataSet dsInfo = GetLotsInfo(dbtran, lotKey);
//获取批次信息成功。
if (dsInfo.Tables.Count > 0 && dsInfo.Tables[0].Rows.Count > 0)
{
string nextRunTime = string.Empty;
string sDuration = Convert.ToString(dsInfo.Tables[0].Rows[0][POR_ROUTE_STEP_FIELDS.FIELD_DURATION]);
double duration = 0;
if (!double.TryParse(sDuration, out duration))
{
duration = 0;
}
nextRunTime = dtCurrent.AddMinutes(duration).ToString("yyyy-MM-dd HH:mm:ss");
Hashtable hashWipJob = new Hashtable();
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_EDIT_TIMEZONE, editTimeZone);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_EDITOR, user);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_EDIT_TIME, dtCurrent);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_ENTERPRISE_KEY, dsInfo.Tables[0].Rows[0][POR_LOT_FIELDS.FIELD_ROUTE_ENTERPRISE_VER_KEY].ToString());
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_JOB_CREATETIME, dtCurrent);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_EQUIPMENT_KEY, strEquKey);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_JOB_CLOSETYPE, string.Empty);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_JOB_NEXTRUNTIME, nextRunTime);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_JOB_RUNACCOUNT, "0");
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_JOB_STATUS, "0");
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_JOB_TYPE, ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_TRACKIN);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_LINE_NAME, lineName);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_LOT_KEY, lotKey);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_LOT_NUMBER, lotNumber);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_NOTIFY_USER, string.Empty);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_ROUTE_KEY, dsInfo.Tables[0].Rows[0][POR_LOT_FIELDS.FIELD_CUR_ROUTE_VER_KEY]);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_ROW_KEY, UtilHelper.GenerateNewKey(0));
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_STEP_KEY, dsInfo.Tables[0].Rows[0][POR_LOT_FIELDS.FIELD_CUR_STEP_VER_KEY]);
hashWipJob.Add(WIP_JOB_FIELDS.FIELDS_WORKORDER_NUMBER, dsInfo.Tables[0].Rows[0][POR_WORK_ORDER_FIELDS.FIELD_ORDER_NUMBER]);
//插入一笔自动过站任务。
WipJobAutoTrack.InsertWipJob(db, dbtran, hashWipJob);
}
}
#endregion
//检查是否需要进行数据采集。
string edcPointKey = string.Empty;
if (CheckNeedEdc(dbtran, lotKey, strEquKey, out edcPointKey))
{
IEDCEngine edcEngine = RemotingServer.ServerObjFactory.Get <IEDCEngine>();
edcEngine.SaveEdcMainInfo(dbtran, lotKey, edcPointKey, user, strEquKey, oprLine, shiftKey);
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, 2, "批次" + lotNumber + "需要抽检");
}
else
{
//更新批次状态为9（WaitingForTrackout）
UpdateLotState(dbtran, lotKey, 9);
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, 0, string.Empty);
}
//检查是否需要进行锁定。
CheckAndUpdateFutureHold(dbtran, lotKey, stepKey, shiftName, shiftKey, user,
operateCompName, editTimeZone, ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_TRACKIN);
dbtran.Commit();
}
catch (Exception ex)
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, 1, "批次进站出错" + ex.Message);
LogService.LogError("TrackInLot Error: " + ex.Message);
dbtran.Rollback();
}
finally
{
dbconn.Close();
}
System.DateTime endTime = System.DateTime.Now;
LogService.LogInfo("TrackIn Lot Time: " + (endTime - startTime).TotalMilliseconds.ToString());
return(dsReturn);
}
public DataSet TransferLotToStore(DataSet dataset)
{
//dataset.WriteXml(@"d:\TransferLotToStore.xml");
System.DateTime startTime = System.DateTime.Now;
DataSet dsReturn = new DataSet();
DbConnection dbconn = null;
DbTransaction dbtran = null;
string sql = "", storeKey = "", storeName = "", lotNumber = "";
string strEditor = "", strEditTimeZone = "", strEditTime = "";
string lotKey = "", stepKey = "";
if (dataset != null)
{
if (dataset.Tables.Contains(WST_STORE_MAT_FIELDS.DATABASE_TABLE_NAME))
{
WST_STORE_MAT_FIELDS tableFields = new WST_STORE_MAT_FIELDS();
DataTable dataTable = dataset.Tables[WST_STORE_MAT_FIELDS.DATABASE_TABLE_NAME];
storeName = dataTable.Rows[0][WST_STORE_FIELDS.FIELD_STORE_NAME].ToString();
lotNumber = dataTable.Rows[0][WST_STORE_MAT_FIELDS.FIELD_ITEM_NO].ToString();
strEditor = dataTable.Rows[0][WST_STORE_MAT_FIELDS.FIELD_EDITOR].ToString();
strEditTimeZone = dataTable.Rows[0][WST_STORE_MAT_FIELDS.FIELD_EDIT_TIMEZONE].ToString();
strEditTime = dataTable.Rows[0][WST_STORE_MAT_FIELDS.FIELD_EDIT_TIME].ToString();
lotKey = dataTable.Rows[0][POR_LOT_FIELDS.FIELD_LOT_KEY].ToString();
stepKey = dataTable.Rows[0][POR_LOT_FIELDS.FIELD_CUR_STEP_VER_KEY].ToString();
try
{
#region CheckRecordExpired
KeyValuePair <string, string> kvp = new KeyValuePair <string, string>(POR_LOT_FIELDS.FIELD_LOT_NUMBER, lotNumber);
List <KeyValuePair <string, string> > listCondition = new List <KeyValuePair <string, string> >();
listCondition.Add(kvp);
if (UtilHelper.CheckRecordExpired(db, POR_LOT_FIELDS.DATABASE_TABLE_NAME, listCondition, strEditTime))
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, COMMON_FIELDS.FIELD_COMMON_EDITTIME_EXP);
return(dsReturn);
}
#endregion
sql = @"SELECT STORE_KEY FROM WST_STORE WHERE STORE_NAME='" + storeName + "'";
IDataReader dataReader = db.ExecuteReader(CommandType.Text, sql);
if (dataReader.Read())
{
storeKey = dataReader["STORE_KEY"].ToString();
using (dbconn = db.CreateConnection())
{
dbconn.Open();
//Create Transaction
dbtran = dbconn.BeginTransaction();
try
{
#region insert record into store_mat
dataTable.Rows[0][WST_STORE_MAT_FIELDS.FIELD_EDIT_TIME] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
sql = DatabaseTable.BuildInsertSqlStatement(tableFields, dataTable, 0,
new Dictionary <string, string>()
{
{ WST_STORE_MAT_FIELDS.FIELD_STORE_KEY, storeKey },
{ WST_STORE_MAT_FIELDS.FIELD_ITEM_TYPE, "Lot" },
{ WST_STORE_MAT_FIELDS.FIELD_OBJECT_STATUS, "1" },
},
new List <string>()
{
WST_STORE_FIELDS.FIELD_STORE_NAME,
POR_LOT_FIELDS.FIELD_CUR_STEP_VER_KEY,
POR_LOT_FIELDS.FIELD_LOT_KEY
});
db.ExecuteNonQuery(dbtran, CommandType.Text, sql);
#endregion
#region 更新批次信息
sql = @"UPDATE POR_LOT SET STATE_FLAG=11," +
"EDITOR='" + strEditor + "'," +
"EDIT_TIME=SYSDATE," +
"EDIT_TIMEZONE='" + strEditTimeZone + "' " +
"WHERE LOT_NUMBER='" + lotNumber + "'";
db.ExecuteNonQuery(dbtran, CommandType.Text, sql);
#endregion
#region update ems_lot_equipment
DataSet resDs = new DataSet();
string sqlString = @"SELECT B.EQUIPMENT_KEY,A.EQUIPMENT_NAME,A.EQUIPMENT_STATE_KEY
FROM EMS_EQUIPMENTS A,EMS_LOT_EQUIPMENT B
WHERE A.EQUIPMENT_KEY = B.EQUIPMENT_KEY
AND B.STEP_KEY = '" + stepKey + "' " +
"AND B.LOT_KEY='" + lotKey + "' " +
"AND B.END_TIMESTAMP IS NULL";
db.LoadDataSet(CommandType.Text, sqlString, resDs, new string[] { EMS_OPERATION_EQUIPMENT_FIELDS.DATABASE_TABLE_NAME });
if (resDs != null && resDs.Tables.Count > 0)
{
if (resDs.Tables[0].Rows.Count > 0)
{
string equipmentKey = resDs.Tables[0].Rows[0]["EQUIPMENT_KEY"].ToString();
WipManagement.TrackOutForEquipment(lotKey, stepKey, equipmentKey, strEditor, dbtran);
}
}
#endregion
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "");
dbtran.Commit();
}
catch (Exception ex)
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
//Rollback Transaction
dbtran.Rollback();
LogService.LogError("TransferLotToStore Error: " + ex.Message);
}
finally
{
dbconn.Close();
}
}
}
else
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "${res:SolarViewer.Hemera.Modules.FMM.StoreEngine.StoreIsNotExist}");
return(dsReturn);
}
dataReader.Close();
dataReader.Dispose();
}
catch (Exception ex)
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
}
}
}
System.DateTime endTime = System.DateTime.Now;
LogService.LogInfo("TransferLotToStore Time: " + (endTime - startTime).TotalMilliseconds.ToString());
return(dsReturn);
}
/// <summary>
/// 执行批次出站或仅采集批次报废数量。
/// </summary>
/// <param name="dataset">包含批次出站信息的数据集对象。
/// 必须包含名称为<see cref=" TRANS_TABLES.TABLE_PARAM"/>的数据表，用于存储批次及批出站主信息的数据。
/// 包含名称为<see cref=" WIP_SCRAP_FIELDS.DATABASE_TABLE_NAME"/>的数据表（可选），用于存储批次报废的数据。
/// 包含名称为<see cref="WST_STORE_MAT_FIELDS.DATABASE_TABLE_NAME"/>的数据表（可选），用于存储批次返工或退库的数据。
/// 包含名称为<see cref="EMS_EQUIPMENTS_FIELDS.DATABASE_TABLE_NAME"/>的数据表（可选），用于存储设备数据。</param>
/// <returns>
/// 包含方法执行结果的数据集。
/// </returns>
public DataSet TrackOutLot(DataSet dsParams)
{
System.DateTime startTime = System.DateTime.Now;
DataSet dsReturn = new DataSet();
DbConnection dbConn = null;
DbTransaction dbtran = null;
DataTable dtParams = new DataTable();
Hashtable htParams = new Hashtable();
//string module = "";
int quantityOut = 0;
int quantityToMerge = 0;
string lotKeyForMerge = string.Empty;
string lotKey = string.Empty;
string workOrderKey = string.Empty, lineKey = "", editor = "", opUser = "", editTime = string.Empty;
int workOrderStep = 0; //工单序号
string isAutoTrackIn = string.Empty, oprLine = string.Empty; //是否自动进站，操作线别
string shiftName = string.Empty; //班次名称
bool isFinished = false; //批次完成状态。
string toStepKey = string.Empty; //工步主键
string toRouteKey = string.Empty; //工艺流程主键
string toEnterpriseKey = string.Empty; //工艺流程组主键
string editTimeZone = string.Empty; //编辑时间时区
string operateCompName = string.Empty; //操作计算机名称
string shiftKey = string.Empty; //班次主键
string stepKey = string.Empty; //当前工步主键
try
{
dbConn = db.CreateConnection();
dbConn.Open();
//Create Transaction
dbtran = dbConn.BeginTransaction();
if (dsParams.Tables.Contains(TRANS_TABLES.TABLE_PARAM))
{
dtParams = dsParams.Tables[TRANS_TABLES.TABLE_PARAM];
htParams = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtParams);
lotKey = Convert.ToString(htParams[POR_LOT_FIELDS.FIELD_LOT_KEY]);
lotKeyForMerge = lotKey;
workOrderKey = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_WORK_ORDER_KEY]);
lineKey = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_LINE_KEY]);
oprLine = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE]);
editor = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_EDITOR]);
opUser = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_OPERATOR]);
shiftName = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_NAME]);
editTime = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIME]);
toStepKey = Convert.ToString(htParams[WIP_FIELDS.FIELDS_TO_STEP_VER_KEY]);
toRouteKey = Convert.ToString(htParams[WIP_FIELDS.FIELDS_TO_ROUTE_VER_KEY]);
toEnterpriseKey = Convert.ToString(htParams[WIP_FIELDS.FIELDS_TO_ENTERPRISE_VER_KEY]);
//module = Convert.ToString(htParams[POR_LOT_FIELDS.FIELD_MODULE]);
editTimeZone = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY]);
operateCompName = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_OPR_COMPUTER]);
shiftKey = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_KEY]);
stepKey = Convert.ToString(htParams[WIP_TRANSACTION_FIELDS.FIELD_STEP_KEY]);
//如果哈希表中包含最后一步的字段。表示该工步为最后一个工步，设置批次完成状态为true
if (htParams.ContainsKey("LAST_STEP"))
{
isFinished = Boolean.Parse(htParams["LAST_STEP"].ToString());
}
quantityOut = Convert.ToInt32(htParams[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT]);
quantityToMerge = quantityOut;
}
#region 检查记录是否过期。防止重复修改。
KeyValuePair <string, string> kvp = new KeyValuePair <string, string>(POR_LOT_FIELDS.FIELD_LOT_KEY, lotKey);
List <KeyValuePair <string, string> > listCondition = new List <KeyValuePair <string, string> >();
listCondition.Add(kvp);
//如果数据记录过期，则返回结束方法执行。
if (UtilHelper.CheckRecordExpired(db, POR_LOT_FIELDS.DATABASE_TABLE_NAME, listCondition, editTime))
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, COMMON_FIELDS.FIELD_COMMON_EDITTIME_EXP);
return(dsReturn);
}
#endregion
//如果数据集中包含批次报废数据表。
if (dsParams.Tables.Contains(WIP_SCRAP_FIELDS.DATABASE_TABLE_NAME))
{
WipManagement.SetLossBonus(db, dbtran, dsParams);
}
//如果数据集中包含批次返工或退库的数据表。
if (dsParams.Tables.Contains(WST_STORE_MAT_FIELDS.DATABASE_TABLE_NAME))
{
SetDefect(dbtran, dsParams);
}
//插入批次出站的记录信息。
WipManagement.TrackOutOrReworkLot(db, dbtran, dsParams, ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_TRACKOUT);
//更新批次出站和设备关联的记录信息。
if (dsParams.Tables.Contains(EMS_EQUIPMENTS_FIELDS.DATABASE_TABLE_NAME))
{
TrackOutOrReworkForEquipment(dbtran, dsParams);
}
#region 确定是否自动分批或自动合批
//如果不是完成状态且数量>0
if (isFinished == false && quantityOut > 0)
{
int maxBoxQuantity = -1;
string autoMerge = "";
string autoSplit = "";
//获取下一工步的自定义属性。
DataSet dsStepUda = GetStepUda(toStepKey);
if (dsStepUda.Tables[0].Rows.Count > 0)
{
//获取下一工步的自定义属性成功。
for (int i = 0; i < dsStepUda.Tables[0].Rows.Count; i++)
{
string szStepUdaName = dsStepUda.Tables[0].Rows[i][POR_ROUTE_STEP_ATTR_FIELDS.FIELD_ATTRIBUTE_NAME].ToString();
string szStepUdaValue = dsStepUda.Tables[0].Rows[i][POR_ROUTE_STEP_ATTR_FIELDS.FIELD_ATTRIBUTE_VALUE].ToString();
//箱的最大数量
if (szStepUdaName == "MaxBoxQuantity")
{
maxBoxQuantity = Convert.ToInt32(szStepUdaValue);
}
//自动合批
if (szStepUdaName == "AutoMerge")
{
autoMerge = szStepUdaValue;
}
//自动分批
if (szStepUdaName == "AutoSplit")
{
autoSplit = szStepUdaValue;
}
//自动出站
if (szStepUdaName == "AutoTrackIn")
{
isAutoTrackIn = szStepUdaValue;
}
}
//确定自动分批
if (autoSplit.ToLower() == "true")
{
//箱最大数量
if (maxBoxQuantity == -1)
{
throw new Exception("${res:SolarViewer.Hemera.Addins.WIP.AutoSplit.Exception}");
}
else if (quantityOut > maxBoxQuantity)//出站数量>箱最大数量。
{
#region splitLot
#region MainDataTable
if (htParams.Contains(POR_LOT_FIELDS.FIELD_QUANTITY))
{
htParams.Remove(POR_LOT_FIELDS.FIELD_QUANTITY);
}
htParams.Add(POR_LOT_FIELDS.FIELD_QUANTITY, maxBoxQuantity.ToString());
htParams[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_IN] = quantityOut;
htParams[POR_LOT_FIELDS.FIELD_ROUTE_ENTERPRISE_VER_KEY] = toEnterpriseKey;
htParams[POR_LOT_FIELDS.FIELD_CUR_ROUTE_VER_KEY] = toRouteKey;
htParams[POR_LOT_FIELDS.FIELD_CUR_STEP_VER_KEY] = toStepKey;
htParams.Add(POR_LOT_FIELDS.FIELD_STATE_FLAG, "0");
if (workOrderStep != 0)
{
htParams.Add(COMMON_FIELDS.FIELD_WORK_ORDER_STEP, workOrderStep);
}
DataTable splitTable = SolarViewer.Hemera.Share.Common.CommonUtils.ParseToDataTable(htParams);
splitTable.TableName = TRANS_TABLES.TABLE_MAIN_DATA;
DataSet splitDS = new DataSet();
splitDS.Tables.Add(splitTable);
#endregion
int remainderQty = quantityOut - maxBoxQuantity;
#region ChildTable
DataTable childTable = new DataTable();
//childTable.Columns.Add("LOT_NUMBER", Type.GetType("System.String"));
childTable.Columns.Add("QUANTITY", Type.GetType("System.String"));
childTable.Columns.Add("SPLIT_SEQ", Type.GetType("System.String"));
childTable.Columns.Add("LOT_KEY", Type.GetType("System.String"));
//string childLotNumber = "";
string lastChildLotKey = "";
int i = 0;
//剩余数量-箱最大数量>0,继续分批
while ((remainderQty - maxBoxQuantity) >= 0)
{
#region GenerateChildLotNumber
i++;
#endregion
//childTable.Rows.Add(childLotNumber, maxBoxQuantity.ToString(), i.ToString("00"), Utils.GenerateNewKey(0));
childTable.Rows.Add(maxBoxQuantity.ToString(), i.ToString("00"), UtilHelper.GenerateNewKey(0));
remainderQty = remainderQty - maxBoxQuantity;
}
//如果剩余数量>0,作为最后一批。
if (remainderQty > 0)
{
i++;
lastChildLotKey = UtilHelper.GenerateNewKey(0);
childTable.Rows.Add(remainderQty.ToString(), i.ToString("00"), lastChildLotKey);
}
childTable.TableName = BASE_PARAMETER_FIELDS.DATABASE_TABLE_NAME;
splitDS.Tables.Add(childTable);
#endregion
//Excute Split
//SplitLot(db, dbtran, splitDS);
DataSet childLotReturn = new DataSet();
//执行分批操作。
SplitLotTransact(db, dbtran, splitDS, ref childLotReturn);
quantityToMerge = remainderQty;
lotKeyForMerge = lastChildLotKey;
#endregion
}
}
#region AutoMerge
//如果自动合批。
if (autoMerge.ToLower() == "true")
{
//执行自动合批操作。
AutoMerge(db, dbtran, lotKeyForMerge, workOrderKey, toStepKey, lineKey, quantityToMerge.ToString(), maxBoxQuantity, 0, editor, false, oprLine, shiftName);
}
#endregion
}
}
#endregion
//检查是否需要进行锁定。
int nHoldCount = 0;
if (isFinished == false)
{
nHoldCount = CheckAndUpdateFutureHold(dbtran, lotKey, stepKey, shiftName, shiftKey, editor,
operateCompName, editTimeZone, ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_TRACKOUT);
}
dbtran.Commit();
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, "");
#region AutoTrackIn 确定是否自动进站。
//如果自动进站
if (isFinished == false && isAutoTrackIn.ToLower() == "true" && nHoldCount == 0)
{
//执行自动进站作业。
AutoTrackIn(lotKey, string.Empty, shiftName);
}
#endregion
}
catch (Exception ex)
{
SolarViewer.Hemera.Share.Common.ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
LogService.LogError("TrackOutLot Error: " + ex.Message);
dbtran.Rollback();
}
finally
{
dbConn.Close();
}
//记录操作时间 记录。
System.DateTime endTime = System.DateTime.Now;
LogService.LogInfo("TrackOut Lot Time: " + (endTime - startTime).TotalMilliseconds.ToString());
return(dsReturn);
}
/// <summary>
/// 采集不良数据。
/// </summary>
/// <param name="dbTran">数据操作事务对象。</param>
/// <param name="ds">包含报废数据的数据集对象。</param>
private void SetDefect(DbTransaction dbTran, DataSet ds)
{
DataTable dataTable = ds.Tables[TRANS_TABLES.TABLE_PARAM];
Hashtable hashData = SolarViewer.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dataTable);
string lotKey = Convert.ToString(hashData[POR_LOT_FIELDS.FIELD_LOT_KEY]);
string strWorkOrderKey = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_WORK_ORDER_KEY]);
string strLineKey = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_LINE_KEY]);
string strOprLine = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE]);
string strEditor = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_EDITOR]);
string strOperator = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_OPERATOR]);
string strShiftName = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_NAME]);
string strEditTime = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIME]);
string shiftKey = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_SHIFT_KEY]);
string computeName = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_OPR_COMPUTER]);
string stateFlag = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_STATE_FLAG]);
string reworkFlag = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_REWORK_FLAG]);
//string comment = Convert.ToString(hashData[WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY_COMMENT]); //Q.001
string comment = Convert.ToString(hashData["DEFECTCOMMET"]); //Q.001
DataTable table = ds.Tables[WST_STORE_MAT_FIELDS.DATABASE_TABLE_NAME];
string sql = string.Format(@"SELECT LOT_SEQ,LOT_NUMBER FROM POR_LOT WHERE LOT_KEY='{0}'", lotKey.PreventSQLInjection());
IDataReader readerSEQ = db.ExecuteReader(CommandType.Text, sql);
int seq = 0;
//获取当前批次对应的返工和退库记录数。
string lotNumber = string.Empty;
if (readerSEQ.Read())
{
if (readerSEQ["LOT_SEQ"].ToString() != "")
{
seq = Int32.Parse(readerSEQ["LOT_SEQ"].ToString());
}
lotNumber = readerSEQ[POR_LOT_FIELDS.FIELD_LOT_NUMBER].ToString();
}
readerSEQ.Close();
readerSEQ.Dispose();
for (int i = 0; i < table.Rows.Count; i++)
{
table.Rows[i][WST_STORE_MAT_FIELDS.FIELD_ITEM_NO] = lotNumber + (seq + i + 1).ToString("00");
table.Rows[i][WIP_TRANSACTION_FIELDS.FIELD_SHIFT_NAME] = strShiftName;
}
//插入批次对应的返工和退库记录。
WipManagement.InsertIntoStoreMat(db, dbTran, ds);
//更新批次对应的返工和退库记录数。
sql = string.Format(@"UPDATE POR_LOT SET LOT_SEQ='{0}' WHERE LOT_KEY='{1}'",
seq + table.Rows.Count, lotKey.PreventSQLInjection());
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
//如果包含缺陷代码数据表。设置了先区分不良代码再入库。
if (ds.Tables.Contains(WIP_DEFECT_FIELDS.DATABASE_TABLE_NAME))
{
DataTable dtStoreMat = ds.Tables[WST_STORE_MAT_FIELDS.DATABASE_TABLE_NAME];
DataTable dtDefect = ds.Tables[WIP_DEFECT_FIELDS.DATABASE_TABLE_NAME];
string rowKey = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_ROW_KEY].ToString();
string storeType = dtStoreMat.Rows[0][WST_STORE_FIELDS.FIELD_STORE_TYPE].ToString();
string lineKey = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_LINE_KEY].ToString();
string stepKey = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_STEP_KEY].ToString();
string routeKey = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_ROUTE_KEY].ToString();
string enterpriseKey = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_ENTERPRISE_KEY].ToString();
string quantity = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_ITEM_QTY].ToString();
string editor = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_EDITOR].ToString();
string editTimeZone = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_EDIT_TIMEZONE].ToString();
string workorderNumber = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_WORKORDER_NUMBER].ToString();
string storeKey = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_STORE_KEY].ToString();
string storeName = dtStoreMat.Rows[0][WST_STORE_FIELDS.FIELD_STORE_NAME].ToString();
string objectStatus = dtStoreMat.Rows[0][WST_STORE_MAT_FIELDS.FIELD_OBJECT_STATUS].ToString();
#region RW_STORE_TRANSACTION
Hashtable htReworkLotInStore = new Hashtable();
DataTable dtReworkLotInStore = new DataTable();
htReworkLotInStore.Add(WST_STORE_FIELDS.FIELD_STORE_TYPE, storeType);
htReworkLotInStore.Add(POR_WORK_ORDER_FIELDS.FIELD_WORK_ORDER_KEY, strWorkOrderKey);
htReworkLotInStore.Add(WST_STORE_MAT_FIELDS.FIELD_ROW_KEY, rowKey);
htReworkLotInStore.Add(WST_STORE_MAT_FIELDS.FIELD_LINE_KEY, lineKey);
htReworkLotInStore.Add(WST_STORE_MAT_FIELDS.FIELD_STEP_KEY, stepKey);
htReworkLotInStore.Add(WST_STORE_MAT_FIELDS.FIELD_ROUTE_KEY, routeKey);
htReworkLotInStore.Add(WST_STORE_MAT_FIELDS.FIELD_ENTERPRISE_KEY, enterpriseKey);
htReworkLotInStore.Add(WST_STORE_MAT_FIELDS.FIELD_ITEM_QTY, quantity);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_EDITOR, editor);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY, editTimeZone);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_OPERATOR, strOperator);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_PIECE_KEY, lotKey);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_SHIFT_NAME, strShiftName);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_SHIFT_KEY, shiftKey);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_OPR_COMPUTER, computeName);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_STATE_FLAG, stateFlag);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_REWORK_FLAG, reworkFlag);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE, strOprLine);
htReworkLotInStore.Add(WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY_COMMENT, comment);
dtReworkLotInStore = SolarViewer.Hemera.Share.Common.CommonUtils.ParseToDataTable(htReworkLotInStore);
dtReworkLotInStore.TableName = TRANS_TABLES.TABLE_MAIN_DATA;
DataSet dsReworkLotInStore = new DataSet();
dsReworkLotInStore.Tables.Add(dtReworkLotInStore);
dsReworkLotInStore.Merge(dtDefect);
StoreEngine.ReworkLotInStore(db, dbTran, dsReworkLotInStore);
#endregion
#region RWOUTSTORE
//ReworkLot
DataTable dtReworkLotDetail = new DataTable();
dtReworkLotDetail.TableName = BASE_PARAMETER_FIELDS.DATABASE_TABLE_NAME;
dtReworkLotDetail.Columns.Add("ROW_KEY");
dtReworkLotDetail.Columns.Add("LOT_NUMBER");
dtReworkLotDetail.Columns.Add("LINE_KEY");
dtReworkLotDetail.Columns.Add("LINE_NAME");
dtReworkLotDetail.Columns.Add("ITEM_QTY");
dtReworkLotDetail.Columns.Add("EDIT_TIME");
dtReworkLotDetail.Columns.Add("STEP_KEY");
dtReworkLotDetail.Columns.Add("ROUTE_KEY");
dtReworkLotDetail.Columns.Add("ENTERPRISE_KEY");
dtReworkLotDetail.Columns.Add(WST_STORE_MAT_FIELDS.FIELD_BALANCE_QTY);
dtReworkLotDetail.Columns.Add(WST_STORE_MAT_FIELDS.FIELD_BALANCE_EDITOR);
dtReworkLotDetail.Columns.Add(POR_LOT_FIELDS.FIELD_LOT_KEY);
dtReworkLotDetail.Rows.Add(rowKey, lotNumber, lineKey, strOprLine, quantity, strEditTime,
stepKey, routeKey, enterpriseKey, 0, string.Empty, lotKey);
DataSet dsReworkLot = new DataSet();
dsReworkLot.Tables.Add(dtReworkLotDetail);
Hashtable htReworkLot = new Hashtable();
DataTable dtReworkLot = new DataTable();
htReworkLot.Add(WST_STORE_FIELDS.FIELD_STORE_NAME, storeName);
htReworkLot.Add(WST_STORE_FIELDS.FIELD_STORE_TYPE, storeType);
htReworkLot.Add(POR_WORK_ORDER_FIELDS.FIELD_WORK_ORDER_KEY, strWorkOrderKey);
htReworkLot.Add(WST_STORE_MAT_FIELDS.FIELD_STORE_KEY, storeKey);
htReworkLot.Add(WST_STORE_MAT_FIELDS.FIELD_WORKORDER_NUMBER, workorderNumber);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY, string.Empty);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_EDITOR, editor);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY, editTimeZone);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_OPERATOR, strOperator);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_SHIFT_NAME, strShiftName);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_SHIFT_KEY, shiftKey);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_OPR_COMPUTER, computeName);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_STATE_FLAG, stateFlag);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_REWORK_FLAG, reworkFlag);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE, strOprLine);
htReworkLot.Add(WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY_COMMENT, comment);
htReworkLot.Add("REWORK_QTY", quantity);
dtReworkLot = SolarViewer.Hemera.Share.Common.CommonUtils.ParseToDataTable(htReworkLot);
dtReworkLot.TableName = TRANS_TABLES.TABLE_MAIN_DATA;
dsReworkLot.Tables.Add(dtReworkLot);
StoreEngine.ReworkLot(db, dbTran, dsReworkLot);
#endregion
}
}
