/// <summary> /// Loads only GLM Data selected by Ledger Number, Year and Account Code ... /// </summary> /// <param name="ALedgerNumber"></param> /// <param name="ACurrentFinancialYear"></param> /// <param name="AAccountCode"></param> public TGlmInfo(int ALedgerNumber, int ACurrentFinancialYear, string AAccountCode) { bool NewTransaction = false; try { TDBTransaction transaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); FGLMTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = FGLMTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = ALedgerNumber; GLMTemplateRow.AccountCode = AAccountCode; GLMTemplateRow.Year = ACurrentFinancialYear; FGLMTbl = AGeneralLedgerMasterAccess.LoadUsingTemplate(GLMTemplateRow, transaction); TLogging.LogAtLevel(1, "TGlmInfo(" + ALedgerNumber + ", " + ACurrentFinancialYear + ", " + AAccountCode + ") has loaded " + FGLMTbl.Rows.Count + " Rows."); iPtr = -1; } finally { if (NewTransaction) { DBAccess.GDBAccessObj.RollbackTransaction(); } } }
private Boolean RunRevaluationIntern() { TDBTransaction Transaction = null; AGeneralLedgerMasterTable GlmTable = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow glmTemplate = (AGeneralLedgerMasterRow)GlmTable.NewRowTyped(false); glmTemplate.LedgerNumber = F_LedgerNum; glmTemplate.Year = F_FinancialYear; for (Int32 i = 0; i < F_ForeignAccount.Length; i++) { glmTemplate.AccountCode = F_ForeignAccount[i]; DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted, ref Transaction, delegate { GlmTable = AGeneralLedgerMasterAccess.LoadUsingTemplate(glmTemplate, Transaction); }); if (GlmTable.Rows.Count > 0) { RevaluateAccount(GlmTable, F_ExchangeRate[i], F_ForeignAccount[i]); } } return(CloseRevaluationAccountingBatch()); }
/// <summary> /// /// </summary> /// <param name="ALedgerNumber"></param> /// <param name="AAccountCode"></param> /// <param name="ACurrentFinancialYear">Number of the year after the the installation of the software</param> public TGet_GLM_Info(int ALedgerNumber, string AAccountCode, int ACurrentFinancialYear) { bool NewTransaction = false; try { TDBTransaction transaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); FGLMTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = FGLMTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = ALedgerNumber; GLMTemplateRow.AccountCode = AAccountCode; GLMTemplateRow.Year = ACurrentFinancialYear; FGLMTbl = AGeneralLedgerMasterAccess.LoadUsingTemplate(GLMTemplateRow, transaction); } finally { if (NewTransaction) { DBAccess.GDBAccessObj.RollbackTransaction(); } } }
/// <summary> /// THIS METHOD DOES NOT RETURN USEFUL VALUES because the Year is not specified. /// It is only called from tests, and those tests pass, /// because there's no previous financial year in the database, /// because the data returned by this method is from the earliest year in the ledger. /// </summary> /// <param name="ALedgerNumber"></param> /// <param name="AAccountCode"></param> /// <param name="ACostCentreCode"></param> public TGet_GLM_Info(int ALedgerNumber, string AAccountCode, string ACostCentreCode) { bool NewTransaction = false; try { TDBTransaction transaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); FGLMTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = FGLMTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = ALedgerNumber; GLMTemplateRow.AccountCode = AAccountCode; GLMTemplateRow.CostCentreCode = ACostCentreCode; FGLMTbl = AGeneralLedgerMasterAccess.LoadUsingTemplate(GLMTemplateRow, transaction); if (FGLMTbl.Rows.Count == 0) { // String msg = TLogging.StackTraceToText(new StackTrace(true)); String msg = ""; TLogging.Log(String.Format("ERROR: No TGet_GLM_Info row found for ({0}, {1}).", ACostCentreCode, AAccountCode, msg)); } } finally { if (NewTransaction) { DBAccess.GDBAccessObj.RollbackTransaction(); } } }
/// <summary> /// Loads <b>all</b> GLMP data for the selected year /// </summary> public void LoadByYear(Int32 AYear) { bool NewTransaction = false; try { TDBTransaction transaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, out NewTransaction); AGeneralLedgerMasterTable GLMTemplateTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = GLMTemplateTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = FLedgerNumber; GLMTemplateRow.Year = AYear; FGLMpTable = AGeneralLedgerMasterPeriodAccess.LoadViaAGeneralLedgerMasterTemplate(GLMTemplateRow, transaction); } finally { if (NewTransaction) { DBAccess.GDBAccessObj.RollbackTransaction(); } } }
/// <summary> /// Loads only GLM Data selected by Ledger Number, Year and Account Code ... /// </summary> public TGlmInfo(int ALedgerNumber, int ACurrentFinancialYear, string AAccountCode, TDataBase ADataBase = null) { TDBTransaction transaction = new TDBTransaction(); TDataBase db = DBAccess.Connect("TGlmInfo", ADataBase); db.ReadTransaction( ref transaction, delegate { FGLMTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = FGLMTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = ALedgerNumber; GLMTemplateRow.AccountCode = AAccountCode; GLMTemplateRow.Year = ACurrentFinancialYear; FGLMTbl = AGeneralLedgerMasterAccess.LoadUsingTemplate(GLMTemplateRow, transaction); TLogging.LogAtLevel(1, "TGlmInfo(" + ALedgerNumber + ", " + ACurrentFinancialYear + ", " + AAccountCode + ") has loaded " + FGLMTbl.Rows.Count + " Rows."); iPtr = -1; }); if (ADataBase == null) { db.CloseDBConnection(); } }
/// <summary> /// THIS METHOD DOES NOT RETURN USEFUL VALUES because the Year is not specified. /// It is only called from tests, and those tests pass, /// because there's no previous financial year in the database, /// because the data returned by this method is from the earliest year in the ledger. /// </summary> /// <param name="ALedgerNumber"></param> /// <param name="AAccountCode"></param> /// <param name="ACostCentreCode"></param> /// <param name="ADataBase"></param> public TGet_GLM_Info(int ALedgerNumber, string AAccountCode, string ACostCentreCode, TDataBase ADataBase = null) { TDBTransaction transaction = new TDBTransaction(); TDataBase db = DBAccess.Connect("TGet_GLM_Info", ADataBase); db.ReadTransaction(ref transaction, delegate { FGLMTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = FGLMTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = ALedgerNumber; GLMTemplateRow.AccountCode = AAccountCode; GLMTemplateRow.CostCentreCode = ACostCentreCode; FGLMTbl = AGeneralLedgerMasterAccess.LoadUsingTemplate(GLMTemplateRow, transaction); if (FGLMTbl.Rows.Count == 0) { // String msg = TLogging.StackTraceToText(new StackTrace(true)); String msg = ""; TLogging.Log(String.Format("ERROR: No TGet_GLM_Info row found for ({0}, {1}).", ACostCentreCode, AAccountCode, msg)); } }); if (ADataBase == null) { db.CloseDBConnection(); } }
/// Returns true if it seems to be OK. private Boolean RunRevaluationIntern() { TDBTransaction Transaction = null; AGeneralLedgerMasterTable GlmTable = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow glmTemplate = (AGeneralLedgerMasterRow)GlmTable.NewRowTyped(false); Boolean transactionsWereCreated = false; glmTemplate.LedgerNumber = F_LedgerNum; glmTemplate.Year = F_FinancialYear; for (Int32 i = 0; i < F_ForeignAccount.Length; i++) { glmTemplate.AccountCode = F_ForeignAccount[i]; DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted, ref Transaction, delegate { GlmTable = AGeneralLedgerMasterAccess.LoadUsingTemplate(glmTemplate, Transaction); }); if (GlmTable.Rows.Count > 0) { transactionsWereCreated |= RevaluateAccount(GlmTable, F_ExchangeRate[i], F_ForeignAccount[i]); } } Boolean batchPostedOK = true; if (transactionsWereCreated) { batchPostedOK = CloseRevaluationAccountingBatch(); } if (batchPostedOK) { if (!transactionsWereCreated) // If no transactions were needed, I'll just advise the user: { FVerificationCollection.Add(new TVerificationResult( "Post Forex Batch", "Exchange rates are unchanged - no revaluation was required.", TResultSeverity.Resv_Status)); } for (Int32 i = 0; i < F_ForeignAccount.Length; i++) { TLedgerInitFlag.RemoveFlagComponent(F_LedgerNum, MFinanceConstants.LEDGER_INIT_FLAG_REVAL, F_ForeignAccount[i]); } } else { FVerificationCollection.Add(new TVerificationResult( "Post Forex Batch", "The Revaluation Batch could not be posted.", TResultSeverity.Resv_Critical)); } return(batchPostedOK); }
/// <summary> /// Next Element of the Row list ... /// </summary> /// <returns></returns> public bool MoveNext() { if (++iPtr >= FGLMTbl.Rows.Count) { return(false); } FglmRow = (AGeneralLedgerMasterRow)FGLMTbl.Rows[iPtr]; return(true); }
private void RunRevaluationIntern() { Boolean NewTransaction; TDBTransaction DBTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, out NewTransaction); AAccountTable accountTable = new AAccountTable(); AAccountRow accountTemplate = (AAccountRow)accountTable.NewRowTyped(false); accountTemplate.LedgerNumber = F_LedgerNum; accountTemplate.AccountActiveFlag = true; accountTemplate.ForeignCurrencyFlag = true; accountTable = AAccountAccess.LoadUsingTemplate(accountTemplate, DBTransaction); AGeneralLedgerMasterTable glmTable = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow glmTemplate = (AGeneralLedgerMasterRow)glmTable.NewRowTyped(false); glmTemplate.LedgerNumber = F_LedgerNum; glmTemplate.Year = F_FinancialYear; glmTable = AGeneralLedgerMasterAccess.LoadUsingTemplate(glmTemplate, DBTransaction); if (NewTransaction) { DBAccess.GDBAccessObj.RollbackTransaction(); } if (accountTable.Rows.Count == 0) // not using any foreign accounts? { return; } for (int iCnt = 0; iCnt < accountTable.Rows.Count; ++iCnt) { AAccountRow accountRow = (AAccountRow)accountTable[iCnt]; for (int kCnt = 0; kCnt < F_CurrencyCode.Length; ++kCnt) { // AForeignCurrency[] and ANewExchangeRate[] shall support a value // for this account resp. for the currency of the account if (accountRow.ForeignCurrencyCode.Equals(F_CurrencyCode[kCnt])) { glmTable.DefaultView.RowFilter = "a_account_code_c = '" + accountRow.AccountCode + "'"; if (glmTable.DefaultView.Count > 0) { RevaluateAccount(glmTable.DefaultView, F_ExchangeRate[kCnt]); } } } } CloseRevaluationAccountingBatch(); }
/// <summary> /// Unpost a budget /// </summary> /// <param name="ABudgetRow"></param> /// <param name="ALedgerNumber"></param> /// <returns>true if it seemed to go OK</returns> private static bool UnPostBudget(ABudgetRow ABudgetRow, int ALedgerNumber) { /* post the negative budget, which will result in an empty a_glm_period.budget */ // get the current budget value for each GLM Period, and unpost that budget GLPostingDS.AGeneralLedgerMaster.DefaultView.Sort = String.Format("{0},{1},{2},{3}", AGeneralLedgerMasterTable.GetLedgerNumberDBName(), AGeneralLedgerMasterTable.GetYearDBName(), AGeneralLedgerMasterTable.GetAccountCodeDBName(), AGeneralLedgerMasterTable.GetCostCentreCodeDBName()); int glmIndex = GLPostingDS.AGeneralLedgerMaster.DefaultView.Find( new object[] { ALedgerNumber, ABudgetRow.Year, ABudgetRow.AccountCode, ABudgetRow.CostCentreCode }); if (glmIndex != -1) { AGeneralLedgerMasterRow glmRow = (AGeneralLedgerMasterRow)GLPostingDS.AGeneralLedgerMaster.DefaultView[glmIndex].Row; List <ABudgetPeriodRow> budgetPeriods = new List <ABudgetPeriodRow>(); for (int Period = 1; Period <= GLPostingDS.ALedger[0].NumberOfAccountingPeriods; Period++) { AGeneralLedgerMasterPeriodRow GeneralLedgerMasterPeriodRow = (AGeneralLedgerMasterPeriodRow)GLPostingDS.AGeneralLedgerMasterPeriod.Rows.Find( new object[] { glmRow.GlmSequence, Period }); ABudgetPeriodRow budgetPeriodRow = FBudgetTDS.ABudgetPeriod.NewRowTyped(true); budgetPeriodRow.PeriodNumber = Period; budgetPeriodRow.BudgetSequence = ABudgetRow.BudgetSequence; // use negative amount for unposting budgetPeriodRow.BudgetBase = -1 * GeneralLedgerMasterPeriodRow.BudgetBase; // do not add to the budgetperiod table, but to our local list budgetPeriods.Add(budgetPeriodRow); } PostBudget(ALedgerNumber, ABudgetRow, budgetPeriods); } ABudgetRow.BudgetStatus = false; //i.e. unposted return(true); }
public static void GetForeignCurrencyAccountActuals(ref DataTable AForeignCurrencyAccounts, Int32 ALedgerNumber, Int32 AYear) { DataTable ForeignCurrencyAccounts = AForeignCurrencyAccounts; TDBTransaction Transaction = new TDBTransaction(); TDataBase db = DBAccess.Connect("GetForeignCurrencyAccountActuals"); db.ReadTransaction(ref Transaction, delegate { AGeneralLedgerMasterTable glmTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = glmTbl.NewRowTyped(false); foreach (DataRow ForeignCurrencyAccountRow in ForeignCurrencyAccounts.Rows) { GLMTemplateRow.LedgerNumber = ALedgerNumber; GLMTemplateRow.Year = AYear; GLMTemplateRow.AccountCode = ForeignCurrencyAccountRow[AAccountTable.GetAccountCodeDBName()].ToString(); glmTbl = AGeneralLedgerMasterAccess.LoadUsingTemplate(GLMTemplateRow, Transaction); Decimal YtdActual = 0; Decimal YtdActualForeign = 0; if (glmTbl != null) { // // I need to sum up all the GLM entries for this account: foreach (AGeneralLedgerMasterRow glmRow in glmTbl.Rows) { if (!glmRow.IsYtdActualForeignNull()) { YtdActualForeign += glmRow.YtdActualForeign; } YtdActual += glmRow.YtdActualBase; } } ForeignCurrencyAccountRow[AGeneralLedgerMasterTable.GetYtdActualBaseDBName()] = YtdActual; ForeignCurrencyAccountRow[AGeneralLedgerMasterTable.GetYtdActualForeignDBName()] = YtdActualForeign; } }); db.CloseDBConnection(); }
public static void GetForeignCurrencyAccountActuals(ref DataTable AForeignCurrencyAccounts, Int32 ALedgerNumber, Int32 AYear) { //string ReturnValue = ""; DataTable ForeignCurrencyAccounts = AForeignCurrencyAccounts.Clone(); ForeignCurrencyAccounts.Merge(AForeignCurrencyAccounts); string CostCentreCode = "[" + ALedgerNumber + "]"; TDBTransaction Transaction = null; DBAccess.GDBAccessObj.BeginAutoReadTransaction(ref Transaction, delegate { foreach (DataRow ForeignCurrencyAccountRow in ForeignCurrencyAccounts.Rows) { AGeneralLedgerMasterTable Table = AGeneralLedgerMasterAccess.LoadByUniqueKey( ALedgerNumber, AYear, ForeignCurrencyAccountRow[AAccountTable.GetAccountCodeDBName()].ToString(), CostCentreCode, Transaction); if ((Table != null) && (Table.Rows.Count > 0)) { AGeneralLedgerMasterRow Row = Table[0]; if (Row.IsYtdActualForeignNull()) { ForeignCurrencyAccountRow[AGeneralLedgerMasterTable.GetYtdActualForeignDBName()] = 0; } else { ForeignCurrencyAccountRow[AGeneralLedgerMasterTable.GetYtdActualForeignDBName()] = Row.YtdActualForeign; } ForeignCurrencyAccountRow[AGeneralLedgerMasterTable.GetYtdActualBaseDBName()] = Row.YtdActualBase; } else { ForeignCurrencyAccountRow[AGeneralLedgerMasterTable.GetYtdActualForeignDBName()] = 0; ForeignCurrencyAccountRow[AGeneralLedgerMasterTable.GetYtdActualBaseDBName()] = 0; } } }); AForeignCurrencyAccounts = ForeignCurrencyAccounts; }
/// <summary> /// /// </summary> /// <param name="ALedgerNumber"></param> /// <param name="AAccountCode"></param> /// <param name="ACurrentFinancialYear">Number of the year after the the installation of the software</param> /// <param name="ADataBase"></param> public TGet_GLM_Info(int ALedgerNumber, string AAccountCode, int ACurrentFinancialYear, TDataBase ADataBase = null) { TDBTransaction transaction = new TDBTransaction(); TDataBase db = DBAccess.Connect("TGet_GLM_Info", ADataBase); db.ReadTransaction(ref transaction, delegate { FGLMTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = FGLMTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = ALedgerNumber; GLMTemplateRow.AccountCode = AAccountCode; GLMTemplateRow.Year = ACurrentFinancialYear; FGLMTbl = AGeneralLedgerMasterAccess.LoadUsingTemplate(GLMTemplateRow, transaction); }); if (ADataBase == null) { db.CloseDBConnection(); } }
/// <summary> /// Loads <b>all</b> GLMP data for the selected year /// </summary> public void LoadByYear(Int32 AYear) { TDBTransaction transaction = new TDBTransaction(); TDataBase db = DBAccess.Connect("LoadByYear", FDataBase); db.ReadTransaction(ref transaction, delegate { AGeneralLedgerMasterTable GLMTemplateTbl = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow GLMTemplateRow = GLMTemplateTbl.NewRowTyped(false); GLMTemplateRow.LedgerNumber = FLedgerNumber; GLMTemplateRow.Year = AYear; FGLMpTable = AGeneralLedgerMasterPeriodAccess.LoadViaAGeneralLedgerMasterTemplate(GLMTemplateRow, transaction); }); if (FDataBase == null) { db.CloseDBConnection(); } }
/// <summary> /// Get the actual amount /// </summary> /// <param name="ALedgerNumber"></param> /// <param name="AGLMSeqThisYear"></param> /// <param name="AGLMSeqNextYear"></param> /// <param name="APeriodNumber"></param> /// <param name="ANumberAccountingPeriods"></param> /// <param name="ACurrentFinancialYear"></param> /// <param name="AThisYear"></param> /// <param name="AYTD"></param> /// <param name="ABalSheetForwardPeriods"></param> /// <param name="ACurrencySelect"></param> /// <returns></returns> private static decimal GetActualInternal(int ALedgerNumber, int AGLMSeqThisYear, int AGLMSeqNextYear, int APeriodNumber, int ANumberAccountingPeriods, int ACurrentFinancialYear, int AThisYear, bool AYTD, bool ABalSheetForwardPeriods, string ACurrencySelect) { decimal retVal = 0; decimal currencyAmount = 0; bool incExpAccountFwdPeriod = false; //DEFINE BUFFER a_glm_period FOR a_general_ledger_master_period. //DEFINE BUFFER a_glm FOR a_general_ledger_master. //DEFINE BUFFER buf_account FOR a_account. if (AGLMSeqThisYear == -1) { return(retVal); } bool newTransaction = false; TDataBase db = DBAccess.Connect("GetActualInternal"); TDBTransaction dBTransaction = db.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, out newTransaction); AGeneralLedgerMasterTable generalLedgerMasterTable = null; AGeneralLedgerMasterRow generalLedgerMasterRow = null; AGeneralLedgerMasterPeriodTable generalLedgerMasterPeriodTable = null; AGeneralLedgerMasterPeriodRow generalLedgerMasterPeriodRow = null; AAccountTable AccountTable = null; AAccountRow AccountRow = null; try { if (APeriodNumber == 0) /* start balance */ { generalLedgerMasterTable = AGeneralLedgerMasterAccess.LoadByPrimaryKey(AGLMSeqThisYear, dBTransaction); generalLedgerMasterRow = (AGeneralLedgerMasterRow)generalLedgerMasterTable.Rows[0]; switch (ACurrencySelect) { case MFinanceConstants.CURRENCY_BASE: currencyAmount = generalLedgerMasterRow.StartBalanceBase; break; case MFinanceConstants.CURRENCY_INTERNATIONAL: currencyAmount = generalLedgerMasterRow.StartBalanceIntl; break; default: currencyAmount = generalLedgerMasterRow.StartBalanceForeign; break; } } else if (APeriodNumber > ANumberAccountingPeriods) /* forwarding periods only exist for the current financial year */ { if (ACurrentFinancialYear == AThisYear) { generalLedgerMasterPeriodTable = AGeneralLedgerMasterPeriodAccess.LoadByPrimaryKey(AGLMSeqThisYear, APeriodNumber, dBTransaction); generalLedgerMasterPeriodRow = (AGeneralLedgerMasterPeriodRow)generalLedgerMasterPeriodTable.Rows[0]; } else { generalLedgerMasterPeriodTable = AGeneralLedgerMasterPeriodAccess.LoadByPrimaryKey(AGLMSeqNextYear, (APeriodNumber - ANumberAccountingPeriods), dBTransaction); generalLedgerMasterPeriodRow = (AGeneralLedgerMasterPeriodRow)generalLedgerMasterPeriodTable.Rows[0]; } } else /* normal period */ { generalLedgerMasterPeriodTable = AGeneralLedgerMasterPeriodAccess.LoadByPrimaryKey(AGLMSeqThisYear, APeriodNumber, dBTransaction); generalLedgerMasterPeriodRow = (AGeneralLedgerMasterPeriodRow)generalLedgerMasterPeriodTable.Rows[0]; } if (generalLedgerMasterPeriodRow != null) { switch (ACurrencySelect) { case MFinanceConstants.CURRENCY_BASE: currencyAmount = generalLedgerMasterPeriodRow.ActualBase; break; case MFinanceConstants.CURRENCY_INTERNATIONAL: currencyAmount = generalLedgerMasterPeriodRow.ActualIntl; break; default: currencyAmount = generalLedgerMasterPeriodRow.ActualForeign; break; } } if ((APeriodNumber > ANumberAccountingPeriods) && (ACurrentFinancialYear == AThisYear)) { generalLedgerMasterTable = AGeneralLedgerMasterAccess.LoadByPrimaryKey(AGLMSeqThisYear, dBTransaction); generalLedgerMasterRow = (AGeneralLedgerMasterRow)generalLedgerMasterTable.Rows[0]; AccountTable = AAccountAccess.LoadByPrimaryKey(ALedgerNumber, generalLedgerMasterRow.AccountCode, dBTransaction); AccountRow = (AAccountRow)AccountTable.Rows[0]; if ((AccountRow.AccountCode.ToUpper() == MFinanceConstants.ACCOUNT_TYPE_INCOME.ToUpper()) || (AccountRow.AccountCode.ToUpper() == MFinanceConstants.ACCOUNT_TYPE_EXPENSE.ToUpper()) && !ABalSheetForwardPeriods) { incExpAccountFwdPeriod = true; currencyAmount -= GetActualInternal(ALedgerNumber, AGLMSeqThisYear, AGLMSeqNextYear, ANumberAccountingPeriods, ANumberAccountingPeriods, ACurrentFinancialYear, AThisYear, true, ABalSheetForwardPeriods, ACurrencySelect); } } if (!AYTD) { if (!((APeriodNumber == (ANumberAccountingPeriods + 1)) && incExpAccountFwdPeriod) && !((APeriodNumber == (ANumberAccountingPeriods + 1)) && (ACurrentFinancialYear > AThisYear))) { /* if it is an income expense acount, and we are in period 13, nothing needs to be subtracted, * because that was done in correcting the amount in the block above; * if we are in a previous year, in period 13, don't worry about subtracting. * * THIS IS CLEARLY INCORRECT - THE CONDITION ABOVE APPLIES *ONLY* IN THE FIRST FORWARDING PERIOD, NOT IN EVERY FORWARDING PERIOD. * IF THE METHOD IS ONLY CALLED FROM AUTOGENERATE BUDGETS, THIS IS PROBABLY INCONSEQUENTIAL. */ currencyAmount -= GetActualInternal(ALedgerNumber, AGLMSeqThisYear, AGLMSeqNextYear, (APeriodNumber - 1), ANumberAccountingPeriods, ACurrentFinancialYear, AThisYear, true, ABalSheetForwardPeriods, ACurrencySelect); } } retVal = currencyAmount; } finally { if (newTransaction) { dBTransaction.Rollback(); } } return(retVal); }
/// <summary> /// Next Element of the Row list ... /// </summary> /// <returns></returns> public bool MoveNext() { if (++iPtr >= FGLMTbl.Rows.Count) { return false; } FglmRow = (AGeneralLedgerMasterRow)FGLMTbl.Rows[iPtr]; return true; }
/// <summary> /// Run the revaluation and set the flag for the ledger /// Returns true if a Reval batch was posted. /// </summary> public Boolean RunRevaluation(out Int32 glBatchNumber) { glBatchNumber = -1; try { TLedgerInfo ledger = new TLedgerInfo(F_LedgerNum, FDataBase); F_BaseCurrency = ledger.BaseCurrency; F_BaseCurrencyDigits = new TCurrencyInfo(F_BaseCurrency).digits; F_RevaluationAccCode = ledger.RevaluationAccount; F_FinancialYear = ledger.CurrentFinancialYear; F_AccountingPeriod = ledger.CurrentPeriod; TDBTransaction Transaction = new TDBTransaction(); FDataBase = DBAccess.Connect("RunRevaluation", FDataBase); AGeneralLedgerMasterTable GlmTable = new AGeneralLedgerMasterTable(); AGeneralLedgerMasterRow glmTemplate = (AGeneralLedgerMasterRow)GlmTable.NewRowTyped(false); Boolean transactionsWereCreated = false; glmTemplate.LedgerNumber = F_LedgerNum; glmTemplate.Year = F_FinancialYear; for (Int32 i = 0; i < F_ForeignAccount.Length; i++) { glmTemplate.AccountCode = F_ForeignAccount[i]; FDataBase.ReadTransaction( ref Transaction, delegate { GlmTable = AGeneralLedgerMasterAccess.LoadUsingTemplate(glmTemplate, Transaction); }); if (GlmTable.Rows.Count > 0) { transactionsWereCreated |= RevaluateAccount(GlmTable, F_ExchangeRate[i], F_ForeignCurrency[i]); } } Boolean batchPostedOK = true; if (transactionsWereCreated) { batchPostedOK = CloseRevaluationAccountingBatch(out glBatchNumber); } if (batchPostedOK) { if (!transactionsWereCreated) // If no transactions were needed, I'll just advise the user: { FVerificationCollection.Add(new TVerificationResult( "Post Forex Batch", "Exchange rates are unchanged - no revaluation was required.", TResultSeverity.Resv_Status)); } TLedgerInitFlag flag = new TLedgerInitFlag(F_LedgerNum, "", FDataBase); for (Int32 i = 0; i < F_ForeignAccount.Length; i++) { flag.RemoveFlagComponent(MFinanceConstants.LEDGER_INIT_FLAG_REVAL, F_ForeignAccount[i]); } } else { FVerificationCollection.Add(new TVerificationResult( "Post Forex Batch", "The Revaluation Batch could not be posted.", TResultSeverity.Resv_Critical)); } return(batchPostedOK); } catch (EVerificationException terminate) { FVerificationCollection = terminate.ResultCollection(); return(false); } } // Run Revaluation
public static bool LoadBudgetForConsolidate(Int32 ALedgerNumber) { FBudgetTDS = new BudgetTDS(); TDBTransaction Transaction = null; DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, ref Transaction, delegate { ALedgerAccess.LoadByPrimaryKey(FBudgetTDS, ALedgerNumber, Transaction); string sqlLoadBudgetForThisAndNextYear = string.Format("SELECT * FROM PUB_{0} WHERE {1}=? AND ({2} = ? OR {2} = ?)", ABudgetTable.GetTableDBName(), ABudgetTable.GetLedgerNumberDBName(), ABudgetTable.GetYearDBName()); List <OdbcParameter> parameters = new List <OdbcParameter>(); OdbcParameter param = new OdbcParameter("ledgernumber", OdbcType.Int); param.Value = ALedgerNumber; parameters.Add(param); param = new OdbcParameter("thisyear", OdbcType.Int); param.Value = FBudgetTDS.ALedger[0].CurrentFinancialYear; parameters.Add(param); param = new OdbcParameter("nextyear", OdbcType.Int); param.Value = FBudgetTDS.ALedger[0].CurrentFinancialYear + 1; parameters.Add(param); DBAccess.GDBAccessObj.Select(FBudgetTDS, sqlLoadBudgetForThisAndNextYear, FBudgetTDS.ABudget.TableName, Transaction, parameters.ToArray()); string sqlLoadBudgetPeriodForThisAndNextYear = string.Format("SELECT {0}.* FROM PUB_{0}, PUB_{1} WHERE {0}.a_budget_sequence_i = {1}.a_budget_sequence_i AND " + "{2}=? AND ({3} = ? OR {3} = ?)", ABudgetPeriodTable.GetTableDBName(), ABudgetTable.GetTableDBName(), ABudgetTable.GetLedgerNumberDBName(), ABudgetTable.GetYearDBName()); DBAccess.GDBAccessObj.Select(FBudgetTDS, sqlLoadBudgetPeriodForThisAndNextYear, FBudgetTDS.ABudgetPeriod.TableName, Transaction, parameters.ToArray()); // Accept row changes here so that the Client gets 'unmodified' rows FBudgetTDS.AcceptChanges(); GLPostingDS = new GLPostingTDS(); AAccountAccess.LoadViaALedger(GLPostingDS, ALedgerNumber, Transaction); AAccountHierarchyDetailAccess.LoadViaALedger(GLPostingDS, ALedgerNumber, Transaction); ACostCentreAccess.LoadViaALedger(GLPostingDS, ALedgerNumber, Transaction); ALedgerAccess.LoadByPrimaryKey(GLPostingDS, ALedgerNumber, Transaction); // get the glm sequences for this year and next year for (int i = 0; i <= 1; i++) { int Year = GLPostingDS.ALedger[0].CurrentFinancialYear + i; AGeneralLedgerMasterRow TemplateRow = (AGeneralLedgerMasterRow)GLPostingDS.AGeneralLedgerMaster.NewRowTyped(false); TemplateRow.LedgerNumber = ALedgerNumber; TemplateRow.Year = Year; GLPostingDS.AGeneralLedgerMaster.Merge(AGeneralLedgerMasterAccess.LoadUsingTemplate(TemplateRow, Transaction)); } string sqlLoadGlmperiodForThisAndNextYear = string.Format("SELECT {0}.* FROM PUB_{0}, PUB_{1} WHERE {0}.a_glm_sequence_i = {1}.a_glm_sequence_i AND " + "{2}=? AND ({3} = ? OR {3} = ?)", AGeneralLedgerMasterPeriodTable.GetTableDBName(), AGeneralLedgerMasterTable.GetTableDBName(), AGeneralLedgerMasterTable.GetLedgerNumberDBName(), AGeneralLedgerMasterTable.GetYearDBName()); DBAccess.GDBAccessObj.Select(GLPostingDS, sqlLoadGlmperiodForThisAndNextYear, GLPostingDS.AGeneralLedgerMasterPeriod.TableName, Transaction, parameters.ToArray()); }); GLPostingDS.AcceptChanges(); return(true); }
private void RevaluateAccount(DataView GLMView, decimal AExchangeRate) { foreach (DataRowView RowView in GLMView) { AGeneralLedgerMasterRow glmRow = (AGeneralLedgerMasterRow)RowView.Row; ACostCentreTable tempTbl = null; AGeneralLedgerMasterPeriodTable glmpTbl = null; TDBTransaction transaction = null; DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted, TEnforceIsolationLevel.eilMinimum, ref transaction, delegate { tempTbl = ACostCentreAccess.LoadByPrimaryKey(F_LedgerNum, glmRow.CostCentreCode, transaction); glmpTbl = AGeneralLedgerMasterPeriodAccess.LoadByPrimaryKey(glmRow.GlmSequence, F_AccountingPeriod, transaction); }); if (tempTbl.Rows.Count == 0) { continue; // I really don't expect this, but if it does happen, this will prevent a crash! } ACostCentreRow tempRow = tempTbl[0]; if (!tempRow.PostingCostCentreFlag) { continue; // I do expect this - many rows are not "posting" cost centres. } try { if (glmpTbl.Rows.Count == 0) { continue; // I really don't expect this, but if it does happen, this will prevent a crash! } AGeneralLedgerMasterPeriodRow glmpRow = glmpTbl[0]; // // If ActualForeign has not been set, I can't allow the ORM to even attempt to access them: // (If ActualForeign is NULL, that's probably a fault, but this has occured in historical data.) if (glmpRow.IsActualBaseNull() || glmpRow.IsActualForeignNull()) { continue; } decimal delta = AccountDelta(glmpRow.ActualBase, glmpRow.ActualForeign, AExchangeRate, F_BaseCurrencyDigits); if (delta != 0) { // Now we have the relevant Cost Centre ... RevaluateCostCentre(glmRow.AccountCode, glmRow.CostCentreCode, delta); } else { string strMessage = String.Format( Catalog.GetString("The account {1}:{0} does not require revaluation."), glmRow.AccountCode, glmRow.CostCentreCode, AExchangeRate); FVerificationCollection.Add(new TVerificationResult( strStatusContent, strMessage, TResultSeverity.Resv_Noncritical)); } } catch (EVerificationException terminate) { FVerificationCollection = terminate.ResultCollection(); } catch (DivideByZeroException) { FVerificationCollection.Add(new TVerificationResult( strStatusContent, Catalog.GetString("DivideByZeroException"), TResultSeverity.Resv_Noncritical)); } catch (OverflowException) { FVerificationCollection.Add(new TVerificationResult( strStatusContent, Catalog.GetString("OverflowException"), TResultSeverity.Resv_Noncritical)); } } }
/// <summary> /// Next-Year records will be created, and the Ledger will be moved to the new year. /// </summary> public override Int32 RunOperation() { Int32 TempGLMSequence = -1; Int32 EntryCount = 0; if (!FInfoMode) { FYearEndOperator.SetNextPeriod(); } try { foreach (AGeneralLedgerMasterRow GlmRowFrom in FGlmPostingFrom.Rows) { ++EntryCount; if (FInfoMode) { continue; } FGlmpFrom.DefaultView.RowFilter = "a_glm_sequence_i=" + GlmRowFrom.GlmSequence; AGeneralLedgerMasterRow GlmRowTo = null; // // If there's not already a GLM row for this Account / Cost Centre, // I need to create one now. // Int32 GlmToRowIdx = GlmTDS.AGeneralLedgerMaster.DefaultView.Find( new Object[] { GlmRowFrom.AccountCode, GlmRowFrom.CostCentreCode } ); if (GlmToRowIdx >= 0) { GlmRowTo = (AGeneralLedgerMasterRow)GlmTDS.AGeneralLedgerMaster.DefaultView[GlmToRowIdx].Row; } else // GLM record Not present - I'll make one now... { GlmRowTo = GlmTDS.AGeneralLedgerMaster.NewRowTyped(true); GlmRowTo.GlmSequence = TempGLMSequence; TempGLMSequence--; GlmRowTo.LedgerNumber = FLedgerInfo.LedgerNumber; GlmRowTo.AccountCode = GlmRowFrom.AccountCode; GlmRowTo.CostCentreCode = GlmRowFrom.CostCentreCode; GlmRowTo.Year = FNewYearNum; GlmTDS.AGeneralLedgerMaster.Rows.Add(GlmRowTo); GlmRowTo.YtdActualBase = GlmRowFrom.YtdActualBase; if (!GlmRowFrom.IsYtdActualForeignNull()) { GlmRowTo.YtdActualForeign = GlmRowFrom.YtdActualForeign; } } // If the GlmRowTo row already existed, its GLMP records will also exist, // but I need to update them with data from last year's forward periods. // Otherwise I need to create a clutch of matching GLMP records. // The first (FwdPostingPeriods) rows are copies of last year's Fwd records, // and the remainder have the balances carried forward. Int32 LastPeriodFromLastYear = FGlmpFrom.DefaultView.Count; Decimal ActualBase = GlmRowTo.YtdActualBase; Decimal ActualForeign = 0; Boolean UsingForeign = false; if (!GlmRowTo.IsYtdActualForeignNull()) { ActualForeign = GlmRowTo.YtdActualForeign; UsingForeign = true; } for (int PeriodCount = 1; PeriodCount <= FLedgerAccountingPeriods + FLedgerFwdPeriods; PeriodCount++) { AGeneralLedgerMasterPeriodRow glmPeriodRow; if (GlmToRowIdx >= 0) // If there's already a GLM entry, I need to use the existing GLMP row for this period { glmPeriodRow = (AGeneralLedgerMasterPeriodRow)GlmTDS.AGeneralLedgerMasterPeriod.DefaultView[PeriodCount - 1].Row; } else // otherwise I need to create one now. { glmPeriodRow = GlmTDS.AGeneralLedgerMasterPeriod.NewRowTyped(true); glmPeriodRow.GlmSequence = GlmRowTo.GlmSequence; glmPeriodRow.PeriodNumber = PeriodCount; GlmTDS.AGeneralLedgerMasterPeriod.Rows.Add(glmPeriodRow); } if (PeriodCount <= LastPeriodFromLastYear) // For any forward periods, I've already got data... { AGeneralLedgerMasterPeriodRow GlmFromRow = (AGeneralLedgerMasterPeriodRow)FGlmpFrom.DefaultView[PeriodCount - 1].Row; ActualBase = GlmFromRow.ActualBase; if (!GlmFromRow.IsActualForeignNull()) { ActualForeign = GlmFromRow.ActualForeign; UsingForeign = true; } } glmPeriodRow.ActualBase = ActualBase; if (UsingForeign) { glmPeriodRow.ActualForeign = ActualForeign; } } } } finally { // Nothing special to do } if (DoExecuteableCode) { GlmTDS.ThrowAwayAfterSubmitChanges = true; GLPostingTDSAccess.SubmitChanges(GlmTDS); } return EntryCount; } // RunOperation