/// <summary> /// 工程跨班時設置新的班次內生產數據 /// </summary> /// <param name="shiftInfo">新的班次信息</param> /// <param name="projectData">上班次生產工程數據</param> public abstract void SetNewShiftProjectProductionData(MachineShiftData newShiftInfo, ProjectProductionData projectData);
/// <summary> /// 班次結束時班次內工程生產數據校驗 /// </summary> /// <param name="shiftInfo">舊班次信息</param> /// <param name="projectData">舊班次內工程生產數據</param> public abstract void ShiftFinishProjectProductionCheck(MachineShiftData shiftInfo, ProjectProductionData projectData);
/// <summary> /// 檢查要“抽起”或“結束”的工程生產數據是否完整，如果不完整則返回一個殘缺數據的類型 /// </summary> /// <param name="departmentCode">機台所屬科組編號</param> /// <param name="operationType">操作類型“抽起”或“結束”</param> /// <param name="shiftInfo">當前班次信息</param> /// <param name="projectData">當前工程生產數據</param> /// <returns>返回一個殘缺的數據類型</returns> public abstract CommonDefine.ProjectDataType CheckProjectProductionDataFull(string departmentCode, CustEnum.ProjectStatus operationType, MachineShiftData shiftInfo, ProjectProductionData projectData);
/// <summary> /// 工程“抽起”或“結束”生產數據校驗 /// </summary> /// <param name="shiftInfo">當前班次信息</param> /// <param name="projectData">當前工程生產數據</param> /// <param name="projectStatus">工程狀態</param> public abstract void ProjectFinishProductionDataCheck(MachineShiftData shiftInfo, ProjectProductionData projectData,string projectStatus);
/// <summary>
/// 已“抽起”、“結束”、“跨班結束”的生產工程數據對象上傳到服務器數據庫中
/// </summary>
/// <param name="projectProductionData">已“抽起”、“結束”、“跨班結束”的生產工程數據對象</param>
/// <returns></returns>
public bool SynFirstCompletedProjectProductionDataToDB(ProjectProductionData projectProductionData)
{
try
{
bool l_lIsSuess = false;
ScheduleProjectData scheduleProjectData = (projectProductionData != null ? projectProductionData.ProjectBaseData : null );
ProjectMachineProductionData projectMachineProductionData = (projectProductionData != null ? projectProductionData.ProjectMProductionData : null );
ShiftProjectProductionData shiftProjectData = ( projectProductionData != null ? projectProductionData.ShiftProjectData : null);
ProjectExtractionReason extractionReasonData = (projectProductionData != null ? projectProductionData.ExtractionReason : null);
ProjectAdditionalInformation additionalInformation = ( projectMachineProductionData != null ? projectMachineProductionData.AdditionalInformation : null);
List<ProjectPrepareJobItem> projectPrepareJobItems = (projectProductionData != null ? projectProductionData.PrepareJobItems : null);
List<ProjectMaterial> projectMaterials = (shiftProjectData != null ? shiftProjectData.ProjectMaterials : null);
List<ProjectMachineHaltRecord> machineHaltRecords = (shiftProjectData != null ? shiftProjectData.MachineHaltRecords : null);
List<ProjectQCRecord> qCRecords = (shiftProjectData != null ? shiftProjectData.QCRecords : null);
List<ProjectCorrectRecord> correctRecords = (shiftProjectData != null ? shiftProjectData.CorrectRecords : null);
List<ProjectPrepareJobExtraTime> prepareJobExtraTimes = null;
if (shiftProjectData != null && shiftProjectData.PrepareJob != null)
{
prepareJobExtraTimes = shiftProjectData.PrepareJob.ExtraTimeItems;
}
Guid gSWL_ID = (scheduleProjectData != null ? scheduleProjectData.RecordID : Guid.Empty);
Guid gPPJ_ID = (projectMachineProductionData != null ? projectMachineProductionData.RecordID : Guid.Empty);
Guid gSPL_ID = (shiftProjectData != null ? shiftProjectData.RecordID : Guid.Empty);
using (SqlConnection conn = new SqlConnection(DbHelperSQL.connectionString))
{
SqlTransaction transaction = null;
conn.Open(); //開啟連接
transaction = conn.BeginTransaction(); //開啟事務
try
{
//★檢查服務器數據庫是否存在工程排期資料（SWL），
//如果不存在則將工程排期資料新增到相應的數據表中
if (scheduleProjectData != null && gSWL_ID != Guid.Empty)
{
ScheduleProjectData checkExistScheduleProjListData = null;
checkExistScheduleProjListData = this.m_objProductionDataSynDAL.GetScheduleProjectData("swl_RecordID = '" + gSWL_ID.ToString() + "'").FirstOrDefault();
if (checkExistScheduleProjListData == null)
{
l_lIsSuess = this.m_objProductionDataSynDAL.AddScheduleProjListData(scheduleProjectData, transaction);
}
//如果存在則更新工程排期資料記錄的“工程狀態”、“已完成數量”、“最後修改日期”。
//公式：“已完成數量”＝“已完成數量[要取DB裡的已完成數]”+“班次內工程的實際生產數量”
else
{
int iNewCompletedQty = checkExistScheduleProjListData.swl_iCompletedQty + shiftProjectData.spl_iQTY;
l_lIsSuess = this.m_objProductionDataSynDAL.UpdateScheduleProjListData(gSWL_ID, scheduleProjectData.swl_cMachineNO, scheduleProjectData.swl_cProjStatus, scheduleProjectData.swl_dStatusChange, iNewCompletedQty, DateTime.Now, transaction);
}
}
//★檢查服務器數據庫是否存在生產工程的機台工程生產資料（表PPJ）
//如果不存在則將生產工程的機台工程生產資料新增到相應的數據表中
if (projectMachineProductionData != null && gPPJ_ID != Guid.Empty)
{
ProjectMachineProductionData CheckExistProjectMachineProductionData = null;
CheckExistProjectMachineProductionData = this.m_objProductionDataSynDAL.GetProjectMachineProductionData("ppj_RecordID='" + gPPJ_ID.ToString() + "'").FirstOrDefault();
if (CheckExistProjectMachineProductionData == null)
{
l_lIsSuess = this.m_objProductionDataSynDAL.AddProjectMachineProductionData(projectMachineProductionData, transaction);
}
else //如果存在則更新如下
{
//1.判斷“工程開始生產時間”是否為空，如空時則更新其“工程開始生產時間”
//2.更新“抽檢間隔”、“速度設定”、“工程結束時間”（對象屬性為空時不更新）、“預計準備需時”、“ 實際準備時間”、“停機時間”、“停機次數”、“總生產數量”、“已耗時間”、“ 生產速度”、“備忘錄”、“總運作時間”、“正常生產時間”、“品檢時間”、“品檢次數”、“總廢品數量”、“總次品數量”、“結束工程時：印件完成狀態”、“級別”
//***公式：
//“ 實際準備時間”＝“ 實際準備時間”(DB裡的)+“班次內工程的實際準備時間”
//“停機時間”＝“停機時間”(DB裡的)+“班次內工程的停機時間”
//“停機次數”＝“停機次數”(DB裡的)+“班次內工程的停機次數”
//“總生產數量”＝“總生產數量”(DB裡的)+“班次內工程的總生產數量”
//“總運作時間”＝“總運作時間”(DB裡的)+“班次內工程的總運作時間”
//“正常生產時間”＝“正常生產時間”(DB裡的)+“班次內工程的正常生產時間”
//“品檢時間”＝“品檢時間”(DB裡的)+“班次內工程的品檢時間”
//“品檢次數”＝“品檢次數”(DB裡的)+“班次內工程的品檢次數”
//“總廢品數量”＝“總廢品數量”(DB裡的)+“班次內工程的總廢品數量”
//“總次品數量”＝“總次品數量”(DB裡的)+“班次內工程的總次品數量”
if (shiftProjectData != null)
{
projectMachineProductionData.ppj_iActualPrepairTime = CheckExistProjectMachineProductionData.ppj_iActualPrepairTime + shiftProjectData.spl_iPrepairTime;
projectMachineProductionData.ppj_iStopTime = CheckExistProjectMachineProductionData.ppj_iStopTime + shiftProjectData.spl_iStopTime;
projectMachineProductionData.ppj_iStopTimes = CheckExistProjectMachineProductionData.ppj_iStopTimes + shiftProjectData.spl_iStopTimes;
projectMachineProductionData.ppj_iCountProdNum = CheckExistProjectMachineProductionData.ppj_iCountProdNum + shiftProjectData.spl_iCalQTY;
projectMachineProductionData.ppj_iActualProdNum = CheckExistProjectMachineProductionData.ppj_iActualProdNum + shiftProjectData.spl_iQTY;
projectMachineProductionData.ppj_iProjRunTime = CheckExistProjectMachineProductionData.ppj_iProjRunTime + shiftProjectData.spl_iRunTime;
projectMachineProductionData.ppj_iProdSumTime = CheckExistProjectMachineProductionData.ppj_iProdSumTime + shiftProjectData.spl_iProdSumTime;
projectMachineProductionData.ppj_iQCSumTime = CheckExistProjectMachineProductionData.ppj_iQCSumTime + shiftProjectData.spl_iQCTime;
projectMachineProductionData.ppj_iCountWastNum = CheckExistProjectMachineProductionData.ppj_iCountWastNum + shiftProjectData.spl_iWastQTY;
projectMachineProductionData.ppj_iCountDefectiveQty = CheckExistProjectMachineProductionData.ppj_iCountDefectiveQty + shiftProjectData.spl_iDefectiveQty;
}
l_lIsSuess = this.m_objProductionDataSynDAL.UpdateProjectMachineProductionData(projectMachineProductionData, transaction);
}
}
//★檢查服務器數據庫是否存在生產工程的班次內工程生產資料（表SPL）
//如果不存在則將生產工程的班次內工程生產資料新增到相應的數據表中
if (shiftProjectData != null && gSPL_ID != Guid.Empty)
{
if (this.m_objProductionDataSynDAL.CheckExistShiftProjectProductionData(gSPL_ID) == false)
{
l_lIsSuess = this.m_objProductionDataSynDAL.AddShiftProjectProductionData(shiftProjectData, transaction);
}
else//如果存在則更新如下
{
//1.判斷“工程開始生產時間”是否為空，如空時則更新其“工程開始生產時間”。
//2.更新“班次內工程結束時間”、“總生產數量”、“實際生產數量”、“實際準備時間”、“停機時間”、“停機次數”、“總運作時間”、“正常生產時間”、“品檢時間”、“品檢次數”、“總廢品數量”、“總次品數量”
l_lIsSuess = this.m_objProductionDataSynDAL.UpdateShiftProjectProductionData(shiftProjectData, transaction);
}
}
//★
//同步以下數據，（先根據條件進行刪除後再進行新增）
{
//**抽起原因
this.m_objProductionDataSynDAL.DeleteProjectExtractionReason_BySWLID(gSWL_ID, transaction);
if (extractionReasonData != null && extractionReasonData.ExtractionReasonIems != null)
{
foreach (ProjectExtractionReasonIem reasonItem in extractionReasonData.ExtractionReasonIems)
{
this.m_objProductionDataSynDAL.AddProjectExtractionReason(reasonItem.RecordID.ToString(), extractionReasonData.psr_SWLID, reasonItem.psr_cStopCode, extractionReasonData.psr_cRemark, reasonItem.AddDate, transaction);
}
}
//**生產工程更多資料
this.m_objProductionDataSynDAL.DeleteProjectAdditionalInformation_ByPPJID(gPPJ_ID, transaction);
if (additionalInformation != null)
{
this.m_objProductionDataSynDAL.AddProjectAdditionalInformation(additionalInformation, transaction);
}
//**準備工作項
this.m_objProductionDataSynDAL.DeleteProjectPrepareJobItem_ByPPJID(gPPJ_ID, transaction);
if (projectPrepareJobItems != null)
{
foreach (ProjectPrepareJobItem projectPrepareJobItem in projectPrepareJobItems)
{
this.m_objProductionDataSynDAL.AddProjectPrepareJobItem(projectPrepareJobItem, transaction);
}
}
//**工程相關物料
this.m_objProductionDataSynDAL.DeleteProjectMaterial_BySPLID(gSPL_ID, transaction);
if (projectMaterials != null)
{
foreach (ProjectMaterial projectMaterial in projectMaterials)
{
this.m_objProductionDataSynDAL.AddProjectMaterial(projectMaterial, transaction);
}
}
//**工程停機記錄
this.m_objProductionDataSynDAL.DeleteProjectMachineHaltRecord_BySPLID(gSPL_ID, transaction);
if (machineHaltRecords != null)
{
foreach (ProjectMachineHaltRecord machineHaltRecord in machineHaltRecords)
{
if (machineHaltRecord != null)
{
this.m_objProductionDataSynDAL.AddProjectMachineHaltRecord(machineHaltRecord, transaction);
}
}
}
//**工程品檢記錄
this.m_objProductionDataSynDAL.DeleteProjectQCRecord_BySPLID(gSPL_ID, transaction);
if (qCRecords != null)
{
foreach (ProjectQCRecord qCRecord in qCRecords)
{
this.m_objProductionDataSynDAL.AddProjectQCRecord(qCRecord, transaction);
}
}
//**班次內工程消數、糾數記錄
this.m_objProductionDataSynDAL.DeleteProjectCorrectRecord_BySPLID(gSPL_ID, transaction);
if (correctRecords != null)
{
foreach (ProjectCorrectRecord correctRecord in correctRecords)
{
this.m_objProductionDataSynDAL.AddProjectCorrectRecord(correctRecord, transaction);
}
}
//**班次內工程準備工作額外項目時間記錄
this.m_objProductionDataSynDAL.DeleteProjectPreJobExtraTime_BySPLID(gSPL_ID, transaction);
if (prepareJobExtraTimes != null)
{
foreach (ProjectPrepareJobExtraTime extraTime in prepareJobExtraTimes)
{
this.m_objProductionDataSynDAL.AddProjectPreJobExtraTime(gSPL_ID, extraTime, transaction);
}
}
}
l_lIsSuess = true;
}
catch (Exception exTran)
{
l_lIsSuess = false;
throw exTran;
}
finally
{
if (l_lIsSuess)
transaction.Commit();
else
transaction.Rollback();
}
return true;
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 班次內工程生產信息實時數據上傳到服務器數據庫中
/// </summary>
/// <param name="shiftProjectProductionData">班次內工程生產信息</param>
/// <returns></returns>
public bool SynShiftProjectProductionDataToDB(ProjectProductionData shiftProjectProductionData)
{
try
{
bool l_lIsSuess = false;
ScheduleProjectData scheduleProjectData = (shiftProjectProductionData != null ? shiftProjectProductionData.ProjectBaseData : null);
ProjectMachineProductionData projectMachineProductionData = (shiftProjectProductionData != null ? shiftProjectProductionData.ProjectMProductionData : null);
ShiftProjectProductionData shiftProjectData = (shiftProjectProductionData != null ? shiftProjectProductionData.ShiftProjectData : null);
Guid gSWL_ID = (shiftProjectProductionData != null ? scheduleProjectData.RecordID : Guid.Empty);
Guid gPPJ_ID = (projectMachineProductionData != null ? projectMachineProductionData.RecordID : Guid.Empty);
Guid gSPL_ID = (shiftProjectData != null ? shiftProjectData.RecordID : Guid.Empty);
using (SqlConnection conn = new SqlConnection(DbHelperSQL.connectionString))
{
SqlTransaction transaction = null;
conn.Open(); //開啟連接
transaction = conn.BeginTransaction(); //開啟事務
try
{
//★檢查服務器數據庫是否存在工程排期資料（SWL）
//如果不存在則將工程排期資料新增到相應的數據表中
if (shiftProjectProductionData != null && gSWL_ID != Guid.Empty)
{
if (this.m_objProductionDataSynDAL.CheckExistScheduleProjListData(gSWL_ID) == false)
{
l_lIsSuess = this.m_objProductionDataSynDAL.AddScheduleProjListData(scheduleProjectData, transaction);
}
//如果存在則更新工程排期資料記錄的“工程狀態”
else
{
l_lIsSuess = this.m_objProductionDataSynDAL.UpdateScheduleProjListData(gSWL_ID, scheduleProjectData.swl_cProjStatus, scheduleProjectData.swl_dStatusChange, transaction);
}
}
//★檢查服務器數據庫是否存在生產工程的機台工程生產資料（表PPJ）
//如果不存在則將生產工程的機台工程生產資料新增到相應的數據表中
if (projectMachineProductionData != null && gPPJ_ID != Guid.Empty)
{
if (this.m_objProductionDataSynDAL.CheckExistProjectMachineProductionData(gPPJ_ID) == false)
{
l_lIsSuess = this.m_objProductionDataSynDAL.AddProjectMachineProductionData(projectMachineProductionData, transaction);
}
//如果存在則判斷“工程開始生產時間”是否為空，如空時則更新其“工程開始生產時間”
else
{
ProjectMachineProductionData data_DB = this.m_objProductionDataSynDAL.GetProjectMachineProductionData("ppj_RecordID='" + projectMachineProductionData.RecordID + "'").FirstOrDefault();
if (data_DB != null && data_DB.ppj_dProdBeginTime == null)
l_lIsSuess = this.m_objProductionDataSynDAL.UpdateProjectMachineProductionData_UpdateProdBeginTime(projectMachineProductionData.RecordID, projectMachineProductionData.ppj_dProdBeginTime, transaction);
}
}
//★檢查服務器數據庫是否存在生產工程的班次內工程生產資料（表SPL）
//如果不存在則將生產工程的班次內工程生產資料新增到相應的數據表中
if (shiftProjectData != null && gSPL_ID != Guid.Empty)
{
if (this.m_objProductionDataSynDAL.CheckExistShiftProjectProductionData(gSPL_ID) == false)
{
l_lIsSuess = this.m_objProductionDataSynDAL.AddShiftProjectProductionData(shiftProjectData, transaction);
}
else//如果存在則更新如下
{
//1.判斷“工程開始生產時間”是否為空，如空時則更新其“工程開始生產時間”。
//2.更新“總生產數量”、“實際生產數量”
l_lIsSuess = this.m_objProductionDataSynDAL.UpdateShiftProjectProductionData2(shiftProjectData, transaction);
}
}
l_lIsSuess = true;
}
catch (Exception exTran)
{
l_lIsSuess = false;
throw exTran;
}
finally
{
if (l_lIsSuess)
transaction.Commit();
else
transaction.Rollback();
}
return true;
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 檢查要“抽起”或“結束”的工程生產數據是否完整，如果不完整則返回一個殘缺數據的類型。
/// </summary>
/// <param name="departmentCode">機台所屬科組編號</param>
/// <param name="operationType">操作類型“抽起”或“結束”</param>
/// <param name="shiftInfo">當前班次信息</param>
/// <param name="projectData">當前工程生產數據</param>
/// <returns>返回一個殘缺的數據類型</returns>
public override CommonDefine.ProjectDataType CheckProjectProductionDataFull(string departmentCode, CustEnum.ProjectStatus operationType, MachineShiftData shiftInfo, ProjectProductionData projectData)
{
try
{
CommonDefine.ProjectDataType l_enumDataFull = CommonDefine.ProjectDataType.DataFull;
//■■■檢查“工程更多資料”是否缺少數據，如果缺少時返回一個“工程更多資料”類型，
//需要根據不同科組來進行不同的檢查，並退出方法
ReturnValueInfo projectAdditionalResult = this.CheckProjectAdditionalDataFull(departmentCode, projectData.ProjectMProductionData.AdditionalInformation);
if (projectAdditionalResult != null)
{
if (!projectAdditionalResult.boolValue)
{
return CommonDefine.ProjectDataType.ProjectAdditionalInformation;
}
}
//■■■檢查“停機記錄”列表中是否存在沒有 選擇停機原因的記錄，如果存在則返回一個“停機記錄”類型，並退出方法
foreach (var item in projectData.ShiftProjectData.MachineHaltRecords)
{
if (item.StopReasons == null || item.StopReasons.Count == 0)
return CommonDefine.ProjectDataType.MachineHaltRecord;
}
//■■■檢查“檢品記錄”列表中是否存在沒有進行品檢的記錄，如果存在則返回一個“檢品記錄”類型，並退出方法
foreach (var item in projectData.ShiftProjectData.QCRecords)
{
if (item.pqc_dQCEndTime.HasValue==false)
return CommonDefine.ProjectDataType.ProjectQC;
}
//■■■檢查“班次人員”列表中 是否已選擇了班次人員，如果 沒有選擇則返回一個“班次人員”類型，並退出方法
bool isSelectedStaff= false;
if (shiftInfo.StaffInfos != null && shiftInfo.StaffInfos.Count > 0)
{
isSelectedStaff = true;
}
if (shiftInfo.sifo_DutyCaptainID != null && shiftInfo.sifo_DutyCaptainID!=Guid.Empty)
{
isSelectedStaff = true;
}
if (!isSelectedStaff)
{
return CommonDefine.ProjectDataType.ShiftStaff;
}
//■■■數據都完整，返回一個完整的類型
return l_enumDataFull;
}
catch (Exception ex) { throw ex; }
}
/// <summary>
/// 設置工程信息
/// </summary>
/// <param name="projectData"></param>
/// <param name="prodcutionData"></param>
/// <returns></returns>
MachineRealtimeSummary SetProductionDataByProject(ProjectProductionData projectData, MachineRealtimeSummary prodcutionData)
{
if (projectData == null)
{
return null;
}
prodcutionData.PPJID = projectData.ProjectMachineProductionID;
prodcutionData.ProjectNo = projectData.ProjectBaseData.swl_cProjectNO;
prodcutionData.SONo = projectData.ProjectBaseData.swl_cSONO;
prodcutionData.ItemNo = projectData.ProjectBaseData.swl_cItemNO;
prodcutionData.ItemName = projectData.ProjectBaseData.swl_cItemName;
prodcutionData.Edition = projectData.ProjectBaseData.swl_cEdition;
prodcutionData.PlanProdQty = projectData.ProjectBaseData.swl_iPlanProdQty;
prodcutionData.ProjBeginTime = projectData.ProjectMProductionData.ppj_dProjBeginTime;
prodcutionData.ProdBeginTime = projectData.ProjectMProductionData.ppj_dProdBeginTime;
prodcutionData.ProdActualQty = projectData.ProjectMProductionData.ppj_iActualProdNum + projectData.ShiftProjectData.ActualProdQty;
prodcutionData.PrepareBeginTime = projectData.ProjectMProductionData.ppj_dProjBeginTime;
prodcutionData.PrepareEndTime = projectData.ProjectMProductionData.ppj_dProdBeginTime;
string prepareItems = string.Empty;
if (projectData.PrepareJobItems != null && projectData.PrepareJobItems.Count > 0)
{
for (int i = 0; i < projectData.PrepareJobItems.Count; i++)
{
ProjectPrepareJobItem prepareItem=projectData.PrepareJobItems[i];
if (prepareItem != null)
{
if (prepareItems.Trim().Length > 0)
{
prepareItems += ",";
}
prepareItems += prepareItem.ItemName.Trim();
}
}
}
prodcutionData.PrepareItemsDesc = prepareItems;
prodcutionData.PrepareCountdown = projectData.ShiftProjectData.PrepareCountdown;
//停機次數
int machineHaltTimes = projectData.ProjectMProductionData.ppj_iStopTimes;
if (projectData.ShiftProjectData.MachineHaltRecords != null)
{
machineHaltTimes += projectData.ShiftProjectData.MachineHaltRecords.Count;
}
prodcutionData.MachineHaltTimes = machineHaltTimes;
//停機時間
int machineHaltTime = projectData.ProjectMProductionData.ppj_iStopTime;
machineHaltTime += this.CountProjectStopTime(projectData.ShiftProjectData.MachineHaltRecords);
prodcutionData.MachineHaltDuration = machineHaltTime;
return prodcutionData;
}
/// <summary>
/// 計算欄位(***ShiftFinishProjectProductionCheck與ProjectFinishProductionDataCheck都共用***)
/// </summary>
/// <param name="projectData"></param>
private void CalculateField(ProjectProductionData projectData)
{
/*■■■
* 計算欄位:
* 如下為“班次內工程生產數據資料”對象的欄位
a.“當班實際生產數量” ＝“當班累計生產數量”+“糾數”
b.“廢品數量”＝加總“工程品檢記錄列表”中的廢品數量
c.“次品數量”＝加總“工程品檢記錄列表”中的次品數量
d.“品檢次數”＝“工程品檢記錄列表”記錄數量
e.“合格產品數量”＝a-b-c
f.“當班停機時間”＝加總“ 工程停機記錄列表”中的“實際停機時間”
g.“當班停機次數”＝ “工程停機記錄列表”的記錄數量
h.“總運作時間”＝“工程結束時間”－“工程開始時間”
i. “正常生產時間”＝h-“準備時間”-f-“用餐時間”
j.“品檢合計時間”＝加總“工程品檢記錄列表”中的品檢時間
*
*
* 如下為“工程機台生產數據”對象的欄位
k.“停機時間”＝“停機時間”+f
l.“停機次數”＝“停機次數”+g
m.“計算生產數量”＝“計算生產數量”+“當班累計生產數量”
n.“實際生產數量”＝“實際生產數量”+a
o.“合格生產數量”＝“合格生產數量”+e
p.“生產總運作時間”＝“生產總運作時間”+h
q.“正常生產合計時間”＝“ 正常生產合計時間”+i
r.“品檢合計時間”＝“品檢合計時間”+j
s.“總廢品數量”＝“總廢品數量”+b
t.“總次品數量”＝“ 總次品數量”+c
u. “實際準備時間”＝“實際準備時間”+“班次內工程生產數據資料”中的“準備時間”
*/
int l_iCorrectQty = 0;
l_iCorrectQty = projectData.ShiftProjectData.CorrectRecords.Where(p => p.ctr_cType == CustEnum.KEY2.CORRECTQTY.ToString()).Sum(item => ((item.ctr_iAdjustProdQTY - item.ctr_iProdQTY)));
projectData.ShiftProjectData.spl_iQTY = projectData.ShiftProjectData.spl_iCalQTY + l_iCorrectQty;
int l_iWastQTY = 0, l_iDefectiveQty = 0, l_iQCTime = 0;
int l_iStopTime = 0;
foreach (var item in projectData.ShiftProjectData.QCRecords)
{
if (item.pqc_dQCEndTime.HasValue && item.pqc_dQCBeginTime.HasValue)
l_iQCTime += (int)(item.pqc_dQCEndTime.Value - item.pqc_dQCBeginTime.Value).TotalSeconds;
if (item.QCProblems != null)
{
foreach (ProjectQCRecordProblem problemInfo in item.QCProblems)
{
l_iWastQTY += problemInfo.pqcp_iWasteQty;
l_iDefectiveQty += problemInfo.pqcp_iDefectiveQty;
}
}
}
projectData.ShiftProjectData.spl_iWastQTY = l_iWastQTY;
projectData.ShiftProjectData.spl_iDefectiveQty = l_iDefectiveQty;
projectData.ShiftProjectData.spl_iQCTimes = projectData.ShiftProjectData.QCRecords.Count(p=>p.pqc_dQCEndTime.HasValue);
projectData.ShiftProjectData.QualifiedQty = projectData.ShiftProjectData.spl_iQTY - projectData.ShiftProjectData.spl_iWastQTY
- projectData.ShiftProjectData.spl_iDefectiveQty;
int machineHaltDinnerTime = 0;
foreach (var item in projectData.ShiftProjectData.MachineHaltRecords)
{
l_iStopTime += item.psrd_iActualStopTime;
machineHaltDinnerTime += item.psrd_iDinnerTime;//計算停機記錄中的所有用餐時間
}
projectData.ShiftProjectData.spl_iStopTime = l_iStopTime;
projectData.ShiftProjectData.spl_iStopTimes = projectData.ShiftProjectData.MachineHaltRecords.Count();
if (projectData.ShiftProjectData.spl_dEndTime.HasValue && projectData.ShiftProjectData.spl_dBeginTime.HasValue)
projectData.ShiftProjectData.spl_iRunTime = (int)(projectData.ShiftProjectData.spl_dEndTime.Value - projectData.ShiftProjectData.spl_dBeginTime.Value).TotalSeconds;
projectData.ShiftProjectData.spl_iProdSumTime = projectData.ShiftProjectData.spl_iRunTime - projectData.ShiftProjectData.spl_iPrepairTime
- projectData.ShiftProjectData.spl_iStopTime - projectData.ShiftProjectData.spl_iDinnerTime
+ projectData.ShiftProjectData.spl_iPrepairDinnerTime //準備時間中已經包涵了準備時間中的用餐時間，所以需要加上準備時間中的用餐時間
+ machineHaltDinnerTime;//有的停機時間中已經包涵了停機中的用餐時間，所以需要加上停機中的用餐時間
projectData.ShiftProjectData.spl_iQCTime = l_iQCTime;
projectData.ProjectMProductionData.ppj_iStopTime += projectData.ShiftProjectData.spl_iStopTime;
projectData.ProjectMProductionData.ppj_iStopTimes += projectData.ShiftProjectData.spl_iStopTimes;
projectData.ProjectMProductionData.ppj_iCountProdNum += projectData.ShiftProjectData.spl_iCalQTY;
projectData.ProjectMProductionData.ppj_iActualProdNum += projectData.ShiftProjectData.spl_iQTY;
projectData.ProjectMProductionData.ppj_iQualifiedQty += projectData.ShiftProjectData.QualifiedQty;
projectData.ProjectMProductionData.ppj_iProjRunTime += projectData.ShiftProjectData.spl_iRunTime;
projectData.ProjectMProductionData.ppj_iProdSumTime += projectData.ShiftProjectData.spl_iProdSumTime;
projectData.ProjectMProductionData.ppj_iQCSumTime += projectData.ShiftProjectData.spl_iQCTime;
projectData.ProjectMProductionData.ppj_iCountWastNum += projectData.ShiftProjectData.spl_iWastQTY;
projectData.ProjectMProductionData.ppj_iCountDefectiveQty += projectData.ShiftProjectData.spl_iDefectiveQty;
projectData.ProjectMProductionData.ppj_iActualPrepairTime += projectData.ShiftProjectData.spl_iPrepairTime;
projectData.ProjectBaseData.swl_iCompletedQty += projectData.ShiftProjectData.spl_iQTY;
}
/// <summary>
/// 設置班次內工程用餐時間信息
///■■■設置用餐記錄列表中記錄的“工程ID”、“生產工程ID”、“班次內工程ID”，■■■
///首先找出在班次內工程的“工程結束時間”和“工程開始時間”範圍內的所有用餐記錄，
///再判斷這些記錄是否存在“工程ID”，如果不存在時才進行設置
/// </summary>
/// <param name="dinnerRecords"></param>
/// <param name="projectData"></param>
int SetShiftProjcetDinnerInfo(List<DinnerRecord> dinnerRecords, ProjectProductionData projectData)
{
int l_iShiftProjectData_DinnerTime = 0;
if (dinnerRecords != null && projectData.ShiftProjectData != null)
{
List<DinnerRecord> lstFindDinnerRecord = dinnerRecords.Where
(p => p.dnr_dBeginTime >= projectData.ShiftProjectData.spl_dBeginTime &&
p.dnr_dEndTime <= projectData.ShiftProjectData.spl_dEndTime).ToList();
if (lstFindDinnerRecord != null)
{
foreach (DinnerRecord item in lstFindDinnerRecord)
{
if (item.dsm_swlID == Guid.Empty)
{
item.dsm_swlID = projectData.ScheduleProjectID;
item.dsm_ppjID = projectData.ProjectMachineProductionID;
item.dsm_splID = projectData.ShiftProjectID;
item.LastDate = DateTime.Now;
}
if (item.dnr_dEndTime.HasValue && item.dnr_dBeginTime.HasValue)
l_iShiftProjectData_DinnerTime += (int)(item.dnr_dEndTime.Value - item.dnr_dBeginTime.Value).TotalSeconds;
}
}
}
//■■■計算“班次內工程生產數據資料”中的“用餐時間”（秒）■■■
projectData.ShiftProjectData.spl_iDinnerTime = l_iShiftProjectData_DinnerTime;
return l_iShiftProjectData_DinnerTime;
}
/// <summary>
/// 班次結束時班次內工程生產數據校驗
/// </summary>
/// <param name="shiftInfo">舊班次信息</param>
/// <param name="projectData">舊班次內工程生產數據</param>
public override void ShiftFinishProjectProductionCheck(MachineShiftData shiftInfo, ProjectProductionData projectData)
{
try
{
int l_iShiftProjectData_DinnerTime = 0; //班次內工程的用餐時間
//■■■設置“班次內工程生產數據資料”對象中的“工程結束時間”屬性為所在班次的班次結束時間■■■
projectData.ShiftProjectData.spl_dEndTime = shiftInfo.sifo_dEndTime;
//■■■設置用餐記錄列表中記錄的“工程ID”、“生產工程ID”、“班次內工程ID”，■■■
//首先找出在班次內工程的“工程結束時間”和“工程開始時間”範圍內的所有用餐記錄，
//再判斷這些記錄是否存在“工程ID”，如果不存在時才進行設置
l_iShiftProjectData_DinnerTime=this.SetShiftProjcetDinnerInfo(shiftInfo.DinnerRecords, projectData);
//■■■當工程狀態為“準備中”、“準備即將超時”、“準備超時”時■■■
if (projectData.ProjectBaseData.swl_cProjStatus.ToUpper() == CustEnum.ProjectStatus.PREPARE.ToString().ToUpper()
|| projectData.ProjectBaseData.swl_cProjStatus.ToUpper() == CustEnum.ProjectStatus.PREPARE_WOT.ToString().ToUpper()
|| projectData.ProjectBaseData.swl_cProjStatus.ToUpper() == CustEnum.ProjectStatus.PREPARE_OT.ToString().ToUpper()
)
{
/*
計算欄位：
a.“班次內工程生產數據資料”中的“準備時間”
b.“班次內工程生產數據資料”中的 “準備中的用餐時間”
c. “工程機台生產數據”中的“實際準備時間”
d. “班次內工程生產數據資料”中的 “總運作時間”
e. “工程機台生產數據”中的“生產總運作時間”
計算公式：
a＝所在班次的班次結束時間－班次內工程開始時間
b＝班次內已累計的用餐時間（通過“班次內工程開始時間”和“班次內工程結束時間”，從用餐記錄列表中尋找出所有屬於這個時段之內的用餐記錄來計算出用餐時間）
c＝c +a
d＝“工程結束時間”－“工程開始時間”
e＝e+d
*/
if (shiftInfo.sifo_dEndTime.HasValue && projectData.ShiftProjectData.spl_dBeginTime.HasValue)
projectData.ShiftProjectData.spl_iPrepairTime = (int)(shiftInfo.sifo_dEndTime.Value - projectData.ShiftProjectData.spl_dBeginTime.Value).TotalSeconds;
projectData.ShiftProjectData.spl_iPrepairDinnerTime = l_iShiftProjectData_DinnerTime;
projectData.ProjectMProductionData.ppj_iActualPrepairTime += projectData.ShiftProjectData.spl_iPrepairTime;
if (projectData.ShiftProjectData.spl_dEndTime.HasValue && projectData.ShiftProjectData.spl_dBeginTime.HasValue)
projectData.ShiftProjectData.spl_iRunTime = (int)(projectData.ShiftProjectData.spl_dEndTime.Value - projectData.ShiftProjectData.spl_dBeginTime.Value).TotalSeconds;
projectData.ProjectMProductionData.ppj_iProjRunTime += projectData.ShiftProjectData.spl_iRunTime;
}
//■■■當工程狀態為不是“準備中”、“準備即將超時”、“準備超時” 時■■■
else if (projectData.ProjectBaseData.swl_cProjStatus.ToUpper() != CustEnum.ProjectStatus.PREPARE.ToString().ToUpper()
&& projectData.ProjectBaseData.swl_cProjStatus.ToUpper() != CustEnum.ProjectStatus.PREPARE_WOT.ToString().ToUpper()
&& projectData.ProjectBaseData.swl_cProjStatus.ToUpper() != CustEnum.ProjectStatus.PREPARE_OT.ToString().ToUpper()
)
{
/*
檢查“班次內工程生產數據資料”中的“工程停機記錄列表”是否存在沒有停機結束時間的記錄，
如果存在：
a.將“工程停機記錄”中的“停機結束時間”設置為所在班次的班次結束時間
b.計算出“工程停機記錄”中的“實際停機時間”（停機結束時間－停機開始時間）
c. 計算出“工程停機記錄”中的“用餐時間”，通過此記錄的“停機開始時間”及“停機結束時間”，
* 從用餐記錄列表中尋找出所有在此時間範圍內的用餐記錄計算出總的用餐時間，
* 並設置用餐記錄中的“停機記錄ID”屬性
*/
ProjectMachineHaltRecord objNotEndTimeHaltRecord = projectData.ShiftProjectData.MachineHaltRecords.FirstOrDefault(p => p.psrd_dEndTime.HasValue == false);
if (objNotEndTimeHaltRecord != null)
{
objNotEndTimeHaltRecord.psrd_dEndTime = shiftInfo.sifo_dEndTime;
}
//設置停機記錄用餐信息
this.SetMachineHaltRecordDinnerInfo(shiftInfo.DinnerRecords, projectData.ShiftProjectData.MachineHaltRecords);
this.SetShiftProjcetQCTimeInfo(projectData.ShiftProjectData.QCRecords,shiftInfo.sifo_dEndTime.Value);
}
//■■■計算欄位
this.CalculateField(projectData);
}
catch (Exception ex) { throw ex; }
}
/// <summary>
/// 工程跨班時設置新的班次內生產數據
/// </summary>
/// <param name="shiftInfo">新的班次信息</param>
/// <param name="projectData">上班次生產工程數據</param>
public override void SetNewShiftProjectProductionData(MachineShiftData newShiftInfo, ProjectProductionData projectData)
{
try
{
Guid l_gPPJ_ID = projectData.ProjectMachineProductionID; //工程機台生產ID
Guid l_gSPL_ID = Guid.NewGuid(); //班次內工程生產ID
Guid l_gSIFO_ID = newShiftInfo.RecordID; //班次ID
string l_cMachineNo = newShiftInfo.sifo_cMachineNO;
//■■■重新創建 “工程生產數據資料”對象中的“班次內工程生產ID”■■■
projectData.ShiftProjectID = l_gSPL_ID;
//■■■“班次內工程生產數據” 對象■■■
projectData.ShiftProjectData = new ShiftProjectProductionData();
projectData.ShiftProjectData.RecordID = l_gSPL_ID;
projectData.ShiftProjectData.spl_PPJID = l_gPPJ_ID;
projectData.ShiftProjectData.spl_SIFOID = l_gSIFO_ID;
projectData.ShiftProjectData.spl_dBeginTime = newShiftInfo.sifo_dBeginTime;
//班次內工程準備工作”對象地址
projectData.ShiftProjectData.PrepareJob = new ProjectPrepareJob();
//“工程相關物料列表” 對象地址
projectData.ShiftProjectData.ProjectMaterials = new List<ProjectMaterial>();
//工程停機記錄列表” 對象地址
projectData.ShiftProjectData.MachineHaltRecords = new List<ProjectMachineHaltRecord>();
//“工程品檢記錄列表” 對象地址
projectData.ShiftProjectData.QCRecords = new List<ProjectQCRecord>();
//“班次內工程消數、糾數記錄列表” 對象地址
projectData.ShiftProjectData.CorrectRecords = new List<ProjectCorrectRecord>();
//■■■當工程狀態為不是“準備中”、“準備即將超時”、“準備超時” 時，設置“生產開始時間”為所在班次的班次開始時間
if (projectData.ProjectBaseData.swl_cProjStatus.ToUpper() != CustEnum.ProjectStatus.PREPARE.ToString().ToUpper()
&& projectData.ProjectBaseData.swl_cProjStatus.ToUpper() != CustEnum.ProjectStatus.PREPARE_WOT.ToString().ToUpper()
&& projectData.ProjectBaseData.swl_cProjStatus.ToUpper() != CustEnum.ProjectStatus.PREPARE_OT.ToString().ToUpper()
)
{
projectData.ShiftProjectData.spl_dProdBegin = newShiftInfo.sifo_dBeginTime;
}
//■■■當工程狀態為“準備中”、“準備即將超時”、“準備超時” 時，設置“班次內工程準備工作”對象的屬性“工程機台生產數據 ID”、“班次內工程ID”、“開始時間”
else if (projectData.ProjectBaseData.swl_cProjStatus.ToUpper() == CustEnum.ProjectStatus.PREPARE.ToString().ToUpper()
|| projectData.ProjectBaseData.swl_cProjStatus.ToUpper() == CustEnum.ProjectStatus.PREPARE_WOT.ToString().ToUpper()
|| projectData.ProjectBaseData.swl_cProjStatus.ToUpper() == CustEnum.ProjectStatus.PREPARE_OT.ToString().ToUpper()
)
{
projectData.ShiftProjectData.PrepareJob.PPJID = l_gPPJ_ID;
projectData.ShiftProjectData.PrepareJob.SPLID = l_gSPL_ID;
projectData.ShiftProjectData.PrepareJob.BeginDatetime = DateTime.Now;
}
}
catch (Exception ex) { throw ex; }
}
/// <summary>
/// 工程“抽起”或“結束”生產數據校驗
/// </summary>
/// <param name="shiftInfo">當前班次信息</param>
/// <param name="projectData">當前工程生產數據</param>
/// <param name="projectStatus">工程狀態</param>
public override void ProjectFinishProductionDataCheck(MachineShiftData shiftInfo, ProjectProductionData projectData, string projectStatus)
{
try
{
//■■■設置“生產工程的基本資料（待生產工程資料）”中的“工程狀態”屬性。
projectData.ProjectBaseData.swl_cProjStatus = projectStatus;
projectData.ProjectBaseData.swl_dStatusChange = DateTime.Now;
/*■■■檢查“班次內工程生產數據資料”中的“工程停機記錄列表”是否存在沒有停機結束時間的記錄，如果存在：
a.將“工程停機記錄”中的“停機結束時間”設置為系統當前時間
b.計算出“工程停機記錄”中的“實際停機時間”（停機結束時間－停機開始時間）
c.計算出“工程停機記錄”中的“用餐時間”，通過此記錄的“停機開始時間”及“停機結束時間”，
從用餐記錄列表中尋找出所有在此時間範圍內的用餐記錄計算出總的用餐時間，並設置用餐記錄中的“停機記錄ID”
*/
ProjectMachineHaltRecord objNotEndTimeHaltRecord = projectData.ShiftProjectData.MachineHaltRecords.FirstOrDefault(p => p.psrd_dEndTime.HasValue == false);
if (objNotEndTimeHaltRecord != null)
{
objNotEndTimeHaltRecord.psrd_dEndTime = DateTime.Now;
}
//設置停機記錄用餐信息
this.SetMachineHaltRecordDinnerInfo(shiftInfo.DinnerRecords, projectData.ShiftProjectData.MachineHaltRecords);
//■■■設置“班次內工程生產數據資料”對象中的“工程結束時間”屬性為系統當前時間
projectData.ShiftProjectData.spl_dEndTime = DateTime.Now;
//■■■設置用餐記錄列表中記錄的“工程ID”、“生產工程ID”、“班次內工程ID”，
//首先找出在班次內工程的“工程結束時間”和“工程開始時間”範圍內的所有用餐記錄，
//再判斷這些記錄是否存在“工程ID”，如果不存在時才進行設置
this.SetShiftProjcetDinnerInfo(shiftInfo.DinnerRecords, projectData);
//■■■設置“工程機台生產數據”中的“結束生產時間”屬性為系統當前時間
projectData.ProjectMProductionData.ppj_dProdEndTime = DateTime.Now;
//■■■計算欄位
this.CalculateField(projectData);
}
catch (Exception ex) { throw ex; }
}
/// <summary>
/// 新工程開始時獲取新的班次內生產數據
/// </summary>
/// <param name="newShiftInfo">新的班次信息</param>
/// <param name="scheduleProject">排期工程</param>
/// <param name="projectBaseData">機台生產工程下的基本資料</param>
/// <param name="spareStatusID">空閒狀態記錄ID</param>
public override ProjectProductionData GetShiftProjectProductionData(MachineShiftData newShiftInfo, ScheduleProjectData scheduleProject, ProjectBaseData projectBaseData, Guid spareStatusID)
{
try
{
Guid l_gSWL_ID = scheduleProject.RecordID; //排期工程ID(待印刷工程ID)
Guid l_gPPJ_ID = Guid.NewGuid(); //工程機台生產ID
Guid l_gSPL_ID = Guid.NewGuid(); //班次內工程生產ID
Guid l_gSIFO_ID = newShiftInfo.RecordID; //班次ID
string l_cMachineNo = newShiftInfo.sifo_cMachineNO;
scheduleProject.swl_cMachineNO = l_cMachineNo;
//■■■創建新的“工程生產數據資料”對象■■■
ProjectProductionData objProjectProductionData = new ProjectProductionData();
objProjectProductionData.MachineNo = l_cMachineNo;
objProjectProductionData.ScheduleProjectID = l_gSWL_ID;
objProjectProductionData.ProjectMachineProductionID = l_gPPJ_ID;
objProjectProductionData.ShiftProjectID = l_gSPL_ID;
objProjectProductionData.ProjectBaseData = scheduleProject;
//===============================================================================//
//■■■“抽起原因”對象地址■■■
objProjectProductionData.ExtractionReason = new ProjectExtractionReason();
objProjectProductionData.ExtractionReason.RecordID = Guid.NewGuid();
objProjectProductionData.ExtractionReason.psr_SWLID = l_gSWL_ID;
objProjectProductionData.ExtractionReason.ExtractionReasonIems = new List<ProjectExtractionReasonIem>();
//===============================================================================//
//■■■“準備工作項列表” 對象地址■■■
objProjectProductionData.PrepareJobItems = new List<ProjectPrepareJobItem>();
//===============================================================================//
//■■■“工程機台生產數據”對象■■■
objProjectProductionData.ProjectMProductionData = new ProjectMachineProductionData();
objProjectProductionData.ProjectMProductionData.RecordID = l_gPPJ_ID;
objProjectProductionData.ProjectMProductionData.ppj_SWLID = l_gSWL_ID;
objProjectProductionData.ProjectMProductionData.ppj_cMachineNo = l_cMachineNo;
objProjectProductionData.ProjectMProductionData.ppj_dProjBeginTime = DateTime.Now;
objProjectProductionData.ProjectMProductionData.ppj_iQCInterval = projectBaseData.ProjectQCInervalTime;
objProjectProductionData.ProjectMProductionData.ppj_iSpeed = projectBaseData.TargetSpeed;
objProjectProductionData.ProjectMProductionData.ppj_iPertimeProdNum = 1;
//“生產工程更多資料”對象
objProjectProductionData.ProjectMProductionData.AdditionalInformation = new ProjectAdditionalInformation();
objProjectProductionData.ProjectMProductionData.AdditionalInformation.RecordID = Guid.NewGuid();
objProjectProductionData.ProjectMProductionData.AdditionalInformation.pai_PPJRecordID = l_gPPJ_ID;
//===============================================================================//
//■■■“班次內工程生產數據” 對象■■■
objProjectProductionData.ShiftProjectData = new ShiftProjectProductionData();
objProjectProductionData.ShiftProjectData.RecordID = l_gSPL_ID;
objProjectProductionData.ShiftProjectData.spl_PPJID = l_gPPJ_ID;
objProjectProductionData.ShiftProjectData.spl_SIFOID = l_gSIFO_ID;
objProjectProductionData.ShiftProjectData.spl_dBeginTime = DateTime.Now;
objProjectProductionData.ShiftProjectData.spl_SpareStatusID = spareStatusID;
//班次內工程準備工作”對象地址
objProjectProductionData.ShiftProjectData.PrepareJob = new ProjectPrepareJob();
objProjectProductionData.ShiftProjectData.PrepareJob.PPJID = l_gPPJ_ID;
objProjectProductionData.ShiftProjectData.PrepareJob.SPLID = l_gSPL_ID;
objProjectProductionData.ShiftProjectData.PrepareJob.BeginDatetime = DateTime.Now;
//“工程相關物料列表” 對象地址
objProjectProductionData.ShiftProjectData.ProjectMaterials = new List<ProjectMaterial>();
//工程停機記錄列表” 對象地址
objProjectProductionData.ShiftProjectData.MachineHaltRecords = new List<ProjectMachineHaltRecord>();
//“工程品檢記錄列表” 對象地址
objProjectProductionData.ShiftProjectData.QCRecords = new List<ProjectQCRecord>();
//“班次內工程消數、糾數記錄列表” 對象地址
objProjectProductionData.ShiftProjectData.CorrectRecords = new List<ProjectCorrectRecord>();
//===============================================================================//
return objProjectProductionData;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 創建序列化文件并返回其反序列化實體
/// </summary>
/// <param name="macShiftData">工程生產數據</param>
/// <param name="strFilePath">序列化的路徑</param>
private ProjectProductionData CreateAndGetEntity_ProjectProductionData(ProjectProductionData projProdData, string strFilePath)
{
if (projProdData == null)
{
return null;
}
if (string.IsNullOrEmpty(strFilePath))
{
return null;
}
ProjectProductionData reObj = null;
string strErrMsg = string.Empty;
for (int i = 0; i < mc_iMaxReTryDeserialization; i++)
{
try
{
using (FileStream stream = new FileStream(strFilePath, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
XmlSerializer serializer = new XmlSerializer(typeof(ProjectProductionData));
serializer.Serialize(stream, projProdData);
stream.Seek(0, SeekOrigin.Begin);//保持文件流讀取的順序從文件頭開始讀取
reObj = serializer.Deserialize(stream) as ProjectProductionData;
if (reObj != null)
{
break;
}
}
}
catch (Exception ex)
{
if (i < mc_iMaxReTryDeserialization - 1)
{
//判斷是否已到重試的最後一次，若是則保留反序列化失敗的文件，否則刪除
try
{
if (File.Exists(strFilePath))
{
File.Delete(strFilePath);
}
}
catch (Exception exDel)
{
strErrMsg += exDel.Message + Environment.NewLine;
}
}
strErrMsg += ex.Message + Environment.NewLine;
reObj = null;
continue;
}
}
if (!string.IsNullOrEmpty(strErrMsg))
{
base.OnException(mc_strControllerName, "CreateAndGetEntity_ProjectProductionData", strErrMsg);
}
return reObj;
}
