/// <summary>
/// Post a budget
/// </summary>
private static void PostBudget(int ALedgerNumber, ABudgetRow ABudgetRow, List <ABudgetPeriodRow> ABudgetPeriodRows)
{
//gb5300.p
string AccountCode = ABudgetRow.AccountCode;
string CostCentreList = ABudgetRow.CostCentreCode; /* posting CC and parents */
//Populate list of affected Cost Centres
CostCentreParentsList(ALedgerNumber, ref CostCentreList);
//Locate the row for the current account
AAccountRow AccountRow = (AAccountRow)GLPostingDS.AAccount.Rows.Find(new object[] { ALedgerNumber, AccountCode });
GLPostingDS.AGeneralLedgerMaster.DefaultView.Sort = String.Format("{0},{1},{2},{3}",
AGeneralLedgerMasterTable.GetLedgerNumberDBName(),
AGeneralLedgerMasterTable.GetYearDBName(),
AGeneralLedgerMasterTable.GetAccountCodeDBName(),
AGeneralLedgerMasterTable.GetCostCentreCodeDBName());
/* calculate values for budgets and store them in a temp table; uses lb_budget */
ProcessAccountParent(
ALedgerNumber,
AccountCode,
AccountRow.DebitCreditIndicator,
CostCentreList,
ABudgetRow,
ABudgetPeriodRows);
}
public static BudgetTDS LoadBudgetForAutoGenerate(Int32 ALedgerNumber)
{
BudgetTDS FMainDS = new BudgetTDS();
TDBTransaction Transaction = new TDBTransaction();
TDataBase db = DBAccess.Connect("LoadBudgetForAutoGenerate");
db.ReadTransaction(
ref Transaction,
delegate
{
ALedgerAccess.LoadByPrimaryKey(FMainDS, ALedgerNumber, Transaction);
#region Validate Data
if ((FMainDS.ALedger == null) || (FMainDS.ALedger.Count == 0))
{
throw new EFinanceSystemDataTableReturnedNoDataException(String.Format(Catalog.GetString(
"Function:{0} - Ledger data for Ledger number {1} does not exist or could not be accessed!"),
Utilities.GetMethodName(true),
ALedgerNumber));
}
#endregion Validate Data
int CurrentFinancialYear = FMainDS.ALedger[0].CurrentFinancialYear;
//Load all by Ledger/Year but none may exist
ABudgetTable BudgetTable = new ABudgetTable();
ABudgetRow TemplateRow = (ABudgetRow)BudgetTable.NewRow();
TemplateRow.LedgerNumber = ALedgerNumber;
TemplateRow.Year = CurrentFinancialYear;
StringCollection Operators = StringHelper.InitStrArr(new string[] { "=", "=" });
StringCollection OrderList = new StringCollection();
OrderList.Add("ORDER BY");
OrderList.Add(ABudgetTable.GetCostCentreCodeDBName() + " ASC");
OrderList.Add(ABudgetTable.GetAccountCodeDBName() + " ASC");
ABudgetAccess.LoadUsingTemplate(FMainDS, TemplateRow, Operators, null, Transaction, OrderList, 0, 0);
ABudgetPeriodAccess.LoadViaABudgetTemplate(FMainDS, TemplateRow, Operators, null, Transaction, OrderList, 0, 0);
ABudgetRevisionAccess.LoadByPrimaryKey(FMainDS, ALedgerNumber, CurrentFinancialYear, 0, Transaction);
ABudgetTypeAccess.LoadAll(FMainDS, Transaction);
});
// Accept row changes here so that the Client gets 'unmodified' rows
FMainDS.AcceptChanges();
// Remove all Tables that were not filled with data before remoting them.
FMainDS.RemoveEmptyTables();
return(FMainDS);
}
/// <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);
}
/// <summary>
/// Post a budget
/// </summary>
private static void PostBudget(int ALedgerNumber, ABudgetRow ABudgetRow, List <ABudgetPeriodRow> ABudgetPeriodRows)
{
GLPostingDS.AGeneralLedgerMaster.DefaultView.Sort = String.Format("{0},{1},{2},{3}",
AGeneralLedgerMasterTable.GetLedgerNumberDBName(),
AGeneralLedgerMasterTable.GetYearDBName(),
AGeneralLedgerMasterTable.GetAccountCodeDBName(),
AGeneralLedgerMasterTable.GetCostCentreCodeDBName());
int glmRowIndex = GLPostingDS.AGeneralLedgerMaster.DefaultView.Find(new object[] {
ALedgerNumber,
ABudgetRow.Year,
ABudgetRow.AccountCode,
ABudgetRow.CostCentreCode
});
if (glmRowIndex == -1)
{
TGLPosting.CreateGLMYear(ref GLPostingDS,
ALedgerNumber,
ABudgetRow.Year,
ABudgetRow.AccountCode,
ABudgetRow.CostCentreCode);
glmRowIndex = GLPostingDS.AGeneralLedgerMaster.DefaultView.Find(new object[] {
ALedgerNumber,
ABudgetRow.Year,
ABudgetRow.AccountCode,
ABudgetRow.CostCentreCode
});
}
int GLMSequence = ((AGeneralLedgerMasterRow)GLPostingDS.AGeneralLedgerMaster.DefaultView[glmRowIndex].Row).GlmSequence;
/* Update totals for the General Ledger Master period record. */
foreach (ABudgetPeriodRow BPR in ABudgetPeriodRows)
{
AddBudgetValue(GLMSequence, BPR.PeriodNumber, BPR.BudgetBase);
}
}
/// <summary>
/// Import the budget from a CSV file
/// </summary>
/// <param name="ALedgerNumber"></param>
/// <param name="ACurrentBudgetYear"></param>
/// <param name="ACSVFileName"></param>
/// <param name="AFdlgSeparator"></param>
/// <param name="AImportDS"></param>
/// <param name="AVerificationResult"></param>
/// <returns>Total number of records imported and number of which updated as the fractional part</returns>
private static decimal ImportBudgetFromCSV(Int32 ALedgerNumber,
Int32 ACurrentBudgetYear,
string ACSVFileName,
string[] AFdlgSeparator,
ref BudgetTDS AImportDS,
ref TVerificationResultCollection AVerificationResult)
{
StreamReader DataFile = new StreamReader(ACSVFileName, System.Text.Encoding.Default);
string Separator = AFdlgSeparator[0];
string DateFormat = AFdlgSeparator[1];
string NumberFormat = AFdlgSeparator[2];
FCultureInfoNumberFormat = new CultureInfo(NumberFormat.Equals("American") ? "en-US" : "de-DE");
CultureInfo MyCultureInfoDate = new CultureInfo("en-GB");
MyCultureInfoDate.DateTimeFormat.ShortDatePattern = DateFormat;
// To store the From and To currencies
// Use an array to store these to make for easy
// inverting of the two currencies when calculating
// the inverse value.
//string currentBudgetVal = string.Empty;
//string mess = string.Empty;
string CostCentre = string.Empty;
string Account = string.Empty;
string budgetType = string.Empty;
string budgetYearString = string.Empty;
int budgetYear = 0;
Int32 numPeriods = TAccountingPeriodsWebConnector.GetNumberOfPeriods(ALedgerNumber);
decimal[] BudgetPeriods = new decimal[numPeriods];
int YearForBudgetRevision = 0;
int BdgRevision = 0; //not currently implementing versioning so always zero
decimal rowNumber = 0;
decimal duplicateRowNumber = 0;
while (!DataFile.EndOfStream)
{
decimal totalBudgetRowAmount = 0;
try
{
string Line = DataFile.ReadLine();
CostCentre = StringHelper.GetNextCSV(ref Line, Separator, false).ToString();
if (CostCentre == "Cost Centre")
{
//Read the next line
Line = DataFile.ReadLine();
CostCentre = StringHelper.GetNextCSV(ref Line, Separator, false).ToString();
}
//Increment row number
rowNumber++;
//Convert separator to a char
// char Sep = Separator[0];
//Turn current line into string array of column values
// string[] CsvColumns = Line.Split(Sep);
//int NumCols = CsvColumns.Length;
//If number of columns is not 4 then import csv file is wrongly formed.
// if (NumCols != 24)
// {
// AVerificationResult. MessageBox.Show(Catalog.GetString("Failed to import the CSV budget file:\r\n\r\n" +
// " " + ADataFilename + "\r\n\r\n" +
// "It contains " + NumCols.ToString() + " columns. " +
// ), AImportMode + " Exchange Rates Import Error");
// return;
// }
//Read the values for the current line
Account = StringHelper.GetNextCSV(ref Line, Separator, false).ToString();
budgetType = StringHelper.GetNextCSV(ref Line, Separator, false).ToString().ToUpper();
budgetType = budgetType.Replace(" ", ""); //Ad hoc will become ADHOC
//Allow for variations on Inf.Base and Inf.N
if (budgetType.Contains("INF"))
{
if (budgetType.Contains("BASE"))
{
if (budgetType != MFinanceConstants.BUDGET_INFLATE_BASE)
{
budgetType = MFinanceConstants.BUDGET_INFLATE_BASE;
}
}
else if (budgetType != MFinanceConstants.BUDGET_INFLATE_N)
{
budgetType = MFinanceConstants.BUDGET_INFLATE_N;
}
}
if ((budgetType != MFinanceConstants.BUDGET_ADHOC) &&
(budgetType != MFinanceConstants.BUDGET_SAME) &&
(budgetType != MFinanceConstants.BUDGET_INFLATE_N) &&
(budgetType != MFinanceConstants.BUDGET_SPLIT) &&
(budgetType != MFinanceConstants.BUDGET_INFLATE_BASE)
)
{
throw new InvalidOperationException("Budget Type: " + budgetType + " in row: " + rowNumber.ToString() + " does not exist.");
}
//Calculate the budget Year
budgetYearString = StringHelper.GetNextCSV(ref Line, Separator, false);
YearForBudgetRevision = BudgetRevisionYearNumber(ALedgerNumber, budgetYearString);
//Add budget revision record if there's not one already.
if (AImportDS.ABudgetRevision.Rows.Find(new object[] { ALedgerNumber, YearForBudgetRevision, BdgRevision }) == null)
{
ABudgetRevisionRow BudgetRevisionRow = (ABudgetRevisionRow)AImportDS.ABudgetRevision.NewRowTyped();
BudgetRevisionRow.LedgerNumber = ALedgerNumber;
BudgetRevisionRow.Year = YearForBudgetRevision;
BudgetRevisionRow.Revision = BdgRevision;
BudgetRevisionRow.Description = "Budget Import from: " + ACSVFileName;
AImportDS.ABudgetRevision.Rows.Add(BudgetRevisionRow);
}
//Read the budgetperiod values to check if valid according to type
Array.Clear(BudgetPeriods, 0, numPeriods);
bool successfulBudgetRowProcessing = ProcessBudgetTypeImportDetails(ref Line, Separator, budgetType, ref BudgetPeriods);
for (int i = 0; i < numPeriods; i++)
{
totalBudgetRowAmount += BudgetPeriods[i];
}
if (!successfulBudgetRowProcessing)
{
throw new InvalidOperationException(String.Format(
"The budget in row {0} for Ledger: {1}, Year: {2}, Cost Centre: {3} and Account: {4}, does not have values consistent with Budget Type: {5}.",
rowNumber,
ALedgerNumber,
budgetYear,
CostCentre,
Account,
budgetType));
}
BudgetTDS MainDS = new BudgetTDS();
TDBTransaction transaction = null;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref transaction,
delegate
{
ABudgetAccess.LoadByUniqueKey(MainDS, ALedgerNumber, YearForBudgetRevision, BdgRevision, CostCentre, Account, transaction);
//TODO: need to filter on ABudgetPeriod using LoadViaBudget or LoadViaUniqueKey
});
//Check to see if the budget combination already exists:
if (MainDS.ABudget.Count > 0)
{
ABudgetRow BR2 = (ABudgetRow)MainDS.ABudget.Rows[0];
int BTSeq = BR2.BudgetSequence;
ABudgetRow BdgTRow = (ABudgetRow)AImportDS.ABudget.Rows.Find(new object[] { BTSeq });
if (BdgTRow != null)
{
duplicateRowNumber++;
BdgTRow.BeginEdit();
//Edit the new budget row
BdgTRow.BudgetTypeCode = budgetType;
BdgTRow.EndEdit();
ABudgetPeriodRow BPRow = null;
for (int i = 0; i < numPeriods; i++)
{
BPRow = (ABudgetPeriodRow)AImportDS.ABudgetPeriod.Rows.Find(new object[] { BTSeq, i + 1 });
if (BPRow != null)
{
BPRow.BeginEdit();
BPRow.BudgetBase = BudgetPeriods[i];
BPRow.EndEdit();
}
BPRow = null;
}
}
}
else
{
//Add the new budget row
ABudgetRow BudgetRow = (ABudgetRow)AImportDS.ABudget.NewRowTyped();
int newSequence = -1 * (AImportDS.ABudget.Rows.Count + 1);
BudgetRow.BudgetSequence = newSequence;
BudgetRow.LedgerNumber = ALedgerNumber;
BudgetRow.Year = YearForBudgetRevision;
BudgetRow.Revision = BdgRevision;
BudgetRow.CostCentreCode = CostCentre;
BudgetRow.AccountCode = Account;
BudgetRow.BudgetTypeCode = budgetType;
AImportDS.ABudget.Rows.Add(BudgetRow);
//Add the budget periods
for (int i = 0; i < numPeriods; i++)
{
ABudgetPeriodRow BudgetPeriodRow = (ABudgetPeriodRow)AImportDS.ABudgetPeriod.NewRowTyped();
BudgetPeriodRow.BudgetSequence = newSequence;
BudgetPeriodRow.PeriodNumber = i + 1;
BudgetPeriodRow.BudgetBase = BudgetPeriods[i];
AImportDS.ABudgetPeriod.Rows.Add(BudgetPeriodRow);
}
}
}
catch (Exception)
{
throw;
}
}
DataFile.Close();
if (duplicateRowNumber > 0)
{
//fractional part is the number of updates divided by 10000
if (duplicateRowNumber < 10000)
{
rowNumber += (duplicateRowNumber / 10000);
}
}
return(rowNumber);
}
private void PostDeleteManual(ABudgetRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
//Disable the controls if no records found
if (FPreviouslySelectedDetailRow == null)
{
EnableBudgetEntry(false);
}
}
/// <summary>
/// Deletes the current row and optionally populates a completion message
/// </summary>
/// <param name="ARowToDelete">the currently selected row to delete</param>
/// <param name="ACompletionMessage">if specified, is the deletion completion message</param>
/// <returns>true if row deletion is successful</returns>
private bool DeleteRowManual(ABudgetRow ARowToDelete, ref string ACompletionMessage)
{
ACompletionMessage = String.Empty;
int budgetSequence = ARowToDelete.BudgetSequence;
DeleteBudgetPeriodData(budgetSequence);
ARowToDelete.Delete();
return true;
}
/// <summary>
/// Performs checks to determine whether a deletion of the current
/// row is permissable
/// </summary>
/// <param name="ARowToDelete">the currently selected row to be deleted</param>
/// <param name="ADeletionQuestion">can be changed to a context-sensitive deletion confirmation question</param>
/// <returns>true if user is permitted and able to delete the current row</returns>
private bool PreDeleteManual(ABudgetRow ARowToDelete, ref string ADeletionQuestion)
{
ADeletionQuestion = String.Format(Catalog.GetString(
"You have chosen to delete this budget (Cost Centre: {0}, Account: {1}, Type: {2}, Revision: {3}).{4}{4}Do you really want to delete it?"),
ARowToDelete.CostCentreCode,
ARowToDelete.AccountCode,
ARowToDelete.BudgetTypeCode,
ARowToDelete.Revision,
Environment.NewLine);
return true;
}
private void NewRowManual(ref ABudgetRow ARow)
{
if (!cmbDetailAccountCode.Enabled)
{
EnableBudgetEntry(true);
}
ARow.BudgetSequence = Convert.ToInt32(TRemote.MCommon.WebConnectors.GetNextSequence(TSequenceNames.seq_budget));
ARow.LedgerNumber = FLedgerNumber;
ARow.Revision = CreateBudgetRevisionRow(FLedgerNumber, FCurrentBudgetYear);
ARow.Year = FCurrentBudgetYear;
//Add the budget period values
for (int i = 1; i <= FNumberOfPeriods; i++)
{
ABudgetPeriodRow budgetPeriodRow = FMainDS.ABudgetPeriod.NewRowTyped();
budgetPeriodRow.BudgetSequence = ARow.BudgetSequence;
budgetPeriodRow.PeriodNumber = i;
budgetPeriodRow.BudgetBase = 0;
FMainDS.ABudgetPeriod.Rows.Add(budgetPeriodRow);
budgetPeriodRow = null;
}
}
private bool GetDetailDataFromControlsManual(ABudgetRow ARow)
{
if (ARow != null)
{
ARow.BeginEdit();
if (rbtAdHoc.Checked)
{
if (FPetraUtilsObject.HasChanges)
{
ProcessBudgetTypeAdhoc(null, null);
ClearBudgetTypeTextboxesExcept(MFinanceConstants.BUDGET_ADHOC);
}
ARow.BudgetTypeCode = MFinanceConstants.BUDGET_ADHOC;
}
else if (rbtSame.Checked)
{
if (FPetraUtilsObject.HasChanges)
{
ProcessBudgetTypeSame(null, null);
ClearBudgetTypeTextboxesExcept(MFinanceConstants.BUDGET_SAME);
}
ARow.BudgetTypeCode = MFinanceConstants.BUDGET_SAME;
}
else if (rbtSplit.Checked)
{
if (FPetraUtilsObject.HasChanges)
{
ProcessBudgetTypeSplit(null, null);
ClearBudgetTypeTextboxesExcept(MFinanceConstants.BUDGET_SPLIT);
}
ARow.BudgetTypeCode = MFinanceConstants.BUDGET_SPLIT;
}
else if (rbtInflateN.Checked)
{
if (FPetraUtilsObject.HasChanges)
{
ProcessBudgetTypeInflateN(null, null);
ClearBudgetTypeTextboxesExcept(MFinanceConstants.BUDGET_INFLATE_N);
}
ARow.BudgetTypeCode = MFinanceConstants.BUDGET_INFLATE_N;
}
else //rbtInflateBase.Checked
{
if (FPetraUtilsObject.HasChanges)
{
ProcessBudgetTypeInflateBase(null, null);
ClearBudgetTypeTextboxesExcept(MFinanceConstants.BUDGET_INFLATE_BASE);
}
ARow.BudgetTypeCode = MFinanceConstants.BUDGET_INFLATE_BASE;
}
//TODO switch to using Ledger financial year
ARow.Year = Convert.ToInt16(cmbSelectBudgetYear.GetSelectedString());
ARow.Revision = CreateBudgetRevisionRow(FLedgerNumber, ARow.Year);
ARow.EndEdit();
}
return true;
}
private void ShowDetailsManual(ABudgetRow ARow)
{
ClearBudgetTypeTextboxesExcept("None");
UpdateCurrencyCode();
if ((ARow == null) || ((grdDetails.Rows.Count < 2) && rgrBudgetTypeCode.Enabled))
{
FBudgetSequence = -1;
EnableBudgetEntry(false);
return;
}
else if (rgrBudgetTypeCode.Enabled == false)
{
EnableBudgetEntry(true);
}
if (ARow.BudgetTypeCode == MFinanceConstants.BUDGET_SPLIT)
{
rbtSplit.Checked = true;
DisplayBudgetTypeSplit();
}
else if (ARow.BudgetTypeCode == MFinanceConstants.BUDGET_ADHOC)
{
rbtAdHoc.Checked = true;
DisplayBudgetTypeAdhoc();
}
else if (ARow.BudgetTypeCode == MFinanceConstants.BUDGET_SAME)
{
rbtSame.Checked = true;
DisplayBudgetTypeSame();
}
else if (ARow.BudgetTypeCode == MFinanceConstants.BUDGET_INFLATE_BASE)
{
rbtInflateBase.Checked = true;
DisplayBudgetTypeInflateBase();
}
else //ARow.BudgetTypeCode = MFinanceConstants.BUDGET_INFLATE_N
{
rbtInflateN.Checked = true;
DisplayBudgetTypeInflateN();
}
FBudgetSequence = ARow.BudgetSequence;
pnlBudgetTypeAdhoc.Visible = rbtAdHoc.Checked;
pnlBudgetTypeSame.Visible = rbtSame.Checked;
pnlBudgetTypeSplit.Visible = rbtSplit.Checked;
pnlBudgetTypeInflateN.Visible = rbtInflateN.Checked;
pnlBudgetTypeInflateBase.Visible = rbtInflateBase.Checked;
}
public static bool GenBudgetForNextYear(int ALedgerNumber, int ABudgetSeq, string AForecastType)
{
bool retVal = false;
decimal budgetSum;
decimal priorAmount = 0;
decimal afterAmount = 0;
int periodOfChange = 0;
int gLMSequenceThisYear = 0;
int gLMSequenceLastYear = 0;
ALedgerTable ledgerTable = FMainDS.ALedger;
ALedgerRow ledgerRow = (ALedgerRow)ledgerTable.Rows[0];
int currentFinancialYear = ledgerRow.CurrentFinancialYear;
int currentPeriod = ledgerRow.CurrentPeriod;
int numAccPeriods = ledgerRow.NumberOfAccountingPeriods;
ABudgetTable budgetTable = FMainDS.ABudget;
ABudgetRow budgetRow = (ABudgetRow)budgetTable.Rows.Find(new object[] { ABudgetSeq });
#region Validate Method Parameters
if ((budgetRow == null) || (budgetRow.LedgerNumber != ledgerRow.LedgerNumber) || (budgetRow.Year != currentFinancialYear))
{
TLogging.Log("GenBudgetForNextYear: either could not find budget sequence " + ABudgetSeq.ToString() +
"or the sequence does not apply to ledger " + ledgerRow.LedgerNumber.ToString() +
"or to ledger current year " + currentFinancialYear.ToString());
return(retVal);
}
if (ALedgerNumber != ledgerRow.LedgerNumber)
{
TLogging.Log("GenBudgetForNextYear: method parameter ALedgerNumber is " + ALedgerNumber.ToString() +
" but the data set expected the ledger to be " + ledgerRow.LedgerNumber.ToString());
}
#endregion
string accountCode = budgetRow.AccountCode;
string costCentreCode = budgetRow.CostCentreCode;
gLMSequenceThisYear = TCommonBudgetMaintain.GetGLMSequenceForBudget(ALedgerNumber,
accountCode,
costCentreCode,
currentFinancialYear);
gLMSequenceLastYear = TCommonBudgetMaintain.GetGLMSequenceForBudget(ALedgerNumber,
accountCode,
costCentreCode,
(currentFinancialYear - 1));
try
{
//Update the budget status
budgetRow.BeginEdit();
budgetRow.BudgetStatus = false;
budgetRow.EndEdit();
string budgetType = budgetRow.BudgetTypeCode;
decimal budgetAmount = 0;
decimal actualAmount = 0;
bool validBudgetType = true;
switch (budgetType)
{
case MFinanceConstants.BUDGET_ADHOC:
case MFinanceConstants.BUDGET_INFLATE_BASE:
for (int i = 1; i < currentPeriod; i++)
{
//Set budget period
actualAmount = TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
i,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
false,
MFinanceConstants.CURRENCY_BASE);
SetBudgetPeriodBaseAmount(ABudgetSeq, i, actualAmount);
}
for (int j = currentPeriod; j <= MFinanceConstants.MAX_PERIODS; j++)
{
if (AForecastType == MFinanceConstants.FORECAST_TYPE_BUDGET)
{
budgetAmount =
Math.Round(TCommonBudgetMaintain.GetBudget(gLMSequenceThisYear, -1, j, numAccPeriods,
false,
MFinanceConstants.CURRENCY_BASE));
SetBudgetPeriodBaseAmount(ABudgetSeq, j, budgetAmount);
}
else
{
actualAmount = TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
j,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
false,
MFinanceConstants.CURRENCY_BASE);
SetBudgetPeriodBaseAmount(ABudgetSeq, j, actualAmount);
}
}
break;
case MFinanceConstants.BUDGET_SAME: //because this case has no code it will fall through to the next case until it finds code.
case MFinanceConstants.BUDGET_SPLIT:
if ((currentPeriod - 1) != 0)
{
budgetSum =
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceThisYear,
-1,
(currentPeriod - 1),
numAccPeriods,
currentFinancialYear,
currentFinancialYear,
true,
MFinanceConstants.CURRENCY_BASE);
}
else
{
budgetSum = 0;
}
if (AForecastType == MFinanceConstants.FORECAST_TYPE_BUDGET)
{
for (int i = currentPeriod; i <= numAccPeriods; i++)
{
budgetSum += TCommonBudgetMaintain.GetBudget(gLMSequenceThisYear,
-1,
i,
numAccPeriods,
false,
MFinanceConstants.CURRENCY_BASE);
}
}
else
{
if (currentPeriod > 1)
{
budgetSum += TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
numAccPeriods,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE) -
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
(currentPeriod - 1),
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE);
}
else
{
budgetSum += TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
numAccPeriods,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE);
}
}
budgetSum = budgetSum / numAccPeriods;
for (int i = 1; i <= numAccPeriods; i++)
{
SetBudgetPeriodBaseAmount(ABudgetSeq, i, Math.Round(budgetSum));
}
break;
case MFinanceConstants.BUDGET_INFLATE_N:
for (int i = 1; i <= numAccPeriods; i++)
{
if (GetBudgetPeriodAmount(ABudgetSeq, i) != GetBudgetPeriodAmount(ABudgetSeq, 1))
{
periodOfChange = i - 1;
break;
}
}
/* Calculate average prior to change and after change. */
if (periodOfChange < (currentPeriod - 1))
{
priorAmount = TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceThisYear,
-1,
periodOfChange,
numAccPeriods,
currentFinancialYear,
currentFinancialYear,
true,
MFinanceConstants.CURRENCY_BASE);
afterAmount =
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceThisYear,
-1,
(currentPeriod - 1),
numAccPeriods,
currentFinancialYear,
currentFinancialYear,
true,
MFinanceConstants.CURRENCY_BASE) -
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceThisYear,
-1,
periodOfChange + 1,
numAccPeriods,
currentFinancialYear,
currentFinancialYear,
true,
MFinanceConstants.CURRENCY_BASE);
if (AForecastType == MFinanceConstants.FORECAST_TYPE_BUDGET)
{
for (int i = currentPeriod; i <= numAccPeriods; i++)
{
afterAmount += TCommonBudgetMaintain.GetBudget(gLMSequenceThisYear,
-1,
i,
numAccPeriods,
false,
MFinanceConstants.CURRENCY_BASE);
}
}
else
{
afterAmount += TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
numAccPeriods,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE) -
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
currentPeriod,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE);
}
}
else /* Period of change HAS NOT taken place. */
{
if ((currentPeriod - 1) != 0)
{
priorAmount =
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceThisYear,
-1,
(currentPeriod - 1),
numAccPeriods,
currentFinancialYear,
currentFinancialYear,
true,
MFinanceConstants.CURRENCY_BASE);
}
else
{
priorAmount = 0;
}
if (AForecastType == MFinanceConstants.FORECAST_TYPE_BUDGET)
{
for (int i = currentPeriod; i <= periodOfChange; i++)
{
priorAmount += TCommonBudgetMaintain.GetBudget(gLMSequenceThisYear,
-1,
i,
numAccPeriods,
false,
MFinanceConstants.CURRENCY_BASE);
}
}
else
{
priorAmount = TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
periodOfChange,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE) -
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
currentPeriod,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE);
}
if (AForecastType == MFinanceConstants.FORECAST_TYPE_BUDGET)
{
for (int i = (periodOfChange + 1); i <= numAccPeriods; i++)
{
afterAmount += TCommonBudgetMaintain.GetBudget(gLMSequenceThisYear,
-1,
i,
numAccPeriods,
false,
MFinanceConstants.CURRENCY_BASE);
}
}
else
{
afterAmount = TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
numAccPeriods,
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE) -
TCommonBudgetMaintain.GetActual(ALedgerNumber,
gLMSequenceLastYear,
gLMSequenceThisYear,
(periodOfChange + 1),
numAccPeriods,
currentFinancialYear,
(currentFinancialYear - 1),
true,
MFinanceConstants.CURRENCY_BASE);
}
/* Dividing after sum by prior sum gives rate of inflation. */
priorAmount = priorAmount / periodOfChange;
afterAmount = afterAmount / (numAccPeriods - periodOfChange);
for (int i = 1; i <= periodOfChange; i++)
{
SetBudgetPeriodBaseAmount(ABudgetSeq, i, Math.Round(priorAmount, 0));
}
for (int i = (periodOfChange + 1); i <= numAccPeriods; i++)
{
SetBudgetPeriodBaseAmount(ABudgetSeq, i, Math.Round(afterAmount, 0));
}
}
break;
default:
validBudgetType = false;
break;
}
if (!validBudgetType)
{
throw new InvalidOperationException(String.Format("Invalid budget type of: {0} for Budget Seq.: {1}",
budgetType,
budgetRow.BudgetSequence));
}
retVal = true;
}
catch (Exception)
{
throw;
}
return(retVal);
}
/// <summary>
/// Post a budget
/// </summary>
private static void PostBudget(int ALedgerNumber, ABudgetRow ABudgetRow, List <ABudgetPeriodRow>ABudgetPeriodRows)
{
GLPostingDS.AGeneralLedgerMaster.DefaultView.Sort = String.Format("{0},{1},{2},{3}",
AGeneralLedgerMasterTable.GetLedgerNumberDBName(),
AGeneralLedgerMasterTable.GetYearDBName(),
AGeneralLedgerMasterTable.GetAccountCodeDBName(),
AGeneralLedgerMasterTable.GetCostCentreCodeDBName());
int glmRowIndex = GLPostingDS.AGeneralLedgerMaster.DefaultView.Find(new object[] {
ALedgerNumber,
ABudgetRow.Year,
ABudgetRow.AccountCode,
ABudgetRow.CostCentreCode
});
if (glmRowIndex == -1)
{
TGLPosting.CreateGLMYear(ref GLPostingDS,
ALedgerNumber,
ABudgetRow.Year,
ABudgetRow.AccountCode,
ABudgetRow.CostCentreCode);
glmRowIndex = GLPostingDS.AGeneralLedgerMaster.DefaultView.Find(new object[] {
ALedgerNumber,
ABudgetRow.Year,
ABudgetRow.AccountCode,
ABudgetRow.CostCentreCode
});
}
int GLMSequence = ((AGeneralLedgerMasterRow)GLPostingDS.AGeneralLedgerMaster.DefaultView[glmRowIndex].Row).GlmSequence;
/* Update totals for the General Ledger Master period record. */
foreach (ABudgetPeriodRow BPR in ABudgetPeriodRows)
{
AddBudgetValue(GLMSequence, BPR.PeriodNumber, BPR.BudgetBase);
}
}
/// <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;
}
/// <summary>
/// Performs checks to determine whether a deletion of the current
/// row is permissable
/// </summary>
/// <param name="ARowToDelete">the currently selected row to be deleted</param>
/// <param name="ADeletionQuestion">can be changed to a context-sensitive deletion confirmation question</param>
/// <returns>true if user is permitted and able to delete the current row</returns>
private bool PreDeleteManual(ABudgetRow ARowToDelete, ref string ADeletionQuestion)
{
ADeletionQuestion = String.Format(Catalog.GetString(
"You have chosen to delete the current budget for:{0}{0}" +
" Year Ending: {1}, Cost Centre: {2}, Account: {3}, Type: {4}.{0}{0}" +
"Do you really want to delete it?"),
Environment.NewLine,
cmbSelectBudgetYear.GetSelectedDescription(),
ARowToDelete.CostCentreCode,
ARowToDelete.AccountCode,
ARowToDelete.BudgetTypeCode);
return true;
//TODO: When budget revisioning is added:
//"You have chosen to delete Budget: {0} Year Ending: {1}, Cost Centre: {2}, Account: {3}, Type: {4}, Revision: {5}.{0}{0}Do you really want to delete it?"),
// ARowToDelete.Revision,
}
/// <summary>
/// Process the account code parent codes
/// </summary>
private static void ProcessAccountParent(
int ALedgerNumber,
string CurrAccountCode,
bool ADebitCreditIndicator,
string ACostCentreList,
ABudgetRow ABudgetRow,
List <ABudgetPeriodRow> ABudgetPeriods)
{
AAccountRow AccountRow = (AAccountRow)GLPostingDS.AAccount.Rows.Find(new object[] { ALedgerNumber, CurrAccountCode });
AAccountHierarchyDetailRow AccountHierarchyDetailRow = (AAccountHierarchyDetailRow)GLPostingDS.AAccountHierarchyDetail.Rows.Find(
new object[] { ALedgerNumber, MFinanceConstants.ACCOUNT_HIERARCHY_STANDARD, CurrAccountCode });
if (AccountHierarchyDetailRow != null)
{
string AccountCodeToReportTo = AccountHierarchyDetailRow.AccountCodeToReportTo;
if ((AccountCodeToReportTo != null) && (AccountCodeToReportTo != string.Empty))
{
/* Recursively call this procedure. */
ProcessAccountParent(
ALedgerNumber,
AccountCodeToReportTo,
ADebitCreditIndicator,
ACostCentreList,
ABudgetRow,
ABudgetPeriods);
}
}
int DebitCreditMultiply = 1; /* needed if the debit credit indicator is not the same */
/* If the account has the same db/cr indicator as the original
* account for which the budget was created, add the budget amount.
* Otherwise, subtract. */
if (AccountRow.DebitCreditIndicator != ADebitCreditIndicator)
{
DebitCreditMultiply = -1;
}
string[] CostCentres = ACostCentreList.Split(':');
string AccCode = AccountRow.AccountCode;
/* For each associated Cost Centre, update the General Ledger Master. */
foreach (string CostCentreCode in CostCentres)
{
int glmRowIndex = GLPostingDS.AGeneralLedgerMaster.DefaultView.Find(new object[] { ALedgerNumber, ABudgetRow.Year, AccCode,
CostCentreCode });
if (glmRowIndex == -1)
{
TGLPosting.CreateGLMYear(ref GLPostingDS, ALedgerNumber, ABudgetRow.Year, AccCode, CostCentreCode);
glmRowIndex = GLPostingDS.AGeneralLedgerMaster.DefaultView.Find(new object[] { ALedgerNumber, ABudgetRow.Year, AccCode,
CostCentreCode });
}
int GLMSequence = ((AGeneralLedgerMasterRow)GLPostingDS.AGeneralLedgerMaster.DefaultView[glmRowIndex].Row).GlmSequence;
/* Update totals for the General Ledger Master period record. */
foreach (ABudgetPeriodRow BPR in ABudgetPeriods)
{
AddBudgetValue(GLMSequence, BPR.PeriodNumber, DebitCreditMultiply * BPR.BudgetBase);
}
}
}
