protected bool loadObject()
{
obj = new EEmpBankAccount();
bool isNew = WebFormWorkers.loadKeys(db, obj, DecryptedRequest);
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", CurEmpID));
filter.add(WebUtils.AddRankFilter(Session, "EmpID", true));
if (EEmpPersonalInfo.db.count(dbConn, filter) == 0)
{
if (CurEmpID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
if (!db.select(dbConn, obj))
{
if (CurID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
if (obj.EmpID != CurEmpID)
{
if (CurID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
//DBFilter filter = new DBFilter();
//filter.add(new Match("EmpBankAccountID", obj.EmpBankAccountID));
//filter.add(WebUtils.AddRankFilter(Session, "EmpID", true));
//ArrayList empBankAccountList = EEmpBankAccount.db.select(dbConn, filter);
//if (empBankAccountList.Count == 0)
// return false;
//obj = (EEmpBankAccount)empBankAccountList[0];
Hashtable values = new Hashtable();
db.populate(obj, values);
binding.toControl(values);
return(true);
}
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);
}
}
protected void Delete_Click(object sender, EventArgs e)
{
PageErrors errors = PageErrors.getErrors(sdb, Page.Master);
errors.clear();
ArrayList list = new ArrayList();
foreach (RepeaterItem i in Repeater.Items)
{
CheckBox cb = (CheckBox)i.FindControl("ItemSelect");
if (cb.Checked)
{
EEmpBankAccount o = new EEmpBankAccount();
WebFormUtils.GetKeys(sdb, o, cb);
list.Add(o);
}
}
foreach (EEmpBankAccount obj in list)
{
sdb.select(dbConn, obj);
DBFilter paymentRecordFilter = new DBFilter();
paymentRecordFilter.add(new Match("EmpAccID", obj.EmpBankAccountID));
IN inTerms = new IN("EmpPayrollID", "Select EmpPayrollID From " + EPaymentRecord.db.dbclass.tableName, paymentRecordFilter);
DBFilter empPayrollFilter = new DBFilter();
empPayrollFilter.add(inTerms);
empPayrollFilter.add("empid", true);
ArrayList empPayrollList = EEmpPayroll.db.select(dbConn, empPayrollFilter);
if (empPayrollList.Count > 0)
{
errors.addError(string.Format(HROne.Translation.PageErrorMessage.ERROR_CODE_IS_IN_USE, new string[] { HROne.Common.WebUtility.GetLocalizedString("Bank Account") }));
errors.addError(HROne.Translation.PageErrorMessage.ERROR_ACTION_ABORT);
}
else
{
WebUtils.StartFunction(Session, FUNCTION_CODE, obj.EmpID);
sdb.delete(dbConn, obj);
WebUtils.EndFunction(dbConn);
}
}
loadData(info, sdb, Repeater);
}
public bool Delete()
{
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
EEmpBankAccount obj = new EEmpBankAccount();
obj.EmpBankAccountID = EmpBankAccountID;
db.select(dbConn, obj);
DBFilter paymentRecordFilter = new DBFilter();
paymentRecordFilter.add(new Match("EmpAccID", obj.EmpBankAccountID));
IN inTerms = new IN("EmpPayrollID", "Select EmpPayrollID From " + EPaymentRecord.db.dbclass.tableName, paymentRecordFilter);
DBFilter empPayrollFilter = new DBFilter();
empPayrollFilter.add(inTerms);
empPayrollFilter.add("empid", true);
ArrayList empPayrollList = EEmpPayroll.db.select(dbConn, empPayrollFilter);
if (empPayrollList.Count > 0)
{
errors.addError(string.Format(HROne.Translation.PageErrorMessage.ERROR_CODE_IS_IN_USE, new string[] { HROne.Common.WebUtility.GetLocalizedString("Bank Account") }));
errors.addError(HROne.Translation.PageErrorMessage.ERROR_ACTION_ABORT);
return(false);
}
else
{
WebUtils.StartFunction(Session, FUNCTION_CODE, obj.EmpID);
db.delete(dbConn, obj);
WebUtils.EndFunction(dbConn);
}
return(true);
}
protected void Delete_Click(object sender, EventArgs e)
{
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
EEmpBankAccount obj = new EEmpBankAccount();
obj.EmpBankAccountID = CurID;
db.select(dbConn, obj);
DBFilter paymentRecordFilter = new DBFilter();
paymentRecordFilter.add(new Match("EmpAccID", obj.EmpBankAccountID));
IN inTerms = new IN("EmpPayrollID", "Select EmpPayrollID From " + EPaymentRecord.db.dbclass.tableName, paymentRecordFilter);
DBFilter empPayrollFilter = new DBFilter();
empPayrollFilter.add(inTerms);
empPayrollFilter.add("empid", true);
ArrayList empPayrollList = EEmpPayroll.db.select(dbConn, empPayrollFilter);
if (empPayrollList.Count > 0)
{
errors.addError(string.Format(HROne.Translation.PageErrorMessage.ERROR_CODE_IS_IN_USE, new string[] { HROne.Common.WebUtility.GetLocalizedString("Bank Account") }));
errors.addError(HROne.Translation.PageErrorMessage.ERROR_ACTION_ABORT);
return;
}
else
{
WebUtils.StartFunction(Session, FUNCTION_CODE, obj.EmpID);
db.delete(dbConn, obj);
WebUtils.EndFunction(dbConn);
}
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "EmpTab_BankAccount_View.aspx?EmpID=" + EmpID.Value);
}
protected void Page_PreRender(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
if (CurrentEmpRPID > 0)
{
loadObject();
}
else if (PrevEmpRPID > 0)
{
loadObject();
}
else
{
if (DecryptedRequest["NonPayrollItem"] == "Y")
{
EmpRPIsNonPayrollItem.Checked = true;
}
}
}
CurrencyID.SelectedValue = "HKD";
if (EmpRPMethod.SelectedValue.Equals("A"))
{
BankAccountRow.Visible = true;
lblDefaultBankAccount.Text = string.Empty;
if (EmpAccID.SelectedValue.Equals(string.Empty))
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, CurrentEmpID);
if (bankAccount != null)
{
lblDefaultBankAccount.Text = bankAccount.EmpBankCode + "-" + bankAccount.EmpBranchCode + "-" + bankAccount.EmpAccountNo;
}
}
}
else
{
BankAccountRow.Visible = false;
}
if (EmpRPUnit.SelectedValue.Equals("P"))
{
EmpRPUnitPeriodAsDaily.Visible = true;
if (EmpRPUnitPeriodAsDaily.Checked)
{
EmpRPUnitPeriodAsDailyPayFormIDRow.Visible = true;
}
else
{
EmpRPUnitPeriodAsDailyPayFormIDRow.Visible = false;
}
}
else
{
EmpRPUnitPeriodAsDaily.Visible = false;
EmpRPUnitPeriodAsDailyPayFormIDRow.Visible = false;
}
HROne.ProductLicense productLicense = WebUtils.productLicense(Session);
CostCenterRow.Visible = productLicense.IsCostCenter;
if (productLicense.ProductType != HROne.ProductLicense.ProductLicenseType.HROne)
{
EmpRPUnit.Items.FindByValue("D").Enabled = false;
EmpRPUnit.Items.FindByValue("H").Enabled = false;
EmpRPUnitPeriodAsDaily.Checked = false;
EmpRPUnitPeriodAsDaily.Visible = false;
EmpRPUnitPeriodAsDailyPayFormIDRow.Visible = false;
}
}
public override CrystalDecisions.CrystalReports.Engine.ReportDocument GenerateReport()
{
DataSet.Payroll_NetPaymentList dataSet = new DataSet.Payroll_NetPaymentList();
if (ByAutoPay)
{
DataSet.Payroll_NetPaymentList.PaymentMethodRow payMethodRow = dataSet.PaymentMethod.NewPaymentMethodRow();
payMethodRow.PayMethodCode = "A";
payMethodRow.PayMethodDesc = "Autopay";
dataSet.PaymentMethod.AddPaymentMethodRow(payMethodRow);
}
if (ByCheque)
{
DataSet.Payroll_NetPaymentList.PaymentMethodRow payMethodRow = dataSet.PaymentMethod.NewPaymentMethodRow();
payMethodRow.PayMethodCode = "Q";
payMethodRow.PayMethodDesc = "Cheque";
dataSet.PaymentMethod.AddPaymentMethodRow(payMethodRow);
}
if (ByCash)
{
DataSet.Payroll_NetPaymentList.PaymentMethodRow payMethodRow = dataSet.PaymentMethod.NewPaymentMethodRow();
payMethodRow.PayMethodCode = "C";
payMethodRow.PayMethodDesc = "Cash";
dataSet.PaymentMethod.AddPaymentMethodRow(payMethodRow);
}
if (ByOthers)
{
DataSet.Payroll_NetPaymentList.PaymentMethodRow payMethodRow = dataSet.PaymentMethod.NewPaymentMethodRow();
payMethodRow.PayMethodCode = "O";
payMethodRow.PayMethodDesc = "Others";
dataSet.PaymentMethod.AddPaymentMethodRow(payMethodRow);
}
foreach (EEmpPersonalInfo empInfo in EmpList)
{
if (EEmpPersonalInfo.db.select(dbConn, empInfo))
{
DataSet.Payroll_NetPaymentList.employeedetailRow row = dataSet.employeedetail.NewemployeedetailRow();
{
EEmpPositionInfo posInfo = AppUtils.GetLastPositionInfo(dbConn, empInfo.EmpID);
if (posInfo != null)
{
ECompany company = new ECompany();
company.CompanyID = posInfo.CompanyID;
if (ECompany.db.select(dbConn, company))
{
row.CompanyCode = company.CompanyCode;
row.CompanyID = company.CompanyID;
row.CompanyName = company.CompanyName;
}
else
{
row.CompanyCode = string.Empty;
row.CompanyID = 0;
row.CompanyName = "-";
}
row.EmpPosEffFr = posInfo.EmpPosEffFr;
row.EmpPosEffTo = posInfo.EmpPosEffTo;
//posInfo.EmploymentTypeID
row.EmpPosID = posInfo.EmpPosID;
row.LeavePlanID = posInfo.LeavePlanID;
row.PayGroupID = posInfo.PayGroupID;
EPosition position = new EPosition();
position.PositionID = posInfo.PositionID;
if (EPosition.db.select(dbConn, position))
{
row.PositionCode = position.PositionCode;
row.PositionDesc = position.PositionDesc;
row.PositionID = position.PositionID;
}
else
{
row.PositionCode = string.Empty;
row.PositionDesc = "-";
row.PositionID = 0;
}
row.RankID = posInfo.RankID;
row.Remark = empInfo.Remark;
row.StaffTypeID = posInfo.StaffTypeID;
//posInfo.YebPlanID;
ArrayList HierarchyLevelList = EHierarchyLevel.db.select(dbConn, new DBFilter());
foreach (EHierarchyLevel hLevel in HierarchyLevelList)
{
if (hLevel.HLevelSeqNo < 4 && hLevel.HLevelSeqNo > 0)
{
DBFilter empHierarchyFilter = new DBFilter();
empHierarchyFilter.add(new Match("EmpPosID", posInfo.EmpPosID));
empHierarchyFilter.add(new Match("HLevelID", hLevel.HLevelID));
ArrayList empHierarchyList = EEmpHierarchy.db.select(dbConn, empHierarchyFilter);
if (empHierarchyList.Count > 0)
{
EEmpHierarchy empHierarchy = (EEmpHierarchy)empHierarchyList[0];
EHierarchyElement hElement = new EHierarchyElement();
hElement.HElementID = empHierarchy.HElementID;
EHierarchyElement.db.select(dbConn, hElement);
row["HierarchyCode" + hLevel.HLevelSeqNo] = hElement.HElementCode;
row["HierarchyDesc" + hLevel.HLevelSeqNo] = hElement.HElementDesc;
}
}
}
}
else
{
row.CompanyCode = string.Empty;
row.CompanyID = 0;
row.CompanyName = "-";
row.PositionCode = string.Empty;
row.PositionDesc = "-";
row.PositionID = 0;
}
}
row.EmpAlias = empInfo.EmpAlias;
row.EmpChiFullName = empInfo.EmpChiFullName;
row.EmpCorAddr = empInfo.EmpCorAddr;
row.EmpDateOfBirth = empInfo.EmpDateOfBirth;
row.EmpDateOfJoin = empInfo.EmpDateOfJoin;
row.EmpEmail = empInfo.EmpEmail;
row.EmpEngOtherName = empInfo.EmpEngOtherName;
row.EmpEngSurname = empInfo.EmpEngSurname;
row.EmpEngFullName = empInfo.EmpEngFullName;
row.EmpGender = empInfo.EmpGender;
row.EmpHKID = empInfo.EmpHKID;
row.EmpHomePhoneNo = empInfo.EmpHomePhoneNo;
row.EmpID = empInfo.EmpID;
row.EmpMaritalStatus = empInfo.EmpMaritalStatus;
row.EmpMobileNo = empInfo.EmpMobileNo;
row.EmpNationality = empInfo.EmpNationality;
row.EmpNo = empInfo.EmpNo;
row.EmpNoticePeriod = empInfo.EmpNoticePeriod;
row.EmpNoticeUnit = empInfo.EmpNoticeUnit;
row.EmpOfficePhoneNo = empInfo.EmpOfficePhoneNo;
row.EmpPassportExpiryDate = empInfo.EmpPassportExpiryDate;
row.EmpPassportIssuedCountry = empInfo.EmpPassportIssuedCountry;
row.EmpPassportNo = empInfo.EmpPassportNo;
row.EmpPlaceOfBirth = empInfo.EmpPlaceOfBirth;
row.EmpProbaLastDate = empInfo.EmpProbaLastDate;
row.EmpProbaPeriod = empInfo.EmpProbaPeriod;
row.EmpProbaUnit = empInfo.EmpProbaUnit;
row.EmpResAddr = empInfo.EmpResAddr;
row.EmpResAddrAreaCode = empInfo.EmpResAddrAreaCode;
row.EmpServiceDate = empInfo.EmpServiceDate;
row.EmpStatus = empInfo.EmpStatus;
DBFilter empTermFilter = new DBFilter();
empTermFilter.add(new Match("EmpID", empInfo.EmpID));
ArrayList empTermList = EEmpTermination.db.select(dbConn, empTermFilter);
if (empTermList.Count > 0)
{
row.EmpTermLastDate = ((EEmpTermination)empTermList[0]).EmpTermLastDate;
}
dataSet.employeedetail.AddemployeedetailRow(row);
DBFilter empPayrollFilter = new DBFilter();
empPayrollFilter.add(new Match("EmpID", empInfo.EmpID));
OR orPayrollBatch = new OR();
foreach (EPayrollBatch payBatch in PayrollBatchList)
{
orPayrollBatch.add(new Match("PayBatchID", payBatch.PayBatchID));
}
empPayrollFilter.add(orPayrollBatch);
IN inEmpPayroll = new IN("EmpPayrollID", "Select EmpPayrollID from EmpPayroll", empPayrollFilter);
DBFilter autoPayPaymentRecordFilter = new DBFilter();
autoPayPaymentRecordFilter.add(inEmpPayroll);
autoPayPaymentRecordFilter.add("EmpAccID", true);
ArrayList autoPayPaymentRecords = EPaymentRecord.db.select(dbConn, autoPayPaymentRecordFilter);
foreach (EPaymentRecord paymentRecord in autoPayPaymentRecords)
{
DataSet.Payroll_NetPaymentList.PaymentRecordRow paymentRow = dataSet.PaymentRecord.NewPaymentRecordRow();
paymentRow.PayRecID = paymentRecord.PayRecID;
paymentRow.EmpID = empInfo.EmpID;
paymentRow.PayRecActAmount = paymentRecord.PayRecActAmount;
paymentRow.PayRecMethod = paymentRecord.PayRecMethod;
paymentRow.EmpAccountNo = string.Empty;
EEmpPayroll empPayroll = new EEmpPayroll();
empPayroll.EmpPayrollID = paymentRecord.EmpPayrollID;
if (EEmpPayroll.db.select(dbConn, empPayroll))
{
if (!empPayroll.EmpPayValueDate.Ticks.Equals(0))
{
paymentRow.EmpPayValueDate = empPayroll.EmpPayValueDate;
}
}
if (paymentRecord.PayRecMethod.Equals("A", StringComparison.CurrentCultureIgnoreCase))
{
// Only Autopay payment show account no
EEmpBankAccount empBankAccount = new EEmpBankAccount();
empBankAccount.EmpBankAccountID = paymentRecord.EmpAccID;
if (EEmpBankAccount.db.select(dbConn, empBankAccount))
{
if (empBankAccount.EmpID.Equals(empInfo.EmpID))
{
paymentRow.EmpAccountNo = empBankAccount.EmpBankCode + "-" + empBankAccount.EmpBranchCode + "-" + empBankAccount.EmpAccountNo;
paymentRow.EmpAccID = paymentRecord.EmpAccID;
}
}
}
dataSet.PaymentRecord.AddPaymentRecordRow(paymentRow);
}
}
}
if (reportDocument == null)
{
reportDocument = new ReportTemplate.Report_Payroll_NetPaymentListByPaymentMethod();
}
else
{
}
reportDocument.SetDataSource(dataSet);
return(reportDocument);
}
public static DataTable Export(DatabaseConnection dbConn, ArrayList empList, bool IsIncludeCurrentPositionInfo, bool IsShowDescription, bool IsIncludeSyncID, DateTime ReferenceDateTime)
{
DataTable tmpDataTable = new DataTable(TABLE_NAME);
//if (IsIncludeInternalID)
// tmpDataTable.Columns.Add(FIELD_INTERNAL_ID, typeof(string));
tmpDataTable.Columns.Add(FIELD_EMP_NO, typeof(string));
if (IsIncludeCurrentPositionInfo)
{
ImportEmpPersonalInfoProcess.AddEmployeeInfoHeader(tmpDataTable);
ImportEmpPositionInfoProcess.AddEmployeePositionInfoHeader(dbConn, tmpDataTable);
}
tmpDataTable.Columns.Add(FIELD_FROM, typeof(DateTime));
tmpDataTable.Columns.Add(FIELD_TO, typeof(DateTime));
tmpDataTable.Columns.Add(FIELD_PAYMENT_CODE, typeof(string));
if (ESystemParameter.getParameter(dbConn, ESystemParameter.PARAM_CODE_PAYSCALE_POINT_SYSTEM) == "Y") // for WaiJe
{
tmpDataTable.Columns.Add(FIELD_SCHEME_CODE, typeof(string));
tmpDataTable.Columns.Add(FIELD_CAPACITY, typeof(string));
tmpDataTable.Columns.Add(FIELD_POINT, typeof(decimal));
}
if (ESystemParameter.getParameter(dbConn, ESystemParameter.PARAM_CODE_MONTHLY_ACHIEVEMENT_COMMISSION) == "Y") // for F&V
{
tmpDataTable.Columns.Add(FIELD_BASIC_SALARY, typeof(decimal));
tmpDataTable.Columns.Add(FIELD_FPS, typeof(decimal));
}
tmpDataTable.Columns.Add(FIELD_AMOUNT, typeof(double));
tmpDataTable.Columns.Add(FIELD_UNIT, typeof(string));
tmpDataTable.Columns.Add(FIELD_METHOD, typeof(string));
tmpDataTable.Columns.Add(FIELD_ACCOUNT_NO, typeof(string));
tmpDataTable.Columns.Add(FIELD_IS_NON_PAYROLL_ITEM, typeof(string));
tmpDataTable.Columns.Add(FIELD_COST_CENTER, typeof(string));
tmpDataTable.Columns.Add(FIELD_REMARK, typeof(string));
if (IsIncludeSyncID)
{
tmpDataTable.Columns.Add(FIELD_SYNC_ID, typeof(string));
}
foreach (EEmpPersonalInfo empInfo in empList)
{
if (EEmpPersonalInfo.db.select(dbConn, empInfo))
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", empInfo.EmpID));
filter.add(getCreateModifiedRecordsAfterDBTerm(ReferenceDateTime));
ArrayList list = EEmpRecurringPayment.db.select(dbConn, filter);
foreach (EEmpRecurringPayment empRecurringPayment in list)
{
DataRow row = tmpDataTable.NewRow();
//if (IsIncludeInternalID)
// row[FIELD_INTERNAL_ID] = ToHexDecWithCheckDigit(empRecurringPayment.EmpRPID);
row[FIELD_EMP_NO] = empInfo.EmpNo;
if (IsIncludeCurrentPositionInfo)
{
ImportEmpPersonalInfoProcess.AddEmployeeInfo(dbConn, row, empInfo.EmpID);
ImportEmpPositionInfoProcess.AddEmployeePositionInfo(dbConn, row, empInfo.EmpID);
}
row[FIELD_FROM] = empRecurringPayment.EmpRPEffFr;
row[FIELD_TO] = empRecurringPayment.EmpRPEffTo;
EPaymentCode paymentCode = new EPaymentCode();
paymentCode.PaymentCodeID = empRecurringPayment.PayCodeID;
if (EPaymentCode.db.select(dbConn, paymentCode))
{
row[FIELD_PAYMENT_CODE] = IsShowDescription ? paymentCode.PaymentCodeDesc : paymentCode.PaymentCode;
}
if (ESystemParameter.getParameter(dbConn, ESystemParameter.PARAM_CODE_PAYSCALE_POINT_SYSTEM) == "Y") // for WaiJe
{
row[FIELD_SCHEME_CODE] = empRecurringPayment.SchemeCode;
row[FIELD_CAPACITY] = empRecurringPayment.Capacity;
row[FIELD_POINT] = empRecurringPayment.Point;
}
if (ESystemParameter.getParameter(dbConn, ESystemParameter.PARAM_CODE_MONTHLY_ACHIEVEMENT_COMMISSION) == "Y") // for F&V
{
row[FIELD_BASIC_SALARY] = empRecurringPayment.EmpRPBasicSalary;
row[FIELD_FPS] = empRecurringPayment.EmpRPFPS;
}
row[FIELD_AMOUNT] = empRecurringPayment.EmpRPAmount;
if (empRecurringPayment.EmpRPUnit.Equals("H"))
{
row[FIELD_UNIT] = "Hourly";
}
else if (empRecurringPayment.EmpRPUnit.Equals("D"))
{
row[FIELD_UNIT] = "Daily";
}
else if (empRecurringPayment.EmpRPUnit.Equals("P"))
{
row[FIELD_UNIT] = "Once per payroll cycle";
}
if (empRecurringPayment.EmpRPMethod.Equals("A"))
{
row[FIELD_METHOD] = "Autopay";
EEmpBankAccount empBankAccount = new EEmpBankAccount();
empBankAccount.EmpBankAccountID = empRecurringPayment.EmpAccID;
if (EEmpBankAccount.db.select(dbConn, empBankAccount))
{
row[FIELD_ACCOUNT_NO] = empBankAccount.EmpBankCode + "-" + empBankAccount.EmpBranchCode + "-" + empBankAccount.EmpAccountNo;
}
}
else if (empRecurringPayment.EmpRPMethod.Equals("Q"))
{
row[FIELD_METHOD] = "Cheque";
}
else if (empRecurringPayment.EmpRPMethod.Equals("C"))
{
row[FIELD_METHOD] = "Cash";
}
else
{
row[FIELD_METHOD] = "Others";
}
row[FIELD_IS_NON_PAYROLL_ITEM] = empRecurringPayment.EmpRPIsNonPayrollItem ? "Yes" : "No";
ECostCenter costCenter = new ECostCenter();
costCenter.CostCenterID = empRecurringPayment.CostCenterID;
if (ECostCenter.db.select(dbConn, costCenter))
{
row[FIELD_COST_CENTER] = IsShowDescription ? costCenter.CostCenterDesc : costCenter.CostCenterCode;
}
row[FIELD_REMARK] = empRecurringPayment.EmpRPRemark;
if (IsIncludeSyncID)
{
row[FIELD_SYNC_ID] = empRecurringPayment.SynID;
}
tmpDataTable.Rows.Add(row);
}
}
}
if (IsIncludeCurrentPositionInfo)
{
ImportEmpPositionInfoProcess.RetriveHierarchyLevelHeader(dbConn, tmpDataTable);
}
return(tmpDataTable);
}
//protected void init_PaymentCodeDropdown()
//{
// if (PaymentCode.Items.Count <= 0)
// {
// PaymentCode.Items.Add(new ListItem("Not Selected", "-1"));
// DBFilter m_filter = new DBFilter();
// m_filter.add("PaymentCode", true);
// foreach (EPaymentCode o in EPaymentCode.db.select(dbConn, m_filter))
// {
// PaymentCode.Items.Add(new ListItem(string.Format("{0} - {1}", o.PaymentCode, o.PaymentCodeDesc), o.PaymentCodeID.ToString()));
// }
// }
//}
protected DataSet GenerateCND(int ProcessID, DateTime PaymentDate)
{
EHitRateProcessImportBatch m_process = EHitRateProcessImportBatch.GetObject(dbConn, ProcessID);
DataSet dataSet = new DataSet();//export.GetDataSet();
DataTable dataTable = new DataTable("ClaimsAndDeduction$");
dataSet.Tables.Add(dataTable);
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO, typeof(string));
dataTable.Columns.Add("English Name", typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE, typeof(DateTime));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER, typeof(string));
DBFilter m_detailFilter = new DBFilter();
m_detailFilter.add(new Match("HitRateProcessImportBatchID", ProcessID));
m_detailFilter.add("EmpID", true);
foreach (EHitRateProcess m_detail in EHitRateProcess.db.select(dbConn, m_detailFilter))
{
DBFilter m_rpFilter = new DBFilter();
m_rpFilter.add(new NullTerm("EmpRPEffTo"));
m_rpFilter.add(new Match("PayCodeID", m_detail.payCodeID));
m_rpFilter.add(new Match("EmpID", m_detail.EmpID));
m_rpFilter.add("EmpRPEffTo", true);
ArrayList m_empRPList = EEmpRecurringPayment.db.select(dbConn, m_rpFilter);
if (m_empRPList.Count > 0)
{
EEmpRecurringPayment m_empRP = (EEmpRecurringPayment)m_empRPList[0];
double m_amount = m_empRP.EmpRPAmount * m_detail.HitRate / (double)100;
string m_remarks;
// if (m_amount > 0 && Math.Abs(m_amount) >= 0.01)
{
m_remarks = String.Format("{0}*{1}%", m_empRP.EmpRPAmount.ToString("#,##0.00"),
m_detail.HitRate.ToString("#,##0.00"));
EEmpPersonalInfo m_empInfo = new EEmpPersonalInfo();
m_empInfo.EmpID = m_empRP.EmpID;
EEmpPersonalInfo.db.select(dbConn, m_empInfo);
DataRow m_row = dataTable.NewRow();
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO] = m_empInfo.EmpNo;
m_row["English Name"] = m_empInfo.EmpEngFullName;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE] = PaymentDate;
EPaymentCode m_paymentCode = EPaymentCode.GetObject(dbConn, m_empRP.PayCodeID);
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE] = m_paymentCode.PaymentCode;
switch (m_empRP.EmpRPMethod)
{
case "A":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Autopay";
break;
case "Q":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cheque";
break;
case "C":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cash";
break;
default:
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Other";
break;
}
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT] = Math.Round(m_amount, 2);
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST] = 0; //DateTime.DaysInMonth(m_process.AsAtDate);
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT] = "No";
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK] = m_remarks;
if (m_empRP.EmpAccID > 0) // account number specified
{
EEmpBankAccount m_bank = new EEmpBankAccount();
m_bank.EmpBankAccountID = m_empRP.EmpAccID;
if (EEmpBankAccount.db.select(dbConn, m_bank))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO] = m_bank.EmpAccountNo;
}
}
//else
//{
// // get default bank account
// DBFilter m_bankAccFilter = new DBFilter();
// m_bankAccFilter.add(new Match("EmpID", m_empRP.EmpID));
// m_bankAccFilter.add(new Match("EmpAccDefault", true));
// m_bankAccFilter.add("empBankAccountID", true);
// ArrayList m_bankAccList = EEmpBankAccount.db.select(dbConn, m_bankAccFilter);
// if (m_bankAccList.Count > 0)
// {
// m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO] = ((EEmpBankAccount)m_bankAccList[0]).EmpAccountNo;
// }
//}
ECostCenter m_costCenter = new ECostCenter();
m_costCenter.CostCenterID = m_empRP.CostCenterID;
if (ECostCenter.db.select(dbConn, m_costCenter))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER] = m_costCenter.CostCenterCode;
}
dataTable.Rows.Add(m_row);
}
}
}
return(dataSet);
}
protected DataSet GenerateCND(int ProcessID, int PaymentCodeID, DateTime PaymentDate)
{
EPaymentCode m_paymentCode = EPaymentCode.GetObject(dbConn, PaymentCodeID);
ECommissionAchievementImportBatch m_process = ECommissionAchievementImportBatch.GetObject(dbConn, ProcessID);
DataSet dataSet = new DataSet();//export.GetDataSet();
DataTable dataTable = new DataTable("ClaimsAndDeduction$");
dataSet.Tables.Add(dataTable);
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO, typeof(string));
dataTable.Columns.Add("English Name", typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE, typeof(DateTime));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER, typeof(string));
DBFilter m_detailFilter = new DBFilter();
m_detailFilter.add(new Match("CAImportBatchID", ProcessID));
m_detailFilter.add("EmpID", true);
foreach (ECommissionAchievement m_detail in ECommissionAchievement.db.select(dbConn, m_detailFilter))
{
DBFilter m_rpFilter = new DBFilter();
OR m_orDate = new OR();
m_orDate.add(new NullTerm("EmpRPEffTo"));
m_orDate.add(new Match("EmpRPEffTo", ">=", m_detail.CAEffDate));
m_rpFilter.add(m_orDate);
m_rpFilter.add(new Match("EmpRPEffFr", "<=", m_detail.CAEffDate));
m_rpFilter.add(new Match("EmpID", m_detail.EmpID));
//m_rpFilter.add(new NullTerm("NOT EmpRPBasicSalary"));
m_rpFilter.add(new Match("EmpRPBasicSalary", ">", 0));
m_rpFilter.add(new Match("EmpRPFPS", "<", 100));
m_rpFilter.add(new Match("EmpRPFPS", ">", 0));
foreach (EEmpRecurringPayment m_empRP in EEmpRecurringPayment.db.select(dbConn, m_rpFilter))
{
double m_amount = m_empRP.EmpRPBasicSalary * m_detail.CAPercent / 100 - m_empRP.EmpRPAmount;
string m_remarks;
if (m_amount > 0 && Math.Abs(m_amount) >= 0.01)
{
m_remarks = String.Format("({0}*{1}%) - {2}", m_empRP.EmpRPBasicSalary.ToString("#,##0.00"),
m_detail.CAPercent.ToString("#,##0.00"),
m_empRP.EmpRPAmount.ToString("#,##0.00"));
EEmpPersonalInfo m_empInfo = new EEmpPersonalInfo();
m_empInfo.EmpID = m_empRP.EmpID;
EEmpPersonalInfo.db.select(dbConn, m_empInfo);
DataRow m_row = dataTable.NewRow();
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO] = m_empInfo.EmpNo;
m_row["English Name"] = m_empInfo.EmpEngFullName;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE] = PaymentDate;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE] = m_paymentCode.PaymentCode;
switch (m_empRP.EmpRPMethod)
{
case "A":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Autopay";
break;
case "Q":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cheque";
break;
case "C":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cash";
break;
default:
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Other";
break;
}
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT] = Math.Round(m_amount, 2);
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST] = 0; //DateTime.DaysInMonth(m_process.AsAtDate);
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT] = "No";
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK] = m_remarks;
EEmpBankAccount m_bank = new EEmpBankAccount();
m_bank.EmpBankAccountID = m_empRP.EmpAccID;
if (EEmpBankAccount.db.select(dbConn, m_bank))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO] = m_bank.EmpAccountNo;
}
ECostCenter m_costCenter = new ECostCenter();
m_costCenter.CostCenterID = m_empRP.CostCenterID;
if (ECostCenter.db.select(dbConn, m_costCenter))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER] = m_costCenter.CostCenterCode;
}
dataTable.Rows.Add(m_row);
}
}
}
return(dataSet);
}
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));
}
protected void Page_Load(object sender, EventArgs e)
{
if (!WebUtils.CheckAccess(Response, Session, FUNCTION_CODE, WebUtils.AccessLevel.ReadWrite))
{
return;
}
toolBar.FunctionCode = FUNCTION_CODE;
if (!int.TryParse(DecryptedRequest["EmpFinalPayID"], out CurID))
{
CurID = -1;
}
if (!int.TryParse(DecryptedRequest["EmpID"], out CurEmpID))
{
CurEmpID = -1;
}
binding = new Binding(dbConn, db);
binding.add(EmpFinalPayID);
binding.add(EmpID);
binding.add(new DropDownVLBinder(db, PayCodeID, EPaymentCode.VLPaymentCode).setNotSelected(null));
binding.add(EmpFinalPayAmount);
binding.add(new DropDownVLBinder(db, EmpFinalPayMethod, Values.VLPaymentMethod).setNotSelected(null));
DBFilter empBankAccountFilter = new DBFilter();
OR bankAccountORTerm = new OR();
bankAccountORTerm.add(new Match("EmpID", CurEmpID));
{
EEmpPersonalInfo tmpEmpInfo = new EEmpPersonalInfo();
tmpEmpInfo.EmpID = CurEmpID;
if (EEmpPersonalInfo.db.select(dbConn, tmpEmpInfo) && tmpEmpInfo.MasterEmpID > 0)
{
bankAccountORTerm.add(new Match("EmpID", tmpEmpInfo.MasterEmpID));
}
}
empBankAccountFilter.add(bankAccountORTerm);
binding.add(new DropDownVLBinder(db, EmpAccID, EEmpBankAccount.VLBankAccount, empBankAccountFilter).setNotSelected(HROne.Common.WebUtility.GetLocalizedString(EEmpBankAccount.DEFAULT_BANK_ACCOUNT_TEXT)));
binding.add(new DropDownVLBinder(db, CostCenterID, ECostCenter.VLCostCenter).setNotSelected(HROne.Common.WebUtility.GetLocalizedString(ECostCenter.DEFAULT_COST_CENTER_TEXT)));
binding.add(EmpFinalPayRemark);
binding.add(EmpFinalPayNumOfDayAdj);
binding.add(new LabelVLBinder(db, EmpFinalPayIsAutoGen, Values.VLTrueFalseYesNo));
binding.add(new CheckBoxBinder(db, EmpFinalPayIsRestDayPayment));
binding.init(Request, Session);
EmpID.Value = CurEmpID.ToString();
HROne.Common.WebUtility.WebControlsLocalization(this, this.Controls);
if (!Page.IsPostBack)
{
if (CurID > 0)
{
toolBar.DeleteButton_Visible = true;
toolBar.SaveButton_Visible = true;
if (!loadObject())
{
toolBar.DeleteButton_Visible = false;
toolBar.SaveButton_Visible = false;
}
}
else
{
toolBar.DeleteButton_Visible = false;
if (CurEmpID <= 0)
{
toolBar.SaveButton_Visible = false;
}
}
}
if (EmpFinalPayMethod.SelectedValue.Equals("A"))
{
BankAccountRow.Visible = true;
lblDefaultBankAccount.Text = string.Empty;
if (EmpAccID.SelectedValue.Equals(string.Empty))
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, CurEmpID);
if (bankAccount != null)
{
lblDefaultBankAccount.Text = bankAccount.EmpBankCode + "-" + bankAccount.EmpBranchCode + "-" + bankAccount.EmpAccountNo;
}
}
}
else
{
BankAccountRow.Visible = false;
}
CostCenterRow.Visible = WebUtils.productLicense(Session).IsCostCenter;
}
protected void Save_Click(object sender, EventArgs e)
{
EEmpFinalPayment c = new EEmpFinalPayment();
Hashtable values = new Hashtable();
binding.toValues(values);
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
db.validate(errors, values);
if (!errors.isEmpty())
{
return;
}
db.parse(values, c);
if (c.EmpFinalPayMethod.Equals("A"))
{
if (c.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, c.EmpID);
if (bankAccount != null)
{
//c.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError("EmpAccID", HROne.Translation.PageErrorMessage.ERROR_ACCOUNT_REQUIRED);
}
}
}
//DBFilter filter = new DBFilter();
//filter.add(new Match("EmpID", c.EmpID));
//filter.add(new Match("EmpFinalPayID", "<>", c.EmpFinalPayID));
//filter.add(new Match("PayCodeID", c.PayCodeID));
//if (db.count(dbConn, filter) > 0)
//{
// errors.addError(HROne.Translation.PageErrorMessage.ERROR_ONE_PAYMENT_PER_PCODE);
// return;
//}
if (errors.isEmpty())
{
WebUtils.StartFunction(Session, FUNCTION_CODE, c.EmpID);
c.CurrencyID = "HKD";
if (CurID < 0)
{
// Utils.MarkCreate(Session, c);
db.insert(dbConn, c);
CurID = c.EmpFinalPayID;
// url = Utils.BuildURL(-1, CurID);
}
else
{
// Utils.Mark(Session, c);
db.update(dbConn, c);
}
WebUtils.EndFunction(dbConn);
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "Emp_FinalPayment_View.aspx?EmpID=" + c.EmpID + "&EmpFinalPayID=" + CurID);
}
}
protected bool loadObject()
{
obj = new EEmpFinalPayment();
bool isNew = WebFormWorkers.loadKeys(db, obj, DecryptedRequest);
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", CurEmpID));
filter.add(WebUtils.AddRankFilter(Session, "EmpID", true));
if (EEmpPersonalInfo.db.count(dbConn, filter) == 0)
{
if (CurEmpID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
if (!db.select(dbConn, obj))
{
if (CurID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
if (obj.EmpID != CurEmpID)
{
if (CurID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
Hashtable values = new Hashtable();
db.populate(obj, values);
binding.toControl(values);
if (obj.EmpFinalPayMethod.Equals("A"))
{
BankAccountRow.Visible = true;
lblDefaultBankAccount.Text = string.Empty;
if (obj.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, CurEmpID);
if (bankAccount != null)
{
lblDefaultBankAccount.Text = bankAccount.EmpBankCode + "-" + bankAccount.EmpBranchCode + "-" + bankAccount.EmpAccountNo;
}
}
}
else
{
BankAccountRow.Visible = false;
}
return(true);
}
public void GenerateDetailByEmpID()
{
dataSet = new DataSet.Payroll_PaySlip();
if (PayPeriodList == null)
{
OR orPayBatchIDTerms = new OR();
foreach (EPayrollBatch payBatch in PayBatchList)
{
orPayBatchIDTerms.add(new Match("ep.PayBatchID", payBatch.PayBatchID));
}
DBFilter empPayrollFilter = new DBFilter();
empPayrollFilter.add(orPayBatchIDTerms);
DBFilter payPeriodFilter = new DBFilter();
payPeriodFilter.add(new IN(EPayrollPeriod.db.dbclass.tableName + ".PayPeriodID ", "SELECT DISTINCT PayPeriodID FROM " + EEmpPayroll.db.dbclass.tableName + " ep", empPayrollFilter));
PayPeriodList = EPayrollPeriod.db.select(dbConn, payPeriodFilter);
}
foreach (EPayrollPeriod payPeriod in PayPeriodList)
{
if (EPayrollPeriod.db.select(dbConn, payPeriod))
{
EPayrollGroup payGroup = new EPayrollGroup();
payGroup.PayGroupID = payPeriod.PayGroupID;
EPayrollGroup.db.select(dbConn, payGroup);
string strPayPeriod = payPeriod.PayPeriodFr.ToString("yyyy-MM-dd") + " - " + payPeriod.PayPeriodTo.ToString("yyyy-MM-dd");
DataSet.Payroll_PaySlip.EmpInfoDataTable empInfoTable = dataSet.EmpInfo;
DataSet.Payroll_PaySlip.PaySlipDataTable dataTable = dataSet.PaySlip;
DataSet.Payroll_PaySlip.PaySlip_MPFDataTable mpfTable = dataSet.PaySlip_MPF;
DataSet.Payroll_PaySlip.PaySlip_ORSODataTable orsoTable = dataSet.PaySlip_ORSO;
foreach (EEmpPersonalInfo empInfo in EmpList)
{
EEmpPersonalInfo.db.select(dbConn, empInfo);
if ((reportType.Equals(ReportType.PaySlip) || reportType.Equals(ReportType.PaySlipDotMatrix)) && empInfo.MasterEmpID > 0 && empInfo.EmpIsCombinePaySlip)
{
continue;
}
DBFilter bankAccountFilter = new DBFilter();
if ((reportType.Equals(ReportType.PaySlip) || reportType.Equals(ReportType.PaySlipDotMatrix)))
{
bankAccountFilter.add(empInfo.GetAllRoleEmpIDTerms(dbConn, "EmpID", EEmpPersonalInfo.RoleFilterOptionEnum.Payslip));
}
else
{
bankAccountFilter.add(new Match("EmpID", empInfo.EmpID));
}
bankAccountFilter.add(new Match("EmpAccDefault", 1));
ArrayList bankAccounts = EEmpBankAccount.db.select(dbConn, bankAccountFilter);
EEmpBankAccount bankAccount;
if (bankAccounts.Count > 0)
{
bankAccount = (EEmpBankAccount)bankAccounts[0];
}
else
{
bankAccount = new EEmpBankAccount();
}
// Get Last Position using selected payroll group;
DBFilter positionFilter = new DBFilter();
positionFilter.add(new Match("EmpID", empInfo.EmpID));
positionFilter.add(new Match("PayGroupID", payGroup.PayGroupID));
positionFilter.add(new Match("EmpPosEffFr", "<=", payPeriod.PayPeriodTo));
OR orPosEffToTerms = new OR();
orPosEffToTerms.add(new Match("EmpPosEffTo", ">=", payPeriod.PayPeriodFr));
orPosEffToTerms.add(new NullTerm("EmpPosEffTo"));
positionFilter.add(orPosEffToTerms);
ArrayList positionInfos = EEmpPositionInfo.db.select(dbConn, positionFilter);
EEmpPositionInfo empPos = null;
if (positionInfos.Count > 0)
{
empPos = (EEmpPositionInfo)positionInfos[0];
}
else
{
empPos = AppUtils.GetLastPositionInfo(dbConn, payPeriod.PayPeriodTo, empInfo.EmpID);
}
EPosition position = new EPosition();
ECompany company = new ECompany();
if (empPos != null)
{
position.PositionID = empPos.PositionID;
EPosition.db.select(dbConn, position);
company.CompanyID = empPos.CompanyID;
ECompany.db.select(dbConn, company);
}
DBFilter empPayrollFilter = new DBFilter();
if ((reportType.Equals(ReportType.PaySlip) || reportType.Equals(ReportType.PaySlipDotMatrix)))
{
empPayrollFilter.add(empInfo.GetAllRoleEmpIDTerms(dbConn, "EmpID", EEmpPersonalInfo.RoleFilterOptionEnum.Payslip));
}
else
{
empPayrollFilter.add(new Match("EmpID", empInfo.EmpID));
}
if (reportType.Equals(ReportType.TrialRun))
{
empPayrollFilter.add(new Match("EmpPayStatus", "=", "T"));
}
else
{
empPayrollFilter.add(new Match("EmpPayStatus", "<>", "T"));
}
if (PayBatchList != null)
{
bool skipPayBatch = false;
if ((reportType.Equals(ReportType.PaySlip) || reportType.Equals(ReportType.PaySlipDotMatrix)))
{
if (empInfo.GetOtherRoleList(dbConn, EEmpPersonalInfo.RoleFilterOptionEnum.Payslip).Count > 0)
{
skipPayBatch = true;
}
}
if (!skipPayBatch)
{
OR orPayrollBatch = new OR();
foreach (EPayrollBatch payrollBatch in PayBatchList)
{
orPayrollBatch.add(new Match("PayBatchID", payrollBatch.PayBatchID));
}
empPayrollFilter.add(orPayrollBatch);
}
}
empPayrollFilter.add(new Match("PayPeriodID", payPeriod.PayPeriodID));
IN inEmpPayroll = new IN("EmpPayrollID", "Select EmpPayrollID from EmpPayroll", empPayrollFilter);
ArrayList empPayrollList = EEmpPayroll.db.select(dbConn, empPayrollFilter);
if (empPayrollList.Count > 0)
{
DBFilter paymentRecordFilter = new DBFilter();
paymentRecordFilter.add(inEmpPayroll);
paymentRecordFilter.add(new Match("PayRecStatus", "A"));
paymentRecordFilter.add("PaymentCodeID", true);
paymentRecordFilter.add("PayRecMethod", true);
ArrayList paymentRecords = EPaymentRecord.db.select(dbConn, paymentRecordFilter);
DBFilter mpfRecordFilter = new DBFilter();
mpfRecordFilter.add(inEmpPayroll);
mpfRecordFilter.add("MPFRecPeriodFr", true);
ArrayList mpfRecords = EMPFRecord.db.select(dbConn, mpfRecordFilter);
DBFilter orsoRecordFilter = new DBFilter();
orsoRecordFilter.add(inEmpPayroll);
orsoRecordFilter.add("ORSORecPeriodFr", true);
ArrayList orsoRecords = EORSORecord.db.select(dbConn, orsoRecordFilter);
//// need double confirm
//DBFilter payBatchFilter = new DBFilter();
//payBatchFilter.add(new IN("PayBatchID", "Select PayBatchID from EmpPayroll", empPayrollFilter));
//payBatchFilter.add("PayBatchValueDate", false);
//ArrayList payBatchs = EPayrollBatch.db.select(dbConn, payBatchFilter);
//EPayrollBatch payBatch = null;
//if (payBatchs.Count > 0)
// payBatch = (EPayrollBatch)payBatchs[0];
DataSet.Payroll_PaySlip.EmpInfoRow empInfoRow = empInfoTable.NewEmpInfoRow();
empInfoRow.ActualEmpID = empInfo.EmpID;
empInfoRow.EmpNo = empInfo.EmpNo;
empInfoRow.EmpName = empInfo.EmpEngFullName;
empInfoRow.EmpAlias = empInfo.EmpAlias;
empInfoRow.EmpEngFullNameWithAlias = empInfo.EmpEngFullNameWithAlias;
empInfoRow.EmpChineseName = empInfo.EmpChiFullName;
empInfoRow.EmpDateOfJoin = empInfo.EmpDateOfJoin;
empInfoRow.PayGroupDesc = payGroup.PayGroupCode + " - " + payGroup.PayGroupDesc;
empInfoRow.PayrollPeriod = strPayPeriod;
empInfoRow.PeriodFr = payPeriod.PayPeriodFr;
empInfoRow.PeriodTo = payPeriod.PayPeriodTo;
empInfoRow.MPFDate = new DateTime(payPeriod.PayPeriodTo.Year, payPeriod.PayPeriodTo.Month, 10).AddMonths(1);
empInfoRow.BankAccount = bankAccount.EmpBankCode + " - " + bankAccount.EmpBranchCode + "-" + bankAccount.EmpAccountNo;
empInfoRow.CompanyCode = company.CompanyCode;
empInfoRow.CompanyName = company.CompanyName;
empInfoRow.PositionDesc = position.PositionDesc;
empInfoRow.IsShowMinWageInfo = IsShowMinimumWage;
empInfoRow.TotalWagesForMinWages = HROne.Payroll.PayrollProcess.GetTotalWagesWithoutRestDayPayment(dbConn, empInfo.EmpID, payPeriod.PayPeriodFr, payPeriod.PayPeriodTo, null);
empInfoRow.TotalWorkingHours = HROne.Payroll.PayrollProcess.GetTotalEmpPayrollWorkingHours(dbConn, empInfo.EmpID, payPeriod.PayPeriodID);
empInfoRow.MinWagesRequired = empInfoRow.TotalWorkingHours * HROne.Payroll.PayrollProcess.GetMinimumWages(dbConn, empInfo.EmpID, payPeriod.PayPeriodTo);
//if (payBatch != null)
// if (payBatch.PayBatchValueDate.Ticks != 0)
// empInfoRow.ValueDate = payBatch.PayBatchValueDate;
if (HLevelIDDisplayList != null && empPos != null)
{
for (int count = 0; count < HLevelIDDisplayList.Count && count < 2; count++)
{
int hLevelID = Convert.ToInt32(HLevelIDDisplayList[count]);
EHierarchyLevel hLevel = new EHierarchyLevel();
hLevel.HLevelID = hLevelID;
if (EHierarchyLevel.db.select(dbConn, hLevel))
{
empInfoRow["HLevelDesc" + (count + 1)] = hLevel.HLevelDesc;
DBFilter empHierarchyFilter = new DBFilter();
empHierarchyFilter.add(new Match("EmpPosID", empPos.EmpPosID));
empHierarchyFilter.add(new Match("HLevelID", hLevelID));
ArrayList empHierarchyList = EEmpHierarchy.db.select(dbConn, empHierarchyFilter);
if (empHierarchyList.Count > 0)
{
EEmpHierarchy empHierarchy = (EEmpHierarchy)empHierarchyList[0];
EHierarchyElement hElement = new EHierarchyElement();
hElement.HElementID = empHierarchy.HElementID;
if (EHierarchyElement.db.select(dbConn, hElement))
{
empInfoRow["HElementCode" + (count + 1)] = hElement.HElementCode;
empInfoRow["HElementDesc" + (count + 1)] = hElement.HElementDesc;
}
}
}
}
}
foreach (EEmpPayroll empPayroll in empPayrollList)
{
if (!string.IsNullOrEmpty(empPayroll.EmpPayRemark))
{
if (empInfoRow.IsRemarkNull())
{
empInfoRow.Remark = empPayroll.EmpPayRemark.Trim();
}
else if (string.IsNullOrEmpty(empInfoRow.Remark))
{
empInfoRow.Remark = empPayroll.EmpPayRemark.Trim();
}
else
{
empInfoRow.Remark += "\r\n" + empPayroll.EmpPayRemark.Trim();
}
}
}
empInfoTable.Rows.Add(empInfoRow);
empInfoRow.EmpID = empInfoRow.PaySlipID;
DateTime LastValueDate;
GeneratePayrollData(empInfoRow.PaySlipID, paymentRecords, out LastValueDate);
bool hasMPF = false, hasORSO = false, hasLeaveBalance = false;
if (IsShowLeaveBalance)
{
hasLeaveBalance = GenerateLeaveBalanceData(empInfoRow.PaySlipID, empInfo.EmpID, payPeriod.PayPeriodTo);
}
hasMPF = GenerateMPFData(empInfoRow.PaySlipID, mpfRecords);
hasORSO = GenerateORSOData(empInfoRow.PaySlipID, orsoRecords);
empInfoRow.HasMPF = hasMPF;
empInfoRow.HasORSO = hasORSO;
empInfoRow.HasLeaveBalance = hasLeaveBalance;
if (!LastValueDate.Ticks.Equals(0))
{
empInfoRow.ValueDate = LastValueDate;
}
}
}
}
}
System.Data.DataRow[] allowanceRows = dataSet.PaySlip.Select("PayAmount > 0", "PaymentCodeDisplaySeqNo");
foreach (System.Data.DataRow importRow in allowanceRows)
{
dataSet.PaySlip_Allowance.ImportRow(importRow);
}
System.Data.DataRow[] deductionRows = dataSet.PaySlip.Select("PayAmount < 0", "PaymentCodeDisplaySeqNo");
foreach (System.Data.DataRow importRow in deductionRows)
{
dataSet.PaySlip_Deduction.ImportRow(importRow);
}
}
public bool Save()
{
EEmpRecurringPayment c = new EEmpRecurringPayment();
Hashtable values = new Hashtable();
binding.toValues(values);
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
db.validate(errors, values);
if (!errors.isEmpty())
{
return(false);
}
db.parse(values, c);
if (c.EmpRPMethod.Equals("A"))
{
if (c.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, c.EmpID);
if (bankAccount != null)
{
//c.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError("EmpAccID", HROne.Translation.PageErrorMessage.ERROR_ACCOUNT_REQUIRED);
}
}
}
else
{
c.EmpAccID = 0;
}
AND andTerms = new AND();
andTerms.add(new Match("EmpRPID", "<>", c.EmpRPID));
andTerms.add(new Match("EmpRPEffFr", "<", c.EmpRPEffFr));
andTerms.add(new Match("PayCodeID", c.PayCodeID));
EEmpRecurringPayment lastObj = (EEmpRecurringPayment)AppUtils.GetLastObj(dbConn, db, "EmpRPEffFr", c.EmpID, andTerms);
//if (CurID < 0)
//{
// if (lastObj != null && c.EmpRPEffFr <= lastObj.EmpRPEffFr)
// errors.addError("EmpRPEffFr", HROne.Translation.SystemMessage.ERROR_DATE_FROM_OVERLAP);
//}
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", c.EmpID));
filter.add(new Match("PayCodeID", c.PayCodeID));
filter.add(new Match("EmpRPID", "<>", c.EmpRPID));
OR or = new OR();
AND and;
and = new AND();
and.add(new Match("EmpRPEffFr", "<=", c.EmpRPEffFr));
and.add(new Match("EmpRPEffTo", ">=", c.EmpRPEffFr));
or.add(and);
and = new AND();
and.add(new NullTerm("EmpRPEffTo"));
and.add(new Match("EmpRPEffFr", "=", c.EmpRPEffFr));
or.add(and);
if (c.EmpRPEffTo > DateTime.MinValue)
{
and = new AND();
and.add(new Match("EmpRPEffFr", "<=", c.EmpRPEffTo));
and.add(new Match("EmpRPEffTo", ">=", c.EmpRPEffTo));
or.add(and);
and = new AND();
and.add(new Match("EmpRPEffFr", ">=", c.EmpRPEffFr));
and.add(new Match("EmpRPEffFr", "<=", c.EmpRPEffTo));
or.add(and);
}
filter.add(or);
if (db.count(dbConn, filter) > 0)
{
errors.addError(HROne.Translation.PageErrorMessage.ERROR_PAY_EFF_DATE_OVERLAP);
}
if (!errors.isEmpty())
{
return(false);
}
c.SchemeCode = null;
c.Capacity = null;
c.Point = 0;
if (SchemeCode.SelectedIndex > 0)
{
c.SchemeCode = SchemeCode.Text;
c.Capacity = CapacitySelect.Text;
if (PointSelect.Text != "")
{
c.Point = Decimal.Parse(PointSelect.Text);
}
}
WebUtils.StartFunction(Session, FUNCTION_CODE, c.EmpID);
if (CurrentEmpRPID <= 0)
{
// Utils.MarkCreate(Session, c);
db.insert(dbConn, c);
CurrentEmpRPID = c.EmpRPID;
// url = Utils.BuildURL(-1, CurID);
if (lastObj != null && lastObj.EmpRPEffFr < c.EmpRPEffFr)
{
if (lastObj.EmpRPEffTo < lastObj.EmpRPEffFr)
{
lastObj.EmpRPEffTo = c.EmpRPEffFr.AddDays(-1);
db.update(dbConn, lastObj);
}
}
}
else
{
// Utils.Mark(Session, c);
db.update(dbConn, c);
}
WebUtils.EndFunction(dbConn);
return(true);
}
protected void Save_Click(object sender, EventArgs e)
{
EEmpContractTerms c = new EEmpContractTerms();
Hashtable values = new Hashtable();
binding.toValues(values);
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
db.validate(errors, values);
if (!errors.isEmpty())
{
return;
}
db.parse(values, c);
if (c.EmpContractGratuityMethod.Equals("A"))
{
if (c.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, c.EmpID);
if (bankAccount != null)
{
c.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError("EmpAccID", HROne.Translation.PageErrorMessage.ERROR_ACCOUNT_REQUIRED);
}
}
}
else
{
c.EmpAccID = 0;
}
if (c.EmpContractEmployedTo != DateTime.MinValue && c.EmpContractEmployedFrom > c.EmpContractEmployedTo)
{
errors.addError("EmpPoRFrom", HROne.Translation.PageErrorMessage.ERROR_DATE_TO_TOO_EARLY);
return;
}
WebUtils.StartFunction(Session, FUNCTION_CODE, c.EmpID);
c.CurrencyID = "HKD";
if (CurID < 0)
{
// Utils.MarkCreate(Session, c);
db.insert(dbConn, c);
CurID = c.EmpContractID;
// url = Utils.BuildURL(-1, CurID);
}
else
{
// Utils.Mark(Session, c);
db.update(dbConn, c);
}
WebUtils.EndFunction(dbConn);
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "Emp_Contract_View.aspx?EmpContractID=" + CurID + "&EmpID=" + c.EmpID);
}
protected void Add_Click(object sender, EventArgs e)
{
// Hard code set Currency to HKD
CurrencyID.SelectedValue = "HKD";
Repeater.EditItemIndex = -1;
EPaymentRecord c = new EPaymentRecord();
Hashtable values = new Hashtable();
newBinding.toValues(values);
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
db.validate(errors, values);
if (!errors.isEmpty())
{
return;
}
db.parse(values, c);
EEmpPayroll empPayroll = new EEmpPayroll();
empPayroll.EmpPayrollID = c.EmpPayrollID;
if (EEmpPayroll.db.select(dbConn, empPayroll))
{
if (c.PayRecMethod.Equals("A"))
{
if (c.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, empPayroll.EmpID);
if (bankAccount != null)
{
//c.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError("EmpAccID", HROne.Translation.PageErrorMessage.ERROR_ACCOUNT_REQUIRED);
}
}
}
if (!errors.isEmpty())
{
return;
}
c.PayRecCalAmount = 0;
//c.PayRecNumOfDayAdj = 0;
c.PayRecStatus = PaymentRecordStatus.PAYRECORDSTATUS_ACTIVE;
if (EmpPayStatus.Value == "C")
{
c.PayRecType = PaymentRecordType.PAYRECORDTYPE_CONFIRM_ADJUSTMENT;
}
else
{
c.PayRecType = PaymentRecordType.PAYRECORDTYPE_TRIALRUN_ADJUSTMENT;
}
WebUtils.StartFunction(Session, m_FunctionCode, empPayroll.EmpID);
db.insert(dbConn, c);
WebUtils.EndFunction(dbConn);
PaymentCodeID.SelectedIndex = 0;
CurrencyID.SelectedIndex = 0;
PayRecActAmount.Text = string.Empty;
PayRecMethod.SelectedIndex = 0;
PayRecNumOfDayAdj.Text = string.Empty;
PayRecRemark.Text = string.Empty;
view = loadData(info, db, Repeater);
}
//Response.Redirect(Request.Url.LocalPath + "?" + Request.QueryString);
}
public static DataTable Export(DatabaseConnection dbConn, ArrayList empList, bool IsIncludeCurrentPositionInfo, bool IsShowDescription, bool IsIncludeSyncID, DateTime ReferenceDateTime)
{
DataTable tmpDataTable = new DataTable(TABLE_NAME);
//if (IsIncludeInternalID)
// tmpDataTable.Columns.Add(FIELD_INTERNAL_ID, typeof(string));
tmpDataTable.Columns.Add(FIELD_EMP_NO, typeof(string));
if (IsIncludeCurrentPositionInfo)
{
ImportEmpPersonalInfoProcess.AddEmployeeInfoHeader(tmpDataTable);
ImportEmpPositionInfoProcess.AddEmployeePositionInfoHeader(dbConn, tmpDataTable);
}
tmpDataTable.Columns.Add(FIELD_PAYMENT_CODE, typeof(string));
tmpDataTable.Columns.Add(FIELD_AMOUNT, typeof(double));
tmpDataTable.Columns.Add(FIELD_METHOD, typeof(string));
tmpDataTable.Columns.Add(FIELD_ACCOUNT_NO, typeof(string));
tmpDataTable.Columns.Add(FIELD_COST_CENTER, typeof(string));
tmpDataTable.Columns.Add(FIELD_NUM_OF_DAY_ADJUST, typeof(double));
tmpDataTable.Columns.Add(FIELD_REMARK, typeof(string));
if (IsIncludeSyncID)
{
tmpDataTable.Columns.Add(FIELD_SYNC_ID, typeof(string));
}
foreach (EEmpPersonalInfo empInfo in empList)
{
if (EEmpPersonalInfo.db.select(dbConn, empInfo))
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", empInfo.EmpID));
filter.add(getCreateModifiedRecordsAfterDBTerm(ReferenceDateTime));
ArrayList list = EEmpFinalPayment.db.select(dbConn, filter);
foreach (EEmpFinalPayment empFinalPayment in list)
{
DataRow row = tmpDataTable.NewRow();
//if (IsIncludeInternalID)
// row[FIELD_INTERNAL_ID] = ToHexDecWithCheckDigit(empFinalPayment.EmpFinalPayID);
row[FIELD_EMP_NO] = empInfo.EmpNo;
if (IsIncludeCurrentPositionInfo)
{
ImportEmpPersonalInfoProcess.AddEmployeeInfo(dbConn, row, empInfo.EmpID);
ImportEmpPositionInfoProcess.AddEmployeePositionInfo(dbConn, row, empInfo.EmpID);
}
EPaymentCode paymentCode = new EPaymentCode();
paymentCode.PaymentCodeID = empFinalPayment.PayCodeID;
if (EPaymentCode.db.select(dbConn, paymentCode))
{
row[FIELD_PAYMENT_CODE] = IsShowDescription ? paymentCode.PaymentCodeDesc : paymentCode.PaymentCode;
}
row[FIELD_AMOUNT] = empFinalPayment.EmpFinalPayAmount;
if (empFinalPayment.EmpFinalPayMethod.Equals("A"))
{
row[FIELD_METHOD] = "Autopay";
EEmpBankAccount empBankAccount = new EEmpBankAccount();
empBankAccount.EmpBankAccountID = empFinalPayment.EmpAccID;
if (EEmpBankAccount.db.select(dbConn, empBankAccount))
{
row[FIELD_ACCOUNT_NO] = empBankAccount.EmpBankCode + "-" + empBankAccount.EmpBranchCode + "-" + empBankAccount.EmpAccountNo;
}
}
else if (empFinalPayment.EmpFinalPayMethod.Equals("Q"))
{
row[FIELD_METHOD] = "Cheque";
}
else if (empFinalPayment.EmpFinalPayMethod.Equals("C"))
{
row[FIELD_METHOD] = "Cash";
}
else
{
row[FIELD_METHOD] = "Others";
}
ECostCenter costCenter = new ECostCenter();
costCenter.CostCenterID = empFinalPayment.CostCenterID;
if (ECostCenter.db.select(dbConn, costCenter))
{
row[FIELD_COST_CENTER] = IsShowDescription ? costCenter.CostCenterDesc : costCenter.CostCenterCode;
}
row[FIELD_NUM_OF_DAY_ADJUST] = empFinalPayment.EmpFinalPayNumOfDayAdj;
row[FIELD_REMARK] = empFinalPayment.EmpFinalPayRemark;
if (IsIncludeSyncID)
{
row[FIELD_SYNC_ID] = empFinalPayment.SynID;
}
tmpDataTable.Rows.Add(row);
}
}
}
if (IsIncludeCurrentPositionInfo)
{
ImportEmpPositionInfoProcess.RetriveHierarchyLevelHeader(dbConn, tmpDataTable);
}
return(tmpDataTable);
}
protected void Repeater_ItemCommand(object source, DataListCommandEventArgs e)
{
Button b = (Button)e.CommandSource;
if (b.ID.Equals("Edit"))
{
Repeater.EditItemIndex = e.Item.ItemIndex;
//AddPanel.Visible = false;
view = loadData(info, db, Repeater);
WebUtils.SetEnabledControlSection(AddPanel, false);
}
else if (b.ID.Equals("Cancel"))
{
Repeater.EditItemIndex = -1;
//AddPanel.Visible = IsAllowEdit;
view = loadData(info, db, Repeater);
WebUtils.SetEnabledControlSection(AddPanel, true);
}
else if (b.ID.Equals("Save"))
{
Binding eBinding;
// Hard code set Currency to HKD
((DropDownList)e.Item.FindControl("CurrencyID")).SelectedValue = "HKD";
eBinding = new Binding(dbConn, db);
eBinding.add(EmpPayrollID);
eBinding.add((HtmlInputHidden)e.Item.FindControl("PayRecID"));
eBinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("CurrencyID"), Values.VLCurrency));
if (((DropDownList)e.Item.FindControl("PaymentCodeID")).Enabled)
{
eBinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("PaymentCodeID"), EPaymentCode.VLPaymentCode));
}
if (((TextBox)e.Item.FindControl("PayRecActAmount")).Enabled)
{
eBinding.add((TextBox)e.Item.FindControl("PayRecActAmount"));
}
if (((TextBox)e.Item.FindControl("PayRecNumOfDayAdj")).Enabled)
{
eBinding.add((TextBox)e.Item.FindControl("PayRecNumOfDayAdj"));
}
if (((TextBox)e.Item.FindControl("PayRecRemark")).Enabled)
{
eBinding.add((TextBox)e.Item.FindControl("PayRecRemark"));
}
eBinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("CostCenterID"), ECostCenter.VLCostCenter).setNotSelected(HROne.Common.WebUtility.GetLocalizedString(ECostCenter.DEFAULT_COST_CENTER_TEXT)));
eBinding.add(new CheckBoxBinder(db, (CheckBox)e.Item.FindControl("PayRecIsRestDayPayment")));
eBinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("PayRecMethod"), Values.VLPaymentMethod).setNotSelected(null));
//DBFilter filter = new DBFilter();
//DBFilter inFilter = new DBFilter();
//inFilter.add(new Match("EmpPayrollID", EmpPayrollID.Value));
//filter.add(new IN("EmpID", "Select EmpID from EmpPayroll", inFilter));
eBinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("EmpAccID"), EEmpBankAccount.VLBankAccount, empBankAccountFilter).setNotSelected(HROne.Common.WebUtility.GetLocalizedString(EEmpBankAccount.DEFAULT_BANK_ACCOUNT_TEXT)));
eBinding.init(Request, Session);
EPaymentRecord obj = new EPaymentRecord();
Hashtable values = new Hashtable();
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
eBinding.toValues(values);
db.validate(errors, values);
if (!errors.isEmpty())
{
HROne.Common.WebUtility.WebControlsLocalization(Session, e.Item.Controls);
return;
}
db.parse(values, obj);
EEmpPayroll empPayroll = new EEmpPayroll();
empPayroll.EmpPayrollID = obj.EmpPayrollID;
if (EEmpPayroll.db.select(dbConn, empPayroll))
{
if (obj.PayRecMethod.Equals("A"))
{
if (obj.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, empPayroll.EmpID);
if (bankAccount != null)
{
//obj.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError("EmpAccID", HROne.Translation.PageErrorMessage.ERROR_ACCOUNT_REQUIRED);
}
}
}
if (!errors.isEmpty())
{
HROne.Common.WebUtility.WebControlsLocalization(Session, e.Item.Controls);
return;
}
WebUtils.StartFunction(Session, m_FunctionCode, empPayroll.EmpID);
db.update(dbConn, obj);
WebUtils.EndFunction(dbConn);
Repeater.EditItemIndex = -1;
//AddPanel.Visible = IsAllowEdit;
view = loadData(info, db, Repeater);
WebUtils.SetEnabledControlSection(AddPanel, true);
}
//Response.Redirect(Request.Url.LocalPath + "?" + Request.QueryString);
}
}
public static string GetValueFromID(DatabaseConnection dbConn, string fieldName, string fieldValue)
{
try
{
string tmpfieldName = fieldName;
if (tmpfieldName.Equals("PreviousEmpID", StringComparison.CurrentCultureIgnoreCase) || tmpfieldName.Equals("NewEmpID", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "EmpID";
}
if (tmpfieldName.EndsWith("PaymentCodeID", StringComparison.CurrentCultureIgnoreCase) || tmpfieldName.EndsWith("PayCodeID", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "PaymentCodeID";
}
if (tmpfieldName.Equals("DefaultMPFPlanID", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "MPFPlanID";
}
if (tmpfieldName.Equals("AttendanceFormulaPayFormID", StringComparison.CurrentCultureIgnoreCase) || tmpfieldName.Equals("ReferencePayFormID", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "PayFormID";
}
if (tmpfieldName.StartsWith("LeaveCode", StringComparison.CurrentCultureIgnoreCase) && tmpfieldName.EndsWith("Formula", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "PayFormID";
}
if (tmpfieldName.StartsWith("PayGroup", StringComparison.CurrentCultureIgnoreCase) && tmpfieldName.EndsWith("Formula", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "PayFormID";
}
if (tmpfieldName.Equals("CurrentPayPeriodID", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "PayPeriodID";
}
if (tmpfieldName.Equals("EmpPosDefaultRosterCodeID", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "RosterCodeID";
}
if (tmpfieldName.Equals("RosterClientMappingSiteCodeToHLevelID", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "HLevelID";
}
if (tmpfieldName.Equals("EmpFirstAuthorizationGp", StringComparison.CurrentCultureIgnoreCase) || tmpfieldName.Equals("EmpSecondAuthorizationGp", StringComparison.CurrentCultureIgnoreCase))
{
tmpfieldName = "AuthorizationGroupID";
}
if (tmpfieldName.StartsWith("A", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("ALProrataRoundingRuleID", StringComparison.CurrentCultureIgnoreCase))
{
EALProrataRoundingRule obj = new EALProrataRoundingRule();
obj.ALProrataRoundingRuleID = int.Parse(fieldValue);
if (EALProrataRoundingRule.db.select(dbConn, obj))
{
return(obj.ALProrataRoundingRuleCode + " - " + obj.ALProrataRoundingRuleDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("AttendancePlanID", StringComparison.CurrentCultureIgnoreCase))
{
EAttendancePlan obj = new EAttendancePlan();
obj.AttendancePlanID = int.Parse(fieldValue);
if (EAttendancePlan.db.select(dbConn, obj))
{
return(obj.AttendancePlanCode + " - " + obj.AttendancePlanDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("AuthorizationGroupID", StringComparison.CurrentCultureIgnoreCase))
{
EAuthorizationGroup obj = new EAuthorizationGroup();
obj.AuthorizationGroupID = int.Parse(fieldValue);
if (EAuthorizationGroup.db.select(dbConn, obj))
{
return(obj.AuthorizationCode + " - " + obj.AuthorizationDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("AVCPlanID", StringComparison.CurrentCultureIgnoreCase))
{
EAVCPlan obj = new EAVCPlan();
obj.AVCPlanID = int.Parse(fieldValue);
if (EAVCPlan.db.select(dbConn, obj))
{
return(obj.AVCPlanCode + " - " + obj.AVCPlanDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("C", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("CessationReasonID", StringComparison.CurrentCultureIgnoreCase))
{
ECessationReason obj = new ECessationReason();
obj.CessationReasonID = int.Parse(fieldValue);
if (ECessationReason.db.select(dbConn, obj))
{
return(obj.CessationReasonCode + " - " + obj.CessationReasonDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("CompanyID", StringComparison.CurrentCultureIgnoreCase))
{
ECompany obj = new ECompany();
obj.CompanyID = int.Parse(fieldValue);
if (ECompany.db.select(dbConn, obj))
{
return(obj.CompanyCode + " - " + obj.CompanyName);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("CostAllocationDetailID", StringComparison.CurrentCultureIgnoreCase))
{
ECostAllocationDetail obj = new ECostAllocationDetail();
obj.CostAllocationDetailID = int.Parse(fieldValue);
if (ECostAllocationDetail.db.select(dbConn, obj))
{
return(GetValueFromID(dbConn, "PayCodeID", obj.PaymentCodeID.ToString()) + ", " + GetValueFromID(dbConn, "CostCenterID", obj.CostCenterID.ToString()));
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("CostAllocationID", StringComparison.CurrentCultureIgnoreCase))
{
ECostAllocation obj = new ECostAllocation();
obj.CostAllocationID = int.Parse(fieldValue);
if (ECostAllocation.db.select(dbConn, obj))
{
return(GetValueFromID(dbConn, "EmpPayrollID", obj.EmpPayrollID.ToString()));
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("CostCenterID", StringComparison.CurrentCultureIgnoreCase))
{
ECostCenter obj = new ECostCenter();
obj.CostCenterID = int.Parse(fieldValue);
if (ECostCenter.db.select(dbConn, obj))
{
return(obj.CostCenterCode + " - " + obj.CostCenterDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("D", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("DocumentTypeID", StringComparison.CurrentCultureIgnoreCase))
{
EDocumentType obj = new EDocumentType();
obj.DocumentTypeID = int.Parse(fieldValue);
if (EDocumentType.db.select(dbConn, obj))
{
return(obj.DocumentTypeCode + " - " + obj.DocumentTypeDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("E", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("EmpAccID", StringComparison.CurrentCultureIgnoreCase))
{
EEmpBankAccount obj = new EEmpBankAccount();
obj.EmpBankAccountID = int.Parse(fieldValue);
if (EEmpBankAccount.db.select(dbConn, obj))
{
return(obj.EmpBankCode + "-" + obj.EmpBranchCode + "-" + obj.EmpAccountNo);
}
//return obj.EmpBankCode + "-" + obj.EmpBranchCode + "-" + string.Empty.PadRight(obj.EmpAccountNo.Length, 'X');
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("EmpCostCenterID", StringComparison.CurrentCultureIgnoreCase))
{
EEmpCostCenter obj = new EEmpCostCenter();
obj.EmpCostCenterID = int.Parse(fieldValue);
if (EEmpCostCenter.db.select(dbConn, obj))
{
return(GetValueFromID(dbConn, "EmpID", obj.EmpID.ToString()));
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("EmpExtraFieldID", StringComparison.CurrentCultureIgnoreCase))
{
EEmpExtraField obj = new EEmpExtraField();
obj.EmpExtraFieldID = int.Parse(fieldValue);
if (EEmpExtraField.db.select(dbConn, obj))
{
return(obj.EmpExtraFieldName);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("EmpID", StringComparison.CurrentCultureIgnoreCase))
{
EEmpPersonalInfo obj = new EEmpPersonalInfo();
obj.EmpID = int.Parse(fieldValue);
if (EEmpPersonalInfo.db.select(dbConn, obj))
{
return(obj.EmpNo + " - " + obj.EmpEngFullName);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("EmpPayrollID", StringComparison.CurrentCultureIgnoreCase))
{
EEmpPayroll obj = new EEmpPayroll();
obj.EmpPayrollID = int.Parse(fieldValue);
if (EEmpPayroll.db.select(dbConn, obj))
{
return(GetValueFromID(dbConn, "EmpID", obj.EmpID.ToString()) + " : " + GetValueFromID(dbConn, "PayPeriodID", obj.PayPeriodID.ToString()));
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("EmpPosID", StringComparison.CurrentCultureIgnoreCase))
{
EEmpPositionInfo obj = new EEmpPositionInfo();
obj.EmpPosID = int.Parse(fieldValue);
if (EEmpPositionInfo.db.select(dbConn, obj))
{
return(obj.EmpPosEffFr.ToString("yyyy-MM-dd") + " - " + (obj.EmpPosEffTo.Ticks.Equals(0) ? "Present" : obj.EmpPosEffTo.ToString("yyyy-MM-dd")));
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("EmploymentTypeID", StringComparison.CurrentCultureIgnoreCase))
{
EEmploymentType obj = new EEmploymentType();
obj.EmploymentTypeID = int.Parse(fieldValue);
if (EEmploymentType.db.select(dbConn, obj))
{
return(obj.EmploymentTypeCode + " - " + obj.EmploymentTypeDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("F", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("FunctionID", StringComparison.CurrentCultureIgnoreCase))
{
ESystemFunction obj = new ESystemFunction();
obj.FunctionID = int.Parse(fieldValue);
if (ESystemFunction.db.select(dbConn, obj))
{
return(obj.FunctionCode + " - " + obj.Description);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("H", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("HElementID", StringComparison.CurrentCultureIgnoreCase))
{
EHierarchyElement obj = new EHierarchyElement();
obj.HElementID = int.Parse(fieldValue);
if (EHierarchyElement.db.select(dbConn, obj))
{
return(obj.HElementCode + " - " + obj.HElementDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("HLevelID", StringComparison.CurrentCultureIgnoreCase))
{
EHierarchyLevel obj = new EHierarchyLevel();
obj.HLevelID = int.Parse(fieldValue);
if (EHierarchyLevel.db.select(dbConn, obj))
{
return(obj.HLevelCode + " - " + obj.HLevelDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("L", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("LeaveTypeID", StringComparison.CurrentCultureIgnoreCase))
{
ELeaveType obj = new ELeaveType();
obj.LeaveTypeID = int.Parse(fieldValue);
if (ELeaveType.db.select(dbConn, obj))
{
return(obj.LeaveType + " - " + obj.LeaveTypeDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("LeaveCodeID", StringComparison.CurrentCultureIgnoreCase))
{
ELeaveCode obj = new ELeaveCode();
obj.LeaveCodeID = int.Parse(fieldValue);
if (ELeaveCode.db.select(dbConn, obj))
{
return(obj.LeaveCode + " - " + obj.LeaveCodeDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("LeavePlanID", StringComparison.CurrentCultureIgnoreCase))
{
ELeavePlan obj = new ELeavePlan();
obj.LeavePlanID = int.Parse(fieldValue);
if (ELeavePlan.db.select(dbConn, obj))
{
return(obj.LeavePlanCode + " - " + obj.LeavePlanDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("M", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("MPFPlanID", StringComparison.CurrentCultureIgnoreCase))
{
EMPFPlan obj = new EMPFPlan();
obj.MPFPlanID = int.Parse(fieldValue);
if (EMPFPlan.db.select(dbConn, obj))
{
return(obj.MPFPlanCode + " - " + obj.MPFPlanDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("MPFSchemeID", StringComparison.CurrentCultureIgnoreCase))
{
EMPFScheme obj = new EMPFScheme();
obj.MPFSchemeID = int.Parse(fieldValue);
if (EMPFScheme.db.select(dbConn, obj))
{
return(obj.MPFSchemeCode + " - " + obj.MPFSchemeDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("MPFSchemeCessationReasonID", StringComparison.CurrentCultureIgnoreCase))
{
EMPFSchemeCessationReason obj = new EMPFSchemeCessationReason();
obj.MPFSchemeCessationReasonID = int.Parse(fieldValue);
if (EMPFSchemeCessationReason.db.select(dbConn, obj))
{
return(obj.MPFSchemeCessationReasonCode + " - " + obj.MPFSchemeCessationReasonDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("O", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("ORSOPlanID", StringComparison.CurrentCultureIgnoreCase))
{
EORSOPlan obj = new EORSOPlan();
obj.ORSOPlanID = int.Parse(fieldValue);
if (EORSOPlan.db.select(dbConn, obj))
{
return(obj.ORSOPlanCode + " - " + obj.ORSOPlanDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("P", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("PayGroupID", StringComparison.CurrentCultureIgnoreCase) || tmpfieldName.Equals("PayrollGroupID", StringComparison.CurrentCultureIgnoreCase))
{
EPayrollGroup obj = new EPayrollGroup();
obj.PayGroupID = int.Parse(fieldValue);
if (EPayrollGroup.db.select(dbConn, obj))
{
return(obj.PayGroupCode + " - " + obj.PayGroupDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("PayFormID", StringComparison.CurrentCultureIgnoreCase))
{
EPayrollProrataFormula obj = new EPayrollProrataFormula();
obj.PayFormID = int.Parse(fieldValue);
if (EPayrollProrataFormula.db.select(dbConn, obj))
{
return(obj.PayFormCode + " - " + obj.PayFormDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("PaymentCodeID", StringComparison.CurrentCultureIgnoreCase) || tmpfieldName.Equals("PayCodeID", StringComparison.CurrentCultureIgnoreCase))
{
EPaymentCode obj = new EPaymentCode();
obj.PaymentCodeID = int.Parse(fieldValue);
if (EPaymentCode.db.select(dbConn, obj))
{
return(obj.PaymentCode + " - " + obj.PaymentCodeDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("PaymentTypeID", StringComparison.CurrentCultureIgnoreCase))
{
EPaymentType obj = new EPaymentType();
obj.PaymentTypeID = int.Parse(fieldValue);
if (EPaymentType.db.select(dbConn, obj))
{
return(obj.PaymentTypeCode + " - " + obj.PaymentTypeDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("PayPeriodID", StringComparison.CurrentCultureIgnoreCase))
{
EPayrollPeriod obj = new EPayrollPeriod();
obj.PayPeriodID = int.Parse(fieldValue);
if (EPayrollPeriod.db.select(dbConn, obj))
{
return(GetValueFromID(dbConn, "PayrollGroupID", obj.PayGroupID.ToString()) + ": " + obj.PayPeriodFr.ToString("yyyy-MM-dd") + " to " + obj.PayPeriodTo.ToString("yyyy-MM-dd"));
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("PermitTypeID", StringComparison.CurrentCultureIgnoreCase))
{
EPermitType obj = new EPermitType();
obj.PermitTypeID = int.Parse(fieldValue);
if (EPermitType.db.select(dbConn, obj))
{
return(obj.PermitTypeCode + " - " + obj.PermitTypeDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("PositionID", StringComparison.CurrentCultureIgnoreCase))
{
EPosition obj = new EPosition();
obj.PositionID = int.Parse(fieldValue);
if (EPosition.db.select(dbConn, obj))
{
return(obj.PositionCode + " - " + obj.PositionDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("Q", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("QualificationID", StringComparison.CurrentCultureIgnoreCase))
{
EQualification obj = new EQualification();
obj.QualificationID = int.Parse(fieldValue);
if (EQualification.db.select(dbConn, obj))
{
return(obj.QualificationCode + " - " + obj.QualificationDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("R", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("RankID", StringComparison.CurrentCultureIgnoreCase))
{
ERank obj = new ERank();
obj.RankID = int.Parse(fieldValue);
if (ERank.db.select(dbConn, obj))
{
return(obj.RankCode + " - " + obj.RankDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("ReminderTypeID", StringComparison.CurrentCultureIgnoreCase))
{
EReminderType obj = new EReminderType();
obj.ReminderTypeID = int.Parse(fieldValue);
if (EReminderType.db.select(dbConn, obj))
{
return(obj.ReminderTypeCode + " - " + obj.ReminderTypeDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("RosterClientID", StringComparison.CurrentCultureIgnoreCase))
{
ERosterClient obj = new ERosterClient();
obj.RosterClientID = int.Parse(fieldValue);
if (ERosterClient.db.select(dbConn, obj))
{
return(obj.RosterClientCode + " - " + obj.RosterClientName);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("RosterClientSiteID", StringComparison.CurrentCultureIgnoreCase))
{
ERosterClientSite obj = new ERosterClientSite();
obj.RosterClientSiteID = int.Parse(fieldValue);
if (ERosterClientSite.db.select(dbConn, obj))
{
return(obj.RosterClientSiteCode);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("RosterCodeID", StringComparison.CurrentCultureIgnoreCase))
{
ERosterCode obj = new ERosterCode();
obj.RosterCodeID = int.Parse(fieldValue);
if (ERosterCode.db.select(dbConn, obj))
{
return(obj.RosterCode + " - " + obj.RosterCodeDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("S", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("SkillID", StringComparison.CurrentCultureIgnoreCase))
{
ESkill obj = new ESkill();
obj.SkillID = int.Parse(fieldValue);
if (ESkill.db.select(dbConn, obj))
{
return(obj.SkillCode + " - " + obj.SkillDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("SkillLevelID", StringComparison.CurrentCultureIgnoreCase))
{
ESkillLevel obj = new ESkillLevel();
obj.SkillLevelID = int.Parse(fieldValue);
if (ESkillLevel.db.select(dbConn, obj))
{
return(obj.SkillLevelCode + " - " + obj.SkillLevelDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("StaffTypeID", StringComparison.CurrentCultureIgnoreCase))
{
EStaffType obj = new EStaffType();
obj.StaffTypeID = int.Parse(fieldValue);
if (EStaffType.db.select(dbConn, obj))
{
return(obj.StaffTypeCode + " - " + obj.StaffTypeDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("T", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("TaxCompID", StringComparison.CurrentCultureIgnoreCase))
{
ETaxCompany obj = new ETaxCompany();
obj.TaxCompID = int.Parse(fieldValue);
if (ETaxCompany.db.select(dbConn, obj))
{
return(obj.TaxCompEmployerName);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("TaxEmpID", StringComparison.CurrentCultureIgnoreCase))
{
ETaxEmp obj = new ETaxEmp();
obj.TaxEmpID = int.Parse(fieldValue);
if (ETaxEmp.db.select(dbConn, obj))
{
return(obj.TaxEmpSurname + ", " + obj.TaxEmpOtherName + ", " + GetValueFromID(dbConn, "TaxFormID", obj.TaxFormID.ToString()));
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("TaxFormID", StringComparison.CurrentCultureIgnoreCase))
{
ETaxForm obj = new ETaxForm();
obj.TaxFormID = int.Parse(fieldValue);
if (ETaxForm.db.select(dbConn, obj))
{
return("Tax Year :" + obj.TaxFormYear + ", Form: IR56" + obj.TaxFormType);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("TaxPayID", StringComparison.CurrentCultureIgnoreCase))
{
ETaxPayment obj = new ETaxPayment();
obj.TaxPayID = int.Parse(fieldValue);
if (ETaxPayment.db.select(dbConn, obj))
{
return(obj.TaxPayCode + " - " + obj.TaxPayDesc);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("TrainingCourseID", StringComparison.CurrentCultureIgnoreCase))
{
ETrainingCourse obj = new ETrainingCourse();
obj.TrainingCourseID = int.Parse(fieldValue);
if (ETrainingCourse.db.select(dbConn, obj))
{
return(obj.TrainingCourseCode + " - " + obj.TrainingCourseName);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("TrainingSeminarID", StringComparison.CurrentCultureIgnoreCase))
{
ETrainingSeminar obj = new ETrainingSeminar();
obj.TrainingSeminarID = int.Parse(fieldValue);
if (ETrainingSeminar.db.select(dbConn, obj))
{
return(GetValueFromID(dbConn, "TrainingCourseID", obj.TrainingCourseID.ToString()) + ": " + obj.TrainingSeminarDateFrom.ToString("yyyy-MM-dd") + " to " + obj.TrainingSeminarDateTo.ToString("yyyy-MM-dd"));
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("U", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("UserID", StringComparison.CurrentCultureIgnoreCase))
{
EUser obj = new EUser();
obj.UserID = int.Parse(fieldValue);
if (EUser.db.select(dbConn, obj))
{
return(obj.LoginID + " - " + obj.UserName);
}
else
{
return(string.Empty);
}
}
if (tmpfieldName.Equals("UserGroupID", StringComparison.CurrentCultureIgnoreCase))
{
EUserGroup obj = new EUserGroup();
obj.UserGroupID = int.Parse(fieldValue);
if (EUserGroup.db.select(dbConn, obj))
{
return(obj.UserGroupName + " - " + obj.UserGroupDesc);
}
else
{
return(string.Empty);
}
}
}
else if (tmpfieldName.StartsWith("Y", StringComparison.CurrentCultureIgnoreCase))
{
if (tmpfieldName.Equals("YebPlanID", StringComparison.CurrentCultureIgnoreCase))
{
EYEBPlan obj = new EYEBPlan();
obj.YEBPlanID = int.Parse(fieldValue);
if (EYEBPlan.db.select(dbConn, obj))
{
return(obj.YEBPlanCode + " - " + obj.YEBPlanDesc);
}
else
{
return(string.Empty);
}
}
}
if (tmpfieldName.EndsWith("ID") && !tmpfieldName.EndsWith("HKID") && !tmpfieldName.EndsWith("LoginID") && !tmpfieldName.EndsWith("CurrencyID") && !tmpfieldName.EndsWith("LeaveAppID") && !tmpfieldName.EndsWith("EmpPaymentID") && !tmpfieldName.EndsWith("PayBatchID") && !tmpfieldName.EndsWith("PayRecID") && !tmpfieldName.EndsWith("RosterTableID") && !tmpfieldName.EndsWith("SynID") && !tmpfieldName.EndsWith("CNDImportBatchID"))
{
if (ESystemParameter.getParameter(dbConn, "DebugMode").Equals("Y"))
{
throw new Exception("ID field not define:" + fieldName);
}
}
return(string.Empty);
}
catch (Exception ex)
{
if (ESystemParameter.getParameter(dbConn, "DebugMode").Equals("Y"))
{
throw ex;
}
else
{
return(string.Empty);
}
}
}
public DataTable UploadToTempDatabase(DataTable rawDataTable, int UserID)
{
if (rawDataTable == null)
{
return(GetImportDataFromTempDatabase(null));
}
int rowCount = 1;
//ArrayList results = new ArrayList();
try
{
foreach (DataRow row in rawDataTable.Rows)
{
rowCount++;
string EmpNo = row[FIELD_EMP_NO].ToString();
int EmpID = HROne.Import.Parse.GetEmpID(dbConn, EmpNo, UserID);
if (EmpID < 0)
{
errors.addError(ImportErrorMessage.ERROR_ACCESS_DENIED_EMP_NO, new string[] { EmpNo, rowCount.ToString() });
}
string PaymentCode = row[FIELD_PAYMENT_CODE].ToString();
int PayCodeID = HROne.Import.Parse.GetPaymentCodeID(dbConn, PaymentCode);
string BankCode = row[FIELD_BANK_ACCOUNT_NO].ToString();
int BankAccID = HROne.Import.Parse.GetEmpAccID(dbConn, BankCode, EmpID);
string EffDateString = row[FIELD_EFFECTIVE_DATE].ToString();
DateTime EffDate = Import.Parse.toDateTimeObject(row[FIELD_EFFECTIVE_DATE]);
//if (EffDateString.Trim().Length == 8 && long.TryParse(EffDateString, out tryEffDateString))
//{
// EffDate = new DateTime(int.Parse(EffDateString.Substring(0, 4)), int.Parse(EffDateString.Substring(4, 2)), int.Parse(EffDateString.Substring(6, 2)));
//}
string PayMethod = row[FIELD_PAYMENT_METHOD].ToString().Trim();
string Remark = row[FIELD_REMARK].ToString();
string amountString = row[FIELD_AMOUNT].ToString();
double amount = 0;
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.Trim()))
{
if (!double.TryParse(NumOfDayAdjustString, out NumOfDayAdjust))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_NUM_OF_DAY_ADJUST + "=" + NumOfDayAdjustString, EmpNo, rowCount.ToString() });
}
}
}
bool IsRestDayPayment = false;
if (rawDataTable.Columns.Contains(FIELD_REST_PAYMENT))
{
if (row.IsNull(FIELD_REST_PAYMENT))
{
IsRestDayPayment = false;
}
else
{
IsRestDayPayment = (row[FIELD_REST_PAYMENT].ToString().Equals("Y", StringComparison.CurrentCultureIgnoreCase) || row[FIELD_REST_PAYMENT].ToString().Equals("Yes", StringComparison.CurrentCultureIgnoreCase));
}
}
int CostCenterID = 0;
if (rawDataTable.Columns.Contains(FIELD_COST_CENTER))
{
string CostCenter = row[FIELD_COST_CENTER].ToString();
if (!string.IsNullOrEmpty(CostCenter))
{
CostCenterID = HROne.Import.Parse.GetCostCenterID(dbConn, CostCenter, false, UserID);
if (CostCenterID <= 0)
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_COST_CENTER + "=" + CostCenter, EmpNo, rowCount.ToString() });
}
}
}
//if (!double.TryParse(amountString, out amount))
//{
// throw new ImportException("Amount", amountString, "Invalid Number Format");
//}
if (EmpID > 0 && PayCodeID > 0 && (BankAccID > 0 || BankAccID == 0 && BankCode.Trim().Equals(string.Empty)) && EffDate.Ticks != 0 && double.TryParse(amountString, out amount))
{
EUploadClaimsAndDeductions CND = new EUploadClaimsAndDeductions();
CND.EmpID = EmpID;
CND.CNDEffDate = EffDate;
CND.PayCodeID = PayCodeID;
CND.CurrencyID = HROne.Lib.ExchangeCurrency.DefaultCurrency();
CND.EmpAccID = BankAccID;
CND.CNDNumOfDayAdj = NumOfDayAdjust;
if (PayMethod.Equals("Autopay", StringComparison.CurrentCultureIgnoreCase))
{
CND.CNDPayMethod = "A";
if (CND.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, CND.EmpID);
if (bankAccount != null)
{
//CND.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_BANK_ACCOUNT_NO + "=" + BankCode, EmpNo, rowCount.ToString() });
}
}
}
else if (PayMethod.Equals("Cash", StringComparison.CurrentCultureIgnoreCase))
{
CND.CNDPayMethod = "C";
}
else if (PayMethod.Equals("Cheque", StringComparison.CurrentCultureIgnoreCase))
{
CND.CNDPayMethod = "Q";
}
else
{
CND.CNDPayMethod = "O";
}
CND.CNDIsRestDayPayment = IsRestDayPayment;
CND.CostCenterID = CostCenterID;
CND.CNDRemark = Remark;
CND.CNDAmount = HROne.CommonLib.GenericRoundingFunctions.RoundingTo(amount, 2, 2);
CND.SessionID = m_SessionID;
CND.TransactionDate = UploadDateTime;
CND.ImportActionStatus = ImportDBObject.ImportActionEnum.UPDATE;
db.insert(dbConn, CND);
//results.Add(CND);
}
else
{
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 (BankAccID == 0 && !BankCode.Trim().Equals(string.Empty))
{
errors.addError(ImportErrorMessage.ERROR_INVALID_FIELD_VALUE, new string[] { FIELD_BANK_ACCOUNT_NO + "=" + BankCode, 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() });
}
}
}
}
catch (Exception e)
{
errors.addError(e.Message, null);
}
if (errors.List.Count > 0)
{
ClearTempTable();
throw (new HRImportException(rawDataTable.TableName + "\r\n" + errors.Message()));
}
return(GetImportDataFromTempDatabase(null));
}
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));
}
protected DataSet GenerateCND(int ProcessID, int PaymentCodeID, DateTime PaymentDate)
{
DateTime m_paymentDate = new DateTime();
string m_paymentCode = "";
ESalaryIncrementBatch m_process = ESalaryIncrementBatch.GetObject(dbConn, ProcessID);
DataSet dataSet = new DataSet();//export.GetDataSet();
DataTable dataTable = new DataTable("ClaimsAndDeduction$");
dataSet.Tables.Add(dataTable);
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO, typeof(string));
dataTable.Columns.Add("English Name", typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE, typeof(DateTime));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER, typeof(string));
DBFilter m_detailFilter = new DBFilter();
m_detailFilter.add(new Match("BatchID", m_process.BatchID));
m_detailFilter.add("DetailID", true);
foreach (ESalaryIncrementBatchDetail m_detail in ESalaryIncrementBatchDetail.db.select(dbConn, m_detailFilter))
{
DBFilter m_rpFilter = new DBFilter();
m_rpFilter.add(new Match("EmpRPID", m_detail.EmpRPID));
//m_rpFilter.add(new IN("EmpRPID", "SELECT EmpRPID FROM PS_SalaryIncrementBatchDetail ", m_detailFilter));
foreach (EEmpRecurringPayment m_empRP in EEmpRecurringPayment.db.select(dbConn, m_rpFilter))
{
DBFilter m_mapFilter = new DBFilter();
m_mapFilter.add(new Match("SchemeCode", AppUtils.Encode(EPayScaleMap.db.getField("SchemeCode"), m_empRP.SchemeCode)));
m_mapFilter.add(new Match("Point", m_detail.NewPoint));
m_mapFilter.add(new NullTerm("ExpiryDate"));
foreach (EPayScaleMap m_map in EPayScaleMap.db.select(dbConn, m_mapFilter))
{
decimal m_newSalary = m_map.Salary;
string m_remarks = "";
double m_amount = System.Convert.ToDouble(m_newSalary) - m_empRP.EmpRPAmount;
if (Math.Abs(m_amount) > 0.01)
{
m_remarks = String.Format("Backpay {0}: {1}-{2}.", m_process.AsAtDate.ToString("yyyy-MM"),
m_newSalary.ToString("#,##0.00"),
m_empRP.EmpRPAmount.ToString("#,##0.00"));
EEmpPersonalInfo m_empInfo = new EEmpPersonalInfo();
m_empInfo.EmpID = m_empRP.EmpID;
EEmpPersonalInfo.db.select(dbConn, m_empInfo);
DataRow m_row = dataTable.NewRow();
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO] = m_empInfo.EmpNo;
m_row["English Name"] = m_empInfo.EmpEngFullName;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE] = m_paymentDate;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE] = m_paymentCode;
switch (m_empRP.EmpRPMethod)
{
case "A":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Autopay";
break;
case "Q":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cheque";
break;
case "C":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cash";
break;
default:
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Other";
break;
}
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT] = Math.Round(m_amount, 2);
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST] = 0; //DateTime.DaysInMonth(m_process.AsAtDate);
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT] = "No";
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK] = m_remarks;
EEmpBankAccount m_bank = new EEmpBankAccount();
m_bank.EmpBankAccountID = m_empRP.EmpAccID;
if (EEmpBankAccount.db.select(dbConn, m_bank))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO] = m_bank.EmpAccountNo;
}
ECostCenter m_costCenter = new ECostCenter();
m_costCenter.CostCenterID = m_empRP.CostCenterID;
if (ECostCenter.db.select(dbConn, m_costCenter))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER] = m_costCenter.CostCenterCode;
}
dataTable.Rows.Add(m_row);
}
}
}
}
return(dataSet);
}
public bool Save()
{
EEmpBankAccount c = new EEmpBankAccount();
Hashtable values = new Hashtable();
binding.toValues(values);
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
db.validate(errors, values);
if (!errors.isEmpty())
{
return(false);
}
db.parse(values, c);
DBFilter bankAccountFilter = new DBFilter();
bankAccountFilter.add(new Match("EmpID", c.EmpID));
bankAccountFilter.add(new Match("EmpBankAccountID", "<>", c.EmpBankAccountID));
ArrayList bankAccountLIst = EEmpBankAccount.db.select(dbConn, bankAccountFilter);
foreach (EEmpBankAccount empBankAccount in bankAccountLIst)
{
if (empBankAccount.EmpBankCode.Equals(c.EmpBankCode) && empBankAccount.EmpBranchCode.Equals(c.EmpBranchCode) && empBankAccount.EmpAccountNo.Equals(c.EmpAccountNo))
{
if (c.EmpBankAccountRemark.Equals(empBankAccount.EmpBankAccountRemark) || string.IsNullOrEmpty(c.EmpBankAccountRemark) && string.IsNullOrEmpty(empBankAccount.EmpBankAccountRemark))
{
errors.addError(string.Format(HROne.Common.WebUtility.GetLocalizedString("ERROR_CODE_DUPLICATE"), new string[] { HROne.Common.WebUtility.GetLocalizedString("Bank Account"), c.EmpBankCode + "-" + c.EmpBranchCode + "-" + c.EmpAccountNo }));
}
}
}
if (!errors.isEmpty())
{
return(false);
}
WebUtils.StartFunction(Session, FUNCTION_CODE, c.EmpID);
if (c.EmpBankAccountID <= 0)
{
// Utils.MarkCreate(Session, c);
db.insert(dbConn, c);
EmpBankAccountID = c.EmpBankAccountID;
// url = Utils.BuildURL(-1, CurID);
}
else
{
// Utils.Mark(Session, c);
db.update(dbConn, c);
}
WebUtils.EndFunction(dbConn);
if (c.EmpAccDefault)
{
DBFilter filter = new DBFilter();
filter.add(new Match("EmpBankAccountID", "<>", c.EmpBankAccountID));
filter.add(new Match("EmpID", c.EmpID));
filter.add(new Match("EmpAccDefault", "<>", false));
EEmpBankAccount t = new EEmpBankAccount();
t.EmpAccDefault = false;
db.updateByTemplate(dbConn, t, filter);
}
return(true);
}
protected void Add_Click(object sender, EventArgs e)
{
// Hard code set Currency to HKD
CurrencyID.SelectedValue = "HKD";
Repeater.EditItemIndex = -1;
EClaimsAndDeductions c = new EClaimsAndDeductions();
Hashtable values = new Hashtable();
newBinding.toValues(values);
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
db.validate(errors, values);
if (!errors.isEmpty())
{
return;
}
db.parse(values, c);
if (c.CNDPayMethod.Equals("A"))
{
if (c.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, c.EmpID);
if (bankAccount != null)
{
//c.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError("EmpAccID", HROne.Translation.PageErrorMessage.ERROR_ACCOUNT_REQUIRED);
}
}
}
else
{
c.EmpAccID = 0;
}
if (!errors.isEmpty())
{
return;
}
WebUtils.StartFunction(Session, FUNCTION_CODE, c.EmpID);
db.insert(dbConn, c);
WebUtils.EndFunction(dbConn);
CNDEffDate.Value = string.Empty;
PayCodeID.SelectedIndex = 0;
CurrencyID.SelectedIndex = 0;
CNDAmount.Text = string.Empty;
CNDPayMethod.SelectedIndex = 0;
CNDRemark.Text = string.Empty;
EmpAccID.SelectedIndex = 0;
CNDIsRestDayPayment.Checked = false;
CNDNumOfDayAdj.Text = string.Empty;
loadData(info, db, Repeater);
}
private DataSet GenerateBackpayTemplate(String schemeCode, int paymentCodeID, DateTime paymentDate)
{
//Dictionary<int, string> m_PaymentCodeList = new Dictionary<int, string>();
//foreach (EPaymentCode o in EPaymentCode.db.select(dbConn, new DBFilter()))
//{
// m_PaymentCodeList.Add(o.PaymentCodeID, o.PaymentCode);
//}
string m_paymentCode = (EPaymentCode.GetObject(dbConn, paymentCodeID)).PaymentCode;
DataSet dataSet = new DataSet();//export.GetDataSet();
DataTable dataTable = new DataTable("ClaimsAndDeduction$");
dataSet.Tables.Add(dataTable);
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO, typeof(string));
dataTable.Columns.Add("English Name", typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE, typeof(DateTime));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST, typeof(double));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK, typeof(string));
dataTable.Columns.Add(HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER, typeof(string));
DBFilter m_payscaleFilter = new DBFilter();
m_payscaleFilter.add(new NullTerm("ExpiryDate"));
if (schemeCode != "")
{
m_payscaleFilter.add(new Match("SchemeCode", schemeCode));
}
m_payscaleFilter.add("EffectiveDate", false);
foreach (EPayScaleMap m_latestPayscale in EPayScaleMap.db.select(dbConn, m_payscaleFilter))
{
DBFilter m_payPeriodFilter = new DBFilter();
m_payPeriodFilter.add(new Match("PayPeriodFr", ">=", m_latestPayscale.EffectiveDate));
m_payPeriodFilter.add(new Match("PayPeriodStatus", "=", EPayrollPeriod.PAYPERIOD_STATUS_PROCESSEND_FLAG));
m_payPeriodFilter.add(WebUtils.AddRankFilter(Session, "EmpID", true));
foreach (EPayrollPeriod m_payrollPeriod in EPayrollPeriod.db.select(dbConn, m_payPeriodFilter))
{
DBFilter m_empPayrollFilter = new DBFilter();
m_empPayrollFilter.add(new Match("PayPeriodID", m_payrollPeriod.PayPeriodID));
DBFilter m_paymentRecordFilter = new DBFilter();
DBFilter m_paymentTypeFilter = new DBFilter();
DBFilter m_paymentCodeFilter = new DBFilter();
m_paymentTypeFilter.add(new Match("PaymentTypeCode", "BASICSAL"));
m_paymentCodeFilter.add(new IN("PaymentTypeID", "SELECT PaymentTypeID FROM PaymentType", m_paymentTypeFilter));
m_paymentRecordFilter.add(new Match("EmpRPIDforBP", ">", 0));
m_paymentRecordFilter.add(new IN("EmpPayrollID", "SELECT EmpPayrollID FROM EmpPayroll", m_empPayrollFilter));
m_paymentRecordFilter.add(new IN("PaymentCodeID", "SELECT PaymentCodeID FROM PaymentCode", m_paymentCodeFilter));
foreach (EPaymentRecord m_payRecord in EPaymentRecord.db.select(dbConn, m_paymentRecordFilter))
{
EEmpRecurringPayment m_empRP = EEmpRecurringPayment.GetObject(dbConn, m_payRecord.EmpRPIDforBP);
if (schemeCode != "")
{
if (m_empRP.SchemeCode == null || m_empRP.SchemeCode != schemeCode)
{
break;
}
}
decimal m_newSalary = GetPayScale(m_empRP);
string m_remarks = "";
double m_amount = 0;
if (m_newSalary > 0)
{
// m_amount = Math.Round((m_payRecord.PayRecActAmount / m_empRP.EmpRPAmount) * (System.Convert.ToDouble(m_newSalary) - m_empRP.EmpRPAmount), 2);
int m_daysInMonth = DateTime.DaysInMonth(m_payrollPeriod.PayPeriodFr.Year, m_payrollPeriod.PayPeriodFr.Month);
if (m_payRecord.PayRecNumOfDayAdj != m_daysInMonth)
{
m_amount = Math.Round((System.Convert.ToDouble(m_newSalary) - m_empRP.EmpRPAmount) * m_payRecord.PayRecNumOfDayAdj / m_daysInMonth, 2);
m_remarks = String.Format("Backpay {0}: ({1}-{2})*{3}/{4}.", m_payrollPeriod.PayPeriodFr.ToString("yyyy-MM"),
m_newSalary.ToString("#,##0.00"),
m_empRP.EmpRPAmount.ToString("#,##0.00"),
m_payRecord.PayRecNumOfDayAdj,
m_daysInMonth);
}
else
{
m_amount = Math.Round((System.Convert.ToDouble(m_newSalary) - m_empRP.EmpRPAmount), 2);
m_remarks = String.Format("Backpay {0}: {1}-{2}.", m_payrollPeriod.PayPeriodFr.ToString("yyyy-MM"),
m_newSalary.ToString("#,##0.00"),
m_empRP.EmpRPAmount.ToString("#,##0.00"));
}
if (m_amount > 0)
{
EEmpPersonalInfo m_empInfo = new EEmpPersonalInfo();
m_empInfo.EmpID = m_empRP.EmpID;
EEmpPersonalInfo.db.select(dbConn, m_empInfo);
DataRow m_row = dataTable.NewRow();
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EMP_NO] = m_empInfo.EmpNo;
m_row["English Name"] = m_empInfo.EmpEngFullName;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_EFFECTIVE_DATE] = paymentDate;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_CODE] = m_paymentCode;
switch (m_empRP.EmpRPMethod)
{
case "A":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Autopay";
break;
case "Q":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cheque";
break;
case "C":
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Cash";
break;
default:
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_PAYMENT_METHOD] = "Other";
break;
}
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_AMOUNT] = m_amount;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_NUM_OF_DAY_ADJUST] = 0;
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REST_PAYMENT] = "No";
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_REMARK] = m_remarks;
EEmpBankAccount m_bank = new EEmpBankAccount();
m_bank.EmpBankAccountID = m_empRP.EmpAccID;
if (EEmpBankAccount.db.select(dbConn, m_bank))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_BANK_ACCOUNT_NO] = m_bank.EmpAccountNo;
}
ECostCenter m_costCenter = new ECostCenter();
m_costCenter.CostCenterID = m_empRP.CostCenterID;
if (ECostCenter.db.select(dbConn, m_costCenter))
{
m_row[HROne.Import.ImportClaimsAndDeductionsProcess.FIELD_COST_CENTER] = m_costCenter.CostCenterCode;
}
dataTable.Rows.Add(m_row);
}
}
}
}
break; // handle only 1 effective date
}
return(dataSet);
}
protected void Repeater_ItemCommand(object source, DataListCommandEventArgs e)
{
Button b = (Button)e.CommandSource;
if (b.ID.Equals("Edit"))
{
Repeater.EditItemIndex = e.Item.ItemIndex;
//CNDAddPanel.Visible = false;
loadData(info, db, Repeater);
WebUtils.SetEnabledControlSection(CNDAddPanel, false);
}
else if (b.ID.Equals("Cancel"))
{
Repeater.EditItemIndex = -1;
//CNDAddPanel.Visible = IsAllowEdit;
loadData(info, db, Repeater);
WebUtils.SetEnabledControlSection(CNDAddPanel, true);
}
else if (b.ID.Equals("Save"))
{
Binding ebinding;
// Hard code set Currency to HKD
((DropDownList)e.Item.FindControl("CurrencyID")).SelectedValue = "HKD";
ebinding = new Binding(dbConn, db);
ebinding.add(EmpID);
ebinding.add(new TextBoxBinder(db, ((WebDatePicker)e.Item.FindControl("CNDEffDate")).TextBox, "CNDEffDate"));
ebinding.add((HtmlInputHidden)e.Item.FindControl("CNDID"));
ebinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("PayCodeID"), EPaymentCode.VLPaymentCode));
ebinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("CurrencyID"), Values.VLCurrency));
ebinding.add((TextBox)e.Item.FindControl("CNDAmount"));
ebinding.add(new CheckBoxBinder(db, (CheckBox)e.Item.FindControl("CNDIsRestDayPayment")));
ebinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("CNDPayMethod"), Values.VLPaymentMethod).setNotSelected(null));
ebinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("CostCenterID"), ECostCenter.VLCostCenter).setNotSelected(HROne.Common.WebUtility.GetLocalizedString(ECostCenter.DEFAULT_COST_CENTER_TEXT)));
ebinding.add((TextBox)e.Item.FindControl("CNDNumOfDayAdj"));
ebinding.add((TextBox)e.Item.FindControl("CNDRemark"));
DBFilter empBankAccountFilter = new DBFilter();
OR bankAccountORTerm = new OR();
bankAccountORTerm.add(new Match("EmpID", CurID));
{
EEmpPersonalInfo tmpEmpInfo = new EEmpPersonalInfo();
tmpEmpInfo.EmpID = CurID;
if (EEmpPersonalInfo.db.select(dbConn, tmpEmpInfo) && tmpEmpInfo.MasterEmpID > 0)
{
bankAccountORTerm.add(new Match("EmpID", tmpEmpInfo.MasterEmpID));
}
}
empBankAccountFilter.add(bankAccountORTerm);
ebinding.add(new DropDownVLBinder(db, (DropDownList)e.Item.FindControl("EmpAccID"), EEmpBankAccount.VLBankAccount, empBankAccountFilter).setNotSelected(HROne.Common.WebUtility.GetLocalizedString(EEmpBankAccount.DEFAULT_BANK_ACCOUNT_TEXT)));
ebinding.init(Request, Session);
EClaimsAndDeductions obj = new EClaimsAndDeductions();
Hashtable values = new Hashtable();
PageErrors errors = PageErrors.getErrors(db, Page.Master);
errors.clear();
ebinding.toValues(values);
db.validate(errors, values);
if (!errors.isEmpty())
{
HROne.Common.WebUtility.WebControlsLocalization(this, e.Item.Controls);
return;
}
db.parse(values, obj);
if (obj.CNDPayMethod.Equals("A"))
{
if (obj.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, int.Parse(EmpID.Value));
if (bankAccount != null)
{
//obj.EmpAccID = bankAccount.EmpBankAccountID;
}
else
{
errors.addError("EmpAccID", HROne.Translation.PageErrorMessage.ERROR_ACCOUNT_REQUIRED);
}
}
}
else
{
obj.EmpAccID = 0;
}
if (!errors.isEmpty())
{
HROne.Common.WebUtility.WebControlsLocalization(this, e.Item.Controls);
return;
}
WebUtils.StartFunction(Session, FUNCTION_CODE, obj.EmpID);
db.update(dbConn, obj);
WebUtils.EndFunction(dbConn);
Repeater.EditItemIndex = -1;
//CNDAddPanel.Visible = IsAllowEdit;
loadData(info, db, Repeater);
WebUtils.SetEnabledControlSection(CNDAddPanel, true);
}
}
public virtual void LoadBankFileDetail(ArrayList PayrollBatchList, ArrayList EmpList)
{
BankFileDetails.Clear();
m_TotalAmount = 0;
// Move autoPayList out of the EmpList loop for sharing bank account feature between roles
Dictionary <EmpBankTransactionBreakDownKey, GenericBankFileDetail> autoPayList = new Dictionary <EmpBankTransactionBreakDownKey, GenericBankFileDetail>();
List <int> PayPeriodIDList = new List <int>();
foreach (EEmpPersonalInfo empInfo in EmpList)
{
Dictionary <EmpBankTransactionBreakDownKey, GenericBankFileDetail> chequePaymentList = new Dictionary <EmpBankTransactionBreakDownKey, GenericBankFileDetail>();
DBFilter empPayrollFilter = new DBFilter();
empPayrollFilter.add(new Match("EmpID", empInfo.EmpID));
OR orPayrollBatch = new OR();
foreach (EPayrollBatch payBatch in PayrollBatchList)
{
orPayrollBatch.add(new Match("PayBatchID", payBatch.PayBatchID));
}
empPayrollFilter.add(orPayrollBatch);
ArrayList empPayrollList = EEmpPayroll.db.select(dbConn, empPayrollFilter);
foreach (EEmpPayroll empPayroll in empPayrollList)
{
if (!PayPeriodIDList.Contains(empPayroll.PayPeriodID))
{
PayPeriodIDList.Add(empPayroll.PayPeriodID);
}
if (!m_ValueDate.Ticks.Equals(0))
{
empPayroll.EmpPayValueDate = m_ValueDate;
}
if (empPayroll.EmpPayValueDate.Ticks.Equals(0))
{
EPayrollBatch payBatch = new EPayrollBatch();
payBatch.PayBatchID = empPayroll.PayBatchID;
if (EPayrollBatch.db.select(dbConn, payBatch))
{
empPayroll.EmpPayValueDate = payBatch.PayBatchValueDate;
}
}
DBFilter paymentRecordFilter = new DBFilter();
paymentRecordFilter.add(new Match("EmpPayrollID", empPayroll.EmpPayrollID));
OR orPaymentMethodTerm = new OR();
orPaymentMethodTerm.add(new Match("PayRecMethod", "A"));
if (m_IsGenerateChequePayment)
{
orPaymentMethodTerm.add(new Match("PayRecMethod", "Q"));
}
paymentRecordFilter.add(orPaymentMethodTerm);
ArrayList paymentRecordList = EPaymentRecord.db.select(dbConn, paymentRecordFilter);
foreach (EPaymentRecord paymentRecord in paymentRecordList)
{
if (paymentRecord.PayRecMethod.Equals("A"))
{
EEmpBankAccount empAcc = new EEmpBankAccount();
empAcc.EmpBankAccountID = paymentRecord.EmpAccID;
if (!EEmpBankAccount.db.select(dbConn, empAcc))
{
empAcc = EEmpBankAccount.GetDefaultBankAccount(dbConn, empInfo.EmpID);
if (empAcc == null)
{
EEmpPersonalInfo.db.select(dbConn, empInfo);
throw new InvalidEEBankAccountException(empInfo.EmpNo, empInfo.EmpEngFullName);
}
}
EmpBankTransactionBreakDownKey key = new EmpBankTransactionBreakDownKey(empAcc.EmpBankAccountID, empPayroll.EmpPayValueDate);
GenericBankFileDetail BankFileDetail;
if (autoPayList.ContainsKey(key))
{
BankFileDetail = autoPayList[key];
}
else
{
BankFileDetail = CreateBankFileDetail(empAcc.EmpID);
BankFileDetail.EmpBankAccountHolderName = empAcc.EmpBankAccountHolderName.Trim();
BankFileDetail.BankCode = empAcc.EmpBankCode;
BankFileDetail.BranchCode = empAcc.EmpBranchCode;
BankFileDetail.AccountNo = empAcc.EmpAccountNo;
BankFileDetail.ValueDate = empPayroll.EmpPayValueDate;
autoPayList.Add(key, BankFileDetail);
}
BankFileDetail.Amount += paymentRecord.PayRecActAmount;
BankFileDetail.Amount = Math.Round(BankFileDetail.Amount, 2, MidpointRounding.AwayFromZero);
m_TotalAmount += paymentRecord.PayRecActAmount;
}
else if (paymentRecord.PayRecMethod.Equals("Q") && m_IsGenerateChequePayment)
{
EmpBankTransactionBreakDownKey key = new EmpBankTransactionBreakDownKey(0, empPayroll.EmpPayValueDate);
GenericBankFileDetail BankFileDetail;
if (chequePaymentList.ContainsKey(key))
{
BankFileDetail = chequePaymentList[key];
}
else
{
BankFileDetail = CreateBankFileDetail(empInfo.EmpID);
BankFileDetail.ValueDate = empPayroll.EmpPayValueDate;
BankFileDetail.IsChequePayment = true;
chequePaymentList.Add(key, BankFileDetail);
}
BankFileDetail.Amount += paymentRecord.PayRecActAmount;
BankFileDetail.Amount = Math.Round(BankFileDetail.Amount, 2, MidpointRounding.AwayFromZero);
m_TotalAmount += paymentRecord.PayRecActAmount;
}
}
}
BankFileDetails.AddRange(chequePaymentList.Values);
chequePaymentList.Clear();
}
BankFileDetails.AddRange(autoPayList.Values);
autoPayList.Clear();
List <GenericBankFileDetail> NegativeBankFileDetailList = new List <GenericBankFileDetail>();
List <GenericBankFileDetail> zeroAmountBankFileDetails = new List <GenericBankFileDetail>();
foreach (GenericBankFileDetail bankFileDetail in BankFileDetails)
{
if (bankFileDetail != null)
{
if (bankFileDetail.Amount < 0)
{
NegativeBankFileDetailList.Add(bankFileDetail);
}
else if (Math.Abs(bankFileDetail.Amount) <= 0.005)
{
zeroAmountBankFileDetails.Add(bankFileDetail);
}
}
}
foreach (GenericBankFileDetail bankFileDetail in zeroAmountBankFileDetails)
{
BankFileDetails.Remove(bankFileDetail);
ZeroBankFileDetails.Add(bankFileDetail);
}
foreach (int PayPeriodID in PayPeriodIDList)
{
EPayrollPeriod payPeriod = new EPayrollPeriod();
payPeriod.PayPeriodID = PayPeriodID;
if (EPayrollPeriod.db.select(dbConn, payPeriod))
{
if (m_PayPeriodFr.Ticks.Equals(0) || m_PayPeriodFr > payPeriod.PayPeriodFr)
{
m_PayPeriodFr = payPeriod.PayPeriodFr;
}
if (m_PayPeriodTo.Ticks.Equals(0) || m_PayPeriodTo < payPeriod.PayPeriodTo)
{
m_PayPeriodTo = payPeriod.PayPeriodTo;
}
}
}
if (NegativeBankFileDetailList.Count > 0)
{
throw new NegativeAmountException(new ArrayList(NegativeBankFileDetailList));
}
}
protected bool loadObject()
{
obj = new EEmpRecurringPayment();
bool isNew = WebFormWorkers.loadKeys(db, obj, DecryptedRequest);
DBFilter filter = new DBFilter();
filter.add(new Match("EmpID", CurEmpID));
filter.add(WebUtils.AddRankFilter(Session, "EmpID", true));
if (EEmpPersonalInfo.db.count(dbConn, filter) == 0)
{
if (CurEmpID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
if (!db.select(dbConn, obj))
{
if (CurID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
if (obj.EmpID != CurEmpID)
{
if (CurID <= 0)
{
return(false);
}
else
{
HROne.Common.WebUtility.RedirectURLwithEncryptedQueryString(Response, Session, "~/AccessDeny.aspx");
}
}
Emp_RecurringPayment_List1.CurrentEmpID = obj.EmpID;
Emp_RecurringPayment_List1.CurrentPayCodeID = obj.PayCodeID;
CurPayCodeID = obj.PayCodeID;
Hashtable values = new Hashtable();
db.populate(obj, values);
binding.toControl(values);
if (obj.EmpRPMethod.Equals("A"))
{
BankAccountRow.Visible = true;
lblDefaultBankAccount.Text = string.Empty;
if (obj.EmpAccID == 0)
{
EEmpBankAccount bankAccount = EEmpBankAccount.GetDefaultBankAccount(dbConn, CurEmpID);
if (bankAccount != null)
{
lblDefaultBankAccount.Text = bankAccount.EmpBankCode + "-" + bankAccount.EmpBranchCode + "-" + bankAccount.EmpAccountNo;
}
}
}
else
{
BankAccountRow.Visible = false;
}
if (obj.EmpRPUnit.Equals("P"))
{
//EmpRPUnitPeriodAsDaily.Visible = true;
if (obj.EmpRPUnitPeriodAsDaily)
{
EmpRPUnitPeriodAsDaily.Visible = true;
EmpRPUnitPeriodAsDailyPayFormIDRow.Visible = true;
}
else
{
EmpRPUnitPeriodAsDaily.Visible = false;
EmpRPUnitPeriodAsDailyPayFormIDRow.Visible = false;
}
}
else
{
EmpRPUnitPeriodAsDaily.Visible = false;
EmpRPUnitPeriodAsDailyPayFormIDRow.Visible = false;
}
// Start 0000166, KuangWei, 2015-02-04
init_ShiftDutyCodeLabel();
init_PayCalFormulaCodeLabel();
// End 0000166, KuangWei, 2015-02-04
return(true);
}
