/// <summary>
/// 电池片回收操作，用于撤销电池片报废和电池片补片。
/// </summary>
/// <remarks>
/// 操作名称：<see cref="ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_RECOVERED"/>。
/// </remarks>
/// <param name="dsParams">包含回收信息的数据集对象。</param>
/// <returns>包含结果数据的数据集对象。</returns>
public DataSet LotRecovered(DataSet dsParams)
{
DataSet dsReturn = new DataSet();
DbConnection dbConn = null;
DbTransaction dbTran = null;
try
{
dbConn = db.CreateConnection();
dbConn.Open();
dbTran = dbConn.BeginTransaction();
//参数数据。
if (dsParams == null ||
!dsParams.Tables.Contains(TRANS_TABLES.TABLE_PARAM) || //存放附加参数数据
!dsParams.Tables.Contains(WIP_TRANSACTION_FIELDS.DATABASE_TABLE_NAME)) //存放操作数据
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, "传入参数不正确，请检查。");
return(dsReturn);
}
DataTable dtParams = dsParams.Tables[TRANS_TABLES.TABLE_PARAM]; //存放附加参数数据
DataTable dtTransaction = dsParams.Tables[WIP_TRANSACTION_FIELDS.DATABASE_TABLE_NAME]; //存放操作数据
Hashtable htTransaction = FanHai.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtTransaction);
Hashtable htParams = FanHai.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtParams);
string opEditTime = Convert.ToString(htParams[COMMON_FIELDS.FIELD_COMMON_EDIT_TIME]); //操作时编辑时间
string lotKey = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_PIECE_KEY]);
string editTimeZone = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY]);
string editor = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_EDITOR]);
double leftQty = Convert.ToDouble(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT]);
string activity = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY]);
//操作动作必须是 RECOVERED(电池片回收)
if (activity != ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_RECOVERED)
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, "传入参数的电池片回收操作动作不正确，请检查。");
return(dsReturn);
}
//检查记录是否过期。防止重复修改。
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, opEditTime))
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, "信息已过期，请关闭该界面后重试。");
return(dsReturn);
}
string transactionKey = UtilHelper.GenerateNewKey(0);
AddWIPLot(dbTran, transactionKey, lotKey);
//更新批次数量。
string sql = string.Format(@"UPDATE POR_LOT
SET QUANTITY={0},EDITOR='{1}',EDIT_TIME=GETDATE(),EDIT_TIMEZONE='{2}'
WHERE LOT_KEY='{3}'",
leftQty,
editor.PreventSQLInjection(),
editTimeZone.PreventSQLInjection(),
lotKey.PreventSQLInjection());
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
//向WIP_TRANSACTION表插入批次回收的操作记录。
WIP_TRANSACTION_FIELDS wipFields = new WIP_TRANSACTION_FIELDS();
if (!htTransaction.ContainsKey(WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY))
{
htTransaction.Add(WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY, transactionKey);
}
htTransaction[WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY] = transactionKey;
sql = DatabaseTable.BuildInsertSqlStatement(wipFields, htTransaction, null);
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
//如果数据集中包含名称WIP_RECOVERED_FIELDS.DATABASE_TABLE_NAME的数据表对象。
if (dsParams.Tables.Contains(WIP_RECOVERED_FIELDS.DATABASE_TABLE_NAME))
{
WIP_RECOVERED_FIELDS recoveredFields = new WIP_RECOVERED_FIELDS();
DataTable dtRecovered = dsParams.Tables[WIP_RECOVERED_FIELDS.DATABASE_TABLE_NAME]; //存放回收明细数据
//获取不重复的被回收批次及其对应的编辑时间，只有在电池片回收是撤销补片操作时才发生。
var distinctRecoveredLot = from item in dtRecovered.AsEnumerable()
where Convert.ToString(item[WIP_RECOVERED_FIELDS.FIELD_RECOVERED_LOT_KEY]) != lotKey //排除回收批次
group item by new
{
LotKey = Convert.ToString(item[WIP_RECOVERED_FIELDS.FIELD_RECOVERED_LOT_KEY]),
EditTime = Convert.ToString(item[WIP_RECOVERED_FIELDS.FIELD_EDIT_TIME])
} into g
select new { LotKey = g.Key.LotKey, EditTime = g.Key.EditTime, Count = g.Count() };
foreach (var item in distinctRecoveredLot)
{
//检查记录是否过期。防止重复修改。
kvp = new KeyValuePair <string, string>(POR_LOT_FIELDS.FIELD_LOT_KEY, item.LotKey);
listCondition = new List <KeyValuePair <string, string> >();
listCondition.Add(kvp);
//如果记录过期，编辑时间<数据库中的记录编辑时间。结束方法执行。
if (UtilHelper.CheckRecordExpired(db, POR_LOT_FIELDS.DATABASE_TABLE_NAME, listCondition, item.EditTime))
{
string msg = string.Format("信息已过期，请关闭该界面后重试。");
ReturnMessageUtils.AddServerReturnMessage(dsReturn, msg);
return(dsReturn);
}
}
//遍历批次的回收数据。
for (int i = 0; i < dtRecovered.Rows.Count; i++)
{
DataRow drRecovered = dtRecovered.Rows[i];
Hashtable htRecovered = CommonUtils.ConvertRowToHashtable(drRecovered);
string beRecoveredTransactionKey = string.Empty;
string recoveredType = Convert.ToString(htRecovered[WIP_RECOVERED_FIELDS.FIELD_RECOVERED_TYPE]);
//回收类型为撤销电池片补片（PATCH）操作,需要新增被回收批次的操作记录。
if (recoveredType == ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_PATCH)
{
string beRecoveredLotKey = Convert.ToString(htRecovered[WIP_RECOVERED_FIELDS.FIELD_BERECOVERED_LOT_KEY]);
double recoveredQuantity = Convert.ToDouble(htRecovered[WIP_RECOVERED_FIELDS.FIELD_RECOVERED_QUANTITY]);
//获取被回收批次的信息
DataSet dsPatchLotInfo = LotManagement.GetLotBasicInfo(db, dbTran, beRecoveredLotKey);
DataRow drPatchLotInfo = dsPatchLotInfo.Tables[0].Rows[0];
double quantityIn = Convert.ToDouble(drPatchLotInfo[POR_LOT_FIELDS.FIELD_QUANTITY]);
//double quantityOut = quantityIn - recoveredQuantity; //电池片补片时不再回加被补片批次的数量，所以在不需要减去回收数量
double quantityOut = quantityIn;
string enterpriseKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_ROUTE_ENTERPRISE_VER_KEY]);
string enterpriseName = Convert.ToString(drPatchLotInfo[POR_ROUTE_ENTERPRISE_VER_FIELDS.FIELD_ENTERPRISE_NAME]);
string routeKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_CUR_ROUTE_VER_KEY]);
string routeName = Convert.ToString(drPatchLotInfo[POR_ROUTE_ROUTE_VER_FIELDS.FIELD_ROUTE_NAME]);
string stepKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_CUR_STEP_VER_KEY]);
string stepName = Convert.ToString(drPatchLotInfo[POR_ROUTE_STEP_FIELDS.FIELD_ROUTE_STEP_NAME]);
string workOrderKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_WORK_ORDER_KEY]);
string stateFlag = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_STATE_FLAG]);
string reworkFlag = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_IS_REWORKED]);
string lineKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_CUR_PRODUCTION_LINE_KEY]);
string lineName = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_OPR_LINE]);
string edcInsKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_EDC_INS_KEY]);
string equipmentKey = Convert.ToString(drPatchLotInfo[EMS_EQUIPMENTS_FIELDS.FIELD_EQUIPMENT_KEY]);
beRecoveredTransactionKey = UtilHelper.GenerateNewKey(0);
AddWIPLot(dbTran, beRecoveredTransactionKey, beRecoveredLotKey);
//更新被回收批次的数量
sql = string.Format(@"UPDATE POR_LOT
SET QUANTITY={0},EDITOR='{1}',EDIT_TIME=GETDATE(),EDIT_TIMEZONE='{2}'
WHERE LOT_KEY='{3}'",
quantityOut,
editor.PreventSQLInjection(),
editTimeZone.PreventSQLInjection(),
beRecoveredLotKey.PreventSQLInjection());
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
//插入被回收批次的操作记录
Hashtable htBeRecoveredTransaction = new Hashtable(htTransaction);
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY] = beRecoveredTransactionKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_PIECE_KEY] = beRecoveredLotKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY] = ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_BE_RECOVERED;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_IN] = quantityIn;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT] = quantityOut;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_ENTERPRISE_KEY] = enterpriseKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_ENTERPRISE_NAME] = enterpriseName;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_ROUTE_KEY] = routeKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_ROUTE_NAME] = routeName;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_STEP_KEY] = stepKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_STEP_NAME] = stepName;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_WORK_ORDER_KEY] = workOrderKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_STATE_FLAG] = stateFlag;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_REWORK_FLAG] = reworkFlag;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_LINE_KEY] = lineKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE] = lineName;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE_PRE] = lineName;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_EDC_INS_KEY] = edcInsKey;
htBeRecoveredTransaction[WIP_TRANSACTION_FIELDS.FIELD_EQUIPMENT_KEY] = equipmentKey;
sql = DatabaseTable.BuildInsertSqlStatement(wipFields, htBeRecoveredTransaction, null);
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
}
//插入一笔批次回收明细数据
//回收操作记录主键。
if (!htRecovered.ContainsKey(WIP_RECOVERED_FIELDS.FIELD_TRANSACTION_KEY))
{
htRecovered.Add(WIP_RECOVERED_FIELDS.FIELD_TRANSACTION_KEY, transactionKey);
}
htRecovered[WIP_RECOVERED_FIELDS.FIELD_TRANSACTION_KEY] = transactionKey;
//被回收批次操作记录主键，只是回收操作是撤销电池片补片时才有值，否则为空白值。
if (!htRecovered.ContainsKey(WIP_RECOVERED_FIELDS.FIELD_BERECOVERED_TRANSACTION_KEY))
{
htRecovered.Add(WIP_RECOVERED_FIELDS.FIELD_BERECOVERED_TRANSACTION_KEY, beRecoveredTransactionKey);
}
htRecovered[WIP_RECOVERED_FIELDS.FIELD_BERECOVERED_TRANSACTION_KEY] = beRecoveredTransactionKey;
//重置回收明细的编辑时间为当前时间。
htRecovered[WIP_RECOVERED_FIELDS.FIELD_EDIT_TIME] = null;
sql = DatabaseTable.BuildInsertSqlStatement(recoveredFields, htRecovered, null);
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
}
}
dbTran.Commit();
ReturnMessageUtils.AddServerReturnMessage(dsReturn, string.Empty);
}
catch (Exception ex)
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
LogService.LogError("LotRecovered Error: " + ex.Message);
dbTran.Rollback();
}
finally
{
dbConn.Close();
}
return(dsReturn);
}
/// <summary>
/// 电池片补片操作。
/// </summary>
/// <remarks>
/// 操作名称：<see cref="ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_PATCH"/>。
/// </remarks>
/// <param name="dsParams">包含补片信息的数据集对象。</param>
/// <returns>包含结果数据的数据集对象。</returns>
public DataSet LotPatch(DataSet dsParams)
{
DataSet dsReturn = new DataSet();
DbConnection dbConn = null;
DbTransaction dbTran = null;
try
{
dbConn = db.CreateConnection();
dbConn.Open();
dbTran = dbConn.BeginTransaction();
//参数数据。
if (dsParams == null ||
!dsParams.Tables.Contains(TRANS_TABLES.TABLE_PARAM) || //存放附加参数数据
!dsParams.Tables.Contains(WIP_TRANSACTION_FIELDS.DATABASE_TABLE_NAME)) //存放操作数据
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, "传入参数不正确，请检查。");
return(dsReturn);
}
DataTable dtParams = dsParams.Tables[TRANS_TABLES.TABLE_PARAM]; //存放附加参数数据
DataTable dtTransaction = dsParams.Tables[WIP_TRANSACTION_FIELDS.DATABASE_TABLE_NAME]; //存放操作数据
Hashtable htTransaction = FanHai.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtTransaction);
Hashtable htParams = FanHai.Hemera.Share.Common.CommonUtils.ConvertToHashtable(dtParams);
string opEditTime = Convert.ToString(htParams[COMMON_FIELDS.FIELD_COMMON_EDIT_TIME]); //操作时编辑时间
string lotKey = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_PIECE_KEY]);
string editTimeZone = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_EDIT_TIMEZONE_KEY]);
string editor = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_EDITOR]);
double leftQty = Convert.ToDouble(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT]);
string activity = Convert.ToString(htTransaction[WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY]);
//操作动作必须是 PATCH
if (activity != ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_PATCH)
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, "传入参数的补片操作动作不正确，请检查。");
return(dsReturn);
}
//如果数据集中包含名称WIP_PATCH_FIELDS.DATABASE_TABLE_NAME的数据表对象。
if (dsParams.Tables.Contains(WIP_PATCH_FIELDS.DATABASE_TABLE_NAME))
{
string transactionKey = UtilHelper.GenerateNewKey(0);
string sql = string.Empty;
double sumPatchedQty = 0;
WIP_TRANSACTION_FIELDS wipFields = new WIP_TRANSACTION_FIELDS();
WIP_PATCH_FIELDS patchFields = new WIP_PATCH_FIELDS();
DataTable dtPatch = dsParams.Tables[WIP_PATCH_FIELDS.DATABASE_TABLE_NAME]; //存放补片明细数据
//遍历批次的报废数据。
for (int i = 0; i < dtPatch.Rows.Count; i++)
{
DataRow drPatch = dtPatch.Rows[i];
Hashtable htPatch = CommonUtils.ConvertRowToHashtable(drPatch);
string patchedLotKey = Convert.ToString(htPatch[WIP_PATCH_FIELDS.FIELD_PATCHED_LOT_KEY]);
double patchedQuantity = Convert.ToDouble(htPatch[WIP_PATCH_FIELDS.FIELD_PATCH_QUANTITY]);
sumPatchedQty += patchedQuantity; //总的补片数量。
int isOnlyPatch = Convert.ToInt32(htPatch[WIP_PATCH_FIELDS.FIELD_IS_ONLY_PATCHED]);
//获取被补片批次的信息
DataSet dsPatchLotInfo = LotManagement.GetLotBasicInfo(db, dbTran, patchedLotKey);
DataRow drPatchLotInfo = dsPatchLotInfo.Tables[0].Rows[0];
double quantityIn = Convert.ToDouble(drPatchLotInfo[POR_LOT_FIELDS.FIELD_QUANTITY]);
//isOnlyPatch=0 先报废后补片，所以数量不需要改变。isOnlyPatch=1 仅做补片。
double quantityOut = isOnlyPatch == 0? quantityIn: quantityIn + patchedQuantity;
string enterpriseKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_ROUTE_ENTERPRISE_VER_KEY]);
string enterpriseName = Convert.ToString(drPatchLotInfo[POR_ROUTE_ENTERPRISE_VER_FIELDS.FIELD_ENTERPRISE_NAME]);
string routeKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_CUR_ROUTE_VER_KEY]);
string routeName = Convert.ToString(drPatchLotInfo[POR_ROUTE_ROUTE_VER_FIELDS.FIELD_ROUTE_NAME]);
string stepKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_CUR_STEP_VER_KEY]);
string stepName = Convert.ToString(drPatchLotInfo[POR_ROUTE_STEP_FIELDS.FIELD_ROUTE_STEP_NAME]);
string workOrderKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_WORK_ORDER_KEY]);
string stateFlag = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_STATE_FLAG]);
string reworkFlag = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_IS_REWORKED]);
string lineKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_CUR_PRODUCTION_LINE_KEY]);
string lineName = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_OPR_LINE]);
string edcInsKey = Convert.ToString(drPatchLotInfo[POR_LOT_FIELDS.FIELD_EDC_INS_KEY]);
string equipmentKey = Convert.ToString(drPatchLotInfo[EMS_EQUIPMENTS_FIELDS.FIELD_EQUIPMENT_KEY]);
string patchedTransactionKey = UtilHelper.GenerateNewKey(0);
AddWIPLot(dbTran, patchedTransactionKey, patchedLotKey);
//更新被补片批次的数量
sql = string.Format(@"UPDATE POR_LOT
SET QUANTITY={0},EDITOR='{1}',EDIT_TIME=GETDATE(),EDIT_TIMEZONE='{2}'
WHERE LOT_KEY='{3}'",
quantityOut,
editor.PreventSQLInjection(),
editTimeZone.PreventSQLInjection(),
patchedLotKey.PreventSQLInjection());
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
Hashtable htPatchedTransaction = new Hashtable(htTransaction);
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_PIECE_KEY] = patchedLotKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_ENTERPRISE_KEY] = enterpriseKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_ENTERPRISE_NAME] = enterpriseName;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_ROUTE_KEY] = routeKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_ROUTE_NAME] = routeName;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_STEP_KEY] = stepKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_STEP_NAME] = stepName;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_WORK_ORDER_KEY] = workOrderKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_STATE_FLAG] = stateFlag;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_REWORK_FLAG] = reworkFlag;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_LINE_KEY] = lineKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE] = lineName;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_OPR_LINE_PRE] = lineName;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_EDC_INS_KEY] = edcInsKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_EQUIPMENT_KEY] = equipmentKey;
//插入报废记录。
//isOnlyPatch=0 先报废后补片。isOnlyPatch=1 仅做补片。
if (isOnlyPatch == 0)
{
string scrapTransaction = UtilHelper.GenerateNewKey(0);
DataSet dsScrapParams = new DataSet();
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_IN] = quantityIn;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT] = quantityIn - patchedQuantity;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY] = scrapTransaction;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY] = ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_CELLSCRAP;
DataTable dtScrapTransaction = CommonUtils.ParseToDataTable(htPatchedTransaction);
dtScrapTransaction.TableName = WIP_TRANSACTION_FIELDS.DATABASE_TABLE_NAME;
dsScrapParams.Tables.Add(dtScrapTransaction);
DataTable dtScrap = CommonUtils.CreateDataTable(new WIP_SCRAP_FIELDS());
DataRow drScrap = dtScrap.NewRow();
drScrap[WIP_SCRAP_FIELDS.FIELD_DESCRIPTION] = drPatch[WIP_PATCH_FIELDS.FIELD_DESCRIPTION];
drScrap[WIP_SCRAP_FIELDS.FIELD_EDIT_TIME] = drPatch[WIP_PATCH_FIELDS.FIELD_EDIT_TIME];
drScrap[WIP_SCRAP_FIELDS.FIELD_EDIT_TIMEZONE_KEY] = drPatch[WIP_PATCH_FIELDS.FIELD_EDIT_TIMEZONE_KEY];
drScrap[WIP_SCRAP_FIELDS.FIELD_EDITOR] = drPatch[WIP_PATCH_FIELDS.FIELD_EDITOR];
drScrap[WIP_SCRAP_FIELDS.FIELD_ENTERPRISE_KEY] = drPatch[WIP_PATCH_FIELDS.FIELD_ENTERPRISE_KEY];
drScrap[WIP_SCRAP_FIELDS.FIELD_ENTERPRISE_NAME] = drPatch[WIP_PATCH_FIELDS.FIELD_ENTERPRISE_NAME];
drScrap[WIP_SCRAP_FIELDS.FIELD_REASON_CODE_CLASS] = drPatch[WIP_PATCH_FIELDS.FIELD_REASON_CODE_CLASS];
drScrap[WIP_SCRAP_FIELDS.FIELD_REASON_CODE_KEY] = drPatch[WIP_PATCH_FIELDS.FIELD_REASON_CODE_KEY];
drScrap[WIP_SCRAP_FIELDS.FIELD_REASON_CODE_NAME] = drPatch[WIP_PATCH_FIELDS.FIELD_REASON_CODE_NAME];
drScrap[WIP_SCRAP_FIELDS.FIELD_RESPONSIBLE_PERSON] = drPatch[WIP_PATCH_FIELDS.FIELD_RESPONSIBLE_PERSON];
drScrap[WIP_SCRAP_FIELDS.FIELD_ROUTE_KEY] = drPatch[WIP_PATCH_FIELDS.FIELD_ROUTE_KEY];
drScrap[WIP_SCRAP_FIELDS.FIELD_ROUTE_NAME] = drPatch[WIP_PATCH_FIELDS.FIELD_ROUTE_NAME];
drScrap[WIP_SCRAP_FIELDS.FIELD_SCRAP_QUANTITY] = drPatch[WIP_PATCH_FIELDS.FIELD_PATCH_QUANTITY];
drScrap[WIP_SCRAP_FIELDS.FIELD_STEP_KEY] = drPatch[WIP_PATCH_FIELDS.FIELD_STEP_KEY];
drScrap[WIP_SCRAP_FIELDS.FIELD_STEP_NAME] = drPatch[WIP_PATCH_FIELDS.FIELD_STEP_NAME];
drScrap[WIP_SCRAP_FIELDS.FIELD_TRANSACTION_KEY] = scrapTransaction;
dtScrap.Rows.Add(drScrap);
dsScrapParams.Tables.Add(dtScrap);
LotScrap(dsScrapParams, dbTran);
}
//插入被补片批次的操作记录
//isOnlyPatch=0 先报废后补片。isOnlyPatch=1 仅做补片。
if (isOnlyPatch == 0)
{
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_IN] = quantityIn - patchedQuantity;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT] = quantityIn;
}
else
{
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_IN] = quantityIn;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_QUANTITY_OUT] = quantityIn + patchedQuantity;
}
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY] = patchedTransactionKey;
htPatchedTransaction[WIP_TRANSACTION_FIELDS.FIELD_ACTIVITY] = ACTIVITY_FIELD_VALUES.FIELD_ACTIVITY_PATCHED;
sql = DatabaseTable.BuildInsertSqlStatement(wipFields, htPatchedTransaction, null);
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
//插入一笔批次补片明细数据
//补片操作记录主键。
if (!htPatch.ContainsKey(WIP_PATCH_FIELDS.FIELD_TRANSACTION_KEY))
{
htPatch.Add(WIP_PATCH_FIELDS.FIELD_TRANSACTION_KEY, transactionKey);
}
htPatch[WIP_PATCH_FIELDS.FIELD_TRANSACTION_KEY] = transactionKey;
//被补片批次操作记录主键
if (!htPatch.ContainsKey(WIP_PATCH_FIELDS.FIELD_PATCHED_TRANSACTION_KEY))
{
htPatch.Add(WIP_PATCH_FIELDS.FIELD_PATCHED_TRANSACTION_KEY, patchedTransactionKey);
}
htPatch[WIP_PATCH_FIELDS.FIELD_PATCHED_TRANSACTION_KEY] = patchedTransactionKey;
//重置补片明细的编辑时间为当前时间。
htPatch[WIP_PATCH_FIELDS.FIELD_EDIT_TIME] = null;
sql = DatabaseTable.BuildInsertSqlStatement(patchFields, htPatch, null);
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
}
AddWIPLot(dbTran, transactionKey, lotKey);
//获取组件补片批次当前数量
sql = string.Format("SELECT QUANTITY FROM POR_LOT WHERE LOT_KEY='{0}'", lotKey.PreventSQLInjection());
double quantity = Convert.ToDouble(db.ExecuteScalar(CommandType.Text, sql));
if (quantity < sumPatchedQty)
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, string.Format("组件补片批次当前实际数量[{0}]小于补片数量[{1}]，请确认。", quantity, sumPatchedQty));
dbTran.Rollback();
return(dsReturn);
}
//更新批次数量。
sql = string.Format(@"UPDATE POR_LOT
SET QUANTITY={0},EDITOR='{1}',EDIT_TIME=GETDATE(),EDIT_TIMEZONE='{2}',DELETED_TERM_FLAG={3}
WHERE LOT_KEY='{4}'",
quantity - sumPatchedQty,
editor.PreventSQLInjection(),
editTimeZone.PreventSQLInjection(),
(quantity - sumPatchedQty) > 0 ? 0 : 1,
lotKey.PreventSQLInjection());
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
//向WIP_TRANSACTION表插入批次补片的操作记录。
if (!htTransaction.ContainsKey(WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY))
{
htTransaction.Add(WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY, transactionKey);
}
htTransaction[WIP_TRANSACTION_FIELDS.FIELD_TRANSACTION_KEY] = transactionKey;
sql = DatabaseTable.BuildInsertSqlStatement(wipFields, htTransaction, null);
db.ExecuteNonQuery(dbTran, CommandType.Text, sql);
}
dbTran.Commit();
ReturnMessageUtils.AddServerReturnMessage(dsReturn, string.Empty);
}
catch (Exception ex)
{
ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
LogService.LogError("LotPatch Error: " + ex.Message);
dbTran.Rollback();
}
finally
{
dbConn.Close();
}
return(dsReturn);
}
/// <summary>
/// 批次创建。自动生成组件序列号，设定单串焊线别设备
/// </summary>
/// <param name="dsParams">创批的数据集信息</param>
/// <returns>包含创建批次结果的数据集对象</returns>
public DataSet CeateNewLot(DataSet dsParams)
{
DataSet dsReturn = new DataSet();
StringBuilder sbMsg = new StringBuilder();
try
{
DataTable dtMainData = dsParams.Tables[0]; //存放批次主数据
DataTable dtAddtionData = dsParams.Tables[1]; //存放附加数据
DataTable dtNewLot = dsParams.Tables[2]; //存在批次号和硅片供应商
Hashtable htMainData = CommonUtils.ConvertToHashtable(dtMainData);
Hashtable htAddtionData = CommonUtils.ConvertToHashtable(dtAddtionData);
string workOrderNo = Convert.ToString(htMainData[POR_LOT_FIELDS.FIELD_WORK_ORDER_NO]);
string workOrderKey = Convert.ToString(htMainData[POR_LOT_FIELDS.FIELD_WORK_ORDER_KEY]);
string storeMaterialDetailKey = Convert.ToString(htAddtionData["STORE_MATERIAL_DETAIL_KEY"]);
string materialLotNo = Convert.ToString(htMainData[POR_LOT_FIELDS.FIELD_MATERIAL_LOT]);
string locationKey = Convert.ToString(htMainData[POR_LOT_FIELDS.FIELD_FACTORYROOM_KEY]);
string createOperationName = Convert.ToString(htMainData[POR_LOT_FIELDS.FIELD_CREATE_OPERTION_NAME]);
double materialQtyPerLot = Convert.ToDouble(htMainData[POR_LOT_FIELDS.FIELD_QUANTITY_INITIAL]);
//double materialSumQty = dtNewLot.Rows.Count * materialQtyPerLot;
//获取工单指定的组件默认等级。
string sql = @"SELECT b.GRADE_CODE
FROM POR_WORK_ORDER_ATTR a
INNER JOIN V_ProductGrade b ON b.GRADE_NAME=a.ATTRIBUTE_VALUE
WHERE a.ATTRIBUTE_NAME='DefaultGrade'
AND a.ISFLAG=1
AND a.WORK_ORDER_KEY=@workOrderKey";
DbCommand cmd = db.GetSqlStringCommand(sql);
db.AddInParameter(cmd, "@workOrderKey", DbType.String, workOrderKey);
object defaultGradeCode = db.ExecuteScalar(cmd);
if (defaultGradeCode != DBNull.Value && defaultGradeCode != null)
{
if (htMainData.Contains(POR_LOT_FIELDS.FIELD_PRO_LEVEL))
{
htMainData.Add(POR_LOT_FIELDS.FIELD_PRO_LEVEL, defaultGradeCode);
}
else
{
htMainData[POR_LOT_FIELDS.FIELD_PRO_LEVEL] = defaultGradeCode;
}
}
int creatingCount = 0;
int createdCount = 0;
//移除dtNew中的无效列
dtNewLot.Columns.Remove("CHECK_SMALL_PACK_NUMBER");
//增加批次。
foreach (DataRow drLot in dtNewLot.Rows)
{
creatingCount++;
using (System.Transactions.TransactionScope ts = new System.Transactions.TransactionScope())
{
//批次转换为大写字母
string lotNumber = Convert.ToString(drLot["LOT_NUMBER"]).ToUpper();
sql = string.Format(@"SELECT COUNT(1) FROM POR_LOT WHERE LOT_NUMBER='{0}'",
lotNumber.PreventSQLInjection());
int count = Convert.ToInt32(db.ExecuteScalar(CommandType.Text, sql));
if (count > 0)
{
sbMsg.AppendFormat("{1}-【{0}】在数据库中已存在。\r\n", lotNumber, creatingCount);
continue;
}
string siSupplierLot = Convert.ToString(drLot["SI_SUPPLIER_LOT"]);
string smallPackNumber = Convert.ToString(drLot["SMALL_PACK_NUMBER"]); //小包条码 add by yongbing.yang 20130808
string lotType = Convert.ToString(htMainData[POR_LOT_FIELDS.FIELD_LOT_TYPE]);
//判断批次号在数据库中是否存在，如果存在返回。
//获取原材料数量，判断原材料数量是否满足创批需要的原材料数量。
sql = string.Format(@"SELECT ISNULL(SUM(a.CURRENT_QTY),0)
FROM WST_STORE_MATERIAL_DETAIL a
WHERE a.STORE_MATERIAL_DETAIL_KEY='{0}'",
storeMaterialDetailKey.PreventSQLInjection());
double currentMaterialSumQty = Convert.ToDouble(db.ExecuteScalar(CommandType.Text, sql));
double diffQty = currentMaterialSumQty - materialQtyPerLot;
if (diffQty < 0)
{
sbMsg.AppendFormat("因原材料数量不足，创建失败。\r\n", createdCount);
break;
}
//更新原材料数量
sql = string.Format(@"UPDATE WST_STORE_MATERIAL_DETAIL
SET CURRENT_QTY={0}
WHERE STORE_MATERIAL_DETAIL_KEY='{1}'",
diffQty,
storeMaterialDetailKey);
db.ExecuteNonQuery(CommandType.Text, sql);
//查询批次是工单的第几个批次。
sql = string.Format(@"SELECT NEXT_SEQ FROM POR_WORK_ORDER WHERE ORDER_NUMBER='{0}'",
workOrderNo.PreventSQLInjection());
int nextSeq = Convert.ToInt32(db.ExecuteScalar(CommandType.Text, sql));
//设置批次号、硅片供应商和批次在工单中的索引号
htMainData[POR_LOT_FIELDS.FIELD_LOT_NUMBER] = lotNumber;
htMainData[POR_LOT_FIELDS.FIELD_SI_LOT] = siSupplierLot;
htMainData[POR_LOT_FIELDS.FIELD_SMALL_PACK_NUMBER] = smallPackNumber; //小包条码 add by yongbing.yang 20130808
htMainData[POR_LOT_FIELDS.FIELD_WORK_ORDER_SEQ] = nextSeq;
DataSet dsCreateLotParams = new DataSet();
DataTable dtCreateLotMaindata = CommonUtils.ParseToDataTable(htMainData);
dtCreateLotMaindata.TableName = TRANS_TABLES.TABLE_MAIN_DATA;
dsCreateLotParams.Tables.Add(dtCreateLotMaindata);
dsCreateLotParams.Tables.Add(dtAddtionData.Copy());
//创建批次
LotManagement.CreateNewLot(db, dsCreateLotParams, drLot);
//非组件补片批次更新工单剩余数量内。
if (lotType != "L")
{
//更新工单剩余数量
sql = string.Format(@"UPDATE POR_WORK_ORDER
SET QUANTITY_LEFT=QUANTITY_LEFT-1,NEXT_SEQ=NEXT_SEQ+1
WHERE ORDER_NUMBER='{0}'",
workOrderNo.PreventSQLInjection());
db.ExecuteNonQuery(CommandType.Text, sql);
}
createdCount++;
ts.Complete();
}
}
if (sbMsg.Length > 0)
{
sbMsg.AppendFormat("新增{0}块组件。", createdCount);
}
ReturnMessageUtils.AddServerReturnMessage(dsReturn, sbMsg.ToString());
}
catch (Exception ex)
{
LogService.LogError("CeateLot Error: " + ex.Message);
ReturnMessageUtils.AddServerReturnMessage(dsReturn, ex.Message);
}
return(dsReturn);
}
