private void GetChildrenIntern(IList <String> help, string AAccountCode, int AChildLevel)
{
if (FAccountTable.Rows.Count > 0)
{
FAccountTable.DefaultView.Sort =
AAccountHierarchyDetailTable.GetReportOrderDBName() + ", " +
AAccountHierarchyDetailTable.GetReportingAccountCodeDBName();
foreach (DataRowView rv in FAccountTable.DefaultView)
{
accountRow = (AAccountHierarchyDetailRow)rv.Row;
if (accountRow.AccountCodeToReportTo.Equals(AAccountCode))
{
if (accountRow.AccountHierarchyCode.Equals(STANDARD))
{
help.Add(accountRow.ReportingAccountCode);
if (AChildLevel != 0)
{
GetChildrenIntern(help, accountRow.ReportingAccountCode, --AChildLevel);
}
}
}
}
}
}
/// <summary>
/// ...
/// </summary>
/// <param name="ALedgerNumber"></param>
public TGetAccountHierarchyDetailInfo(Int32 ALedgerNumber)
{
#region Validate Arguments
if (ALedgerNumber <= 0)
{
throw new EFinanceSystemInvalidLedgerNumberException(String.Format(Catalog.GetString(
"Function:{0} - The Ledger number must be greater than 0!"),
Utilities.GetMethodName(true)), ALedgerNumber);
}
#endregion Validate Arguments
TDBTransaction Transaction = new TDBTransaction();
TDataBase db = DBAccess.Connect("TGetAccountHierarchyDetailInfo");
try
{
db.ReadTransaction(
ref Transaction,
delegate
{
FHierarchyDetailTable = AAccountHierarchyDetailAccess.LoadViaALedger(ALedgerNumber, Transaction);
FAccountTable = AAccountAccess.LoadViaALedger(ALedgerNumber, Transaction);
FAccountTable.DefaultView.Sort = "a_account_code_c";
});
}
catch (Exception ex)
{
TLogging.LogException(ex, Utilities.GetMethodSignature());
throw;
}
db.CloseDBConnection();
}
/// <summary>
/// ...
/// </summary>
/// <param name="ALedgerNumber"></param>
public TGetAccountHierarchyDetailInfo(Int32 ALedgerNumber)
{
#region Validate Arguments
if (ALedgerNumber <= 0)
{
throw new EFinanceSystemInvalidLedgerNumberException(String.Format(Catalog.GetString(
"Function:{0} - The Ledger number must be greater than 0!"),
Utilities.GetMethodName(true)), ALedgerNumber);
}
#endregion Validate Arguments
TDBTransaction Transaction = null;
try
{
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
FHierarchyDetailTable = AAccountHierarchyDetailAccess.LoadViaALedger(ALedgerNumber, Transaction);
FAccountTable = AAccountAccess.LoadViaALedger(ALedgerNumber, Transaction);
FAccountTable.DefaultView.Sort = "a_account_code_c";
});
}
catch (Exception ex)
{
TLogging.LogException(ex, Utilities.GetMethodSignature());
throw;
}
}
/// <summary>
/// ...
/// </summary>
/// <param name="ALedgerInfo"></param>
public TGetAccountHierarchyDetailInfo(TLedgerInfo ALedgerInfo)
{
FledgerInfo = ALedgerInfo;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
FAccountTable = AAccountHierarchyDetailAccess.LoadViaALedger(
FledgerInfo.LedgerNumber, Transaction);
});
}
/// <summary>
/// ...
/// </summary>
/// <param name="ALedgerInfo"></param>
public TGetAccountHierarchyDetailInfo(TLedgerInfo ALedgerInfo)
{
FledgerInfo = ALedgerInfo;
TDBTransaction Transaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
FAccountTable = AAccountHierarchyDetailAccess.LoadViaALedger(
FledgerInfo.LedgerNumber, Transaction);
});
}
private void GetChildrenIntern(IList <String> help, string AAccountCode, Boolean OnlyPosting, int AChildLevel)
{
if (FHierarchyDetailTable.Rows.Count > 0)
{
FHierarchyDetailTable.DefaultView.Sort =
AAccountHierarchyDetailTable.GetReportOrderDBName() + ", " +
AAccountHierarchyDetailTable.GetReportingAccountCodeDBName();
foreach (DataRowView rv in FHierarchyDetailTable.DefaultView)
{
AAccountHierarchyDetailRow Row = (AAccountHierarchyDetailRow)rv.Row;
if (Row.AccountCodeToReportTo.Equals(AAccountCode))
{
if (Row.AccountHierarchyCode.Equals(STANDARD))
{
Boolean includeThis = true;
if (OnlyPosting)
{
Int32 pos = FAccountTable.DefaultView.Find(Row.ReportingAccountCode);
if (pos >= 0)
{
AAccountRow account = (AAccountRow)FAccountTable.DefaultView[pos].Row;
if (!account.PostingStatus)
{
includeThis = false;
}
}
}
if (includeThis)
{
help.Add(Row.ReportingAccountCode);
}
if (AChildLevel != 0)
{
GetChildrenIntern(help, Row.ReportingAccountCode, OnlyPosting, --AChildLevel);
}
}
}
}
}
}
private void InsertNodeIntoTreeView(GLSetupTDS MainDS,
Int32 LedgerNumber,
TreeNode AParent,
DataView view,
AAccountHierarchyDetailRow ADetailRow)
{
GLSetupTDSAAccountRow AccountRow = (GLSetupTDSAAccountRow)MainDS.AAccount.Rows.Find(
new object[] { LedgerNumber, ADetailRow.ReportingAccountCode });
TreeNode Child = new TreeNode();
AccountNodeDetails NodeTag = AccountNodeDetails.AddNewAccount(Child, AccountRow, ADetailRow);
NodeTag.IsNew = (ADetailRow.RowState == DataRowState.Added);
SetNodeLabel(AccountRow, Child);
if (AParent == null)
{
trvAccounts.Nodes.Add(Child);
}
else
{
InsertInOrder(AParent, Child);
}
// Now add the children of this node:
view.RowFilter =
AAccountHierarchyDetailTable.GetAccountHierarchyCodeDBName() + " = '" + ADetailRow.AccountHierarchyCode + "' AND " +
AAccountHierarchyDetailTable.GetAccountCodeToReportToDBName() + " = '" + ADetailRow.ReportingAccountCode + "'";
if (view.Count > 0)
{
// An account cannot be deleted if it has children.
NodeTag.CanDelete = false;
NodeTag.Msg = Catalog.GetString("Child accounts must be deleted first.");
NodeTag.CanHaveChildren = true;
foreach (DataRowView rowView in view)
{
AAccountHierarchyDetailRow accountDetail = (AAccountHierarchyDetailRow)rowView.Row;
InsertNodeIntoTreeView(MainDS, LedgerNumber, Child, view, accountDetail);
}
}
}
/// <summary>
/// ...
/// </summary>
/// <param name="ALedgerInfo"></param>
public TGetAccountHierarchyDetailInfo(TLedgerInfo ALedgerInfo)
{
FledgerInfo = ALedgerInfo;
bool NewTransaction = false;
TDBTransaction transaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, out NewTransaction);
try
{
FAccountTable = AAccountHierarchyDetailAccess.LoadViaALedger(
FledgerInfo.LedgerNumber, transaction);
}
finally
{
if (NewTransaction)
{
DBAccess.GDBAccessObj.RollbackTransaction();
}
}
}
/// <summary>
/// Load account hierarchy from the dataset into the tree view
/// </summary>
public void PopulateTreeView(GLSetupTDS MainDS, Int32 LedgerNumber, String SelectedHierarchy)
{
FParentForm.SetSelectedAccount(null);
FDuringInitialisation = true;
trvAccounts.BeginUpdate();
trvAccounts.Nodes.Clear();
// TODO: select account hierarchy
AAccountHierarchyRow accountHierarchy = (AAccountHierarchyRow)MainDS.AAccountHierarchy.Rows.Find(new object[] { LedgerNumber,
SelectedHierarchy });
if (accountHierarchy != null)
{
// find the BALSHT account that is reporting to the root account
MainDS.AAccountHierarchyDetail.DefaultView.RowFilter =
AAccountHierarchyDetailTable.GetAccountHierarchyCodeDBName() + " = '" + SelectedHierarchy + "' AND " +
AAccountHierarchyDetailTable.GetAccountCodeToReportToDBName() + " = '" + accountHierarchy.RootAccountCode + "'";
DataView view = new DataView(MainDS.AAccountHierarchyDetail);
view.Sort = AAccountHierarchyDetailTable.GetReportOrderDBName() + ", " + AAccountHierarchyDetailTable.GetReportingAccountCodeDBName();
InsertNodeIntoTreeView(MainDS, LedgerNumber, null, view,
(AAccountHierarchyDetailRow)MainDS.AAccountHierarchyDetail.DefaultView[0].Row);
}
// reset filter so that the defaultview can be used for finding accounts (eg. when adding new account)
MainDS.AAccountHierarchyDetail.DefaultView.RowFilter = "";
trvAccounts.EndUpdate();
FDuringInitialisation = false;
if (trvAccounts.Nodes.Count > 0)
{
SelectNodeByName(trvAccounts.Nodes[0].Name); // Select the first (BAL SHT) item
}
this.trvAccounts.BeforeSelect +=
new System.Windows.Forms.TreeViewCancelEventHandler(this.TreeViewBeforeSelect);
this.trvAccounts.AfterSelect +=
new System.Windows.Forms.TreeViewEventHandler(this.TreeViewAfterSelect);
}
private void ShowDetailsManual(GLSetupTDSAAccountRow ARow)
{
if (ARow != null)
{
strOldDetailAccountCode = txtDetailAccountCode.Text;
ucoAccountAnalysisAttributes.Enabled = ARow.PostingStatus;
// This call to an external user control resets change detection suppression so we need to re-enable it
ucoAccountAnalysisAttributes.AccountCode = ARow.AccountCode;
FPetraUtilsObject.DisableDataChangedEvent();
chkDetailForeignCurrencyFlag.Enabled = (ARow.PostingStatus && !ARow.SystemAccountFlag);
chkDetailBankAccountFlag.Enabled = !ARow.SystemAccountFlag;
chkDetailBudgetControlFlag.Enabled = !ARow.SystemAccountFlag &&
FMainDS.ALedger[0].BudgetControlFlag;
lblDetailBudgetControlFlag.Enabled = FMainDS.ALedger[0].BudgetControlFlag;
cmbDetailForeignCurrencyCode.Enabled = (ARow.PostingStatus && !ARow.SystemAccountFlag && ARow.ForeignCurrencyFlag);
chkDetailIsSummary.Checked = !ARow.PostingStatus;
chkDetailIsSummary.Enabled = !ARow.SystemAccountFlag;
//
// Reporting Order is in AAccountHierarchyDetail
FMainDS.AAccountHierarchyDetail.DefaultView.RowFilter = String.Format("{0}='{1}'",
AAccountHierarchyDetailTable.GetReportingAccountCodeDBName(), ARow.AccountCode);
String txtReportingOrder = "";
if (FMainDS.AAccountHierarchyDetail.DefaultView.Count > 0)
{
txtReportingOrder = ((AAccountHierarchyDetailRow)FMainDS.AAccountHierarchyDetail.DefaultView[0].Row).ReportOrder.ToString();
}
txtRptOrder.Text = txtReportingOrder;
// txtRptOrder.Enabled = !ARow.SystemAccountFlag;
if (!ARow.ForeignCurrencyFlag)
{
cmbDetailForeignCurrencyCode.SelectedIndex = -1;
ARow.ForeignCurrencyCode = "";
}
chkDetailAccountActiveFlag.Enabled = !ARow.SystemAccountFlag;
// I allow the user to attempt to change the primary key,
// but if the selected record is not new, AND they have made any other changes,
// the txtDetailAccountCode _TextChanged method will disallow any change.
SetPrimaryKeyReadOnly(false);
btnRename.Visible = false;
}
}
/// <summary>
/// To build a CSV list of accounts
/// </summary>
/// <param name="ALedgerNumber"></param>
/// <param name="AAccountRowFirst"></param>
/// <param name="DBTransaction"></param>
/// <param name="AChildAccounts"></param>
/// <param name="AVerificationResult"></param>
private static void BuildChildAccountList(int ALedgerNumber,
AAccountRow AAccountRowFirst,
TDBTransaction DBTransaction,
ref string AChildAccounts,
ref TVerificationResultCollection AVerificationResult)
{
//Return value
string AccountCode = AAccountRowFirst.AccountCode;
//Error handling
string ErrorContext = Catalog.GetString("List Child Accounts");
string ErrorMessage = String.Empty;
//Set default type as non-critical
TResultSeverity ErrorType = TResultSeverity.Resv_Noncritical;
try
{
if (AAccountRowFirst.PostingStatus)
{
AChildAccounts += AccountCode + ",";
}
else
{
AAccountHierarchyDetailTable AccountHierarchyDetailTable1 = new AAccountHierarchyDetailTable();
AAccountHierarchyDetailRow TemplateRow = (AAccountHierarchyDetailRow)AccountHierarchyDetailTable1.NewRowTyped(false);
TemplateRow.LedgerNumber = ALedgerNumber;
TemplateRow.AccountHierarchyCode = MFinanceConstants.ACCOUNT_HIERARCHY_CODE;
TemplateRow.AccountCodeToReportTo = AAccountRowFirst.AccountCode;
StringCollection operators = StringHelper.InitStrArr(new string[] { "=", "=", "=" });
AAccountHierarchyDetailTable AccountHierarchyDetailTable2 = AAccountHierarchyDetailAccess.LoadUsingTemplate(TemplateRow,
operators,
null,
DBTransaction);
if (AccountHierarchyDetailTable2 != null)
{
for (int m = 0; m < AccountHierarchyDetailTable2.Count; m++)
{
AAccountHierarchyDetailRow AccountHierarchyDetailRow = (AAccountHierarchyDetailRow)AccountHierarchyDetailTable2.Rows[m];
AAccountTable AccountTable = AAccountAccess.LoadByPrimaryKey(ALedgerNumber,
AccountHierarchyDetailRow.ReportingAccountCode,
DBTransaction);
if (AccountTable != null)
{
AAccountRow AccountRow = (AAccountRow)AccountTable.Rows[0];
BuildChildAccountList(ALedgerNumber,
AccountRow,
DBTransaction,
ref AChildAccounts,
ref AVerificationResult);
}
else
{
break;
}
}
}
}
}
catch (ArgumentException ex)
{
AVerificationResult.Add(new TVerificationResult(ErrorContext, ex.Message, ErrorType));
}
catch (InvalidOperationException ex)
{
AVerificationResult.Add(new TVerificationResult(ErrorContext, ex.Message, ErrorType));
}
catch (Exception ex)
{
ErrorMessage =
String.Format(Catalog.GetString("Unknown error while building list of Child Accounts for Ledger: {0} and Account code: {1}" +
Environment.NewLine + Environment.NewLine + ex.ToString()),
ALedgerNumber,
AAccountRowFirst.AccountCode
);
ErrorType = TResultSeverity.Resv_Critical;
AVerificationResult.Add(new TVerificationResult(ErrorContext, ErrorMessage, ErrorType));
}
}
/// <summary>
/// Utility function for IncomeExpenseTable and BalanceSheet.
/// Create or update the row that this account reports to.
/// USES RECURSION to create or update grandparents, and update AccountLevel and AccountPath.
/// </summary>
private static Int32 AddTotalsToParentAccountRow(
DataTable filteredResults,
AAccountHierarchyDetailTable HierarchyTbl,
Int32 LedgerNumber,
String CostCentreCode,
String AccountCode,
DataRow NewDataRow,
Boolean SortAccountFirst,
Int32 NumPeriodFields,
out string ParentAccountPath,
out Int32 ParentAccountTypeOrder,
TDBTransaction ReadTrans)
{
Boolean ByPeriod = (NumPeriodFields > 0);
Int32 Idx = HierarchyTbl.DefaultView.Find(AccountCode);
// If Idx < 0 that's pretty serious. The next line will raise an exception.
AAccountHierarchyDetailRow HDRow = (AAccountHierarchyDetailRow)HierarchyTbl.DefaultView[Idx].Row;
String ParentAccountCode = HDRow.AccountCodeToReportTo;
if (((filteredResults.TableName == "IncomeExpense") && (ParentAccountCode == "RET EARN")) // This is a literal AccountCode, which (in a non-OM setting) the user could potentially change.
|| (ParentAccountCode == LedgerNumber.ToString())) // And actually this is effectively a literal too.
{
// The calling Row is a "first level" account with no parent.
ParentAccountPath = "";
ParentAccountTypeOrder = 0;
return 0;
}
else
{
String MyParentAccountPath;
Int32 MyParentAccountTypeOrder;
if (CostCentreCode == "")
{
Idx = filteredResults.DefaultView.Find(new object[] { ParentAccountCode });
}
else
{
if (SortAccountFirst)
{
Idx = filteredResults.DefaultView.Find(new object[] { ParentAccountCode, CostCentreCode });
}
else
{
Idx = filteredResults.DefaultView.Find(new object[] { CostCentreCode, ParentAccountCode });
}
}
DataRow ParentRow;
if (Idx < 0) // This Parent Account Code should have a row in the table - if not I need to create one now.
{
ParentRow = filteredResults.NewRow();
DataUtilities.CopyAllColumnValues(NewDataRow, ParentRow);
ParentRow["AccountCode"] = ParentAccountCode;
// I need to find the name of this parent account.
AAccountRow ParentAccountRow = AAccountAccess.LoadByPrimaryKey(LedgerNumber, ParentAccountCode, ReadTrans)[0];
ParentRow["AccountName"] = ParentAccountRow.AccountCodeShortDesc;
ParentRow["AccountType"] = ParentAccountRow.AccountType;
ParentRow["DebitCredit"] = ParentAccountRow.DebitCreditIndicator;
//
// This AccountTypeOrder will be used for sorting the rows in the report,
// but could be overwritten since the "top level" AccountTypeOrder ends up getting copied to all children.
switch (ParentAccountRow.AccountType)
{
case "Income":
case "Asset":
ParentRow["AccountTypeOrder"] = 1;
break;
case "Expense":
case "Liability":
ParentRow["AccountTypeOrder"] = 2;
break;
case "Equity":
ParentRow["AccountTypeOrder"] = 3;
break;
}
ParentRow["AccountIsSummary"] = true;
filteredResults.Rows.Add(ParentRow);
Decimal Sign = (Convert.ToBoolean(ParentRow["DebitCredit"]) == Convert.ToBoolean(NewDataRow["DebitCredit"])) ? 1 : -1;
if (ByPeriod)
{
for (Int32 period = 1; period <= NumPeriodFields; period++)
{
String PeriodField = "P" + period;
ParentRow[PeriodField] = Sign * Convert.ToDecimal(NewDataRow[PeriodField]);
}
ParentRow["Actual"] = 0;
ParentRow["ActualYTD"] = 0;
ParentRow["Budget"] = 0;
ParentRow["BudgetYTD"] = 0;
ParentRow["ActualLastYear"] = 0;
}
else
{
ParentRow["Actual"] = Sign * Convert.ToDecimal(NewDataRow["Actual"]);
ParentRow["ActualYTD"] = Sign * Convert.ToDecimal(NewDataRow["ActualYTD"]);
ParentRow["LastYearActual"] = Sign * Convert.ToDecimal(NewDataRow["LastYearActual"]);
if (filteredResults.Columns.Contains("LastYearEnd"))
{
ParentRow["LastYearEnd"] = Sign * Convert.ToDecimal(NewDataRow["LastYearEnd"]);
ParentRow["LastYearActualYtd"] = Sign * Convert.ToDecimal(NewDataRow["LastYearActualYtd"]);
ParentRow["LastYearLastMonthYtd"] = Sign * Convert.ToDecimal(NewDataRow["LastYearLastMonthYtd"]);
}
}
//
// Now ensure that my newly-created parent also creates her own parent:
Int32 AccountLevel = AddTotalsToParentAccountRow( // Update my parent first
filteredResults,
HierarchyTbl,
LedgerNumber,
CostCentreCode,
ParentAccountCode,
NewDataRow,
SortAccountFirst,
NumPeriodFields,
out MyParentAccountPath,
out MyParentAccountTypeOrder,
ReadTrans);
//
// I need to find the "Report Order" for the parent row:
Idx = HierarchyTbl.DefaultView.Find(ParentAccountCode);
// If Idx < 0 that's pretty serious. The next line will raise an exception.
HDRow = (AAccountHierarchyDetailRow)HierarchyTbl.DefaultView[Idx].Row;
ParentRow["AccountPath"] = MyParentAccountPath + HDRow.ReportOrder + "-" + ParentAccountCode + "~";
ParentRow["AccountLevel"] = AccountLevel;
}
else // Parent row exists already
{
ParentRow = filteredResults.DefaultView[Idx].Row;
//
// I need to add or subtract these values depending on the account type I'm summarizing into.
//
Decimal Sign = (Convert.ToBoolean(ParentRow["DebitCredit"]) == Convert.ToBoolean(NewDataRow["DebitCredit"])) ? 1 : -1;
if (ByPeriod)
{
for (Int32 period = 1; period <= NumPeriodFields; period++)
{
String PeriodField = "P" + period;
ParentRow[PeriodField] = Convert.ToDecimal(ParentRow[PeriodField]) + Sign * Convert.ToDecimal(NewDataRow[PeriodField]);
}
}
else
{
ParentRow["Actual"] = Convert.ToDecimal(ParentRow["Actual"]) + (Sign * Convert.ToDecimal(NewDataRow["Actual"]));
ParentRow["ActualYTD"] = Convert.ToDecimal(ParentRow["ActualYTD"]) + (Sign * Convert.ToDecimal(NewDataRow["ActualYTD"]));
ParentRow["LastYearActual"] = Convert.ToDecimal(ParentRow["LastYearActual"]) +
(Sign * Convert.ToDecimal(NewDataRow["LastYearActual"]));
//
// The Income Expense row contains more LastYear fields:
if (filteredResults.Columns.Contains("LastYearEnd"))
{
ParentRow["LastYearEnd"] = Convert.ToDecimal(ParentRow["LastYearEnd"]) +
(Sign * Convert.ToDecimal(NewDataRow["LastYearEnd"]));
ParentRow["LastYearActualYtd"] = Convert.ToDecimal(ParentRow["LastYearActualYtd"]) +
(Sign * Convert.ToDecimal(NewDataRow["LastYearActualYtd"]));
ParentRow["LastYearLastMonthYtd"] = Convert.ToDecimal(ParentRow["LastYearLastMonthYtd"]) +
(Sign * Convert.ToDecimal(NewDataRow["LastYearLastMonthYtd"]));
}
//
// The Balance Sheet row doesn't have budgets, but the Income Expense does:
if (ParentRow.Table.Columns.Contains("Budget"))
{
ParentRow["Budget"] = Convert.ToDecimal(ParentRow["Budget"]) + (Sign * Convert.ToDecimal(NewDataRow["Budget"]));
ParentRow["BudgetYTD"] = Convert.ToDecimal(ParentRow["BudgetYTD"]) + (Sign * Convert.ToDecimal(NewDataRow["BudgetYTD"]));
ParentRow["LastYearBudget"] = Convert.ToDecimal(ParentRow["LastYearBudget"]) +
(Sign * Convert.ToDecimal(NewDataRow["LastYearBudget"]));
ParentRow["WholeYearBudget"] = Convert.ToDecimal(ParentRow["WholeYearBudget"]) +
(Sign * Convert.ToDecimal(NewDataRow["WholeYearBudget"]));
}
}
//
// Now ensure that my parent also updates her own parent:
AddTotalsToParentAccountRow( // Update my parent first
filteredResults,
HierarchyTbl,
LedgerNumber,
CostCentreCode,
ParentAccountCode,
NewDataRow,
SortAccountFirst,
NumPeriodFields,
out MyParentAccountPath,
out MyParentAccountTypeOrder,
ReadTrans);
}
//
// I'm going to adopt my parent's sort order so that I'm listed under my parent, even if I'm a different account type.
// BUT NOT if my parent is the root of the whole Hierarchy.
if (Convert.ToInt32(ParentRow["AccountLevel"]) > 1)
{
ParentRow["AccountTypeOrder"] = MyParentAccountTypeOrder;
NewDataRow["AccountTypeOrder"] = MyParentAccountTypeOrder;
}
ParentAccountTypeOrder = Convert.ToInt32(ParentRow["AccountTypeOrder"]);
ParentAccountPath = ParentRow["AccountPath"].ToString();
return 1 + Convert.ToInt32(ParentRow["AccountLevel"]);
}
}
private static void GetFormattedReportingAccounts(AAccountHierarchyDetailTable AAccountHierarchyDetail,
ref string AResult,
string ASummaryAccountCodes,
string AAccountHierarchy)
{
string[] Accounts = ASummaryAccountCodes.Split(new char[] { ',' });
foreach (string account in Accounts)
{
DataRowView[] ReportingAccounts = AAccountHierarchyDetail.DefaultView.FindRows(new object[] { AAccountHierarchy, account });
if (ReportingAccounts.Length == 0)
{
AResult += "'" + account + "', ";
}
else
{
foreach (DataRowView rv in ReportingAccounts)
{
AAccountHierarchyDetailRow row = (AAccountHierarchyDetailRow)rv.Row;
GetFormattedReportingAccounts(AAccountHierarchyDetail, ref AResult, row.ReportingAccountCode, AAccountHierarchy);
}
}
}
}
