/// <summary>
/// 取的runcard的資料來源
/// </summary>
/// <param name="LotDataList"></param>
/// <returns></returns>
private DataSet GetRunCardDataSource(LotInfoEx LotData)
{
string sql = @"SELECT * FROM MES_WIP_LOT_NONACTIVE WHERE INVNO = #[STRING]";
sql = string.Format(sql);
SqlAgent sa = SQLCenter.Parse(sql, LotData.InventoryNo);
var lsInvLot = InfoCenter.GetList <LotInfoEx>(sa);
if (lsInvLot.Count == 0)
{
throw new Exception(TextMessage.Error.T00060("InventoryNO:" + LotData.InventoryNo));
}
string sBoxInString = "";
lsInvLot.ForEach(p => {
sBoxInString += "'" + p.Lot + "',";
});
sBoxInString = sBoxInString.EndsWith(",") ? sBoxInString.Substring(0, sBoxInString.Length - 1) : sBoxInString;
var dtInvData = DBCenter.GetDataTable(@"
SELECT WO,INVLOT,SUM(QUANTITY) QUANTITY,DEVICE FROM MES_WIP_LOT_NONACTIVE WHERE LOT IN (
SELECT CURRENTLOT FROM MES_WIP_COMP_NONACTIVE WHERE COMPONENTID IN (
SELECT COMPONENTID FROM CST_WIP_PACK
INNER JOIN CST_WIP_PACK_DATA ON (CST_WIP_PACK.WIP_PACK_SID = CST_WIP_PACK_DATA.WIP_PACK_SID) WHERE
BOXNO IN (" + sBoxInString + "))) GROUP BY WO,INVLOT,DEVICE");
dtInvData.TableName = "INVData";
#region 定義 LOTDATA 資料表
//DataTable dtInvData = lsInvLot.CopyDataToTable("INVData");
dtInvData.Columns.Add("INVDate");
dtInvData.Columns.Add("ITEM");
dtInvData.Columns.Add("DeviceDescr");
dtInvData.Columns.Add("Remark");
dtInvData.Columns.Add("Loaction");
dtInvData.Columns.Add("Factory");
#endregion
for (int i = 0; i < dtInvData.Rows.Count; i++)
{
dtInvData.Rows[i]["INVDate"] = lsInvLot[0]["USERDEFINECOL17"].ToCimesString();
dtInvData.Rows[i]["ITEM"] = (i + 1).ToCimesString();
dtInvData.Rows[i]["Remark"] = lsInvLot[0]["USERDEFINECOL18"].ToCimesString();
dtInvData.Rows[i]["Loaction"] = lsInvLot[0]["LOCATION"].ToCimesString();
dtInvData.Rows[i]["Factory"] = lsInvLot[0]["FACTORY"].ToCimesString();
var DeviceData = DeviceVersionInfoEx.GetActiveDeviceVersion(dtInvData.Rows[i]["DEVICE"].ToString()).ChangeTo <DeviceVersionInfoEx>();
if (DeviceData != null)
{
dtInvData.Rows[i]["DeviceDescr"] = DeviceData.Description;
}
}
DataSet dsReportData = new DataSet();
dsReportData.Tables.Add(dtInvData);
return(dsReportData);
}
/// <summary>
/// 依照輸入LotID取得相關欄位資料及相關Button設定
/// </summary>
/// <param name="LotID">批號名稱</param>
private void LoadControlByLot(string LotID)
{
// 清除欄位資訊
ClearField();
var lsLotData = LotInfoEx.GetLotByLot(LotID).ChangeTo <LotInfoEx>();
//若在製找不到，換到MES_WIP_LOT_NONACTIVE找
if (lsLotData == null)
{
string sql = @"SELECT * FROM MES_WIP_LOT_NONACTIVE WHERE LOT = #[STRING]";
SqlAgent sa = SQLCenter.Parse(sql, LotID);
lsLotData = InfoCenter.GetBySQL <LotInfoEx>(sa);
}
// 若該批號無資料可顯示,離開程式並顯示訊息
if (lsLotData == null)
{
btnPrint.Enabled = false;
throw new Exception(TextMessage.Error.T00060(LotID));
}
btnPrint.Enabled = true;
lotData = lsLotData;
}
/// <summary>
/// 取得流程清單
/// </summary>
private void GetRoute(LotInfoEx lotData)
{
//清除資料
ddlRoute.Items.Clear();
ddlRoute.Enabled = false;
//依據目前的料號及料號版本取得所有可選的流程
var routeList = RouteInfo.GetDeviceRoute(lotData.DeviceName, lotData.DeviceVersion);
if (routeList.Count > 0)
{
ddlRoute.DataSource = routeList;
ddlRoute.DataTextField = "RouteName";
ddlRoute.DataValueField = "RouteSID";
ddlRoute.DataBind();
if (ddlRoute.Items.Count != 1)
{
ddlRoute.Items.Insert(0, "");
}
else
{
ddlRoute.SelectedIndex = 0;
}
ddlRoute.Enabled = true;
}
}
protected void ddlOperation_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
btnOK.Enabled = false;
if (ddlOperation.SelectedValue.IsNullOrEmpty())
{
if (_ProdType == CustomizeFunction.ProdType.B.ToCimesString())
{
ttbWorkpiece.ReadOnly = false;
ttbWorkpiece.Text = "";
}
return;
}
ttbWorkpiece.ReadOnly = true;
//用小工單號找出所有的component，逆排後找出第一個符合選擇站點的component為送待判的對象
var compList = ComponentInfoEx.GetAllComponentByWOLot(ttbWOLot.Text.Trim()).OrderByDescending(p => p.ComponentID).ToList();
ProcessLotData = null;
foreach (var p in compList)
{
var tempLot = LotInfoEx.GetLotByLot(p.CurrentLot);
//第一個找到站點符合的component就不用再找了
if (tempLot.OperationName == ddlOperation.SelectedValue)
{
ProcessLotData = tempLot;
break;
}
}
if (ProcessLotData == null)
{
AjaxFocus(ddlOperation);
ttbWOLot.Text = string.Empty;
throw new RuleCimesException(RuleMessage.Error.C00050(ttbWOLot.Text, ddlOperation.SelectedValue));
}
// 取得子單元
var lstComponents = ComponentInfo.GetLotAllComponents(ProcessLotData).OrderByDescending(p => p.ComponentID).ToList();
_ComponentInfo = lstComponents.Count == 0 ? null : lstComponents[0].ChangeTo <ComponentInfoEx>();
// 判斷子單元是否存在
if (_ComponentInfo == null)
{
throw new CimesException(RuleMessage.Error.C00039(ProcessLotData.Lot));
}
ttbWorkpiece.ReadOnly = true;
ttbWorkpiece.Text = _ComponentInfo.ComponentID;
btnOK.Enabled = true;
}
catch (Exception ex)
{
HandleError(ex);
}
}
public static void AutoMerge(string invLot, TransactionStamp txs, ReasonCategoryInfo reasonCategory)
{
//找到相同的INVLot的序號
var lots = LotInfoEx.GetLotListByInvertoryLot(invLot);
//排除送過NG的序號
var autoMergeLots = lots.FindAll(p => p.UserDefineColumn01.IsNullOrTrimEmpty());
//利用小工單號確認是否還有QC未檢驗的資料(包含FAI、PQC、PPK)
//只要有一張未檢，則代表檢驗未完成，回傳false，反之
var qcFlag = CheckQCInspectionDone(lots[0].WorkOrderLot);
//檢查數量是否可以做AUTOMERGE
var waitMergeLots = autoMergeLots.FindAll(p => p.Status == "WaitMerge");
if (waitMergeLots.Count == autoMergeLots.Count && qcFlag)
{
var customizeFunction = new CustomizeFunction();
//取得命名規則
//var naming = customizeFunction.GetNamingRule("SplitLot", txs.UserID, autoMergeLots[0], null);
//拆批
var split = SplitLotInfo.CreateSplitLotByLotAndQuantity(autoMergeLots[0].Lot, autoMergeLots[0].WorkOrderLot, 0, 0, txs.CategoryReasonCode, txs.Description);
//母批不做結批
var splitIndicator = WIPTxn.SplitIndicator.Create(null, null, null, TerminateBehavior.NoTerminate);
WIPTxn.Default.SplitLot(autoMergeLots[0], split, splitIndicator, txs);
//更新命名規則
//if (naming.Second.Count > 0)
//{
// DBCenter.ExecuteSQL(naming.Second);
//}
//再取一次批號資訊
var newLot = LotInfo.GetLotByLot(split.Lot);
//併批與子單元
List <MergeLotInfo> mergeLotList = new List <MergeLotInfo>();
waitMergeLots.ForEach(mergelot =>
{
var compData = ComponentInfo.GetComponentByComponentID(mergelot.ComponentLot);
var mergeLot = MergeLotInfo.GetMergeLotByLotAndQuantity(mergelot.Lot, new List <ComponentInfo>()
{
compData
}, reasonCategory, txs.Description);
mergeLotList.Add(mergeLot);
});
WIPTransaction.MergeLot(newLot, mergeLotList, txs);
//再取一次批號資訊
var newMergeLot = LotInfo.GetLotByLot(split.Lot);
//將批號狀態變更為wait
WIPTransaction.ModifyLotSystemAttribute(newMergeLot, "STATUS", LotDefaultStatus.Wait.ToCimesString(), txs);
//將COMPLOT、PROCESS_EQUIP欄位清空，因為這個時間點這個欄位已經沒意義了
WIPTransaction.ModifyLotSystemAttribute(newMergeLot, "COMPLOT", string.Empty, txs);
WIPTransaction.ModifyLotSystemAttribute(newMergeLot, "PROCESS_EQUIP", string.Empty, txs);
//Dispatch到下一站
WIPTransaction.DispatchLot(newMergeLot, txs);
}
}
protected void ttbWorkOrderLot_TextChanged(object sender, EventArgs e)
{
try
{
ClearField();
string workorderLot = ttbWorkOrderLot.Text.Trim();
if (workorderLot.IsNullOrEmpty())
{
return;
}
_LotDatas = LotInfoEx.GetLotListByWorkOrderLot(workorderLot);
if (_LotDatas.Count == 0)
{
// [00060] 工件清單沒有資料可顯示！
throw new RuleCimesException(TextMessage.Error.T00060(lblLotList.Text));
}
var judgeOperation = WpcExClassItemInfo.GetInfoByClass("SAIJudgeOperation").Find(p => p.Remark01 == _LotDatas[0].Process);
if (judgeOperation == null)
{
//找不到待判站資訊，請至系統資料維護增加資訊，屬性：{0}
throw new Exception(RuleMessage.Error.C10014(_LotDatas[0].Process));
}
_JudgeOperation = judgeOperation.Remark02;
_LotDatas = _LotDatas.OrderBy(p => p.OperationSequence).ThenBy(p => p.ComponentLot).ToList();
var lotTemp = _LotDatas.FindAll(p => p.OperationName != _JudgeOperation);
var enabled = true;
lotTemp.ForEach(lot => {
if (lot.Status != "WaitMerge")
{
enabled = false;
}
});
btnOK.Enabled = enabled;
//gvWorkpiece.SetDataSource(_LotDatas, true);
gvWorkpiece.DataSource = _LotDatas;
gvWorkpiece.DataBind();
}
catch (Exception ex)
{
AjaxFocus(ttbWorkOrderLot);
HandleError(ex);
}
}
public static void SaveQCData(string InspectionNo, QCType qcType, LotInfoEx lot, EquipmentInfo equipment, string batchID, QCStatus status, string objectType, TransactionStamp txnStamp)
{
QCInspectionInfoEx inspection = null;
#region 產生檢驗單
inspection = InfoCenter.Create <QCInspectionInfo>().ChangeTo <QCInspectionInfoEx>();
inspection.InspectionNo = InspectionNo;
inspection.QCTYPE = qcType.ToCimesString();
inspection.OperationName = lot.OperationName;
inspection.EquipmentName = equipment.EquipmentName;
inspection.DeviceName = lot.DeviceName;
inspection.BatchID = batchID;
inspection.Status = status.ToCimesString();
inspection.CreateUser = txnStamp.UserID;
inspection.CreateTime = txnStamp.RecordTime;
inspection.InsertToDB(txnStamp.UserID, txnStamp.RecordTime);
#endregion
if (inspection == null)
{
//檢驗單主檔沒有資料
throw new Exception(TextMessage.Error.T00060("QCData"));
}
#region 產生檢驗單對象
//新增一筆資料到MES_QC_INSP_OBJ
var inspectionObject = InfoCenter.Create <QCInspectionObjectInfo>();
if (inspectionObject.InfoState == InfoState.NewCreate)
{
inspectionObject.QC_INSP_SID = inspection.QC_INSP_SID;
inspectionObject.ObjectType = objectType;
inspectionObject.OBJECTSID = lot.ID;
inspectionObject.ObjectName = lot.Lot;
//COMPLOT
inspectionObject.ItemName1 = lot.ComponentLot;
//WOLOT
inspectionObject.ItemName2 = lot.WorkOrderLot;
//MATERIALLOT
inspectionObject.ItemName3 = lot.MaterialLot;
//OP1機台
inspectionObject.ItemName5 = lot.ProcessEquipment;
inspectionObject.Quantity = 1;
inspectionObject.Unit = lot.Unit;
inspectionObject.InsertToDB(txnStamp.UserID, txnStamp.RecordTime);
}
#endregion
}
/// <summary>
/// 依照輸入LotID取得相關欄位資料及相關Button設定
/// </summary>
/// <param name="LotID">批號名稱</param>
private void LoadControlByLot(string LotID)
{
// 清除欄位資訊
ClearField();
if (cbxWO.Checked)
{
_LotData = LotInfoEx.GetLotByWorkOrderLot(LotID);
}
if (cbxLot.Checked)
{
_LotData = LotInfoEx.GetLotByLot(LotID);
}
if (cbxSN.Checked)
{
var lot = CustomizeFunction.ConvertDMCCode(LotID);
var compInfo = ComponentInfoEx.GetComponentByComponentID(lot);
if (compInfo == null)
{
var compList = ComponentInfoEx.GetComponentByDMCCode(lot);
if (compList.Count != 0)
{
compInfo = compList[0];
}
}
if (compInfo != null)
{
_LotData = LotInfo.GetLotByLot(compInfo.CurrentLot).ChangeTo <LotInfoEx>();
}
}
// 若該批號無資料可顯示,離開程式並顯示訊息
if (_LotData == null)
{
btnPrint.Enabled = false;
AjaxFocus(ttbWOLot);
throw new Exception(TextMessage.Error.T00060(LotID));
}
btnPrint.Enabled = true;
}
/// <summary>
/// 依據傳入批號資料及工作站來更新預約資料
/// </summary>
/// <param name="txnLotData"></param>
/// <param name="operationName"></param>
/// <param name="txnStamp"></param>
public void UpdateReserveCheckInData(LotInfoEx txnLotData, string operationName, TransactionStamp txnStamp)
{
//取得預約資料
var WIPReserveList = CSTWIPReserveCheckInInfo.GetDataByLotAndOper(txnLotData.Lot, operationName);
WIPReserveList.ForEach(reserveData =>
{
//記錄出站時間
reserveData.OutTime = DBCenter.GetSystemTime();
//記錄LOG
CSTWIPReserveCheckInLogInfo reserveDataLog = InfoCenter.Create <CSTWIPReserveCheckInLogInfo>();
reserveDataLog = reserveData.Fill <CSTWIPReserveCheckInLogInfo>();
reserveDataLog.LinkSID = txnStamp.LinkSID;
reserveData.DeleteFromDB();
reserveDataLog.InsertToDB();
});
}
/// <summary>
/// 確認出站後是否有下一站的預約紀錄，如果有，則將批號進站至下一個工作站
/// </summary>
/// <param name="txnLotData">機加批號</param>
/// <param name="txnStamp"></param>
public void CheckNextReserveCheckIn(LotInfoEx txnLotData, TransactionStamp txnStamp)
{
//取得預約工作站資料
var WIPNextReserveList = CSTWIPReserveCheckInInfo.GetDataByLot(txnLotData.Lot);
if (WIPNextReserveList.Count > 0)
{
//下一個預約工作站資料
var reserveData = WIPNextReserveList[0];
//將預約的進站時間回寫到hist的Remark01
txnStamp.Remark01 = reserveData.InTime;
//取得機台資料
var equipData = EquipmentInfo.GetEquipmentByName(reserveData.Equipment);
if (equipData == null)
{
//[00885]機台{0}不存在！
throw new Exception(TextMessage.Error.T00885(reserveData.Equipment));
}
//取得機台狀態資料
var newStateInfo = EquipmentStateInfo.GetEquipmentStateByState("RUN");
if (equipData.CurrentState != "RUN")
{
//更新機台狀態
EMSTransaction.ChangeState(equipData, newStateInfo, txnStamp);
}
//批號上機台
EMSTxn.Default.AddLotToEquipment(txnLotData, equipData, txnStamp);
//批號進站
WIPTransaction.CheckIn(txnLotData, equipData.EquipmentName, "", "", LotDefaultStatus.Run.ToString(), txnStamp);
//將批號Dispatch到下一規則
WIPTransaction.DispatchLot(txnLotData, txnStamp);
}
}
/// <summary>
/// 查詢不良品資料
/// </summary>
private void Query()
{
_LotDatas = LotInfoEx.GetLotListByStatus("DefectInv");
if (_LotDatas.Count > 0)
{
//取得不良品單號
GetDefectNaming();
_SelectLotDatas.AddRange(_LotDatas);
//計算批數及數量
CalculationCountAndQty();
gvDefect.SetDataSource(_LotDatas, true);
btnOK.Enabled = true;
}
else
{
// gvDefect.CimesEmptyDataText = "No Data";
}
}
protected void ttbWOLot_TextChanged(object sender, EventArgs e)
{
try
{
/***************************************************************************************
* 依照PRODTYP不同，做不同畫面的處置：
* S：有序號，一律刷入DMC處理。
* G：僅有鍛造批，選擇要判定的工作站，系統找出該工作站所有的COMPONENT，順排取最後一個
* W：沒有刻字，選擇要判定的工作站，系統找出該工作站所有的COMPONENT，順排取最後一個
* B：有刻字，但序號無意義。
* 在刻字站前因為未刻字所以選擇要判定的工作站，系統找出該工作站所有的COMPONENT，順排取最後一個
* 刻字後，直接刷入DMC處理
**********************************************************/
// 清除資料與使用者介面
ClearField();
LoadDefaultControl();
string sWOLot = ttbWOLot.Text.Trim();
if (sWOLot.IsNullOrEmpty())
{
return;
}
#region 找出料號型態
// 小工單號找批號，此處找批號只是為了找出料號，也順便可以確認線上還有批號可以做送待判這件事
ProcessLotData = LotInfoEx.GetLotByWorkOrderLot(sWOLot);
if (ProcessLotData == null)
{
ProcessLotData = LotInfoEx.GetLotByLot(sWOLot);
}
if (ProcessLotData == null)
{
ttbWOLot.Text = "";
AjaxFocus(ttbWOLot);
throw new RuleCimesException(TextMessage.Error.T00030(GetUIResource("WOLot"), sWOLot));
}
//取得小工單號的料號版本
var deviceVersionInfo = DeviceVersionInfo.GetLotCurrentDeviceVersion(ProcessLotData).ChangeTo <DeviceVersionInfoEx>();
if (deviceVersionInfo == null)
{
throw new CimesException(TextMessage.Error.T00537(ProcessLotData.DeviceName));
}
if (deviceVersionInfo.ProdType.IsNullOrTrimEmpty())
{
ttbWOLot.Text = "";
AjaxFocus(ttbWOLot);
throw new RuleCimesException(TextMessage.Error.T00031(GetUIResource("Device"), deviceVersionInfo.DeviceName, "PRODTYPE"));
}
_ProdType = deviceVersionInfo.ProdType;
#endregion
#region 取得工作站
ddlOperation.Items.Clear();
var lstLotRouteOperation = RouteOperationInfo.GetLotDefaultOperations(ProcessLotData).OrderBy(p => p.OperationSequence).ToList();
lstLotRouteOperation.ForEach(oper => {
ddlOperation.Items.Add(new ListItem(oper.OperationName + "[" + oper.OperationSequence + "]", oper.OperationName));
});
ddlOperation.Items.Insert(0, "");
#endregion
#region 原因碼選項
ddlDefectReason.Items.Clear();
List <BusinessReason> reason = ReasonCategoryInfo.GetOperationRuleCategoryReasonsWithReasonDescr(ProgramRight, ProcessLotData.OperationName, "Default", ReasonMode.Category);
if (reason.Count == 0)
{
reason = ReasonCategoryInfo.GetOperationRuleCategoryReasonsWithReasonDescr(ProgramRight, "ALL", "Default", ReasonMode.Category);
}
if (reason.Count > 0)
{
ddlDefectReason.DataSource = reason;
ddlDefectReason.DataTextField = "ReasonDescription";
ddlDefectReason.DataValueField = "ReasonCategorySID";
ddlDefectReason.DataBind();
if (ddlDefectReason.Items.Count != 1)
{
ddlDefectReason.Items.Insert(0, "");
}
else
{
ddlDefectReason.SelectedIndex = 0;
}
}
else
{
//[00641]規則:{0} 工作站:{1} 使用的原因碼未設定，請洽IT人員!
throw new Exception(TextMessage.Error.T00641(ProgramRight, ProcessLotData.OperationName));
}
#endregion
#region 依照PRODTYPE處理介面
ttbDefectDesc.ReadOnly = false;
ddlDefectReason.Enabled = true;
if (_ProdType == CustomizeFunction.ProdType.S.ToCimesString())
{
ddlOperation.Enabled = false;
ttbWorkpiece.ReadOnly = false;
}
if (_ProdType == CustomizeFunction.ProdType.W.ToCimesString() || _ProdType == CustomizeFunction.ProdType.G.ToCimesString())
{
ttbWorkpiece.ReadOnly = true;
ddlOperation.Enabled = true;
}
if (_ProdType == CustomizeFunction.ProdType.B.ToCimesString())
{
ttbWorkpiece.ReadOnly = false;
ddlOperation.Enabled = true;
}
#endregion
#region 找出待判站
//在系統資料維護裡，取得此批號對應製程(CPC/CPF)的待判工作站名稱
List <WpcExClassItemInfo> operationList = WpcExClassItemInfo.GetExtendItemListByClassAndRemarks("SAIJudgeOperation");
WpcExClassItemInfo judgeOperationData = operationList.Find(p => p.Remark01 == ProcessLotData.Process);
if (judgeOperationData == null)
{
//找不到待判站資訊，請至系統資料維護增加資訊，屬性：{0}
throw new Exception(RuleMessage.Error.C10014(ProcessLotData.Process));
}
//取得待判工作站名稱
_JudgeOperationName = judgeOperationData.Remark02;
#endregion
if (ttbWorkpiece.Enabled)
{
AjaxFocus(ttbWorkpiece);
}
}
catch (Exception ex)
{
HandleError(ex);
}
}
protected void ttbWOLot_TextChanged(object sender, EventArgs e)
{
try
{
/****************************************************************
* 1. 依照工作站點及料號的設定，判斷批號是否可執行中心孔資訊收集。
* 2. 部分料號就算不收中心孔資訊，但需要收集DMC
* 3. 若不須收集中心孔，且prodType = 'W'，連DMC都不須執行
****************************************************************/
ttbWorkpiece.ReadOnly = true;
ttbTemperature.ReadOnly = true;
// 清除資料與使用者介面
ClearField();
string sWOLot = ttbWOLot.Text.Trim();
if (sWOLot.IsNullOrEmpty())
{
return;
}
// 小工單號找批號
//var lotInfo = LotInfoEx.GetLotByWorkOrderLot(sWOLot);
ProcessLotData = LotInfoEx.GetLotByLot(sWOLot);
if (ProcessLotData == null)
{
ttbWOLot.Text = "";
AjaxFocus(ttbWOLot);
throw new RuleCimesException(TextMessage.Error.T00030(lblWOLot.Text + "(" + sWOLot + ")", GetUIResource("Lot")));
}
_ComponentList = ComponentInfo.GetLotAllComponents(ProcessLotData);
//取得小工單號的料號版本
var deviceVersionInfo = DeviceVersionInfo.GetLotCurrentDeviceVersion(ProcessLotData).ChangeTo <DeviceVersionInfoEx>();
if (deviceVersionInfo == null)
{
throw new CimesException(TextMessage.Error.T00537(ProcessLotData.DeviceName));
}
if (deviceVersionInfo.ProdType.IsNullOrTrimEmpty())
{
ttbWOLot.Text = "";
AjaxFocus(ttbWOLot);
throw new RuleCimesException(TextMessage.Error.T00031(GetUIResource("Device"), deviceVersionInfo.DeviceName, "PRODTYPE"));
}
_ProdType = deviceVersionInfo.ProdType;
_CenterHoleFlag = deviceVersionInfo.CenterHoleFlag;
//確認執行的工作站是否需要收集中心孔
var operData = OperationInfo.GetOperationByName(ProcessLotData.OperationName).ChangeTo <OperationInfoEx>();
if (operData == null)
{
throw new CimesException(TextMessage.Error.T00171(ProcessLotData.OperationName));
}
if (!operData.CenterHoleFlag.ToBool() && !operData.GetDMC.ToBool())
{
AjaxFocus(ttbWOLot);
throw new CimesException(RuleMessage.Error.C00042(ProcessLotData.OperationName));
}
//若不須收集中心孔，且prodType = 'W'，連DMC都不須執行
if (!_CenterHoleFlag.ToBool() && deviceVersionInfo.ProdType == CustomizeFunction.ProdType.W.ToCimesString())
{
AjaxFocus(ttbWOLot);
throw new CimesException(RuleMessage.Error.C00043(ProcessLotData.DeviceName));
}
if (_CenterHoleFlag.ToBool())
{
gvComponentEDC.Visible = true;
}
else
{
gvComponentEDC.Visible = false;
}
ttbWorkpiece.ReadOnly = false;
AjaxFocus(ttbWorkpiece);
}
catch (Exception ex)
{
HandleError(ex);
}
}
protected void ttbWorkpiece_TextChanged(object sender, EventArgs e)
{
try
{
string inputObject = ttbWorkpiece.Text.Trim();
if (inputObject.IsNullOrEmpty())
{
ClearUI();
return;
}
//轉換字串最後"."的字串
inputObject = CustomizeFunction.ConvertDMCCode(inputObject);
//DMCCode有刻字有SN
if (_ProdType == CustomizeFunction.ProdType.S.ToCimesString())
{
ComponentInfo = _ComponentList.Find(p => p.ComponentID == inputObject);
if (ComponentInfo == null)
{
//工件{0}不屬於Runcard {1}，請確認!!
throw new CimesException(RuleMessage.Error.C00030(inputObject, ttbWOLot.Text));
}
#region 以ComponentID找出ComponentInfo
//ComponentInfo = ComponentInfoEx.GetComponentByComponentID(inputObject);
//if (ComponentInfo != null)
//{
// ProcessLotData = LotInfo.GetLotByLot(ComponentInfo.CurrentLot);
//}
#endregion
}
//DMCCode有刻字無SN
if (_ProdType == CustomizeFunction.ProdType.G.ToCimesString())
{
#region 以MLot,WOLot找出ComponentInfo
// 以物料批找出批號
var lstLots = LotInfoEx.GetLotByMaterialLotAndWOLot(inputObject, ProcessLotData.WorkOrderLot);
if (lstLots.Count > 1)
{
throw new RuleCimesException(RuleMessage.Error.C10040(inputObject));
}
// 若物料批找不到批號則以WOLot找出批號
if (lstLots.Count == 0)
{
//[00030]{0}：{1}不存在!
throw new RuleCimesException(TextMessage.Error.T00030(lblWOLot.Text + "(" + ttbWOLot.Text + ")," + lblMaterialLot.Text + "(" + inputObject + ")", GetUIResource("Lot")));
}
ProcessLotData = lstLots[0];
// 取得所有子單元，並取得沒有做過中心孔量測的批號，以ComponentID排序
var lstComponents = ComponentInfo.GetLotAllComponents(ProcessLotData).FindAll(p => p["CENTER_HOLE_FLAG"].ToString() == "N").OrderBy(p => p.ComponentID).ToList();
ComponentInfo = lstComponents.Count == 0 ? null : lstComponents[0];
if (ComponentInfo == null)
{
throw new CimesException(RuleMessage.Error.C00039(ProcessLotData.Lot));
}
#endregion
}
//DMCCode有刻字無意義,或是沒有刻DMCCODE，WOLOT是唯一所以可以直接找到批號
if (_ProdType == CustomizeFunction.ProdType.B.ToCimesString() || _ProdType == CustomizeFunction.ProdType.W.ToCimesString())
{
#region 以小工單號找出批號
// 以小工單號找出批號
//ProcessLotData = LotInfoEx.GetLotByWorkOrderLot(ttbWOLot.Text.Trim());
ProcessLotData = LotInfoEx.GetLotByLot(ttbWOLot.Text.Trim());
if (ProcessLotData == null)
{
throw new RuleCimesException(RuleMessage.Error.C10040(inputObject));
}
var lstComponents = ComponentInfo.GetLotAllComponents(ProcessLotData).ChangeTo <ComponentInfoEx>();
var lstComponentTemp = lstComponents.Find(p => p.DMC == inputObject);
if (lstComponentTemp != null)
{
throw new CimesException(RuleMessage.Error.C00052(inputObject));
}
// 取得所有子單元，並取得沒有做過中心孔量測的批號，以ComponentID排序
lstComponents = lstComponents.FindAll(p => p["CENTER_HOLE_FLAG"].ToString() == "N").OrderBy(p => p.ComponentID).ToList();
ComponentInfo = lstComponents.Count == 0 ? null : lstComponents[0];
if (ComponentInfo == null)
{
throw new CimesException(RuleMessage.Error.C00039(ProcessLotData.Lot));
}
#endregion
}
// 找不到工件
if (ComponentInfo == null)
{
throw new RuleCimesException(TextMessage.Error.T00045(GetUIResource("Workpiece")));
}
// 找不到批號
if (ProcessLotData == null)
{
throw new RuleCimesException(TextMessage.Error.T00045(GetUIResource("Lot")));
}
if (ComponentInfo["CENTER_HOLE_FLAG"].ToString() != "N")
{
throw new RuleCimesException(RuleMessage.Error.C10049());
}
//批號檢查狀態
if (ProcessLotData.Status != LotDefaultStatus.Run.ToCimesString())
{
//[01203]批號狀態不正確, 應為 {0} !
throw new Exception(TextMessage.Error.T01203("Run"));
}
// 顯示機加批號資訊
//ttbWOLot.Text = ProcessLotData["WOLOT"].ToString();
// 顯示鍛造批號資訊
ttbMaterialLot.Text = ProcessLotData["MATERIALLOT"].ToString();
// 顯示工件序號資訊
ttbWorkpieceSerialNumber.Text = ComponentInfo.ComponentID;
// 顯示料號資訊
ttbDeviceName.Text = ProcessLotData.DeviceName;
var deviceInfo = DeviceInfo.GetDeviceByName(ProcessLotData.DeviceName);
// 顯示機加批號資訊
ttbDeviceDescr.Text = deviceInfo.Description;
// 顯示工作站資訊
ttbOperation.Text = ProcessLotData.OperationName;
// 顯示流程名稱資訊
ttbRouteName.Text = ProcessLotData.RouteName;
if (_CenterHoleFlag.ToBool())
{
// 取得中心孔量測設定值
var lstSAICenterHolde = WpcExClassItemInfo.GetExClassItemInfo("SAICenterHole", ProcessLotData.DeviceName);
if (lstSAICenterHolde.Count == 0)
{
lstSAICenterHolde = WpcExClassItemInfo.GetExClassItemInfo("SAICenterHole", "ALL");
}
// 若找不到中心孔量測需拋錯
if (lstSAICenterHolde.Count == 0)
{
throw new RuleCimesException(TextMessage.Error.T00555("SAICenterHole", ProcessLotData.DeviceName + "," + "ALL"));
}
SAICenterHole = lstSAICenterHolde[0];
// 設定中心孔量測的DataTable資料
DataTable dtEmpty = new DataTable();
dtEmpty.Columns.Add("ITEM", typeof(int));
dtEmpty.Columns.Add("EDC", typeof(String));
for (int i = 0; i < SAICenterHole.Remark04.ToDecimal(0); i++)
{
DataRow dr = dtEmpty.NewRow();
dr["ITEM"] = i + 1;
dtEmpty.Rows.Add(dr);
}
// 將產生的資料表顯示在畫面上
gvComponentEDC.DataSource = dtEmpty;
gvComponentEDC.DataBind();
ttbTemperature.ReadOnly = false;
}
else
{
btnOK_Click(null, EventArgs.Empty);
}
}
catch (Exception ex)
{
ttbWorkpiece.Text = "";
ClearUI();
HandleError(ex, ttbWorkpiece.ClientID);
}
}
/// <summary>
/// 取的runcard的資料來源
/// </summary>
/// <param name="LotDataList"></param>
/// <returns></returns>
private DataSet GetRunCardDataSource(LotInfoEx LotData)
{
string sql = "";
string sTableName = "MES_WIP_COMP";
if (LotData.Status == "Finished")
{
sTableName = "MES_WIP_COMP_NONACTIVE";
}
#region 定義 LOTDATA 資料表
DataTable dtLotData = lotData.CopyDataToTable("LOTDATA");
dtLotData.Columns.Add("CartonNo");
dtLotData.Columns.Add("DeviceDescr1");
dtLotData.Columns.Add("DeviceDescr2");
dtLotData.Columns.Add("CustomerNo1");
dtLotData.Columns.Add("CustomerNo2");
dtLotData.Columns.Add("Device1");
dtLotData.Columns.Add("Device2");
dtLotData.Columns.Add("Quantity1");
dtLotData.Columns.Add("Quantity2");
dtLotData.Columns.Add("Remark");
dtLotData.Columns.Add("Inspectors");
dtLotData.Columns.Add("Packers");
dtLotData.Columns.Add("InspectionDate");
#endregion
#region 定義 COMPDATA 資料表
DataTable dtCompData = new DataTable("COMPDATA");
dtCompData.Columns.Add("ComponentID1");
dtCompData.Columns.Add("ComponentID2");
dtCompData.Columns.Add("Quantity1");
dtCompData.Columns.Add("Quantity2");
#endregion
dtLotData.Rows[0]["CartonNo"] = LotData.Lot;
dtLotData.Rows[0]["Remark"] = "";
var packInfo = CSTWIPPackInfo.GetPackInfoByBoxNo(LotData.Lot);
dtLotData.Rows[0]["Inspectors"] = packInfo.INSPUSER;
dtLotData.Rows[0]["Packers"] = packInfo.UserID;
dtLotData.Rows[0]["InspectionDate"] = packInfo.UpdateTime.Substring(0, 10).Replace("/", "-");
sql = @"SELECT DEVICE,COUNT(*) QTY
FROM CST_WIP_PACK
INNER JOIN CST_WIP_PACK_DATA ON CST_WIP_PACK.WIP_PACK_SID = CST_WIP_PACK_DATA.WIP_PACK_SID
WHERE BOXNO = #[STRING]
GROUP BY DEVICE";
DataTable dtData = DBCenter.GetDataTable(sql, LotData.Lot);
int iIndex = 1;
for (int i = 0; i < dtData.Rows.Count; i++)
{
if (i >= 2)
{
break;
}
iIndex = i + 1;
dtLotData.Rows[0]["Quantity" + iIndex.ToCimesString()] = dtData.Rows[i]["QTY"].ToCimesString();
var DeviceData = DeviceVersionInfoEx.GetActiveDeviceVersion(dtData.Rows[i]["DEVICE"].ToCimesString()).ChangeTo <DeviceVersionInfoEx>();
if (DeviceData != null)
{
dtLotData.Rows[0]["DeviceDescr" + iIndex.ToCimesString()] = DeviceData.Description;
dtLotData.Rows[0]["CustomerNo" + iIndex.ToCimesString()] = DeviceData["CustomerNo"].ToCimesString();
dtLotData.Rows[0]["Device" + iIndex.ToCimesString()] = DeviceData.DeviceName;
}
#region 入庫批號
sql = @"SELECT DMC,COUNT(*) COMPONENTQTY
FROM CST_WIP_PACK
INNER JOIN CST_WIP_PACK_DATA ON CST_WIP_PACK.WIP_PACK_SID = CST_WIP_PACK_DATA.WIP_PACK_SID
WHERE BOXNO = #[STRING]
AND DEVICE = #[STRING]
GROUP BY DMC
ORDER BY DMC ";
var dt = DBCenter.GetDataTable(sql, LotData.Lot, DeviceData.DeviceName);
if (dt.Rows.Count > dtCompData.Rows.Count)
{
int iRowCount = dt.Rows.Count - dtCompData.Rows.Count;
for (int j = 0; j < iRowCount; j++)
{
DataRow dr = dtCompData.NewRow();
dtCompData.Rows.Add(dr);
}
}
for (int k = 0; k < dt.Rows.Count; k++)
{
dtCompData.Rows[k]["ComponentID" + iIndex.ToCimesString()] = dt.Rows[k]["DMC"].ToString();
dtCompData.Rows[k]["Quantity" + iIndex.ToCimesString()] = dt.Rows[k]["COMPONENTQTY"].ToString();
}
#endregion
}
dtCompData.AcceptChanges();
DataSet dsReportData = new DataSet();
dsReportData.Tables.Add(dtLotData);
dsReportData.Tables.Add(dtCompData);
return(dsReportData);
}
/// <summary>
/// 輸入機加批號
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ttbLot_TextChanged(object sender, EventArgs e)
{
try
{
/* 1. 驗證批號存在性。(批號不存在)
* 2. 驗證批號狀態，只能輸入Wait或Run的批號。(狀態為XX，不可執行)
* 數量(Label)：帶出批號數量。
* 料號(Label)：帶出批號所屬料號。
* 料號描述(Label)：帶出料號說明。
* 流程(Label)：帶出批號所屬流程。
* 工作站(Label)：帶出批號所屬工作站。
*/
#region 清除介面資料
ttbQty.Text = "";
ttbDevice.Text = "";
ttbRoute.Text = "";
ttbOperation.Text = "";
ttbDeviceDescr.Text = "";
_LotData = null;
_WIPReserveCheckInData = null;
ddlEquip.Items.Clear();
ddlEquip.Enabled = false;
btnOK.Enabled = false;
#endregion
ttbLot.Must(lblLot);
_LotData = LotInfoEx.GetLotByLot(ttbLot.Text);
if (_LotData != null)
{
if (_LotData.Status == LotDefaultStatus.Wait.ToString() || _LotData.Status == LotDefaultStatus.Run.ToString())
{
// 取得預約工作站資料
GetReserveCheckInData();
//取得可使用機台清單
GetEquipmentList(_LotData.OperationName);
//顯示介面欄位內容
var device = DeviceInfo.GetDeviceByName(_LotData.DeviceName);
ttbQty.Text = _LotData.Quantity.ToString();
ttbDevice.Text = _LotData.DeviceName;
ttbRoute.Text = _LotData.RouteName;
ttbOperation.Text = _LotData.OperationName;
ttbDeviceDescr.Text = device.Description;
AjaxFocus(ddlEquip);
}
else
{
//狀態為{0}，不可執行
throw new Exception(RuleMessage.Error.C10003(_LotData.Status));
}
}
else
{
//[00030]{0}：{1}不存在!
throw new Exception(TextMessage.Error.T00030(lblLot.Text, ttbLot.Text));
}
btnOK.Enabled = true;
}
catch (Exception ex)
{
ClearField();
AjaxFocus(ttbLot);
HandleError(ex);
}
}
/// <summary>
/// 輸入機加批號
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ttbLot_TextChanged(object sender, EventArgs e)
{
try
{
#region 驗證批號存在性
_LotData = LotInfoEx.GetLotByLot(ttbLot.Text);
if (_LotData == null)
{
//[00030]{0}：{1}不存在!
throw new Exception(TextMessage.Error.T00030(lblLot.Text, ttbLot.Text));
}
#endregion
#region 驗證批號狀態，Run的批號
if (_LotData.Status != LotDefaultStatus.Run.ToString())
{
//狀態為{0}，不可執行
throw new Exception(RuleMessage.Error.C10003(_LotData.Status));
}
#endregion
#region 驗證currentRule
if (_LotData.CurrentRuleName != _ProgramInformationBlock.ProgramRight)
{
//該批號作業為XXXX，不為此功能，請遵循作業規範
throw new Exception(RuleMessage.Error.C10004(_LotData.CurrentRuleName));
}
#endregion
#region 維修原因碼(DropDownList)：依照原因碼工作站設定，帶出原因碼
ddlRepairReasonCode.Items.Clear();
List <BusinessReason> reasonList = ReasonCategoryInfo.GetOperationRuleCategoryReasonsWithReasonDescr(_LotData.CurrentRuleName, _LotData.OperationName, "Default", ReasonMode.Category);
if (reasonList.Count > 0)
{
ddlRepairReasonCode.DataSource = reasonList;
ddlRepairReasonCode.DataTextField = "ReasonDescription";
ddlRepairReasonCode.DataValueField = "ReasonCategorySID";
ddlRepairReasonCode.DataBind();
if (ddlRepairReasonCode.Items.Count != 1)
{
ddlRepairReasonCode.Items.Insert(0, "");
}
else
{
ddlRepairReasonCode.SelectedIndex = 0;
}
}
else
{
//[00641]規則:{0} 工作站:{1} 使用的原因碼未設定，請洽IT人員!
throw new Exception(TextMessage.Error.T00641(ProgramRight, _LotData.OperationName));
}
#endregion
//取得工件序號
var componentDataList = ComponentInfoEx.GetDataByCurrentLot(_LotData.Lot);
if (componentDataList.Count > 0)
{
ttbItemSN.Text = componentDataList[0].ComponentID;
}
//取得送待判原因
var lotDefectData = LotDefectInfoEx.GetDataByLotAndComponentID(_LotData.Lot, ttbItemSN.Text);
if (lotDefectData != null)
{
_DefectJudgementData = CSTWIPDefectJudgementInfo.GetDataByWIPDefectSID(lotDefectData.DefectSID);
if (_DefectJudgementData != null)
{
ttbJudgeReason.Text = _DefectJudgementData.Reason;
}
}
ttbRepairDescr.Text = "";
btnOK.Enabled = true;
}
catch (Exception ex)
{
ClearField();
AjaxFocus(ttbLot);
HandleError(ex);
}
}
/// <summary>
/// 確認此批號是否為WOLOT
/// </summary>
/// <param name="lot"></param>
/// <returns></returns>
private bool CheckWOLot(string lot)
{
//確認此批號是否為WOLOT
var woLotList = LotDefectInfoEx.GetDataListByWOLot(lot);
if (woLotList.Count == 0)
{
return(false);
}
foreach (var data in woLotList)
{
//取得批號資訊
var lotData = LotInfoEx.GetLotByLot(data.Lot).ChangeTo <LotInfoEx>();
//驗證批號狀態，Wait的批號
if (lotData.Status != LotDefaultStatus.Wait.ToString())
{
continue;
}
//驗證currentRule
if (lotData.CurrentRuleName != _ProgramInformationBlock.ProgramRight)
{
continue;
}
var reason = ReasonInfo.GetReasonByName(data.ReasonCode);
if (reason == null)
{
throw new CimesException(RuleMessage.Error.C00051(data.ReasonCode));
}
//格式:(批號) 原因碼_說明_備註
string defectText = "(" + data.Lot + ")";
defectText += " " + data.ReasonCode;
if (!reason.Description.IsNullOrTrimEmpty())
{
defectText += "_" + reason.Description;
}
if (!data.Description.IsNullOrTrimEmpty())
{
defectText += "_" + data.Description;
}
ddlJudgeDefect.Items.Add(new ListItem(defectText, data.ID));
}
if (ddlJudgeDefect.Items.Count == 0)
{
//查無送待判原因！
throw new Exception(RuleMessage.Error.C10187());
}
else if (ddlJudgeDefect.Items.Count == 1)
{
ddlJudgeDefect_SelectedIndexChanged(null, EventArgs.Empty);
}
else
{
ddlJudgeDefect.Items.Insert(0, new ListItem());
}
return(true);
}
/// <summary>
/// 輸入機加批號
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ttbLot_TextChanged(object sender, EventArgs e)
{
try
{
/* 1. 驗證批號存在性。(批號不存在)
* 2. 驗證批號狀態，只能輸入Wait或Run的批號。(狀態為XX，不可執行)
* 數量(Label)：帶出批號數量。
* 料號(Label)：帶出批號所屬料號。
* 料號描述(Label)：帶出料號說明。
* 流程(Label)：帶出批號所屬流程。
* 工作站(Label)：帶出批號所屬工作站。
*/
ttbLot.Must(lblLot);
#region 清除介面資料
ttbEquip.Text = "";
ttbQty.Text = "";
ttbDevice.Text = "";
ttbRoute.Text = "";
ttbOperation.Text = "";
ttbComponentId.Text = "";
ttbDefectDesc.Text = "";
ttbDefectQty.Text = "";
ttbDeviceDescr.Text = "";
ddlComponentId.Items.Clear();
ddlDefectReason.Items.Clear();
ddlComponentId.Enabled = true;
ttbComponentId.Enabled = true;
_LotData = null;
_SelectedComponetData = null;
_DeviceData = null;
_DispatchReportTable = new DataTable();
_DefectGridData = new List <DefectGridData>();
btnOK.Enabled = false;
gvDefect.SetDataSource(_DispatchReportTable, true);
#endregion
_LotData = LotInfoEx.GetLotByLot(ttbLot.Text).ChangeTo <LotInfoEx>();
//驗證批號存在性。(批號不存在)
if (_LotData != null)
{
//驗證批號狀態，Run的批號。(狀態為XX，不可執行)
if (_LotData.Status == LotDefaultStatus.Run.ToString())
{
//驗證currentRule。
if (_LotData.CurrentRuleName != _ProgramInformationBlock.ProgramRight)
{
//該批號作業為{0}，不為此功能，請遵循作業規範
throw new Exception(RuleMessage.Error.C10004(_LotData.CurrentRuleName));
}
var operData = OperationInfo.GetOperationByName(_LotData.OperationName).ChangeTo <OperationInfoEx>();
if (operData.GetDMC.ToBool())
{
var compList = ComponentInfo.GetLotAllComponents(_LotData.Lot).ChangeTo <ComponentInfoEx>();
foreach (var compData in compList)
{
if (compData.DMC.IsNullOrTrimEmpty())
{
throw new CimesException(RuleMessage.Error.C00040(compData.ComponentID));
}
}
}
_DeviceData = DeviceVersionInfoEx.GetDataByDeviceName(_LotData.DeviceName);
ttbQty.Text = _LotData.Quantity.ToString();
ttbDevice.Text = _LotData.DeviceName;
ttbEquip.Text = _LotData.ResourceName;
ttbDeviceDescr.Text = _DeviceData.Description;
ttbRoute.Text = _LotData.RouteName;
ttbOperation.Text = _LotData.OperationName;
InitialDropDownList();
if (_DeviceData.ProdType == CustomizeFunction.ProdType.S.ToCimesString())
{
ttbDefectQty.Enabled = false;
ttbDefectQty.Text = "1";
}
else if (_DeviceData.ProdType == CustomizeFunction.ProdType.G.ToCimesString() ||
_DeviceData.ProdType == CustomizeFunction.ProdType.W.ToCimesString() ||
_DeviceData.ProdType == CustomizeFunction.ProdType.B.ToCimesString())
{
ttbDefectQty.Enabled = true;
ttbDefectQty.Text = "1";
ddlComponentId.Enabled = false;
ddlComponentId.SelectedIndex = -1;
ttbComponentId.Enabled = false;
}
else
{
//[00031]{0}：{1}的系統屬性：{2} 未設定，請洽IT人員！
throw new Exception(TextMessage.Error.T00031(lblDevice.Text, _DeviceData.DeviceName, _DeviceData.ProdType));
}
}
else
{
//狀態為{0}，不可執行
throw new Exception(RuleMessage.Error.C10003(_LotData.Status));
}
}
else
{
//[00030]{0}：{1}不存在!
throw new Exception(TextMessage.Error.T00030(lblLot.Text, ttbLot.Text));
}
btnOK.Enabled = true;
}
catch (Exception ex)
{
ClearField();
AjaxFocus(ttbLot);
HandleError(ex);
}
}
/// <summary>
/// 確定
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnOK_Click(object sender, EventArgs e)
{
/*******************************************************************
* PPK判定後須執行事項：
* 1. 依照判定的BATCHID+料號，將所屬單號資料更新。
* 2. 依照判定狀態更新CST_WIP_PPK結果。
* 3. 如同一個BATCHID都判定完成，變更機台狀態，從PPK變IDLE。
* 如一個BATCHID有兩個料號，需兩個料號都判定完成才可以變更機台狀態。
******************************************************************/
try
{
//取得所選擇的料號名稱
var deviceName = ddlDevice.SelectedValue;
#region 確認選擇結果，如果是選擇NG，確認是否有選擇原因碼及選擇結果及檢驗清單的勾選是否符合
string result = "";
if (rdbOK.Checked)
{
result = "OK";
}
else if (rdbNG.Checked)
{
result = "NG";
//確認是否有選擇原因碼
ddlPPKReasonCode.Must(lblPPKReasonCode);
if (SelectedNGData() == false)
{
//PPK結果選擇NG，檢驗清單至少勾選一筆資料！
throw new Exception(RuleMessage.Error.C10070());
}
}
else if (rdbCLOSE.Checked)
{
result = "CLOSE";
//確認是否有選擇原因碼
ddlPPKReasonCode.Must(lblPPKReasonCode);
}
#endregion
TransactionStamp txnStamp = new TransactionStamp(User.Identity.Name, ProgramRight, ProgramRight, ApplicationName);
using (var cts = CimesTransactionScope.Create())
{
#region 更新檢驗主檔清單[MES_QC_INSP]
_QCInspectionDataList.ForEach(QCInspectionData =>
{
//符合選擇的料號才進行資料更新
if (QCInspectionData.DeviceName == deviceName)
{
//有選擇原因碼才更新[NG_Category]及[NG_Reason]
if (string.IsNullOrEmpty(ddlPPKReasonCode.SelectedValue) == false)
{
var reason = InfoCenter.GetBySID <ReasonCategoryInfo>(ddlPPKReasonCode.SelectedValue);
QCInspectionData.NG_Category = reason.Category;
QCInspectionData.NG_Reason = reason.Reason;
}
//如果判定結果為結單的話，則必須把結單時間及人員資料寫回資料庫
if (result == "CLOSE")
{
QCInspectionData.FINISHTIME = txnStamp.RecordTime;
QCInspectionData.FINISHUSER = txnStamp.UserID;
}
QCInspectionData.NG_Description = ttbDescr.Text;
QCInspectionData.Result = result;
QCInspectionData.Status = "Finished";
QCInspectionData.UpdateToDB(txnStamp.UserID, txnStamp.RecordTime);
}
});
#endregion
#region 更新機台資訊及檢驗工件結果
//取某一支工件序號的資料來傳入UpdatePPK
var updateLot = InfoCenter.GetBySID <LotInfo>(_QCInspectionObjDataList[0].OBJECTSID).ChangeTo <LotInfoEx>();
//更新[CST_WIP_PPK.PPKCOUNT]
CustomizeFunction.UpdatePPK(_QCInspectionDataList[0].EquipmentName, updateLot.DeviceName, updateLot.DeviceVersion, (rdbNG.Checked) ? "false" : "true");
//將介面上所勾選/不勾選的資料對應到MES_QC_INSP_OBJ.ITEM4的欄位
for (int i = 0; i < gvQC.Rows.Count; i++)
{
var thisCheckBox = (CheckBox)gvQC.Rows[i].FindControl("ckbDefectSelect");
if (thisCheckBox.Checked)
{
_QCInspectionObjDataList[i].ItemName4 = "NG";
}
else
{
_QCInspectionObjDataList[i].ItemName4 = "OK";
}
_QCInspectionObjDataList[i].UpdateToDB(txnStamp.UserID, txnStamp.RecordTime);
}
//更新機台檢驗主檔
_CSTWIPCMMList.ForEach(data =>
{
data.UpdateToDB();
});
//取得相同BatchID的檢驗資料 (理論上應該都完成檢驗...)
//如果是雙料號，每次判定要分料號判定
var QCDataList = QCInspectionInfoEx.GetDataListByBatchIDAndDeviceName(_QCInspectionDataList[0].BatchID, deviceName);
//如果是雙料號，每次判定要分料號判定，但是機台的狀態要該batchID都判定通過，才算PPK完成
var QCDAllataList = QCInspectionInfoEx.GetDataListByBatchID(_QCInspectionDataList[0].BatchID);
#region 如果相同的BatchID都檢驗完成時，則更新機台狀態為IDLE
//相同BatchID都已完成檢驗旗標
//如果是雙料號，每次判定要分料號判定，但是機台的狀態要該batchID都判定通過，才算PPK完成
bool isAllFinish = true;
QCDAllataList.ForEach(p =>
{
if (p.Status != "Finished")
{
isAllFinish = false;
}
});
if (isAllFinish)
{
//取得機台狀態資料
var newStateInfo = EquipmentStateInfo.GetEquipmentStateByState("IDLE");
//檢查機台是否存在
var equipData = EquipmentInfo.GetEquipmentByName(_QCInspectionDataList[0].EquipmentName);
if (equipData == null)
{
//[00885]機台{0}不存在！
throw new Exception(TextMessage.Error.T00885(_QCInspectionDataList[0].EquipmentName));
}
//更新機台狀態
EMSTransaction.ChangeState(equipData, newStateInfo, txnStamp);
}
#endregion
#region 如果相同的BatchID都檢驗完成且結果都為OK時，則更新機台檢驗資料及更新COUNT
//相同BatchID都已完成檢驗及結果都為OK旗標
bool isAllFinishAndOK = true;
QCDataList.ForEach(p =>
{
if (!(p.Status == "Finished" && p.Result == "OK"))
{
isAllFinishAndOK = false;
}
});
if (isAllFinishAndOK)
{
//取得AutoMerge原因碼
var reasonCategory = ReasonCategoryInfo.GetReasonCategoryByCategoryNameAndReason("CustomizeReason", "AutoMerge");
if (reasonCategory == null)
{
//[00030]{0}：{1}不存在!
throw new Exception(TextMessage.Error.T00030("", "CustomizeReason- AutoMerge"));
}
_QCInspectionObjDataList.ForEach(Data =>
{
//更新機台檢驗資料
Data.UpdateToDB(txnStamp.UserID, txnStamp.RecordTime);
});
var mergeList = _QCInspectionObjDataList.Select(p => p.ItemName2).Distinct().ToList();
foreach (var lot in mergeList)
{
var lotData = LotInfoEx.GetLotByWorkOrderLot(lot);
//確認FAI是否已經檢驗完成
if (CustomizeFunction.CheckFAI(_QCInspectionDataList[0].EquipmentName, lotData.Lot))
{
//執行AutoMerge
CustomizeFunction.AutoMerge(lotData.InventoryLot, txnStamp, reasonCategory);
}
}
}
#endregion
#endregion
cts.Complete();
}
ClearField();
AjaxFocus(ttbEquipOrCompLot);
_ProgramInformationBlock.ShowMessage(TextMessage.Hint.T00614(""));
}
catch (Exception ex)
{
HandleError(ex);
}
}
/// <summary>
/// 輸入工件序號
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ttbCompLot_TextChanged(object sender, EventArgs e)
{
try
{
decimal haveMergeQty = 0;
decimal mergeQty = 0;
decimal notMergeQty = 0;
//確認工件序號是否有輸入
ttbCompLot.Must(lblCompLot);
//確認工件序號是否存在
var lotList = LotInfoEx.GetLotListByComponentLot(ttbCompLot.Text);
if (lotList.Count == 0)
{
//工件序號：{0} 不存在!!
throw new Exception(RuleMessage.Error.C10047(ttbCompLot.Text));
}
var compLotData = lotList[0];
//確認狀態是否為WAIT
if (compLotData.Status != LotDefaultStatus.Wait.ToString())
{
//狀態為{0}，不可執行
throw new Exception(RuleMessage.Error.C10003(compLotData.Status));
}
//確認批號執行規則是否與程式相同
//if (compLotData.CurrentRuleName != _ProgramInformationBlock.ProgramRight)
//{
// //該批號作業為XXXX，不為此功能，請遵循作業規範
// throw new Exception(RuleMessage.Error.C10004(compLotData.CurrentRuleName));
//}
//取得小工單資料
var workOrderLot = CSTWorkOrderLotInfo.GetWorkOrderLotDataByWorkOrderLot(compLotData.WorkOrderLot);
if (workOrderLot == null)
{
// [00030]{0}：{1}不存在!
throw new Exception(TextMessage.Error.T00030(lblWOLot.Text, compLotData.WorkOrderLot));
}
//取得相同小工單的工件序號清單資料
var sameWOLotList = LotInfoEx.GetLotListByWorkOrderLot(compLotData.WorkOrderLot);
#region 取得相同工作站、UDC08等於Y及狀態為Wait的工件序號清單
var autoTypeLotList = sameWOLotList.FindAll(lot => lot.UserDefineColumn08 == "Y");
_MergeLotDataList = autoTypeLotList.FindAll(lot => lot.OperationName == compLotData.OperationName && lot.Status == LotDefaultStatus.Wait.ToString());
//計算可合併數量
_MergeLotDataList.ForEach(lot => { mergeQty += lot.Quantity; });
#endregion
#region 取得不可合併的工件序號清單
var notMergeLotDataList = autoTypeLotList.FindAll(lot => (lot.OperationName == compLotData.OperationName && lot.Status == LotDefaultStatus.Wait.ToString()) == false);
//計算不可合併數量
notMergeLotDataList.ForEach(lot => { notMergeQty += lot.Quantity; });
#endregion
#region 取得已合併的工件序號清單
var haveMergeLotDataList = sameWOLotList.FindAll(lot => lot.UserDefineColumn08 == "N");
//計算已合併數量
haveMergeLotDataList.ForEach(lot => { haveMergeQty += lot.Quantity; });
#endregion
//取得流程清單
GetRoute(compLotData);
//顯示介面資料
ttbOperation.Text = compLotData.OperationName;
ttbWOLot.Text = compLotData.WorkOrderLot;
ttbWOQty.Text = workOrderLot.Quantity.ToString();
ttbMergeQty.Text = mergeQty.ToString();
ttbNotMergeQty.Text = notMergeQty.ToString();
ttbHaveMergeQty.Text = haveMergeQty.ToString();
gvMergeCompLot.SetDataSource(_MergeLotDataList, true);
gvNotMergeCompLot.SetDataSource(notMergeLotDataList, true);
btnOK.Enabled = true;
}
catch (Exception ex)
{
ClearField();
AjaxFocus(ttbCompLot);
HandleError(ex);
}
}
/// <summary>
/// 鍛造出站有不良數量直接拆批及送待判工作站
/// </summary>
/// <param name="txnLotData">機加批號</param>
/// <param name="defectGridDataList">不良清單</param>
/// <param name="txnStamp"></param>
public void SplitDefectLotList(LotInfoEx txnLotData, List <DefectGridData> defectGridDataList, TransactionStamp txnStamp)
{
//待判工作站點名稱
string judgeOperationName = "";
//確認是否有不良清單，如果有不良清單的話，則要取得待判工作站資料
if (defectGridDataList.Count > 0)
{
//在系統資料維護裡，取得此批號對應製程(CPC/CPF)的待判工作站名稱
List <WpcExClassItemInfo> operationList = WpcExClassItemInfo.GetExtendItemListByClassAndRemarks("SAIJudgeOperation");
WpcExClassItemInfo judgeOperationData = operationList.Find(p => p.Remark01 == txnLotData.Process);
if (judgeOperationData == null)
{
//找不到待判站資訊，請至系統資料維護增加資訊，屬性：{0}
throw new Exception(RuleMessage.Error.C10014(txnLotData.Process));
}
//取得待判工作站名稱
judgeOperationName = judgeOperationData.Remark02;
}
//處理不良批號
defectGridDataList.ForEach(defectGridData =>
{
//取得原因碼資訊
var reasonData = InfoCenter.GetBySID <ReasonCategoryInfo>(defectGridData.DefectID);
//取得批號子單元資訊
var component = ComponentInfo.GetComponentByComponentID(defectGridData.ComponentID);
//取得不良子批批號名稱
var splitLotNaming = GetNamingRule("SplitLot", txnStamp.UserID, txnLotData);
//批號拆子批
var splitLot = SplitLotInfo.CreateSplitLotByLotAndQuantity(txnLotData.Lot, splitLotNaming.First[0], new List <ComponentInfo>()
{
component
}, reasonData, reasonData.Description);
WIPTxn.Default.SplitLot(txnLotData, splitLot, WIPTxn.SplitIndicator.Create(null, null, null, TerminateBehavior.NoTerminate), txnStamp);
if (splitLotNaming.Second != null && splitLotNaming.Second.Count != 0)
{
DBCenter.ExecuteSQL(splitLotNaming.Second);
}
//註記不良
var compDefect = ComponentDefectObject.Create(component, component.ComponentQuantity, 0, reasonData, defectGridData.DefectDesc);
WIPTransaction.DefectComponent(splitLot, new List <ComponentDefectObject>()
{
compDefect
}, WIPTransaction.DefectIndicator.Create(), txnStamp);
#region 送至待判工作站
//取得目前批號的流程線上版本
RouteVersionInfo RouteVersion = RouteVersionInfo.GetRouteActiveVersion(txnLotData.RouteName);
//以目前工作站名稱去查詢在所有流程中的序號
var routeOperation = RouteOperationInfo.GetRouteAllOperations(RouteVersion).Find(p => p.OperationName == judgeOperationName);
//以目前工作站名稱去查詢在所有流程中的序號
var reasonCategory = ReasonCategoryInfo.GetReasonCategoryByCategoryNameAndReason("Common", "OTHER");
////將批號的UDC01註記不良批
//WIPTransaction.ModifyLotSystemAttribute(splitLot, "USERDEFINECOL01", "Y", txnStamp);
////將批號的UDC02註記工作站序號
//WIPTransaction.ModifyLotSystemAttribute(splitLot, "USERDEFINECOL02", operationSequence, txnStamp);
////將批號的UDC03註記工作站名稱
//WIPTransaction.ModifyLotSystemAttribute(splitLot, "USERDEFINECOL03", operationName, txnStamp);
var modifyAttrList = new List <ModifyLotAttributeInfo>();
//將批號的UDC01註記不良批
modifyAttrList.Add(ModifyLotAttributeInfo.CreateLotSystemAttributeInfo("USERDEFINECOL01", "Y"));
//將批號的UDC02註記工作站序號
modifyAttrList.Add(ModifyLotAttributeInfo.CreateLotSystemAttributeInfo("USERDEFINECOL02", splitLot.OperationSequence));
//將批號的UDC03註記工作站名稱
modifyAttrList.Add(ModifyLotAttributeInfo.CreateLotSystemAttributeInfo("USERDEFINECOL03", splitLot.OperationName));
WIPTransaction.ModifyLotMultipleAttribute(splitLot, modifyAttrList, txnStamp);
WIPTransaction.ReassignOperation(splitLot, routeOperation, reasonCategory, reasonCategory.Description, txnStamp);
#endregion
});
}
protected void ttbWorkpiece_TextChanged(object sender, EventArgs e)
{
try
{
btnOK.Enabled = false;
if (ttbWorkpiece.Text.Trim().IsNullOrEmpty())
{
if (_ProdType == CustomizeFunction.ProdType.B.ToCimesString())
{
ddlOperation.Enabled = true;
ddlOperation.ClearSelection();
}
return;
}
string componentid = CustomizeFunction.ConvertDMCCode(ttbWorkpiece.Text.Trim());
//僅有B跟S型態會刷DMC，故只需針對兩種CASE處理
if (_ProdType == CustomizeFunction.ProdType.B.ToCimesString())
{
_ComponentInfo = ComponentInfoEx.GetOneComponentByDMCCode(componentid);
if (_ComponentInfo == null)
{
throw new RuleCimesException(RuleMessage.Error.C00049(ttbWorkpiece.Text));
}
}
else if (_ProdType == CustomizeFunction.ProdType.S.ToCimesString())
{
_ComponentInfo = ComponentInfoEx.GetComponentByComponentID(componentid);
if (_ComponentInfo == null)
{
throw new RuleCimesException(RuleMessage.Error.C10047(ttbWorkpiece.Text));
}
}
// 找不到工件
if (_ComponentInfo == null)
{
throw new RuleCimesException(RuleMessage.Error.C10047(ttbWorkpiece.Text));
}
ddlOperation.Enabled = false;
ProcessLotData = LotInfoEx.GetLotByLot(_ComponentInfo.CurrentLot);
if (ProcessLotData == null)
{
AjaxFocus(ttbWorkpiece);
throw new RuleCimesException(TextMessage.Error.T00030(lblWOLot.Text + "(" + ttbWOLot.Text.Trim() + ")" + lblttbWorkpiece.Text + "(" + componentid + ")", GetUIResource("Lot")), ttbWorkpiece);
}
if (ProcessLotData.OperationName == _JudgeOperationName)
{
AjaxFocus(ttbWorkpiece);
throw new RuleCimesException(RuleMessage.Error.C10175(_JudgeOperationName), ttbWorkpiece);
}
var item = ddlOperation.Items.FindByValue(ProcessLotData.OperationName);
if (item != null)
{
ddlOperation.ClearSelection();
item.Selected = true;
}
btnOK.Enabled = true;
}
catch (Exception ex)
{
HandleError(ex);
AjaxFocus(ttbWorkpiece);
}
}
/// <summary>
/// 確認此批號是否為COMPONENTID
/// </summary>
/// <param name="lot"></param>
/// <returns></returns>
private bool CheckComponentID(string lot)
{
//確認此批號是否為COMPONENTID
var component = ComponentInfo.GetComponentByComponentID(lot);
if (component == null)
{
return(false);
}
//取得批號資料
var lotData = LotInfoEx.GetLotByLot(component.CurrentLot).ChangeTo <LotInfoEx>();
if (lotData == null)
{
return(false);
}
//驗證批號狀態，Wait的批號
if (lotData.Status != LotDefaultStatus.Wait.ToString())
{
//狀態為{0}，不可執行
throw new Exception(RuleMessage.Error.C10003(lotData.Status));
}
//驗證currentRule
if (lotData.CurrentRuleName != _ProgramInformationBlock.ProgramRight)
{
//該批號作業為XXXX，不為此功能，請遵循作業規範
throw new Exception(RuleMessage.Error.C10004(lotData.CurrentRuleName));
}
//取得工件序號
var componentDataList = ComponentInfoEx.GetDataByCurrentLot(lotData.Lot);
if (componentDataList.Count > 0)
{
ttbItemSN.Text = componentDataList[0].ComponentID;
}
//取得送待判原因
var lotDefectData = LotDefectInfoEx.GetDataByLotAndComponentID(lotData.Lot, ttbItemSN.Text);
if (lotDefectData != null)
{
var reason = ReasonInfo.GetReasonByName(lotDefectData.ReasonCode);
if (reason == null)
{
throw new CimesException(RuleMessage.Error.C00051(lotDefectData.ReasonCode));
}
//格式:(批號) 原因碼_說明_備註
string defectText = "(" + lotDefectData.Lot + ")";
defectText += " " + lotDefectData.ReasonCode;
if (!reason.Description.IsNullOrTrimEmpty())
{
defectText += "_" + reason.Description;
}
if (!lotDefectData.Description.IsNullOrTrimEmpty())
{
defectText += "_" + lotDefectData.Description;
}
ddlJudgeDefect.Items.Add(new ListItem(defectText, lotDefectData.ID));
ddlJudgeDefect_SelectedIndexChanged(null, EventArgs.Empty);
}
else
{
//查無送待判原因！
throw new Exception(RuleMessage.Error.C10187());
}
return(true);
}
/// <summary>
/// 切換不同的送待判原因
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void ddlJudgeDefect_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
//確認是否有選擇送待判原因
ddlJudgeDefect.Must(lblJudgeDefect);
//取得批號資訊
_LotDefectData = InfoCenter.GetBySID <LotDefectInfo>(ddlJudgeDefect.SelectedValue);
_LotData = LotInfoEx.GetLotByLot(_LotDefectData.Lot).ChangeTo <LotInfoEx>();
#region 判定原因碼(DropDownList)：依照原因碼工作站設定，帶出原因碼
ddlJudgeReason.Items.Clear();
List <BusinessReason> reasonList = ReasonCategoryInfo.GetOperationRuleCategoryReasonsWithReasonDescr(_LotData.CurrentRuleName, _LotData.OperationName, "Default", ReasonMode.Category);
if (reasonList.Count > 0)
{
ddlJudgeReason.DataSource = reasonList;
ddlJudgeReason.DataTextField = "ReasonDescription";
ddlJudgeReason.DataValueField = "ReasonCategorySID";
ddlJudgeReason.DataBind();
if (ddlJudgeReason.Items.Count != 1)
{
ddlJudgeReason.Items.Insert(0, "");
}
else
{
ddlJudgeReason.SelectedIndex = 0;
}
}
else
{
//[00641]規則:{0} 工作站:{1} 使用的原因碼未設定，請洽IT人員!
throw new Exception(TextMessage.Error.T00641(ProgramRight, _LotData.OperationName));
}
#endregion
//數量
ttbQty.Text = _LotData.Quantity.ToString();
//取得工件序號
var componentDataList = ComponentInfoEx.GetDataByCurrentLot(_LotData.Lot);
if (componentDataList.Count > 0)
{
ttbItemSN.Text = componentDataList[0].ComponentID;
}
ttbJudgeDescr.Text = "";
btnOK.Enabled = true;
btnPrint.Enabled = true;
}
catch (Exception ex)
{
ttbItemSN.Text = "";
ttbQty.Text = "";
ttbJudgeDescr.Text = "";
ddlJudgeReason.Items.Clear();
btnOK.Enabled = false;
btnPrint.Enabled = false;
_LotData = null;
_LotDefectData = null;
HandleError(ex);
}
}
