public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpBeneficiariesList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpBeneficiaries obj in uploadEmpBeneficiariesList)
{
EEmpBeneficiaries EmpBeneficiaries = new EEmpBeneficiaries();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
EmpBeneficiaries.EmpBeneficiariesID = obj.EmpBeneficiariesID;
uploadDB.select(dbConn, EmpBeneficiaries);
}
obj.ExportToObject(EmpBeneficiaries);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
EmpBeneficiaries.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, EmpBeneficiaries);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, EmpBeneficiaries);
}
tempDB.delete(dbConn, obj);
}
}
public virtual void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpPayList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpRecurringPayment obj in uploadEmpPayList)
{
EEmpRecurringPayment empRP = new EEmpRecurringPayment();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
empRP.EmpRPID = obj.EmpRPID;
uploadDB.select(dbConn, empRP);
}
obj.ExportToObject(empRP);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
empRP.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
AND andTerms = new AND();
andTerms.add(new Match("EmpRPEffFr", "<=", empRP.EmpRPEffFr));
andTerms.add(new Match("PayCodeID", empRP.PayCodeID));
EEmpRecurringPayment lastObj = (EEmpRecurringPayment)AppUtils.GetLastObj(dbConn, EEmpRecurringPayment.db, "EmpRPEffFr", empRP.EmpID, andTerms);
if (lastObj != null)
{
if (lastObj.EmpRPEffTo.Ticks == 0)
{
lastObj.EmpRPEffTo = empRP.EmpRPEffFr.AddDays(-1);
uploadDB.update(dbConn, lastObj);
}
}
if (obj.UploadEmpAccID > 0)
{
empRP.EmpAccID = ParseTemp.GetEmpBankAccIDFromUploadEmpBankAccID(dbConn, obj.UploadEmpAccID);
}
uploadDB.insert(dbConn, empRP);
//DBFilter emplastPosFilter = new DBFilter();
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, empRP);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmppQualificationList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpQualification obj in uploadEmppQualificationList)
{
EEmpQualification empQualification = new EEmpQualification();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
empQualification.EmpQualificationID = obj.EmpQualificationID;
uploadDB.select(dbConn, empQualification);
}
obj.ExportToObject(empQualification);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
//AND andTerms = new AND();
//andTerms.add(new Match("EmpQualificationFrom", "<=", empQualification.EmpQualificationFrom));
//andTerms.add(new Match("QualificationID", empQualification.QualificationID));
//EEmpQualification lastObj = (EEmpQualification)AppUtils.GetLastObj(dbConn, EEmpQualification.db, "EmpQualificationFrom", empQualification.EmpID, andTerms);
//if (lastObj != null)
// if (lastObj.EmpQualificationTo.Ticks == 0)
// {
// lastObj.EmpQualificationTo = empQualification.EmpQualificationFrom.AddDays(-1);
// uploadDB.update(dbConn, lastObj);
// }
empQualification.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, empQualification);
//DBFilter emplastPosFilter = new DBFilter();
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, empQualification);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpBankAccList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpBankAccount obj in uploadEmpBankAccList)
{
EEmpBankAccount empBankAcc = new EEmpBankAccount();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
empBankAcc.EmpBankAccountID = obj.EmpBankAccountID;
uploadDB.select(dbConn, empBankAcc);
}
obj.ExportToObject(empBankAcc);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
empBankAcc.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, empBankAcc);
obj.EmpBankAccountID = empBankAcc.EmpBankAccountID;
tempDB.update(dbConn, obj);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, empBankAcc);
}
if (empBankAcc.EmpAccDefault)
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpBankAccountID", "<>", empBankAcc.EmpBankAccountID));
filter.add(new Match("EmpID", empBankAcc.EmpID));
filter.add(new Match("EmpAccDefault", "<>", false));
EEmpBankAccount t = new EEmpBankAccount();
t.EmpAccDefault = false;
uploadDB.updateByTemplate(dbConn, t, filter);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpTerminationList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpTermination obj in uploadEmpTerminationList)
{
EEmpTermination empTermination = new EEmpTermination();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
empTermination.EmpTermID = obj.EmpTermID;
uploadDB.select(dbConn, empTermination);
}
obj.ExportToObject(empTermination);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
empTermination.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, empTermination);
// Upload Employee Status to Terminated
EEmpPersonalInfo empInfo = new EEmpPersonalInfo();
empInfo.EmpID = empTermination.EmpID;
empInfo.EmpStatus = "T";
EEmpPersonalInfo.db.update(dbConn, empInfo);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, empTermination);
// Upload Employee Status to Terminated
EEmpPersonalInfo empInfo = new EEmpPersonalInfo();
empInfo.EmpID = empTermination.EmpID;
empInfo.EmpStatus = "T";
EEmpPersonalInfo.db.update(dbConn, empInfo);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpPoRList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpPlaceOfResidence obj in uploadEmpPoRList)
{
EEmpPlaceOfResidence empPoR = new EEmpPlaceOfResidence();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
empPoR.EmpPoRID = obj.EmpPoRID;
uploadDB.select(dbConn, empPoR);
}
obj.ExportToObject(empPoR);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
DBFilter emplastPosFilter = new DBFilter();
EEmpPlaceOfResidence lastObj = (EEmpPlaceOfResidence)AppUtils.GetLastObj(dbConn, uploadDB, "EmpPoRFrom", empPoR.EmpID, new Match("EmpPoRFrom", "<", empPoR.EmpPoRFrom));
if (lastObj != null)
{
if (lastObj.EmpPoRTo.Ticks == 0)
{
lastObj.EmpPoRTo = empPoR.EmpPoRFrom.AddDays(-1);
uploadDB.update(dbConn, lastObj);
}
}
empPoR.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, empPoR);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, empPoR);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadLeaveAppList = tempDB.select(dbConn, sessionFilter);
//Dictionary<int, DateTime> recalLeaveBalanceDateList = new Dictionary<int, DateTime>();
foreach (EUploadLeaveApplication obj in uploadLeaveAppList)
{
ELeaveApplication leaveApplication = new ELeaveApplication();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
leaveApplication.LeaveAppID = obj.LeaveAppID;
uploadDB.select(dbConn, leaveApplication);
}
obj.ExportToObject(leaveApplication);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
leaveApplication.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, leaveApplication);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, leaveApplication);
}
tempDB.delete(dbConn, obj);
}
//foreach (int EmpID in recalLeaveBalanceDateList.Keys)
//{
// HROne.LeaveCalc.LeaveBalanceCalc leaaveBalCal = new HROne.LeaveCalc.LeaveBalanceCalc(dbConn, EmpID);
// leaaveBalCal.RecalculateAfter(recalLeaveBalanceDateList[EmpID]);
//}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpRosterTableGroupList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpRosterTableGroup obj in uploadEmpRosterTableGroupList)
{
EEmpRosterTableGroup EmpRosterTableGroup = new EEmpRosterTableGroup();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
EmpRosterTableGroup.EmpRosterTableGroupID = obj.EmpRosterTableGroupID;
uploadDB.select(dbConn, EmpRosterTableGroup);
}
obj.ExportToObject(EmpRosterTableGroup);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
EmpRosterTableGroup.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
//DBFilter emplastPosFilter = new DBFilter();
//EEmpRosterTableGroup lastObj = (EEmpRosterTableGroup)AppUtils.GetLastObj(dbConn, uploadDB, "EmpRosterTableGroupEffFr", EmpRosterTableGroup.EmpID, new Match("EmpRosterTableGroupEffFr", "<", EmpRosterTableGroup.EmpRosterTableGroupEffFr));
//if (lastObj != null)
// if (lastObj.EmpRosterTableGroupEffTo.Ticks == 0)
// {
// lastObj.EmpRosterTableGroupEffTo = EmpRosterTableGroup.EmpRosterTableGroupEffFr.AddDays(-1);
// uploadDB.update(dbConn, lastObj);
// }
uploadDB.insert(dbConn, EmpRosterTableGroup);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, EmpRosterTableGroup);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
ArrayList uploadEmpAVCList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpAVCPlan obj in uploadEmpAVCList)
{
EEmpAVCPlan empAVCPlan = new EEmpAVCPlan();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
empAVCPlan.EmpAVCID = obj.EmpAVCID;
uploadDB.select(dbConn, empAVCPlan);
}
obj.ExportToObject(empAVCPlan);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
empAVCPlan.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
DBFilter emplastPosFilter = new DBFilter();
EEmpAVCPlan lastObj = (EEmpAVCPlan)AppUtils.GetLastObj(dbConn, uploadDB, "EmpAVCEffFr", empAVCPlan.EmpID, new Match("EmpAVCEffFr", "<", empAVCPlan.EmpAVCEffFr));
if (lastObj != null)
if (lastObj.EmpAVCEffTo.Ticks == 0)
{
lastObj.EmpAVCEffTo = empAVCPlan.EmpAVCEffFr.AddDays(-1);
uploadDB.update(dbConn, lastObj);
}
uploadDB.insert(dbConn, empAVCPlan);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, empAVCPlan);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpFinalPayList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpFinalPayment obj in uploadEmpFinalPayList)
{
EEmpFinalPayment EmpFinalPay = new EEmpFinalPayment();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
EmpFinalPay.EmpFinalPayID = obj.EmpFinalPayID;
uploadDB.select(dbConn, EmpFinalPay);
}
obj.ExportToObject(EmpFinalPay);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
EmpFinalPay.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
if (obj.UploadEmpAccID > 0)
{
EmpFinalPay.EmpAccID = ParseTemp.GetEmpBankAccIDFromUploadEmpBankAccID(dbConn, obj.UploadEmpAccID);
}
uploadDB.insert(dbConn, EmpFinalPay);
//DBFilter emplastPosFilter = new DBFilter();
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, EmpFinalPay);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadLeaveBalanceAdjustment obj in uploadList)
{
ELeaveBalanceAdjustment leaveBalanceAdjustment = new ELeaveBalanceAdjustment();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
leaveBalanceAdjustment.LeaveBalAdjID = obj.LeaveBalAdjID;
uploadDB.select(dbConn, leaveBalanceAdjustment);
}
obj.ExportToObject(leaveBalanceAdjustment);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
leaveBalanceAdjustment.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, leaveBalanceAdjustment);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, leaveBalanceAdjustment);
}
tempDB.delete(dbConn, obj);
}
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadCompensationLeaveEntitle obj in uploadList)
{
ECompensationLeaveEntitle compLeaveEntitle = new ECompensationLeaveEntitle();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
compLeaveEntitle.CompensationLeaveEntitleID = obj.CompensationLeaveEntitleID;
uploadDB.select(dbConn, compLeaveEntitle);
}
obj.ExportToObject(compLeaveEntitle);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
compLeaveEntitle.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
uploadDB.insert(dbConn, compLeaveEntitle);
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, compLeaveEntitle);
}
tempDB.delete(dbConn, obj);
}
}
public virtual DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
rowCount++;
EUploadEmpRecurringPayment uploadEmpPay = new EUploadEmpRecurringPayment();
EEmpRecurringPayment lastEmpPay = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpPay.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpPay.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadEmpPay.EmpRPEffFr = Parse.toDateTimeObject(row[FIELD_FROM]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpPay.EmpRPEffTo = Parse.toDateTimeObject(row[FIELD_TO]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpPay.PayCodeID = Parse.GetPaymentCodeID(dbConn, row[FIELD_PAYMENT_CODE].ToString());
if (uploadEmpPay.PayCodeID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + row[FIELD_PAYMENT_CODE].ToString(), EmpNo, rowCount.ToString() });
}
double amount = 0;
if (double.TryParse(row[FIELD_AMOUNT].ToString(), out amount))
{
uploadEmpPay.EmpRPAmount = amount;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + row[FIELD_AMOUNT].ToString(), EmpNo, rowCount.ToString() });
}
if (ESystemParameter.getParameter(dbConn, ESystemParameter.PARAM_CODE_PAYSCALE_POINT_SYSTEM) == "Y")
{
if (amount > 0)
{
decimal m_point = 0;
if (decimal.TryParse(row[FIELD_POINT].ToString(), out m_point))
{
uploadEmpPay.Point = m_point;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_POINT + "=" + row[FIELD_POINT].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpPay.SchemeCode = row[FIELD_SCHEME_CODE].ToString().Trim();
if (uploadEmpPay.SchemeCode == "")
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_SCHEME_CODE + "=" + row[FIELD_SCHEME_CODE].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpPay.Capacity = row[FIELD_CAPACITY].ToString().Trim();
if (uploadEmpPay.Capacity == "")
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CAPACITY + "=" + row[FIELD_CAPACITY].ToString(), EmpNo, rowCount.ToString() });
}
}
}
if (ESystemParameter.getParameter(dbConn, ESystemParameter.PARAM_CODE_MONTHLY_ACHIEVEMENT_COMMISSION) == "Y") // for F&V
{
decimal m_fps;
decimal m_basicSalary;
if (decimal.TryParse(row[FIELD_FPS].ToString(), out m_fps))
{
uploadEmpPay.EmpRPFPS = System.Convert.ToDouble(m_fps);
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FPS + "=" + row[FIELD_FPS].ToString(), EmpNo, rowCount.ToString() });
}
if (decimal.TryParse(row[FIELD_BASIC_SALARY].ToString(), out m_basicSalary))
{
uploadEmpPay.EmpRPBasicSalary = System.Convert.ToDouble(m_basicSalary);
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_BASIC_SALARY + "=" + row[FIELD_BASIC_SALARY].ToString(), EmpNo, rowCount.ToString() });
}
}
uploadEmpPay.CurrencyID = HROne.Lib.ExchangeCurrency.DefaultCurrency();
uploadEmpPay.EmpRPUnit = Parse.toRecurringPaymentUnit(row[FIELD_UNIT].ToString());
uploadEmpPay.EmpRPMethod = Parse.toPaymentMethodCode(row[FIELD_METHOD].ToString());
string BankCode = row[FIELD_ACCOUNT_NO].ToString();
uploadEmpPay.EmpAccID = HROne.Import.Parse.GetEmpAccID(dbConn, BankCode, uploadEmpPay.EmpID);
uploadEmpPay.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpPay.UploadEmpID == 0)
{
if (uploadEmpPay.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpPay.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpPay.EmpID, m_SessionID, UploadDateTime);
}
}
// Check if the bank account no does not exist in database
if (uploadEmpPay.EmpAccID == 0 && !BankCode.Trim().Equals(string.Empty))
{
uploadEmpPay.UploadEmpAccID = ParseTemp.GetUploadEmpAccID(dbConn, BankCode, uploadEmpPay.UploadEmpID);
if (uploadEmpPay.UploadEmpAccID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ACCOUNT_NO + "=" + BankCode, EmpNo, rowCount.ToString() });
}
}
if ((uploadEmpPay.EmpAccID > 0 || uploadEmpPay.UploadEmpAccID > 0) && !uploadEmpPay.EmpRPMethod.Equals("A"))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_METHOD + "=" + row[FIELD_METHOD].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadEmpPay.EmpRPMethod.Equals("A") && uploadEmpPay.EmpAccID == 0 && uploadEmpPay.UploadEmpAccID == 0)
{
EUploadEmpBankAccount uploadBankAccount = EUploadEmpBankAccount.GetDefaultBankAccount(dbConn, uploadEmpPay.EmpID, ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID), m_SessionID);
if (uploadBankAccount != null)
{
//if (uploadBankAccount.EmpBankAccountID > 0)
// uploadEmpPay.EmpAccID = uploadBankAccount.EmpBankAccountID;
//else
// uploadEmpPay.UploadEmpAccID = uploadBankAccount.UploadEmpBankAccountID;
}
else
if (uploadEmpPay.EmpID > 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, uploadEmpPay.EmpID);
if (bankAccount != null)
{
//uploadEmpPay.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ACCOUNT_NO + "=" + BankCode, EmpNo, rowCount.ToString() });
}
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ACCOUNT_NO + "=" + BankCode, EmpNo, rowCount.ToString() });
}
}
if (rawDataTable.Columns.Contains(FIELD_IS_NON_PAYROLL_ITEM))
{
uploadEmpPay.EmpRPIsNonPayrollItem = row[FIELD_IS_NON_PAYROLL_ITEM].ToString().Equals("Yes", StringComparison.CurrentCultureIgnoreCase) || row[FIELD_IS_NON_PAYROLL_ITEM].ToString().Equals("Y", StringComparison.CurrentCultureIgnoreCase);
}
if (rawDataTable.Columns.Contains(FIELD_COST_CENTER))
{
string CostCenter = row[FIELD_COST_CENTER].ToString();
if (!string.IsNullOrEmpty(CostCenter))
{
uploadEmpPay.CostCenterID = HROne.Import.Parse.GetCostCenterID(dbConn, CostCenter, false, UserID);
if (uploadEmpPay.CostCenterID <= 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_COST_CENTER + "=" + CostCenter, EmpNo, rowCount.ToString() });
}
}
else
{
uploadEmpPay.CostCenterID = 0;
}
}
uploadEmpPay.EmpRPRemark = row[FIELD_REMARK].ToString().Trim();
uploadEmpPay.SessionID = m_SessionID;
uploadEmpPay.TransactionDate = UploadDateTime;
if (uploadEmpPay.EmpID != 0 && errors.List.Count <= 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpRecurringPayment tmpObj = new EEmpRecurringPayment();
// tmpObj.EmpRPID = tmpID;
// if (EEmpRecurringPayment.db.select(dbConn, tmpObj))
// uploadEmpPay.EmpRPID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpPay.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpRecurringPayment.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpPay.EmpRPID = ((EEmpRecurringPayment)objSameSynIDList[0]).EmpRPID;
}
}
}
}
if (uploadEmpPay.EmpRPID == 0)
{
AND andTerms = new AND();
andTerms.add(new Match("EmpRPEffFr", "<=", uploadEmpPay.EmpRPEffFr));
andTerms.add(new Match("PayCodeID", uploadEmpPay.PayCodeID));
lastEmpPay = (EEmpRecurringPayment)AppUtils.GetLastObj(dbConn, uploadDB, "EmpRPEffFr", uploadEmpPay.EmpID, andTerms);
if (lastEmpPay != null)
{
if (uploadEmpPay.EmpAccID == lastEmpPay.EmpAccID &&
Math.Abs(uploadEmpPay.EmpRPAmount - lastEmpPay.EmpRPAmount) < 0.01 &&
uploadEmpPay.EmpRPMethod == lastEmpPay.EmpRPMethod &&
uploadEmpPay.EmpRPUnit == lastEmpPay.EmpRPUnit &&
uploadEmpPay.PayCodeID == lastEmpPay.PayCodeID &&
uploadEmpPay.EmpRPEffFr == lastEmpPay.EmpRPEffFr &&
uploadEmpPay.EmpRPEffTo == lastEmpPay.EmpRPEffTo &&
uploadEmpPay.SchemeCode == lastEmpPay.SchemeCode &&
uploadEmpPay.Capacity == lastEmpPay.Capacity &&
uploadEmpPay.Point == lastEmpPay.Point &&
uploadEmpPay.CostCenterID == lastEmpPay.CostCenterID &&
uploadEmpPay.EmpRPRemark == lastEmpPay.EmpRPRemark &&
uploadEmpPay.EmpRPIsNonPayrollItem == lastEmpPay.EmpRPIsNonPayrollItem
)
{
continue;
}
else
{
// add postion terms with new ID
if (lastEmpPay.EmpRPEffFr.Equals(uploadEmpPay.EmpRPEffFr))
{
uploadEmpPay.EmpRPID = lastEmpPay.EmpRPID;
if (uploadEmpPay.EmpRPEffTo.Ticks == 0 && lastEmpPay.EmpRPEffTo.Ticks != 0)
{
AND andNextTerms = new AND();
andNextTerms.add(new Match("EmpRPEffFr", ">", lastEmpPay.EmpRPEffTo));
andNextTerms.add(new Match("PayCodeID", uploadEmpPay.PayCodeID));
EEmpRecurringPayment afterEmpRP = (EEmpRecurringPayment)AppUtils.GetLastObj(dbConn, uploadDB, "EmpRPEffFr", uploadEmpPay.EmpID, andNextTerms);
if (afterEmpRP != null)
{
uploadEmpPay.EmpRPEffTo = afterEmpRP.EmpRPEffFr.AddDays(-1);
}
}
}
else
{
AND lastObjAndTerms = new AND();
lastObjAndTerms.add(new Match("EmpRPEffFr", ">", uploadEmpPay.EmpRPEffFr));
if (!uploadEmpPay.EmpRPEffTo.Ticks.Equals(0))
{
lastObjAndTerms.add(new Match("EmpRPEffFr", "<=", uploadEmpPay.EmpRPEffTo));
}
lastObjAndTerms.add(new Match("PayCodeID", uploadEmpPay.PayCodeID));
EEmpRecurringPayment lastObj = (EEmpRecurringPayment)AppUtils.GetLastObj(dbConn, uploadDB, "EmpRPEffFr", uploadEmpPay.EmpID, lastObjAndTerms);
if (lastObj != null)
{
if (!lastObj.EmpRPEffTo.Ticks.Equals(0))
{
errors.addError(ImportErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadEmpPay.EmpRPEffFr.ToString("yyyy-MM-dd"), rowCount.ToString() });
continue;
}
}
}
}
}
}
}
if (uploadEmpPay.EmpRPID <= 0)
{
uploadEmpPay.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpPay.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpPay, values);
PageErrors pageErrors = new PageErrors(tempDB);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpPay);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpFinalPayment uploadEmpFinalPay = new EUploadEmpFinalPayment();
//EEmpFinalPayment lastEmpFinalPay;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpFinalPay.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpFinalPay.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
uploadEmpFinalPay.PayCodeID = Parse.GetPaymentCodeID(dbConn, row[FIELD_PAYMENT_CODE].ToString());
if (uploadEmpFinalPay.PayCodeID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + row[FIELD_PAYMENT_CODE].ToString(), EmpNo, rowCount.ToString() });
}
double amount = 0;
if (double.TryParse(row[FIELD_AMOUNT].ToString(), out amount))
{
uploadEmpFinalPay.EmpFinalPayAmount = amount;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + row[FIELD_AMOUNT].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpFinalPay.CurrencyID = HROne.Lib.ExchangeCurrency.DefaultCurrency();
uploadEmpFinalPay.EmpFinalPayMethod = Parse.toPaymentMethodCode(row[FIELD_METHOD].ToString());
string BankCode = row[FIELD_ACCOUNT_NO].ToString();
uploadEmpFinalPay.EmpAccID = HROne.Import.Parse.GetEmpAccID(dbConn, BankCode, uploadEmpFinalPay.EmpID);
// Check if the bank account no does not exist in database
if (uploadEmpFinalPay.EmpAccID == 0 && !BankCode.Trim().Equals(string.Empty))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ACCOUNT_NO + "=" + BankCode, EmpNo, rowCount.ToString() });
}
if (uploadEmpFinalPay.EmpAccID > 0 && !uploadEmpFinalPay.EmpFinalPayMethod.Equals("A"))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_METHOD + "=" + row[FIELD_METHOD].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadEmpFinalPay.EmpFinalPayMethod.Equals("A") && uploadEmpFinalPay.EmpAccID == 0)
{
EUploadEmpBankAccount uploadBankAccount = EUploadEmpBankAccount.GetDefaultBankAccount(dbConn, uploadEmpFinalPay.EmpID, ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID), m_SessionID);
if (uploadBankAccount != null)
{
//if (uploadBankAccount.EmpBankAccountID > 0)
// uploadEmpFinalPay.EmpAccID = uploadBankAccount.EmpBankAccountID;
//else
// uploadEmpFinalPay.UploadEmpAccID = uploadBankAccount.UploadEmpBankAccountID;
}
else
if (uploadEmpFinalPay.EmpID > 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, uploadEmpFinalPay.EmpID);
if (bankAccount != null)
{
//uploadEmpFinalPay.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ACCOUNT_NO + "=" + BankCode, EmpNo, rowCount.ToString() });
}
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ACCOUNT_NO + "=" + BankCode, EmpNo, rowCount.ToString() });
}
}
if (rawDataTable.Columns.Contains(FIELD_COST_CENTER))
{
string CostCenter = row[FIELD_COST_CENTER].ToString();
if (!string.IsNullOrEmpty(CostCenter))
{
uploadEmpFinalPay.CostCenterID = HROne.Import.Parse.GetCostCenterID(dbConn, CostCenter, false, UserID);
if (uploadEmpFinalPay.CostCenterID <= 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_COST_CENTER + "=" + CostCenter, EmpNo, rowCount.ToString() });
}
}
else
{
uploadEmpFinalPay.CostCenterID = 0;
}
}
uploadEmpFinalPay.EmpFinalPayRemark = row[FIELD_REMARK].ToString().Trim();
double NumOfDayAdjust = 0;
if (rawDataTable.Columns.Contains(FIELD_NUM_OF_DAY_ADJUST))
{
string NumOfDayAdjustString = row[FIELD_NUM_OF_DAY_ADJUST].ToString();
if (!string.IsNullOrEmpty(NumOfDayAdjustString))
{
if (!double.TryParse(NumOfDayAdjustString, out NumOfDayAdjust))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NUM_OF_DAY_ADJUST + "=" + NumOfDayAdjustString, EmpNo, rowCount.ToString() });
}
else
{
uploadEmpFinalPay.EmpFinalPayNumOfDayAdj = NumOfDayAdjust;
}
}
else
{
uploadEmpFinalPay.EmpFinalPayNumOfDayAdj = 0;
}
}
uploadEmpFinalPay.EmpFinalPayIsAutoGen = false;
uploadEmpFinalPay.SessionID = m_SessionID;
uploadEmpFinalPay.TransactionDate = UploadDateTime;
// Final Payment do NOT have unique constraint, skip checking duplicate record
//if (uploadEmpFinalPay.EmpID != 0)
//{
// AND andTerms = new AND();
// andTerms.add(new Match("PayCodeID", uploadEmpFinalPay.PayCodeID));
// lastEmpFinalPay = (EEmpFinalPayment)AppUtils.GetLastObj(dbConn, uploadDB, "EmpFinalPayID", uploadEmpFinalPay.EmpID, andTerms);
// if (lastEmpFinalPay != null)
// {
// if (uploadEmpFinalPay.EmpAccID == lastEmpFinalPay.EmpAccID
// && Math.Abs(uploadEmpFinalPay.EmpFinalPayAmount - lastEmpFinalPay.EmpFinalPayAmount) < 0.01
// && uploadEmpFinalPay.EmpFinalPayMethod == lastEmpFinalPay.EmpFinalPayMethod
// && uploadEmpFinalPay.PayCodeID == lastEmpFinalPay.PayCodeID
// )
// continue;
// else
// {
// // add postion terms with new ID
// uploadEmpFinalPay.EmpFinalPayID = lastEmpFinalPay.EmpFinalPayID;
// }
// }
//}
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpFinalPayment tmpObj = new EEmpFinalPayment();
// tmpObj.EmpFinalPayID = tmpID;
// if (EEmpFinalPayment.db.select(dbConn, tmpObj))
// uploadEmpFinalPay.EmpFinalPayID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpFinalPay.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpFinalPayment.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpFinalPay.EmpFinalPayID = ((EEmpFinalPayment)objSameSynIDList[0]).EmpFinalPayID;
}
}
}
}
if (uploadEmpFinalPay.EmpFinalPayID <= 0)
{
uploadEmpFinalPay.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpFinalPay.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpFinalPay.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpFinalPay.UploadEmpID == 0)
{
if (uploadEmpFinalPay.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpFinalPay.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpFinalPay.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpFinalPay, values);
PageErrors pageErrors = new PageErrors(tempDB);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpFinalPay);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadLeaveBalanceAdjustment uploadLeaveBalanceAdjustment = new EUploadLeaveBalanceAdjustment();
//EEmpAVCPlan lastEmpAVC = null;
//ArrayList uploadHierarchyList = new ArrayList();
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadLeaveBalanceAdjustment.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadLeaveBalanceAdjustment.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadLeaveBalanceAdjustment.LeaveBalAdjDate = Parse.toDateTimeObject(row[FIELD_DATE_ADJUST]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_DATE_ADJUST + "=" + row[FIELD_DATE_ADJUST].ToString(), EmpNo, rowCount.ToString() });
}
uploadLeaveBalanceAdjustment.LeaveTypeID = Import.Parse.GetLeaveTypeID(dbConn, row[FIELD_LEAVE_TYPE].ToString(), false, UserID);
if (uploadLeaveBalanceAdjustment.LeaveTypeID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_LEAVE_TYPE + "=" + row[FIELD_LEAVE_TYPE].ToString(), EmpNo, rowCount.ToString() });
}
string tempString;
if (rawDataTable.Columns.Contains(FIELD_ADJUST_TYPE))
{
tempString = row[FIELD_ADJUST_TYPE].ToString().Trim();
if (tempString.Equals(ELeaveBalanceAdjustment.ADJUST_TYPE_RESET_BALANCE_NAME, StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals(ELeaveBalanceAdjustment.ADJUST_TYPE_RESET_BALANCE, StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveBalanceAdjustment.LeaveBalAdjType = ELeaveBalanceAdjustment.ADJUST_TYPE_RESET_BALANCE;
}
else if (tempString.Equals(ELeaveBalanceAdjustment.ADJUST_TYPE_ADJUSTMENT_NAME, StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals(ELeaveBalanceAdjustment.ADJUST_TYPE_ADJUSTMENT, StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveBalanceAdjustment.LeaveBalAdjType = ELeaveBalanceAdjustment.ADJUST_TYPE_ADJUSTMENT;
}
//else if (tempString.Equals(string.Empty))
// uploadLeaveApp.LeaveAppUnit = string.Empty;
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ADJUST_TYPE + "=" + row[FIELD_ADJUST_TYPE].ToString(), EmpNo, rowCount.ToString() });
}
}
double adjustValue;
if (double.TryParse(row[FIELD_ADJUST_VALUE].ToString(), out adjustValue))
{
uploadLeaveBalanceAdjustment.LeaveBalAdjValue = adjustValue;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ADJUST_VALUE + "=" + row[FIELD_ADJUST_VALUE].ToString(), EmpNo, rowCount.ToString() });
}
uploadLeaveBalanceAdjustment.LeaveBalAdjRemark = row[FIELD_REMARK].ToString();
uploadLeaveBalanceAdjustment.SessionID = m_SessionID;
uploadLeaveBalanceAdjustment.TransactionDate = UploadDateTime;
if (uploadLeaveBalanceAdjustment.EmpID != 0 && errors.List.Count <= 0)
{
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadLeaveBalanceAdjustment.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = ELeaveBalanceAdjustment.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadLeaveBalanceAdjustment.LeaveBalAdjID = ((ELeaveBalanceAdjustment)objSameSynIDList[0]).LeaveBalAdjID;
}
}
}
}
if (uploadLeaveBalanceAdjustment.LeaveBalAdjID == 0)
{
AND andTerm = new AND();
andTerm.add(new Match("LeaveBalAdjDate", "=", uploadLeaveBalanceAdjustment.LeaveBalAdjDate));
andTerm.add(new Match("LeaveTypeID", "=", uploadLeaveBalanceAdjustment.LeaveTypeID));
ELeaveBalanceAdjustment lastObject = (ELeaveBalanceAdjustment)AppUtils.GetLastObj(dbConn, uploadDB, "LeaveBalAdjDate", uploadLeaveBalanceAdjustment.EmpID, andTerm);
if (lastObject != null)
{
uploadLeaveBalanceAdjustment.LeaveBalAdjID = lastObject.LeaveBalAdjID;
}
}
}
if (uploadLeaveBalanceAdjustment.LeaveBalAdjID <= 0)
{
uploadLeaveBalanceAdjustment.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadLeaveBalanceAdjustment.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadLeaveBalanceAdjustment.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadLeaveBalanceAdjustment.UploadEmpID == 0)
{
if (uploadLeaveBalanceAdjustment.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadLeaveBalanceAdjustment.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadLeaveBalanceAdjustment.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadLeaveBalanceAdjustment, values);
PageErrors pageErrors = new PageErrors(EUploadLeaveBalanceAdjustment.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadLeaveBalanceAdjustment);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
//if (EmpID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (EffDate.Ticks == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EFFECTIVE_DATE + "=" + EffDateString, EmpNo, rowCount.ToString() });
//else if (double.TryParse(amountString, out amount))
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + amountString, EmpNo, rowCount.ToString() });
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpPlaceOfResidence uploadEmpPoR = new EUploadEmpPlaceOfResidence();
EEmpPlaceOfResidence lastEmpPoR = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpPoR.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpPoR.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadEmpPoR.EmpPoRFrom = Parse.toDateTimeObject(row[FIELD_FROM]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpPoR.EmpPoRTo = Parse.toDateTimeObject(row[FIELD_TO]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpPoR.EmpPoRNature = row[FIELD_NATURE].ToString();
uploadEmpPoR.EmpPoRLandLord = row[FIELD_LANDLORD].ToString();
uploadEmpPoR.EmpPoRPropertyAddr = row[FIELD_ADDRESS].ToString();
uploadEmpPoR.EmpPoRLandLordAddr = row[FIELD_LANDLORD_ADDRESS].ToString();
double amount = 0;
if (double.TryParse(row[FIELD_ER_RENT_PAID].ToString(), out amount))
{
uploadEmpPoR.EmpPoRPayToLandER = amount;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ER_RENT_PAID + "=" + row[FIELD_ER_RENT_PAID].ToString(), EmpNo, rowCount.ToString() });
}
if (double.TryParse(row[FIELD_EE_RENT_PAID].ToString(), out amount))
{
uploadEmpPoR.EmpPoRPayToLandEE = amount;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EE_RENT_PAID + "=" + row[FIELD_EE_RENT_PAID].ToString(), EmpNo, rowCount.ToString() });
}
if (double.TryParse(row[FIELD_EE_RENT_REFUND].ToString(), out amount))
{
uploadEmpPoR.EmpPoRRefundToEE = amount;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EE_RENT_REFUND + "=" + row[FIELD_EE_RENT_REFUND].ToString(), EmpNo, rowCount.ToString() });
}
if (double.TryParse(row[FIELD_EE_RENT_PAID_TO_ER].ToString(), out amount))
{
uploadEmpPoR.EmpPoRPayToERByEE = amount;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EE_RENT_PAID_TO_ER + "=" + row[FIELD_EE_RENT_PAID_TO_ER].ToString(), EmpNo, rowCount.ToString() });
}
//uploadEmpPoR.EmpPoRPayToLandER = double.Parse(row[FIELD_ER_RENT_PAID].ToString());
//uploadEmpPoR.EmpPoRPayToLandEE = double.Parse(row[FIELD_EE_RENT_PAID].ToString());
//uploadEmpPoR.EmpPoRRefundToEE = double.Parse(row[FIELD_EE_RENT_REFUND].ToString());
//uploadEmpPoR.EmpPoRPayToERByEE = double.Parse(row[FIELD_EE_RENT_PAID_TO_ER].ToString());
uploadEmpPoR.SessionID = m_SessionID;
uploadEmpPoR.TransactionDate = UploadDateTime;
if (uploadEmpPoR.EmpID != 0)
{
AND andTerms = new AND();
andTerms.add(new Match("EmpPoRFrom", "<=", uploadEmpPoR.EmpPoRFrom));
lastEmpPoR = (EEmpPlaceOfResidence)AppUtils.GetLastObj(dbConn, uploadDB, "EmpPoRFrom", uploadEmpPoR.EmpID, andTerms);
if (lastEmpPoR != null)
{
if (uploadEmpPoR.EmpPoRNature == lastEmpPoR.EmpPoRNature &&
uploadEmpPoR.EmpPoRLandLord == lastEmpPoR.EmpPoRLandLord &&
uploadEmpPoR.EmpPoRPropertyAddr == lastEmpPoR.EmpPoRPropertyAddr &&
uploadEmpPoR.EmpPoRLandLordAddr == lastEmpPoR.EmpPoRLandLordAddr &&
uploadEmpPoR.EmpPoRTo == lastEmpPoR.EmpPoRTo
)
{
continue;
}
else
{
// add postion terms with new ID
if (lastEmpPoR.EmpPoRFrom.Equals(uploadEmpPoR.EmpPoRFrom))
{
uploadEmpPoR.EmpPoRID = lastEmpPoR.EmpPoRID;
if (uploadEmpPoR.EmpPoRTo.Ticks == 0 && lastEmpPoR.EmpPoRTo.Ticks != 0)
{
EEmpPlaceOfResidence afterEmPoR = (EEmpPlaceOfResidence)AppUtils.GetLastObj(dbConn, uploadDB, "EmpPoRFrom", uploadEmpPoR.EmpID, new Match("EmpPoRFrom", ">", lastEmpPoR.EmpPoRTo));
if (afterEmPoR != null)
{
uploadEmpPoR.EmpPoRTo = afterEmPoR.EmpPoRFrom.AddDays(-1);
}
}
}
else
{
EEmpPlaceOfResidence lastObj = (EEmpPlaceOfResidence)AppUtils.GetLastObj(dbConn, uploadDB, "EmpPoRFrom", uploadEmpPoR.EmpID);
if (lastObj != null && uploadEmpPoR.EmpPoRFrom <= lastObj.EmpPoRFrom)
{
errors.addError(ImportErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadEmpPoR.EmpPoRFrom.ToString("yyyy-MM-dd"), rowCount.ToString() });
continue;
}
}
}
}
}
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpPlaceOfResidence tmpObj = new EEmpPlaceOfResidence();
// tmpObj.EmpPoRID = tmpID;
// if (EEmpPlaceOfResidence.db.select(dbConn, tmpObj))
// uploadEmpPoR.EmpPoRID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpPoR.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpPlaceOfResidence.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpPoR.EmpPoRID = ((EEmpPlaceOfResidence)objSameSynIDList[0]).EmpPoRID;
}
}
}
}
if (uploadEmpPoR.EmpPoRID <= 0)
{
uploadEmpPoR.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpPoR.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpPoR.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpPoR.UploadEmpID == 0)
{
if (uploadEmpPoR.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpPoR.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpPoR.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpPoR, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpPoR);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
//if (EmpID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (EffDate.Ticks == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EFFECTIVE_DATE + "=" + EffDateString, EmpNo, rowCount.ToString() });
//else if (double.TryParse(amountString, out amount))
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + amountString, EmpNo, rowCount.ToString() });
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
decimal m_share;
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpBeneficiaries uploadEmpBeneficiaries = new EUploadEmpBeneficiaries();
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpBeneficiaries.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpBeneficiaries.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
if (rawDataTable.Columns.Contains(FIELD_NAME))
{
uploadEmpBeneficiaries.EmpBeneficiariesName = row[FIELD_NAME].ToString().Trim();
}
if (decimal.TryParse(row[FIELD_SHARE].ToString(), out m_share))
{
uploadEmpBeneficiaries.EmpBeneficiariesShare = System.Convert.ToDouble(m_share);
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_SHARE + "=" + row[FIELD_SHARE].ToString(), EmpNo, rowCount.ToString() });
}
if (rawDataTable.Columns.Contains(FIELD_HKID))
{
uploadEmpBeneficiaries.EmpBeneficiariesHKID = row[FIELD_HKID].ToString().Trim();
}
if (rawDataTable.Columns.Contains(FIELD_RELATION))
{
uploadEmpBeneficiaries.EmpBeneficiariesRelation = row[FIELD_RELATION].ToString().Trim();
}
if (rawDataTable.Columns.Contains(FIELD_ADDRESS))
{
uploadEmpBeneficiaries.EmpBeneficiariesAddress = row[FIELD_ADDRESS].ToString().Trim();
}
if (rawDataTable.Columns.Contains(FIELD_DISTRICT))
{
uploadEmpBeneficiaries.EmpBeneficiariesDistrict = row[FIELD_DISTRICT].ToString().Trim();
}
if (rawDataTable.Columns.Contains(FIELD_AREA))
{
uploadEmpBeneficiaries.EmpBeneficiariesArea = row[FIELD_AREA].ToString().Trim();
}
if (rawDataTable.Columns.Contains(FIELD_COUNTRY))
{
uploadEmpBeneficiaries.EmpBeneficiariesCountry = row[FIELD_COUNTRY].ToString().Trim();
}
uploadEmpBeneficiaries.SessionID = m_SessionID;
uploadEmpBeneficiaries.TransactionDate = UploadDateTime;
if (uploadEmpBeneficiaries.EmpID != 0)
{
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpBeneficiaries.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpBeneficiaries.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpBeneficiaries.EmpBeneficiariesID = ((EEmpBeneficiaries)objSameSynIDList[0]).EmpBeneficiariesID;
}
}
}
}
if (uploadEmpBeneficiaries.EmpBeneficiariesID == 0)
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", uploadEmpBeneficiaries.EmpID));
ArrayList list = uploadDB.select(dbConn, filter);
bool IsSameEntryExists = false;
foreach (EEmpBeneficiaries currentEmpBeneficiaries in list)
{
if (uploadEmpBeneficiaries.EmpBeneficiariesHKID == currentEmpBeneficiaries.EmpBeneficiariesHKID)
{
uploadEmpBeneficiaries.EmpBeneficiariesID = currentEmpBeneficiaries.EmpBeneficiariesID;
}
if (uploadEmpBeneficiaries.EmpBeneficiariesName == currentEmpBeneficiaries.EmpBeneficiariesName &&
uploadEmpBeneficiaries.EmpBeneficiariesShare == currentEmpBeneficiaries.EmpBeneficiariesShare &&
uploadEmpBeneficiaries.EmpBeneficiariesHKID == currentEmpBeneficiaries.EmpBeneficiariesHKID &&
uploadEmpBeneficiaries.EmpBeneficiariesRelation == currentEmpBeneficiaries.EmpBeneficiariesRelation &&
uploadEmpBeneficiaries.EmpBeneficiariesAddress == currentEmpBeneficiaries.EmpBeneficiariesAddress &&
uploadEmpBeneficiaries.EmpBeneficiariesDistrict == currentEmpBeneficiaries.EmpBeneficiariesDistrict &&
uploadEmpBeneficiaries.EmpBeneficiariesArea == currentEmpBeneficiaries.EmpBeneficiariesArea &&
uploadEmpBeneficiaries.EmpBeneficiariesCountry == currentEmpBeneficiaries.EmpBeneficiariesCountry
)
{
IsSameEntryExists = true;
break;
}
}
if (IsSameEntryExists)
{
continue;
}
}
}
if (uploadEmpBeneficiaries.EmpBeneficiariesID <= 0)
{
uploadEmpBeneficiaries.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpBeneficiaries.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpBeneficiaries.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpBeneficiaries.UploadEmpID == 0)
{
if (uploadEmpBeneficiaries.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpBeneficiaries.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpBeneficiaries.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpBeneficiaries, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpBeneficiaries);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID, bool CreateCodeIfNotExists)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpCostCenter uploadEmpCostCenter = new EUploadEmpCostCenter();
ArrayList uploadEmpCostCenterDetailList = new ArrayList();
ArrayList lastEmpCostCenterDetailList = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpCostCenter.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpCostCenter.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadEmpCostCenter.EmpCostCenterEffFr = Parse.toDateTimeObject(row[FIELD_FROM]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpCostCenter.EmpCostCenterEffTo = Parse.toDateTimeObject(row[FIELD_TO]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
int iFieldCount = 1;
double totalPercentage = 0;
while (row.Table.Columns.Contains(FIELD_COST_CENTER + iFieldCount) && row.Table.Columns.Contains(FIELD_PERCENTAGE + iFieldCount))
{
if (!row.IsNull(FIELD_COST_CENTER + iFieldCount) && !row.IsNull(FIELD_PERCENTAGE + iFieldCount))
{
if (!string.IsNullOrEmpty(row[FIELD_COST_CENTER + iFieldCount].ToString().Trim()) && !string.IsNullOrEmpty(row[FIELD_PERCENTAGE + iFieldCount].ToString().Trim()))
{
EUploadEmpCostCenterDetail uploadEmpCostCenterDetail = new EUploadEmpCostCenterDetail();
uploadEmpCostCenterDetail.CostCenterID = Parse.GetCostCenterID(dbConn, row[FIELD_COST_CENTER + iFieldCount].ToString(), CreateCodeIfNotExists, UserID);
try
{
uploadEmpCostCenterDetail.EmpCostCenterPercentage = double.Parse(row[FIELD_PERCENTAGE + iFieldCount].ToString().Trim());
if (uploadEmpCostCenterDetail.CostCenterID > 0)
{
totalPercentage += uploadEmpCostCenterDetail.EmpCostCenterPercentage;
uploadEmpCostCenterDetailList.Add(uploadEmpCostCenterDetail);
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_COST_CENTER + iFieldCount + "=" + row[FIELD_COST_CENTER + iFieldCount].ToString(), EmpNo, rowCount.ToString() });
}
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PERCENTAGE + iFieldCount + "=" + row[FIELD_PERCENTAGE + iFieldCount].ToString(), EmpNo, rowCount.ToString() });
}
}
}
iFieldCount++;
}
if (Math.Abs(Math.Round(totalPercentage, 2) - 100) >= 0.01)
{
errors.addError(ImportErrorMessage.ERROR_TOTAL_PERCENTAGE_NOT_100, new string[] { rowCount.ToString() });
}
uploadEmpCostCenter.SessionID = m_SessionID;
uploadEmpCostCenter.TransactionDate = UploadDateTime;
if (uploadEmpCostCenter.EmpID != 0 && errors.List.Count <= 0)
{
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpCostCenter.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpCostCenter.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpCostCenter.EmpCostCenterID = ((EEmpCostCenter)objSameSynIDList[0]).EmpCostCenterID;
}
}
if (uploadEmpCostCenter.EmpCostCenterID != 0)
{
DBFilter empCostCenterSetailFilter = new DBFilter();
empCostCenterSetailFilter.add(new Match("EmpCostCenterID", uploadEmpCostCenter.EmpCostCenterID));
lastEmpCostCenterDetailList = EEmpCostCenterDetail.db.select(dbConn, empCostCenterSetailFilter);
bool IsSameDetail = true;
if (
lastEmpCostCenterDetailList.Count == uploadEmpCostCenterDetailList.Count &&
uploadEmpCostCenter.EmpCostCenterEffFr == uploadEmpCostCenter.EmpCostCenterEffFr &&
uploadEmpCostCenter.EmpCostCenterEffTo == uploadEmpCostCenter.EmpCostCenterEffTo
)
{
foreach (EEmpCostCenterDetail empCostCenterDetail in lastEmpCostCenterDetailList)
{
foreach (EUploadEmpCostCenterDetail uploadEmpCostCenterDetail in uploadEmpCostCenterDetailList)
{
if (uploadEmpCostCenterDetail.CostCenterID == empCostCenterDetail.CostCenterID)
{
if (uploadEmpCostCenterDetail.EmpCostCenterPercentage - empCostCenterDetail.EmpCostCenterPercentage >= 0.01)
{
uploadEmpCostCenterDetail.EmpCostCenterDetailID = empCostCenterDetail.EmpCostCenterDetailID;
IsSameDetail = false;
}
else
{
uploadEmpCostCenterDetail.EmpCostCenterID = empCostCenterDetail.EmpCostCenterID;
uploadEmpCostCenterDetail.EmpCostCenterDetailID = empCostCenterDetail.EmpCostCenterDetailID;
}
break;
}
if (uploadEmpCostCenterDetailList[uploadEmpCostCenterDetailList.Count - 1] == uploadEmpCostCenterDetail)
{
IsSameDetail = false;
}
}
}
}
else
{
IsSameDetail = false;
}
if (IsSameDetail)
{
continue;
}
else
{
foreach (EUploadEmpCostCenterDetail uploadEmpCostCenterDetail in uploadEmpCostCenterDetailList)
{
uploadEmpCostCenterDetail.EmpCostCenterID = uploadEmpCostCenter.EmpCostCenterID;
//uploadEmpHierarchy.EmpHierarchyID = empHierarchy.EmpHierarchyID;
}
}
}
}
}
if (uploadEmpCostCenter.EmpCostCenterID == 0)
{
AND andTerms = new AND();
andTerms.add(new Match("EmpCostCenterEffFr", "<=", uploadEmpCostCenter.EmpCostCenterEffFr));
EEmpCostCenter lastEmpCostCenter = (EEmpCostCenter)AppUtils.GetLastObj(dbConn, uploadDB, "EmpCostCenterEffFr", uploadEmpCostCenter.EmpID, andTerms);
if (lastEmpCostCenter != null)
{
DBFilter empCostCenterSetailFilter = new DBFilter();
empCostCenterSetailFilter.add(new Match("EmpCostCenterID", lastEmpCostCenter.EmpCostCenterID));
lastEmpCostCenterDetailList = EEmpCostCenterDetail.db.select(dbConn, empCostCenterSetailFilter);
bool IsSameDetail = true;
if (
lastEmpCostCenterDetailList.Count == uploadEmpCostCenterDetailList.Count &&
uploadEmpCostCenter.EmpCostCenterEffFr == lastEmpCostCenter.EmpCostCenterEffFr &&
uploadEmpCostCenter.EmpCostCenterEffTo == lastEmpCostCenter.EmpCostCenterEffTo
)
{
foreach (EEmpCostCenterDetail empCostCenterDetail in lastEmpCostCenterDetailList)
{
foreach (EUploadEmpCostCenterDetail uploadEmpCostCenterDetail in uploadEmpCostCenterDetailList)
{
if (uploadEmpCostCenterDetail.CostCenterID == empCostCenterDetail.CostCenterID)
{
if (uploadEmpCostCenterDetail.EmpCostCenterPercentage - empCostCenterDetail.EmpCostCenterPercentage >= 0.01)
{
uploadEmpCostCenterDetail.EmpCostCenterDetailID = empCostCenterDetail.EmpCostCenterDetailID;
IsSameDetail = false;
}
else
{
uploadEmpCostCenterDetail.EmpCostCenterID = empCostCenterDetail.EmpCostCenterID;
uploadEmpCostCenterDetail.EmpCostCenterDetailID = empCostCenterDetail.EmpCostCenterDetailID;
}
break;
}
if (uploadEmpCostCenterDetailList[uploadEmpCostCenterDetailList.Count - 1] == uploadEmpCostCenterDetail)
{
IsSameDetail = false;
}
}
}
}
else
{
IsSameDetail = false;
}
if (IsSameDetail)
{
continue;
}
else
{
// add postion terms with new ID
if (lastEmpCostCenter.EmpCostCenterEffFr.Equals(uploadEmpCostCenter.EmpCostCenterEffFr))
{
uploadEmpCostCenter.EmpCostCenterID = lastEmpCostCenter.EmpCostCenterID;
if (uploadEmpCostCenter.EmpCostCenterEffTo.Ticks == 0 && lastEmpCostCenter.EmpCostCenterEffTo.Ticks != 0)
{
EEmpCostCenter afterEmpCostCenter = (EEmpCostCenter)AppUtils.GetLastObj(dbConn, uploadDB, "EmpCostCenterEffFr", uploadEmpCostCenter.EmpID, new Match("EmpCostCenterEffFr", ">", lastEmpCostCenter.EmpCostCenterEffTo));
if (afterEmpCostCenter != null)
{
uploadEmpCostCenter.EmpCostCenterEffTo = afterEmpCostCenter.EmpCostCenterEffFr.AddDays(-1);
}
}
foreach (EUploadEmpCostCenterDetail uploadEmpCostCenterDetail in uploadEmpCostCenterDetailList)
{
uploadEmpCostCenterDetail.EmpCostCenterID = uploadEmpCostCenter.EmpCostCenterID;
//uploadEmpHierarchy.EmpHierarchyID = empHierarchy.EmpHierarchyID;
}
}
else
{
AND lastObjAndTerms = new AND();
lastObjAndTerms.add(new Match("EmpCostCenterEffFr", ">", uploadEmpCostCenter.EmpCostCenterEffFr));
if (!uploadEmpCostCenter.EmpCostCenterEffTo.Ticks.Equals(0))
{
lastObjAndTerms.add(new Match("EmpCostCenterEffFr", "<=", uploadEmpCostCenter.EmpCostCenterEffTo));
}
EEmpCostCenter lastObj = (EEmpCostCenter)AppUtils.GetLastObj(dbConn, uploadDB, "EmpCostCenterEffFr", uploadEmpCostCenter.EmpID, lastObjAndTerms);
if (lastObj != null)
{
if (!lastObj.EmpCostCenterEffTo.Ticks.Equals(0))
{
errors.addError(ImportErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadEmpCostCenter.EmpCostCenterEffFr.ToString("yyyy-MM-dd"), rowCount.ToString() });
continue;
}
}
}
}
}
}
}
if (uploadEmpCostCenter.EmpCostCenterID <= 0)
{
uploadEmpCostCenter.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpCostCenter.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpCostCenter.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpCostCenter.UploadEmpID == 0)
{
if (uploadEmpCostCenter.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpCostCenter.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpCostCenter.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpCostCenter, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpCostCenter);
foreach (EUploadEmpCostCenterDetail uploadCostCenterDetail in uploadEmpCostCenterDetailList)
{
uploadCostCenterDetail.UploadEmpCostCenterID = uploadEmpCostCenter.UploadEmpCostCenterID;
tempDetailDB.insert(dbConn, uploadCostCenterDetail);
}
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
//if (EmpID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (EffDate.Ticks == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EFFECTIVE_DATE + "=" + EffDateString, EmpNo, rowCount.ToString() });
//else if (double.TryParse(amountString, out amount))
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + amountString, EmpNo, rowCount.ToString() });
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID, bool CreateCodeIfNotExists)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpQualification uploadEmpQualification = new EUploadEmpQualification();
//EEmpQualification lastEmpQualification = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpQualification.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpQualification.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadEmpQualification.EmpQualificationFrom = Parse.toDateTimeObject(row[FIELD_FROM]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpQualification.EmpQualificationTo = Parse.toDateTimeObject(row[FIELD_TO]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpQualification.QualificationID = Parse.GetQualificationID(dbConn, row[FIELD_QUALIFICATION].ToString(), CreateCodeIfNotExists, UserID);
if (uploadEmpQualification.QualificationID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_QUALIFICATION + "=" + row[FIELD_QUALIFICATION].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpQualification.EmpQualificationInstitution = row[FIELD_INSTITUTION].ToString();
if (rawDataTable.Columns.Contains(FIELD_LEARNING_METHOD))
{
uploadEmpQualification.EmpQualificationLearningMethod = Import.Parse.toQualificationLearningMethod(row[FIELD_LEARNING_METHOD].ToString());
}
uploadEmpQualification.EmpQualificationRemark = row[FIELD_REMARK].ToString().Trim();
uploadEmpQualification.SessionID = m_SessionID;
uploadEmpQualification.TransactionDate = UploadDateTime;
// Remove the checking. Allow to more than 1 QualificationID per record.
//if (uploadEmpQualification.EmpID != 0 && !uploadEmpQualification.EmpQualificationFrom.Ticks.Equals(0))
//{
// AND andTerms = new AND();
// andTerms.add(new Match("EmpQualificationFrom", "<=", uploadEmpQualification.EmpQualificationFrom));
// andTerms.add(new Match("QualificationID", uploadEmpQualification.QualificationID));
// lastEmpQualification = (EEmpQualification)AppUtils.GetLastObj(dbConn, uploadDB, "EmpQualificationFrom", uploadEmpQualification.EmpID, andTerms);
// if (lastEmpQualification != null)
// {
// if (uploadEmpQualification.EmpQualificationInstitution == lastEmpQualification.EmpQualificationInstitution
// && uploadEmpQualification.EmpQualificationRemark == lastEmpQualification.EmpQualificationRemark
// )
// continue;
// else
// {
// // add postion terms with new ID
// if (lastEmpQualification.EmpQualificationFrom.Equals(uploadEmpQualification.EmpQualificationFrom))
// {
// uploadEmpQualification.EmpQualificationID = lastEmpQualification.EmpQualificationID;
// if (uploadEmpQualification.EmpQualificationTo.Ticks == 0)
// uploadEmpQualification.EmpQualificationTo = lastEmpQualification.EmpQualificationTo;
// }
// else
// {
// AND lastObjAndTerms = new AND();
// lastObjAndTerms.add(new Match("EmpQualificationFrom", "<=", uploadEmpQualification.EmpQualificationFrom));
// lastObjAndTerms.add(new Match("QualificationID", uploadEmpQualification.QualificationID));
// EEmpQualification lastObj = (EEmpQualification)AppUtils.GetLastObj(dbConn, uploadDB, "EmpQualificationFrom", uploadEmpQualification.EmpID, lastObjAndTerms);
// if (lastObj != null && uploadEmpQualification.EmpQualificationFrom <= lastObj.EmpQualificationFrom)
// {
// errors.addError(ImportErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadEmpQualification.EmpQualificationFrom.ToString("yyyy-MM-dd"), rowCount.ToString() });
// continue;
// }
// }
// }
// }
//}
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpQualification tmpObj = new EEmpQualification();
// tmpObj.EmpQualificationID = tmpID;
// if (EEmpQualification.db.select(dbConn, tmpObj))
// uploadEmpQualification.EmpQualificationID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpQualification.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpQualification.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpQualification.EmpQualificationID = ((EEmpQualification)objSameSynIDList[0]).EmpQualificationID;
}
}
}
}
if (uploadEmpQualification.EmpQualificationID <= 0)
{
uploadEmpQualification.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpQualification.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpQualification.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpQualification.UploadEmpID == 0)
{
if (uploadEmpQualification.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpQualification.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpQualification.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpQualification, values);
PageErrors pageErrors = new PageErrors(tempDB);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpQualification);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadLeaveApplication uploadLeaveApp = new EUploadLeaveApplication();
//ELeaveApplication lastLeaveApp = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadLeaveApp.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadLeaveApp.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
uploadLeaveApp.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadLeaveApp.UploadEmpID == 0)
{
if (uploadLeaveApp.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadLeaveApp.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadLeaveApp.EmpID, m_SessionID, UploadDateTime);
}
}
try
{
uploadLeaveApp.LeaveAppDateFrom = Parse.toDateTimeObject(row[FIELD_FROM]);
}
catch
{
uploadLeaveApp.LeaveAppDateFrom = new DateTime();
//errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadLeaveApp.LeaveAppDateFrom.Ticks.Equals(0))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadLeaveApp.LeaveAppDateTo = Parse.toDateTimeObject(row[FIELD_TO]);
}
catch
{
uploadLeaveApp.LeaveAppDateTo = new DateTime();
//errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadLeaveApp.LeaveAppDateTo.Ticks.Equals(0))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadLeaveApp.LeaveAppDateFrom > uploadLeaveApp.LeaveAppDateFrom)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
uploadLeaveApp.LeaveCodeID = Parse.GetLeaveCodeID(dbConn, row[FIELD_LEAVE_CODE].ToString(), false, UserID);
if (uploadLeaveApp.LeaveCodeID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_LEAVE_CODE + "=" + row[FIELD_LEAVE_CODE].ToString(), EmpNo, rowCount.ToString() });
}
double leaveDays;
if (double.TryParse(row[FIELD_DAY_TAKEN].ToString(), out leaveDays))
{
uploadLeaveApp.LeaveAppDays = leaveDays;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_DAY_TAKEN + "=" + row[FIELD_DAY_TAKEN].ToString(), EmpNo, rowCount.ToString() });
}
if (rawDataTable.Columns.Contains(FIELD_HOURS_CLAIM))
{
if (row[FIELD_HOURS_CLAIM] != DBNull.Value)
{
double hoursClaim;
if (double.TryParse(row[FIELD_HOURS_CLAIM].ToString(), out hoursClaim))
{
uploadLeaveApp.LeaveAppHours = hoursClaim;
}
else
{
if (!string.IsNullOrEmpty(row[FIELD_HOURS_CLAIM].ToString().Trim()))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_HOURS_CLAIM + "=" + row[FIELD_HOURS_CLAIM].ToString(), EmpNo, rowCount.ToString() });
}
}
}
else
{
uploadLeaveApp.LeaveAppHours = 0;
}
}
string tempString;
if (rawDataTable.Columns.Contains(FIELD_TYPE))
{
tempString = row[FIELD_TYPE].ToString().Replace(" ", "");
if (tempString.Equals("Days", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Day", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("D", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "D";
}
else if (tempString.Equals("Hours", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Hour", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("H", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "H";
}
else if (tempString.Equals("AM", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("A", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "A";
}
else if (tempString.Equals("PM", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("P", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "P";
}
else if (tempString.Equals(string.Empty))
{
uploadLeaveApp.LeaveAppUnit = string.Empty;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TYPE + "=" + row[FIELD_TYPE].ToString(), EmpNo, rowCount.ToString() });
}
}
else if (rawDataTable.Columns.Contains(FIELD_UNIT))
{
// Obsolate, replaced by Type
tempString = row[FIELD_UNIT].ToString().Replace(" ", "");
if (tempString.Equals("Days", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Day", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("D", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "D";
}
else if (tempString.Equals("Hours", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Hour", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("H", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "H";
}
else if (tempString.Equals("AM", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("A", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "A";
}
else if (tempString.Equals("PM", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("P", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppUnit = "P";
}
else if (tempString.Equals(string.Empty))
{
uploadLeaveApp.LeaveAppUnit = string.Empty;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_UNIT + "=" + row[FIELD_UNIT].ToString(), EmpNo, rowCount.ToString() });
}
}
uploadLeaveApp.LeaveAppRemark = row[FIELD_REMARK].ToString();
tempString = row[FIELD_NOPAYROLLPROCESS].ToString().Replace(" ", "");
if (tempString.Equals("Yes", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Y", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppNoPayProcess = true;
}
else if (tempString.Equals("No", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("N", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals(string.Empty))
{
uploadLeaveApp.LeaveAppNoPayProcess = false;
}
else if (tempString.Equals(string.Empty))
{
uploadLeaveApp.LeaveAppNoPayProcess = false;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NOPAYROLLPROCESS + "=" + row[FIELD_NOPAYROLLPROCESS].ToString(), EmpNo, rowCount.ToString() });
}
// Enforce No Payroll Process flag to true if leave code is skip payroll process
ELeaveCode leaveCode = new ELeaveCode();
leaveCode.LeaveCodeID = uploadLeaveApp.LeaveCodeID;
if (ELeaveCode.db.select(dbConn, leaveCode))
{
if (leaveCode.LeaveCodeIsSkipPayrollProcess)
{
uploadLeaveApp.LeaveAppNoPayProcess = true;
}
}
if (rawDataTable.Columns.Contains(FIELD_MEDICIAL_CERTIFICATE))
{
tempString = row[FIELD_MEDICIAL_CERTIFICATE].ToString().Replace(" ", "");
if (tempString.Equals("Yes", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Y", StringComparison.CurrentCultureIgnoreCase))
{
uploadLeaveApp.LeaveAppHasMedicalCertificate = true;
}
else if (tempString.Equals("No", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("N", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals(string.Empty))
{
uploadLeaveApp.LeaveAppHasMedicalCertificate = false;
}
else if (tempString.Equals(string.Empty))
{
uploadLeaveApp.LeaveAppHasMedicalCertificate = false;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NOPAYROLLPROCESS + "=" + row[FIELD_NOPAYROLLPROCESS].ToString(), EmpNo, rowCount.ToString() });
}
}
uploadLeaveApp.SessionID = m_SessionID;
uploadLeaveApp.TransactionDate = UploadDateTime;
if (errors.List.Count <= 0 && uploadLeaveApp.EmpID != 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// ELeaveApplication tmpObj = new ELeaveApplication();
// tmpObj.LeaveAppID = tmpID;
// if (ELeaveApplication.db.select(dbConn, tmpObj))
// uploadLeaveApp.LeaveAppID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadLeaveApp.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = ELeaveApplication.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadLeaveApp.LeaveAppID = ((ELeaveApplication)objSameSynIDList[0]).LeaveAppID;
}
}
}
}
if (uploadLeaveApp.LeaveAppID == 0)
{
AND lastObjAndTerms = new AND();
lastObjAndTerms.add(new Match("LeaveAppDateTo", ">=", uploadLeaveApp.LeaveAppDateFrom));
lastObjAndTerms.add(new Match("LeaveAppDateFrom", "<=", uploadLeaveApp.LeaveAppDateTo));
if (!uploadLeaveApp.LeaveAppUnit.Equals("D"))
{
lastObjAndTerms.add(new Match("LeaveAppUnit", "D"));
}
ELeaveApplication lastObj = (ELeaveApplication)AppUtils.GetLastObj(dbConn, uploadDB, "LeaveAppDateFrom", uploadLeaveApp.EmpID, lastObjAndTerms);
if (lastObj != null)
{
errors.addError(ImportErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadLeaveApp.LeaveAppDateFrom.ToString("yyyy-MM-dd"), rowCount.ToString() });
continue;
}
//lastLeaveApp = (ELeaveApplication)AppUtils.GetLastObj(dbConn, uploadDB, "LeaveAppDateFrom", uploadLeaveApp.EmpID, new Match("LeaveAppDateFrom", "<=", uploadLeaveApp.LeaveAppDateFrom));
//if (lastLeaveApp != null)
//{
// //if (uploadLeaveApp.LeaveCodeID == lastLeaveApp.LeaveCodeID
// // && uploadLeaveApp.LeaveAppRemark == lastLeaveApp.LeaveAppRemark
// // )
// //{
// // continue;
// //}
// //else
// {
// //// add postion terms with new ID
// //if (lastLeaveApp.LeaveAppDateFrom.Equals(uploadLeaveApp.LeaveAppDateFrom) && lastLeaveApp.LeaveAppUnit.Equals(uploadLeaveApp.LeaveAppUnit) && uploadLeaveApp.LeaveAppUnit.Equals("D"))
// //{
// // if (lastLeaveApp.EmpPayrollID > 0)
// // {
// // errors.addError(ImportErrorMessage.ERROR_LEAVE_DATE_PROCESSED, new string[] { uploadLeaveApp.LeaveAppDateFrom.ToString("yyyy-MM-dd"), rowCount.ToString() });
// // continue;
// // }
// // uploadLeaveApp.LeaveAppID = lastLeaveApp.LeaveAppID;
// //}
// //else
// {
// AND lastObjAndTerms = new AND();
// lastObjAndTerms.add(new Match("LeaveAppDateTo", ">=", uploadLeaveApp.LeaveAppDateFrom));
// lastObjAndTerms.add(new Match("LeaveAppDateFrom", "<=", uploadLeaveApp.LeaveAppDateTo));
// if (!uploadLeaveApp.LeaveAppUnit.Equals("D"))
// lastObjAndTerms.add(new Match("LeaveAppUnit", "D"));
// ELeaveApplication lastObj = (ELeaveApplication)AppUtils.GetLastObj(dbConn, uploadDB, "LeaveAppDateFrom", uploadLeaveApp.EmpID, lastObjAndTerms);
// if (lastObj != null)
// {
// errors.addError(ImportErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadLeaveApp.LeaveAppDateFrom.ToString("yyyy-MM-dd"), rowCount.ToString() });
// continue;
// }
// }
// }
//}
}
}
if (uploadLeaveApp.LeaveAppID <= 0)
{
uploadLeaveApp.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadLeaveApp.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
Hashtable values = new Hashtable();
tempDB.populate(uploadLeaveApp, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadLeaveApp);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpWorkExp uploadEmpWorkExp = new EUploadEmpWorkExp();
//EEmpWorkExp lastEmpWorkExp = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpWorkExp.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpWorkExp.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
string tempString = row[FIELD_FROM_YEAR].ToString();
if (!string.IsNullOrEmpty(tempString))
{
int tmpInteger = 0;
if (int.TryParse(tempString, out tmpInteger))
{
uploadEmpWorkExp.EmpWorkExpFromYear = tmpInteger;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM_YEAR + "=" + tempString, EmpNo, rowCount.ToString() });
}
}
else
{
uploadEmpWorkExp.EmpWorkExpFromYear = 0;
}
tempString = row[FIELD_FROM_MONTH].ToString();
if (!string.IsNullOrEmpty(tempString))
{
int tmpInteger = 0;
if (int.TryParse(tempString, out tmpInteger))
{
uploadEmpWorkExp.EmpWorkExpFromMonth = tmpInteger;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM_MONTH + "=" + tempString, EmpNo, rowCount.ToString() });
}
}
else
{
uploadEmpWorkExp.EmpWorkExpFromMonth = 0;
}
tempString = row[FIELD_TO_YEAR].ToString();
if (!string.IsNullOrEmpty(tempString))
{
int tmpInteger = 0;
if (int.TryParse(tempString, out tmpInteger))
{
uploadEmpWorkExp.EmpWorkExpToYear = tmpInteger;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO_YEAR + "=" + tempString, EmpNo, rowCount.ToString() });
}
}
else
{
uploadEmpWorkExp.EmpWorkExpToYear = 0;
}
tempString = row[FIELD_TO_MONTH].ToString();
if (!string.IsNullOrEmpty(tempString))
{
int tmpInteger = 0;
if (int.TryParse(tempString, out tmpInteger))
{
uploadEmpWorkExp.EmpWorkExpToMonth = tmpInteger;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO_MONTH + "=" + tempString, EmpNo, rowCount.ToString() });
}
}
else
{
uploadEmpWorkExp.EmpWorkExpToMonth = 0;
}
uploadEmpWorkExp.EmpWorkExpCompanyName = row[FIELD_COMPANY].ToString();
uploadEmpWorkExp.EmpWorkExpPosition = row[FIELD_POSITION].ToString();
uploadEmpWorkExp.EmpWorkExpRemark = row[FIELD_REMARK].ToString();
if (rawDataTable.Columns.Contains(FIELD_EMPLOYMENT_TYPE))
{
uploadEmpWorkExp.EmpWorkExpEmploymentTypeID = Import.Parse.GetEmploymentTypeID(dbConn, row[FIELD_EMPLOYMENT_TYPE].ToString(), false, UserID);
}
if (rawDataTable.Columns.Contains(FIELD_IS_RELEVANT_EXPERIENCE))
{
uploadEmpWorkExp.EmpWorkExpIsRelevantExperience = Import.Parse.toBoolean(row[FIELD_IS_RELEVANT_EXPERIENCE].ToString());
}
uploadEmpWorkExp.SessionID = m_SessionID;
uploadEmpWorkExp.TransactionDate = UploadDateTime;
if (uploadEmpWorkExp.EmpID != 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpWorkExp tmpObj = new EEmpWorkExp();
// tmpObj.EmpWorkExpID = tmpID;
// if (EEmpWorkExp.db.select(dbConn, tmpObj))
// uploadEmpWorkExp.EmpWorkExpID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpWorkExp.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpWorkExp.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpWorkExp.EmpWorkExpID = ((EEmpWorkExp)objSameSynIDList[0]).EmpWorkExpID;
}
}
}
}
if (uploadEmpWorkExp.EmpWorkExpID == 0)
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", uploadEmpWorkExp.EmpID));
ArrayList list = uploadDB.select(dbConn, filter);
bool IsSameEntryExists = false;
foreach (EEmpWorkExp currentEmpWorkExp in list)
{
if (uploadEmpWorkExp.EmpWorkExpFromYear == currentEmpWorkExp.EmpWorkExpFromYear &&
uploadEmpWorkExp.EmpWorkExpFromMonth == currentEmpWorkExp.EmpWorkExpFromMonth &&
uploadEmpWorkExp.EmpWorkExpToYear == currentEmpWorkExp.EmpWorkExpToYear &&
uploadEmpWorkExp.EmpWorkExpToMonth == currentEmpWorkExp.EmpWorkExpToMonth &&
uploadEmpWorkExp.EmpWorkExpCompanyName == currentEmpWorkExp.EmpWorkExpCompanyName &&
uploadEmpWorkExp.EmpWorkExpPosition == currentEmpWorkExp.EmpWorkExpPosition &&
uploadEmpWorkExp.EmpWorkExpEmploymentTypeID == currentEmpWorkExp.EmpWorkExpEmploymentTypeID &&
uploadEmpWorkExp.EmpWorkExpIsRelevantExperience == currentEmpWorkExp.EmpWorkExpIsRelevantExperience &&
uploadEmpWorkExp.EmpWorkExpRemark == currentEmpWorkExp.EmpWorkExpRemark
)
{
IsSameEntryExists = true;
}
//if (!string.IsNullOrEmpty(uploadEmpWorkExp.EmpWorkExpName) && !string.IsNullOrEmpty(currentEmpWorkExp.EmpWorkExpName))
// if (currentEmpWorkExp.EmpWorkExpName.Equals(uploadEmpWorkExp.EmpWorkExpName, StringComparison.CurrentCultureIgnoreCase))
// {
// uploadEmpWorkExp.EmpWorkExpID = currentEmpWorkExp.EmpWorkExpID;
// IsSameEntryExists = false;
// break;
// }
}
if (IsSameEntryExists)
{
continue;
}
}
}
if (uploadEmpWorkExp.EmpWorkExpID <= 0)
{
uploadEmpWorkExp.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpWorkExp.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpWorkExp.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpWorkExp.UploadEmpID == 0)
{
if (uploadEmpWorkExp.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpWorkExp.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpWorkExp.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpWorkExp, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpWorkExp);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID, bool CreateCodeIfNotExists)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpTermination uploadEmpTermination = new EUploadEmpTermination();
EEmpTermination lastEmpTermination = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpTermination.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpTermination.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
uploadEmpTermination.CessationReasonID = Parse.GetCessationReasonID(dbConn, row[FIELD_CESSATION_REASON].ToString(), CreateCodeIfNotExists, UserID);
if (uploadEmpTermination.CessationReasonID <= 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CESSATION_REASON + "=" + row[FIELD_CESSATION_REASON].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpTermination.EmpTermResignDate = Parse.toDateTimeObject(row[FIELD_RESIGN_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_RESIGN_DATE + "=" + row[FIELD_RESIGN_DATE].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadEmpTermination.EmpTermResignDate.Ticks.Equals(0))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_RESIGN_DATE + "=" + row[FIELD_RESIGN_DATE].ToString(), EmpNo, rowCount.ToString() });
}
string tempString;
tempString = row[FIELD_NOTICE_PERIOD_UNIT].ToString().Replace(" ", "");
if (tempString.Equals("Days", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Day", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("D", StringComparison.CurrentCultureIgnoreCase))
{
uploadEmpTermination.EmpTermNoticeUnit = "D";
}
else if (tempString.Equals("Months", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("Month", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("M", StringComparison.CurrentCultureIgnoreCase))
{
uploadEmpTermination.EmpTermNoticeUnit = "M";
}
else if (tempString.Equals(string.Empty))
{
uploadEmpTermination.EmpTermNoticeUnit = string.Empty;
}
else
{
uploadEmpTermination.EmpTermNoticeUnit = string.Empty;
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NOTICE_PERIOD_UNIT + "=" + row[FIELD_NOTICE_PERIOD_UNIT].ToString(), EmpNo, rowCount.ToString() });
}
int period = 0;
if (int.TryParse(row[FIELD_NOTICE_PERIOD].ToString(), out period))
{
uploadEmpTermination.EmpTermNoticePeriod = period;
}
else
if (uploadEmpTermination.EmpTermNoticeUnit.Equals(string.Empty))
{
if (uploadEmpTermination.EmpID > 0)
{
// Get Notice Period from EmpInfo
EEmpPersonalInfo empinfo = new EEmpPersonalInfo();
empinfo.EmpID = uploadEmpTermination.EmpID;
EEmpPersonalInfo.db.select(dbConn, empinfo);
if (!empinfo.EmpNoticeUnit.Equals(string.Empty))
{
uploadEmpTermination.EmpTermNoticeUnit = empinfo.EmpNoticeUnit;
uploadEmpTermination.EmpTermNoticePeriod = empinfo.EmpNoticePeriod;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NOTICE_PERIOD + "='" + row[FIELD_NOTICE_PERIOD].ToString() + "'", EmpNo, rowCount.ToString() });
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NOTICE_PERIOD_UNIT + "='" + row[FIELD_NOTICE_PERIOD_UNIT].ToString() + "'", EmpNo, rowCount.ToString() });
}
}
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NOTICE_PERIOD + "='" + row[FIELD_NOTICE_PERIOD].ToString() + "'", EmpNo, rowCount.ToString() });
}
try
{
uploadEmpTermination.EmpTermLastDate = Parse.toDateTimeObject(row[FIELD_LAST_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_LAST_DATE + "=" + row[FIELD_LAST_DATE].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadEmpTermination.EmpTermLastDate.Ticks == 0)
{
if (uploadEmpTermination.EmpTermNoticeUnit.Equals("M"))
{
uploadEmpTermination.EmpTermLastDate = uploadEmpTermination.EmpTermResignDate.AddMonths(uploadEmpTermination.EmpTermNoticePeriod).AddDays(-1);
}
else if (uploadEmpTermination.EmpTermNoticeUnit.Equals("D"))
{
uploadEmpTermination.EmpTermLastDate = uploadEmpTermination.EmpTermResignDate.AddDays(uploadEmpTermination.EmpTermNoticePeriod).AddDays(-1);
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_LAST_DATE + "='" + row[FIELD_LAST_DATE].ToString() + "'", EmpNo, rowCount.ToString() });
}
}
if (rawDataTable.Columns.Contains(FIELD_NEW_EMP_NO))
{
if (!string.IsNullOrEmpty(row[FIELD_NEW_EMP_NO].ToString()))
{
// Use UserID = 0 to allow searching all EmpID
int newEmpID = Parse.GetEmpID(dbConn, row[FIELD_NEW_EMP_NO].ToString().Trim(), 0);
if (newEmpID > 0)
{
if (newEmpID != uploadEmpTermination.EmpID)
{
uploadEmpTermination.EmpTermIsTransferCompany = true;
uploadEmpTermination.NewEmpID = newEmpID;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NEW_EMP_NO + "='" + row[FIELD_NEW_EMP_NO].ToString() + "'", EmpNo, rowCount.ToString() });
}
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NEW_EMP_NO + "='" + row[FIELD_NEW_EMP_NO].ToString() + "'", EmpNo, rowCount.ToString() });
}
}
}
uploadEmpTermination.EmpTermRemark = row[FIELD_REMARK].ToString();
uploadEmpTermination.SessionID = m_SessionID;
uploadEmpTermination.TransactionDate = UploadDateTime;
if (uploadEmpTermination.EmpID != 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpTermination tmpObj = new EEmpTermination();
// tmpObj.EmpTermID = tmpID;
// if (EEmpTermination.db.select(dbConn, tmpObj))
// uploadEmpTermination.EmpTermID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpTermination.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpTermination.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpTermination.EmpTermID = ((EEmpTermination)objSameSynIDList[0]).EmpTermID;
}
}
}
}
if (uploadEmpTermination.EmpTermID == 0)
{
lastEmpTermination = (EEmpTermination)AppUtils.GetLastObj(dbConn, uploadDB, "EmpTermID", uploadEmpTermination.EmpID);
if (lastEmpTermination != null)
{
if (uploadEmpTermination.CessationReasonID == lastEmpTermination.CessationReasonID &&
uploadEmpTermination.EmpTermResignDate == lastEmpTermination.EmpTermResignDate &&
uploadEmpTermination.EmpTermNoticeUnit == lastEmpTermination.EmpTermNoticeUnit &&
uploadEmpTermination.EmpTermNoticePeriod == lastEmpTermination.EmpTermNoticePeriod &&
uploadEmpTermination.EmpTermLastDate == lastEmpTermination.EmpTermLastDate &&
uploadEmpTermination.EmpTermRemark == lastEmpTermination.EmpTermRemark &&
uploadEmpTermination.NewEmpID == lastEmpTermination.NewEmpID
)
{
continue;
}
else
{
uploadEmpTermination.EmpTermID = lastEmpTermination.EmpTermID;
}
}
}
}
if (uploadEmpTermination.EmpTermID <= 0)
{
uploadEmpTermination.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpTermination.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpTermination.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpTermination.UploadEmpID == 0)
{
if (uploadEmpTermination.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpTermination.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpTermination.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpTermination, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpTermination);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + " on line " + rowCount);
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID, bool CreateCodeIfNotExists)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpSkill uploadEmpSkill = new EUploadEmpSkill();
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpSkill.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpSkill.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
uploadEmpSkill.SkillID = Parse.GetSkillID(dbConn, row[FIELD_SKILL].ToString(), CreateCodeIfNotExists, UserID);
uploadEmpSkill.SkillLevelID = Parse.GetSkillLevelID(dbConn, row[FIELD_SKILL_LEVEL].ToString(), CreateCodeIfNotExists, UserID);
if (uploadEmpSkill.SkillLevelID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_SKILL_LEVEL + "=" + row[FIELD_SKILL_LEVEL].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpSkill.SessionID = m_SessionID;
uploadEmpSkill.TransactionDate = UploadDateTime;
if (uploadEmpSkill.EmpID != 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpSkill tmpObj = new EEmpSkill();
// tmpObj.EmpSkillID = tmpID;
// if (EEmpSkill.db.select(dbConn, tmpObj))
// uploadEmpSkill.EmpSkillID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpSkill.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpSkill.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpSkill.EmpSkillID = ((EEmpSkill)objSameSynIDList[0]).EmpSkillID;
}
}
}
}
if (uploadEmpSkill.EmpSkillID == 0)
{
AND andTerms = new AND();
andTerms.add(new Match("SkillID", uploadEmpSkill.SkillID));
EEmpSkill lastEmpSkill = (EEmpSkill)AppUtils.GetLastObj(dbConn, uploadDB, "EmpSkillID", uploadEmpSkill.EmpID, andTerms);
if (lastEmpSkill != null)
{
if (uploadEmpSkill.SkillLevelID == lastEmpSkill.SkillLevelID)
{
continue;
}
else
{
uploadEmpSkill.EmpSkillID = lastEmpSkill.EmpSkillID;
}
}
}
}
if (uploadEmpSkill.EmpSkillID <= 0)
{
uploadEmpSkill.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpSkill.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpSkill.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpSkill.UploadEmpID == 0)
{
if (uploadEmpSkill.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpSkill.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpSkill.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpSkill, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpSkill);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID, bool CreateCodeIfNotExists)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpPermit uploadEmpPermit = new EUploadEmpPermit();
//EEmpPermit lastEmpPermit = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpPermit.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpPermit.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
uploadEmpPermit.PermitTypeID = Parse.GetPermitID(dbConn, row[FIELD_PERMIT_TYPE].ToString(), CreateCodeIfNotExists, UserID);
uploadEmpPermit.EmpPermitNo = row[FIELD_PERMIT_NO].ToString();
try
{
uploadEmpPermit.EmpPermitIssueDate = Import.Parse.toDateTimeObject(row[FIELD_ISSUE_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ISSUE_DATE + "=" + row[FIELD_ISSUE_DATE].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpPermit.EmpPermitExpiryDate = Import.Parse.toDateTimeObject(row[FIELD_EXPIRY_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EXPIRY_DATE + "=" + row[FIELD_EXPIRY_DATE].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpPermit.EmpPermitRemark = row[FIELD_REMARK].ToString();
uploadEmpPermit.SessionID = m_SessionID;
uploadEmpPermit.TransactionDate = UploadDateTime;
if (uploadEmpPermit.EmpID != 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpPermit tmpObj = new EEmpPermit();
// tmpObj.EmpPermitID = tmpID;
// if (EEmpPermit.db.select(dbConn, tmpObj))
// uploadEmpPermit.EmpPermitID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpPermit.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpPermit.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpPermit.EmpPermitID = ((EEmpPermit)objSameSynIDList[0]).EmpPermitID;
}
}
}
}
if (uploadEmpPermit.EmpPermitID == 0)
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", uploadEmpPermit.EmpID));
ArrayList list = uploadDB.select(dbConn, filter);
bool IsSameEntryExists = false;
foreach (EEmpPermit currentEmpPermit in list)
{
if (uploadEmpPermit.PermitTypeID == currentEmpPermit.PermitTypeID &&
uploadEmpPermit.EmpPermitNo == currentEmpPermit.EmpPermitNo &&
uploadEmpPermit.EmpPermitIssueDate == currentEmpPermit.EmpPermitIssueDate &&
uploadEmpPermit.EmpPermitExpiryDate == currentEmpPermit.EmpPermitExpiryDate &&
uploadEmpPermit.EmpPermitRemark == currentEmpPermit.EmpPermitRemark
)
{
IsSameEntryExists = true;
break;
}
}
if (IsSameEntryExists)
{
continue;
}
}
}
if (uploadEmpPermit.EmpPermitID <= 0)
{
uploadEmpPermit.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpPermit.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpPermit.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpPermit.UploadEmpID == 0)
{
if (uploadEmpPermit.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpPermit.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpPermit.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpPermit, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpPermit);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpWorkInjuryRecord uploadEmpWorkInjuryRecord = new EUploadEmpWorkInjuryRecord();
//EEmpWorkInjuryRecord lastEmpWorkInjuryRecord = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpWorkInjuryRecord.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpWorkInjuryRecord.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentDate = Import.Parse.toDateTimeObject(row[FIELD_ACCIDENT_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ACCIDENT_DATE + "=" + row[FIELD_ACCIDENT_DATE].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentLocation = row[FIELD_ACCIDENT_LOCATION].ToString();
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentReason = row[FIELD_ACCIDENT_REASON].ToString();
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordInjuryNature = row[FIELD_INJURY_NATURE].ToString();
try
{
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordReportedDate = Import.Parse.toDateTimeObject(row[FIELD_REPORT_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_REPORT_DATE + "=" + row[FIELD_REPORT_DATE].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordChequeReceivedDate = Import.Parse.toDateTimeObject(row[FIELD_CHEQUE_RECEIVED_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CHEQUE_RECEIVED_DATE + "=" + row[FIELD_CHEQUE_RECEIVED_DATE].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordSettleDate = Import.Parse.toDateTimeObject(row[FIELD_SETTLE_DATE]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CHEQUE_RECEIVED_DATE + "=" + row[FIELD_CHEQUE_RECEIVED_DATE].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordRemark = row[FIELD_REMARK].ToString();
uploadEmpWorkInjuryRecord.SessionID = m_SessionID;
uploadEmpWorkInjuryRecord.TransactionDate = UploadDateTime;
if (uploadEmpWorkInjuryRecord.EmpID != 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpWorkInjuryRecord tmpObj = new EEmpWorkInjuryRecord();
// tmpObj.EmpWorkInjuryRecordID = tmpID;
// if (EEmpWorkInjuryRecord.db.select(dbConn, tmpObj))
// uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpWorkInjuryRecord.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpWorkInjuryRecord.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordID = ((EEmpWorkInjuryRecord)objSameSynIDList[0]).EmpWorkInjuryRecordID;
}
}
}
}
if (uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordID == 0)
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", uploadEmpWorkInjuryRecord.EmpID));
ArrayList list = uploadDB.select(dbConn, filter);
bool IsSameEntryExists = false;
foreach (EEmpWorkInjuryRecord currentEmpWorkInjuryRecord in list)
{
if (uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentDate == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentDate &&
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentLocation == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentLocation &&
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentReason == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordAccidentReason &&
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordInjuryNature == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordInjuryNature &&
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordReportedDate == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordReportedDate &&
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordChequeReceivedDate == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordChequeReceivedDate &&
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordSettleDate == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordSettleDate &&
uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordRemark == currentEmpWorkInjuryRecord.EmpWorkInjuryRecordRemark
)
{
IsSameEntryExists = true;
break;
}
}
if (IsSameEntryExists)
{
continue;
}
}
}
if (uploadEmpWorkInjuryRecord.EmpWorkInjuryRecordID <= 0)
{
uploadEmpWorkInjuryRecord.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpWorkInjuryRecord.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpWorkInjuryRecord.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpWorkInjuryRecord.UploadEmpID == 0)
{
if (uploadEmpWorkInjuryRecord.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpWorkInjuryRecord.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpWorkInjuryRecord.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpWorkInjuryRecord, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpWorkInjuryRecord);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadCompensationLeaveEntitle uploadCompensationLeaveEntitle = new EUploadCompensationLeaveEntitle();
//EEmpAVCPlan lastEmpAVC = null;
//ArrayList uploadHierarchyList = new ArrayList();
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadCompensationLeaveEntitle.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadCompensationLeaveEntitle.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleEffectiveDate = Parse.toDateTimeObject(row[FIELD_EFFECTIVE_DATE]);
}
catch (Exception)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EFFECTIVE_DATE + "=" + row[FIELD_EFFECTIVE_DATE].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleClaimPeriodFrom = Parse.toDateTimeObject(row[FIELD_CLAIM_PERIOD_FROM]);
}
catch (Exception)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CLAIM_PERIOD_FROM + "=" + row[FIELD_CLAIM_PERIOD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleClaimPeriodTo = Parse.toDateTimeObject(row[FIELD_CLAIM_PERIOD_TO]);
}
catch (Exception)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CLAIM_PERIOD_TO + "=" + row[FIELD_CLAIM_PERIOD_TO].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleClaimHourFrom = Parse.toDateTimeObject(row[FIELD_CLAIM_TIME_FROM]);
}
catch (Exception)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CLAIM_TIME_FROM + "=" + row[FIELD_CLAIM_TIME_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleClaimHourTo = Parse.toDateTimeObject(row[FIELD_CLAIM_TIME_TO]);
}
catch (Exception)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_CLAIM_TIME_TO + "=" + row[FIELD_CLAIM_TIME_TO].ToString(), EmpNo, rowCount.ToString() });
}
double adjustValue;
if (double.TryParse(row[FIELD_HOUR_CLAIM].ToString(), out adjustValue))
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleHoursClaim = adjustValue;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_HOUR_CLAIM + "=" + row[FIELD_HOUR_CLAIM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleDateExpiry = Parse.toDateTimeObject(row[FIELD_EXPIRY_DATE]);
}
catch (Exception)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EXPIRY_DATE + "=" + row[FIELD_EXPIRY_DATE].ToString(), EmpNo, rowCount.ToString() });
}
uploadCompensationLeaveEntitle.CompensationLeaveEntitleApprovedBy = row[FIELD_APPROVED_BY].ToString();
uploadCompensationLeaveEntitle.CompensationLeaveEntitleRemark = row[FIELD_REMARK].ToString();
uploadCompensationLeaveEntitle.SessionID = m_SessionID;
uploadCompensationLeaveEntitle.TransactionDate = UploadDateTime;
if (uploadCompensationLeaveEntitle.EmpID != 0 && errors.List.Count <= 0)
{
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadCompensationLeaveEntitle.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = ELeaveApplication.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleID = ((ECompensationLeaveEntitle)objSameSynIDList[0]).CompensationLeaveEntitleID;
}
}
}
}
if (uploadCompensationLeaveEntitle.CompensationLeaveEntitleID == 0)
{
AND andTerm = new AND();
andTerm.add(new Match("CompensationLeaveEntitleEffectiveDate", "=", uploadCompensationLeaveEntitle.CompensationLeaveEntitleEffectiveDate));
ECompensationLeaveEntitle lastObject = (ECompensationLeaveEntitle)AppUtils.GetLastObj(dbConn, uploadDB, "CompensationLeaveEntitleEffectiveDate", uploadCompensationLeaveEntitle.EmpID, andTerm);
if (lastObject != null)
{
uploadCompensationLeaveEntitle.CompensationLeaveEntitleID = lastObject.CompensationLeaveEntitleID;
}
}
}
if (uploadCompensationLeaveEntitle.CompensationLeaveEntitleID <= 0)
{
uploadCompensationLeaveEntitle.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadCompensationLeaveEntitle.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadCompensationLeaveEntitle.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadCompensationLeaveEntitle.UploadEmpID == 0)
{
if (uploadCompensationLeaveEntitle.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadCompensationLeaveEntitle.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadCompensationLeaveEntitle.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadCompensationLeaveEntitle, values);
PageErrors pageErrors = new PageErrors(tempDB);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadCompensationLeaveEntitle);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
//if (EmpID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (EffDate.Ticks == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EFFECTIVE_DATE + "=" + EffDateString, EmpNo, rowCount.ToString() });
//else if (double.TryParse(amountString, out amount))
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + amountString, EmpNo, rowCount.ToString() });
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpDependant uploadEmpDependant = new EUploadEmpDependant();
//EEmpDependant lastEmpDependant = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpDependant.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpDependant.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
uploadEmpDependant.EmpDependantSurname = row[FIELD_SURNAME].ToString();
uploadEmpDependant.EmpDependantOtherName = row[FIELD_OTHER_NAME].ToString();
uploadEmpDependant.EmpDependantChineseName = row[FIELD_CHINESE_NAME].ToString();
try
{
// support old version template
if (rawDataTable.Columns.Contains(FIELD_DATE_OF_BIRTH))
{
uploadEmpDependant.EmpDependantDateOfBirth = Import.Parse.toDateTimeObject(row[FIELD_DATE_OF_BIRTH]);
}
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_DATE_OF_BIRTH + "=" + row[FIELD_DATE_OF_BIRTH].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpDependant.EmpDependantHKID = row[FIELD_HKID].ToString().Trim();
string tempString = row[FIELD_GENDER].ToString();
if (!String.IsNullOrEmpty(tempString))
{
if (tempString.Equals("Male", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("M", StringComparison.CurrentCultureIgnoreCase))
{
uploadEmpDependant.EmpDependantGender = "M";
}
else if (tempString.Equals("Female", StringComparison.CurrentCultureIgnoreCase) ||
tempString.Equals("F", StringComparison.CurrentCultureIgnoreCase))
{
uploadEmpDependant.EmpDependantGender = "F";
}
else
{
uploadEmpDependant.EmpDependantGender = string.Empty;
}
}
//else
// errors.addError(ImportErrorMessage.ERROR_INVALID_GENDER, new string[] { tempString, rowCount.ToString() });
uploadEmpDependant.EmpDependantRelationship = row[FIELD_RELATIONSHIP].ToString();
//Start 0000190, Miranda, 2015-05-18
uploadEmpDependant.EmpDependantMedicalSchemeInsured = Parse.toBoolean(row[FIELD_MEDICAL_SCHEME_INSURED].ToString());
DateTime m_EffectiveDate = new DateTime();
DateTime m_ExpiryDate = new DateTime();
try
{
if (rawDataTable.Columns.Contains(FIELD_MEDICAL_EFFECTIVE_DATE))
{
m_EffectiveDate = Import.Parse.toDateTimeObject(row[FIELD_MEDICAL_EFFECTIVE_DATE]);
}
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_MEDICAL_EFFECTIVE_DATE + "=" + row[FIELD_MEDICAL_EFFECTIVE_DATE].ToString(), EmpNo, rowCount.ToString() });
}
try
{
if (rawDataTable.Columns.Contains(FIELD_EXPIRY_DATE))
{
m_ExpiryDate = Import.Parse.toDateTimeObject(row[FIELD_EXPIRY_DATE]);
}
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EXPIRY_DATE + "=" + row[FIELD_EXPIRY_DATE].ToString(), EmpNo, rowCount.ToString() });
}
if (uploadEmpDependant.EmpDependantMedicalSchemeInsured)
{
if (m_EffectiveDate.Ticks == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_MEDICAL_EFFECTIVE_DATE + "=" + row[FIELD_MEDICAL_EFFECTIVE_DATE].ToString(), EmpNo, rowCount.ToString() });
}
// Start 0000190, Miranda, 2015-06-18
//if (m_ExpiryDate.Ticks == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EXPIRY_DATE + "=" + row[FIELD_EXPIRY_DATE].ToString(), EmpNo, rowCount.ToString() });
// End 0000190, Miranda, 2015-06-18
}
else
{
if (m_EffectiveDate.Ticks > 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_MEDICAL_EFFECTIVE_DATE + "=" + row[FIELD_MEDICAL_EFFECTIVE_DATE].ToString(), EmpNo, rowCount.ToString() });
}
if (m_ExpiryDate.Ticks > 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EXPIRY_DATE + "=" + row[FIELD_EXPIRY_DATE].ToString(), EmpNo, rowCount.ToString() });
}
}
uploadEmpDependant.EmpDependantMedicalEffectiveDate = m_EffectiveDate;
uploadEmpDependant.EmpDependantExpiryDate = m_ExpiryDate;
//End 0000190, Miranda, 2015-05-18
uploadEmpDependant.EmpDependantPassportNo = row[FIELD_PASSPORT_NUMBER].ToString();
uploadEmpDependant.EmpDependantPassportIssuedCountry = row[FIELD_PASSPORT_ISSUE_COUNTRY].ToString();
//if (rawDataTable.Columns.Contains(FIELD_SYNID))
//{
// uploadEmpDependant.SynID = row[FIELD_SYNID].ToString();
//}
uploadEmpDependant.SessionID = m_SessionID;
uploadEmpDependant.TransactionDate = UploadDateTime;
if (uploadEmpDependant.EmpID != 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpDependant tmpObj = new EEmpDependant();
// tmpObj.EmpDependantID = tmpID;
// if (EEmpDependant.db.select(dbConn, tmpObj))
// uploadEmpDependant.EmpDependantID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpDependant.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpDependant.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpDependant.EmpDependantID = ((EEmpDependant)objSameSynIDList[0]).EmpDependantID;
}
}
}
}
if (uploadEmpDependant.EmpDependantID == 0)
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", uploadEmpDependant.EmpID));
ArrayList list = uploadDB.select(dbConn, filter);
bool IsSameEntryExists = false;
foreach (EEmpDependant currentEmpDependant in list)
{
if (uploadEmpDependant.EmpDependantHKID == currentEmpDependant.EmpDependantHKID &&
uploadEmpDependant.EmpDependantSurname == currentEmpDependant.EmpDependantSurname &&
uploadEmpDependant.EmpDependantOtherName == currentEmpDependant.EmpDependantOtherName &&
uploadEmpDependant.EmpDependantChineseName == currentEmpDependant.EmpDependantChineseName &&
uploadEmpDependant.EmpDependantRelationship == currentEmpDependant.EmpDependantRelationship &&
uploadEmpDependant.EmpDependantPassportNo == currentEmpDependant.EmpDependantPassportNo &&
uploadEmpDependant.EmpDependantPassportIssuedCountry == currentEmpDependant.EmpDependantPassportIssuedCountry &&
uploadEmpDependant.EmpDependantDateOfBirth == currentEmpDependant.EmpDependantDateOfBirth
//Start 0000190, Miranda, 2015-05-18
&& uploadEmpDependant.EmpDependantMedicalSchemeInsured == currentEmpDependant.EmpDependantMedicalSchemeInsured &&
uploadEmpDependant.EmpDependantMedicalEffectiveDate == currentEmpDependant.EmpDependantMedicalEffectiveDate &&
uploadEmpDependant.EmpDependantExpiryDate == currentEmpDependant.EmpDependantExpiryDate
//End 0000190, Miranda, 2015-05-18
)
{
IsSameEntryExists = true;
}
//if (!string.IsNullOrEmpty(uploadEmpDependant.SynID) && !string.IsNullOrEmpty(currentEmpDependant.SynID))
// if (currentEmpDependant.SynID.Equals(uploadEmpDependant.SynID, StringComparison.CurrentCultureIgnoreCase))
// {
// uploadEmpDependant.EmpDependantID = currentEmpDependant.EmpDependantID;
// IsSameEntryExists = false;
// break;
// }
}
if (IsSameEntryExists)
{
continue;
}
}
}
if (uploadEmpDependant.EmpDependantID <= 0)
{
uploadEmpDependant.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpDependant.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpDependant.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpDependant.UploadEmpID == 0)
{
if (uploadEmpDependant.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpDependant.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpDependant.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpDependant, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpDependant);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpRosterTableGroup uploadEmpRosterTableGroup = new EUploadEmpRosterTableGroup();
EEmpRosterTableGroup lastEmpRosterTableGroup = null;
ArrayList uploadHierarchyList = new ArrayList();
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpRosterTableGroup.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpRosterTableGroup.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadEmpRosterTableGroup.EmpRosterTableGroupEffFr = Parse.toDateTimeObject(row[FIELD_FROM]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpRosterTableGroup.EmpRosterTableGroupEffTo = Parse.toDateTimeObject(row[FIELD_TO]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpRosterTableGroup.RosterTableGroupID = Parse.GetRosterTableGroupID(dbConn, row[FIELD_ROSTERTABLEGROUP].ToString());
uploadEmpRosterTableGroup.EmpRosterTableGroupIsSupervisor = row[FIELD_ROSTERTABLEGROUP_IS_SUPERVISOR].ToString().Equals("Yes", StringComparison.CurrentCultureIgnoreCase) || row[FIELD_ROSTERTABLEGROUP_IS_SUPERVISOR].ToString().Equals("Y", StringComparison.CurrentCultureIgnoreCase);
if (uploadEmpRosterTableGroup.RosterTableGroupID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_ROSTERTABLEGROUP + "=" + row[FIELD_ROSTERTABLEGROUP].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpRosterTableGroup.SessionID = m_SessionID;
uploadEmpRosterTableGroup.TransactionDate = UploadDateTime;
if (uploadEmpRosterTableGroup.EmpID != 0 && errors.List.Count <= 0)
{
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpRosterTableGroup tmpObj = new EEmpRosterTableGroup();
// tmpObj.EmpRosterTableGroupID = tmpID;
// if (EEmpRosterTableGroup.db.select(dbConn, tmpObj))
// uploadEmpRosterTableGroup.EmpRosterTableGroupID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpRosterTableGroup.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpRosterTableGroup.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpRosterTableGroup.EmpRosterTableGroupID = ((EEmpRosterTableGroup)objSameSynIDList[0]).EmpRosterTableGroupID;
}
}
}
}
if (uploadEmpRosterTableGroup.EmpRosterTableGroupID == 0)
{
// allow multiple group on same date
// do NOT allow same group id appear on same date
AND lastEmpRosterTableGroupAndTerms = new AND();
lastEmpRosterTableGroupAndTerms.add(new Match("EmpRosterTableGroupEffFr", "<=", uploadEmpRosterTableGroup.EmpRosterTableGroupEffFr));
lastEmpRosterTableGroupAndTerms.add(new Match("RosterTableGroupID", uploadEmpRosterTableGroup.RosterTableGroupID));
lastEmpRosterTableGroup = (EEmpRosterTableGroup)AppUtils.GetLastObj(dbConn, uploadDB, "EmpRosterTableGroupEffFr", uploadEmpRosterTableGroup.EmpID, lastEmpRosterTableGroupAndTerms);
if (lastEmpRosterTableGroup != null)
{
if (uploadEmpRosterTableGroup.RosterTableGroupID == lastEmpRosterTableGroup.RosterTableGroupID &&
uploadEmpRosterTableGroup.EmpRosterTableGroupIsSupervisor == lastEmpRosterTableGroup.EmpRosterTableGroupIsSupervisor &&
uploadEmpRosterTableGroup.EmpRosterTableGroupEffTo == lastEmpRosterTableGroup.EmpRosterTableGroupEffTo)
{
continue;
}
else
{
// add postion terms with new ID
if (lastEmpRosterTableGroup.EmpRosterTableGroupEffFr.Equals(uploadEmpRosterTableGroup.EmpRosterTableGroupEffFr) &&
uploadEmpRosterTableGroup.RosterTableGroupID == lastEmpRosterTableGroup.RosterTableGroupID &&
uploadEmpRosterTableGroup.EmpRosterTableGroupIsSupervisor == lastEmpRosterTableGroup.EmpRosterTableGroupIsSupervisor)
{
uploadEmpRosterTableGroup.EmpRosterTableGroupID = lastEmpRosterTableGroup.EmpRosterTableGroupID;
//if (uploadEmpRosterTableGroup.EmpRosterTableGroupEffTo.Ticks == 0 && lastEmpRosterTableGroup.EmpRosterTableGroupEffTo.Ticks != 0)
//{
// EEmpRosterTableGroup afterEmpRosterTableGroup = (EEmpRosterTableGroup)AppUtils.GetLastObj(dbConn, uploadDB, "EmpRosterTableGroupEffFr", uploadEmpRosterTableGroup.EmpID, new Match("EmpRosterTableGroupEffFr", ">", lastEmpRosterTableGroup.EmpRosterTableGroupEffTo));
// if (afterEmpRosterTableGroup != null)
// uploadEmpRosterTableGroup.EmpRosterTableGroupEffTo = afterEmpRosterTableGroup.EmpRosterTableGroupEffFr.AddDays(-1);
//}
}
//else
//{
// AND lastObjAndTerms = new AND();
// lastObjAndTerms.add(new Match("EmpRosterTableGroupEffFr", ">", uploadEmpRosterTableGroup.EmpRosterTableGroupEffFr));
// if (!uploadEmpRosterTableGroup.EmpRosterTableGroupEffTo.Ticks.Equals(0))
// lastObjAndTerms.add(new Match("EmpRosterTableGroupEffFr", "<=", uploadEmpRosterTableGroup.EmpRosterTableGroupEffTo));
// lastObjAndTerms.add(new Match("RosterTableGroupID", uploadEmpRosterTableGroup.RosterTableGroupID));
// EEmpRosterTableGroup lastObj = (EEmpRosterTableGroup)AppUtils.GetLastObj(dbConn, uploadDB, "EmpRosterTableGroupEffFr", uploadEmpRosterTableGroup.EmpID, lastObjAndTerms);
// if (lastObj != null)
// if (!lastObj.EmpRosterTableGroupEffTo.Ticks.Equals(0))
// {
// errors.addError(ImportErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadEmpRosterTableGroup.EmpRosterTableGroupEffFr.ToString("yyyy-MM-dd"), rowCount.ToString() });
// continue;
// }
//}
}
}
}
}
if (uploadEmpRosterTableGroup.EmpRosterTableGroupID <= 0)
{
uploadEmpRosterTableGroup.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpRosterTableGroup.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpRosterTableGroup.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpRosterTableGroup.UploadEmpID == 0)
{
if (uploadEmpRosterTableGroup.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpRosterTableGroup.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpRosterTableGroup.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpRosterTableGroup, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpRosterTableGroup);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
//if (EmpID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (EffDate.Ticks == 0)
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EFFECTIVE_DATE + "=" + EffDateString, EmpNo, rowCount.ToString() });
//else if (double.TryParse(amountString, out amount))
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + amountString, EmpNo, rowCount.ToString() });
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
public void ImportToDatabase(int UploadEmpID)
{
DBFilter sessionFilter = new DBFilter();
sessionFilter.add(new Match("SessionID", m_SessionID));
if (UploadEmpID > 0)
{
sessionFilter.add(new Match("UploadEmpID", UploadEmpID));
}
ArrayList uploadEmpCostCenterList = tempDB.select(dbConn, sessionFilter);
foreach (EUploadEmpCostCenter obj in uploadEmpCostCenterList)
{
EEmpCostCenter empCostCenter = new EEmpCostCenter();
if (obj.ImportActionStatus != ImportDBObject.ImportActionEnum.INSERT)
{
empCostCenter.EmpCostCenterID = obj.EmpCostCenterID;
uploadDB.select(dbConn, empCostCenter);
}
obj.ExportToObject(empCostCenter);
if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.INSERT)
{
empCostCenter.EmpID = ParseTemp.GetEmpIDFromUploadEmpID(dbConn, obj.UploadEmpID);
EEmpCostCenter lastObj = (EEmpCostCenter)AppUtils.GetLastObj(dbConn, EEmpCostCenter.db, "EmpCostCenterEffFr", empCostCenter.EmpID, new Match("EmpCostCenterEffFr", "<", empCostCenter.EmpCostCenterEffFr));
if (lastObj != null)
{
if (lastObj.EmpCostCenterEffTo.Ticks == 0)
{
lastObj.EmpCostCenterEffTo = empCostCenter.EmpCostCenterEffFr.AddDays(-1);
uploadDB.update(dbConn, lastObj);
}
}
uploadDB.insert(dbConn, empCostCenter);
DBFilter uploadEmpCostCenterFilter = new DBFilter();
uploadEmpCostCenterFilter.add(new Match("UploadEmpCostCenterID", obj.UploadEmpCostCenterID));
ArrayList uploadEmpCostCenterDetailList = EUploadEmpCostCenterDetail.db.select(dbConn, uploadEmpCostCenterFilter);
foreach (EUploadEmpCostCenterDetail uploadEmpCostCenterDetail in uploadEmpCostCenterDetailList)
{
uploadEmpCostCenterDetail.EmpCostCenterID = empCostCenter.EmpCostCenterID;
EEmpCostCenterDetail empCostCenterDetail = new EEmpCostCenterDetail();
ImportDBObject.CopyObjectProperties(uploadEmpCostCenterDetail, empCostCenterDetail);
uploadDetailDB.insert(dbConn, empCostCenterDetail);
EUploadEmpCostCenterDetail.db.delete(dbConn, uploadEmpCostCenterDetail);
}
}
else if (obj.ImportActionStatus == ImportDBObject.ImportActionEnum.UPDATE)
{
uploadDB.update(dbConn, empCostCenter);
DBFilter empCostCenterDetailFilter = new DBFilter();
empCostCenterDetailFilter.add(new Match("EmpCostCenterID", empCostCenter.EmpCostCenterID));
uploadDetailDB.delete(dbConn, empCostCenterDetailFilter);
DBFilter uploadEmpCostCenterDetailFilter = new DBFilter();
uploadEmpCostCenterDetailFilter.add(new Match("UploadEmpCostCenterID", obj.UploadEmpCostCenterID));
ArrayList uploadEmpCostCenterDetailList = EUploadEmpCostCenterDetail.db.select(dbConn, uploadEmpCostCenterDetailFilter);
foreach (EUploadEmpCostCenterDetail uploadEmpCostCenterDetail in uploadEmpCostCenterDetailList)
{
EEmpCostCenterDetail empCostCenterDetail = new EEmpCostCenterDetail();
ImportDBObject.CopyObjectProperties(uploadEmpCostCenterDetail, empCostCenterDetail);
uploadDetailDB.insert(dbConn, empCostCenterDetail);
EUploadEmpCostCenterDetail.db.delete(dbConn, uploadEmpCostCenterDetail);
}
}
tempDB.delete(dbConn, obj);
}
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
EUploadEmpContractTerms uploadEmpContract = new EUploadEmpContractTerms();
//EEmpContractTerms lastEmpContact = null;
string EmpNo = row[FIELD_EMP_NO].ToString().Trim();
uploadEmpContract.EmpID = Parse.GetEmpID(dbConn, EmpNo, UserID);
if (uploadEmpContract.EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
try
{
uploadEmpContract.EmpContractEmployedFrom = Parse.toDateTimeObject(row[FIELD_FROM]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_FROM + "=" + row[FIELD_FROM].ToString(), EmpNo, rowCount.ToString() });
}
try
{
uploadEmpContract.EmpContractEmployedTo = Parse.toDateTimeObject(row[FIELD_TO]);
}
catch
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_TO + "=" + row[FIELD_TO].ToString(), EmpNo, rowCount.ToString() });
}
uploadEmpContract.EmpContractCompanyName = row[FIELD_COMPANYNAME].ToString();
uploadEmpContract.EmpContractCompanyAddr = row[FIELD_COMPANYADDRESS].ToString();
uploadEmpContract.EmpContractCompanyContactNo = row[FIELD_CONTRACT_NO].ToString();
double amount = 0;
if (row[FIELD_GRATUITY] != null)
{
if (!row[FIELD_GRATUITY].ToString().Equals(string.Empty))
{
if (double.TryParse(row[FIELD_GRATUITY].ToString(), out amount))
{
uploadEmpContract.EmpContractGratuity = amount;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_GRATUITY + "=" + row[FIELD_GRATUITY].ToString(), EmpNo, rowCount.ToString() });
}
}
}
uploadEmpContract.SessionID = m_SessionID;
uploadEmpContract.TransactionDate = UploadDateTime;
//if (uploadEmpContact.EmpID != 0)
//{
// AND andTerms = new AND();
// andTerms.add(new Match("EmpContractEmployedFrom", "<=", uploadEmpContact.EmpContractEmployedFrom));
// lastEmpContact = (EEmpContractTerms)AppUtils.GetLastObj(dbConn, uploadDB, "EmpContractEmployedFrom", uploadEmpContact.EmpID, andTerms);
// if (lastEmpContact != null)
// {
// if (uploadEmpPay.EmpPoRNature == lastEmpPay.EmpPoRNature
// && uploadEmpPay.EmpPoRLandLord == lastEmpPay.EmpPoRLandLord
// && uploadEmpPay.EmpPoRPropertyAddr == lastEmpPay.EmpPoRPropertyAddr
// && uploadEmpPay.EmpPoRLandLordAddr == lastEmpPay.EmpPoRLandLordAddr
// )
// {
// continue;
// }
// else
// {
// // add postion terms with new ID
// if (lastEmpContact.EmpPoRFrom.Equals(uploadEmpContact.EmpPoRFrom))
// {
// uploadEmpContact.EmpPoRID = lastEmpContact.EmpPoRID;
// if (uploadEmpContact.EmpPoRTo.Ticks == 0)
// uploadEmpContact.EmpPoRTo = lastEmpContact.EmpPoRTo;
// }
// else
// {
// EEmpContractTerms lastObj = (EEmpContractTerms)AppUtils.GetLastObj(dbConn, uploadDB, "EmpPoRFrom", uploadEmpContact.EmpID);
// if (lastObj != null && uploadEmpContact.EmpPoRFrom <= lastObj.EmpPoRFrom)
// {
// errors.addError(HROne.Translation.PageErrorMessage.ERROR_DATE_FROM_OVERLAP, new string[] { uploadEmpContact.EmpPoRFrom.ToString("yyyy-MM-dd"), rowCount.ToString() });
// continue;
// }
// }
// }
// }
//}
//if (rawDataTable.Columns.Contains(FIELD_INTERNAL_ID))
//{
// try
// {
// if (!row.IsNull(FIELD_INTERNAL_ID))
// {
// int tmpID = FromHexDecWithCheckDigit((string)row[FIELD_INTERNAL_ID]);
// EEmpContractTerms tmpObj = new EEmpContractTerms();
// tmpObj.EmpContractID = tmpID;
// if (EEmpContractTerms.db.select(dbConn, tmpObj))
// uploadEmpContact.EmpContractID = tmpID;
// else
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
// }
// }
// catch (Exception ex)
// {
// errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_INTERNAL_ID + "=" + row[FIELD_INTERNAL_ID].ToString(), EmpNo, rowCount.ToString() });
// continue;
// }
//}
if (rawDataTable.Columns.Contains(FIELD_SYNC_ID))
{
if (!row.IsNull(FIELD_SYNC_ID))
{
string strSynID = row[FIELD_SYNC_ID].ToString();
uploadEmpContract.SynID = strSynID;
if (!string.IsNullOrEmpty(strSynID))
{
DBFilter synIDFilter = new DBFilter();
synIDFilter.add(new Match("SynID", strSynID));
ArrayList objSameSynIDList = EEmpContractTerms.db.select(dbConn, synIDFilter);
if (objSameSynIDList.Count > 0)
{
uploadEmpContract.EmpContractID = ((EEmpContractTerms)objSameSynIDList[0]).EmpContractID;
}
}
}
}
if (uploadEmpContract.EmpContractID <= 0)
{
uploadEmpContract.ImportActionStatus = ImportDBObject.ImportActionEnum.INSERT;
}
else
{
uploadEmpContract.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
}
uploadEmpContract.UploadEmpID = ParseTemp.GetUploadEmpID(dbConn, EmpNo, m_SessionID);
if (uploadEmpContract.UploadEmpID == 0)
{
if (uploadEmpContract.EmpID == 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
else
{
uploadEmpContract.UploadEmpID = ImportEmpPersonalInfoProcess.CreateDummyUploadEmployeeInfo(dbConn, uploadEmpContract.EmpID, m_SessionID, UploadDateTime);
}
}
Hashtable values = new Hashtable();
tempDB.populate(uploadEmpContract, values);
PageErrors pageErrors = new PageErrors(EUploadEmpPersonalInfo.db);
tempDB.validate(pageErrors, values);
if (pageErrors.errors.Count == 0)
{
tempDB.insert(dbConn, uploadEmpContract);
}
else
{
pageErrors.addError(rawDataTable.TableName);
throw new HRImportException(pageErrors.getPrompt() + "(line " + rowCount.ToString() + ")");
//if (EmpID == 0)
// errors.addError(HROne.Translation.PageErrorMessage.ERROR_INVALID_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(HROne.Translation.PageErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (PayCodeID == 0)
// errors.addError(HROne.Translation.PageErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_PAYMENT_CODE + "=" + PaymentCode, EmpNo, rowCount.ToString() });
//else if (EffDate.Ticks == 0)
// errors.addError(HROne.Translation.PageErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_EFFECTIVE_DATE + "=" + EffDateString, EmpNo, rowCount.ToString() });
//else if (double.TryParse(amountString, out amount))
// errors.addError(HROne.Translation.PageErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_AMOUNT + "=" + amountString, EmpNo, rowCount.ToString() });
}
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
