/// <summary>
/// Update the specified Journal's LastTransaction number. Assumes all necessary data is loaded for Journal
/// </summary>
/// <param name="AMainDS">ATransactions are filtered on current journal</param>
/// <param name="ACurrentJournal"></param>
/// <returns>false if no change to journal totals</returns>
public static bool UpdateJournalLastTransaction(ref GLBatchTDS AMainDS,
ref GLBatchTDSAJournalRow ACurrentJournal)
{
#region Validate Arguments
if (AMainDS == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString("Function:{0} - The GL Batch dataset is null!"),
Utilities.GetMethodName(true)));
}
else if (ACurrentJournal == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString(
"Function:{0} - The Journal row does not exist or is empty!"),
Utilities.GetMethodName(true)));
}
else if (ACurrentJournal.JournalStatus != MFinanceConstants.BATCH_UNPOSTED)
{
TLogging.Log(String.Format("Function:{0} - Tried to update totals for non-Unposted Batch:{1} and Journal:{2}",
Utilities.GetMethodName(true),
ACurrentJournal.BatchNumber,
ACurrentJournal.JournalNumber));
return(false);
}
#endregion Validate Arguments
bool RowUpdated = false;
int ActualLastTransNumber = 0;
DataView TransDV = new DataView(AMainDS.ATransaction);
TransDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ATransactionTable.GetBatchNumberDBName(),
ACurrentJournal.BatchNumber,
ATransactionTable.GetJournalNumberDBName(),
ACurrentJournal.JournalNumber);
TransDV.Sort = String.Format("{0} DESC",
ATransactionTable.GetTransactionNumberDBName());
foreach (DataRowView drv in TransDV)
{
ATransactionRow transRow = (ATransactionRow)drv.Row;
//Run once only
ActualLastTransNumber = transRow.TransactionNumber;
break;
}
if (ACurrentJournal.LastTransactionNumber != ActualLastTransNumber)
{
ACurrentJournal.BeginEdit();
ACurrentJournal.LastTransactionNumber = ActualLastTransNumber;
ACurrentJournal.EndEdit();
RowUpdated = true;
}
return(RowUpdated);
}
void WriteTransactionLine(ATransactionRow transaction)
{
if (!FTransactionsOnly)
{
WriteStringQuoted("T");
}
WriteStringQuoted(transaction.CostCentreCode);
WriteStringQuoted(transaction.AccountCode);
WriteStringQuoted(transaction.Narrative);
WriteStringQuoted(transaction.Reference);
WriteDate(transaction.TransactionDate);
decimal amount = (FUseBaseCurrency) ? transaction.AmountInBaseCurrency : transaction.TransactionAmount;
if (transaction.DebitCreditIndicator)
{
WriteCurrency(amount);
WriteCurrency(0);
}
else
{
WriteCurrency(0);
WriteCurrency(amount);
}
WriteAnalysisAttributesSuffix(transaction);
}
void WriteAnalysisAttributesSuffix(ATransactionRow transaction)
{
FMainDS.ATransAnalAttrib.DefaultView.Sort = ATransAnalAttribTable.GetAnalysisTypeCodeDBName();
FMainDS.ATransAnalAttrib.DefaultView.RowFilter =
String.Format("{0}={1} and {2}={3} and {4}={5} and {6}={7}",
ATransAnalAttribTable.GetLedgerNumberDBName(),
transaction.LedgerNumber,
ATransAnalAttribTable.GetBatchNumberDBName(),
transaction.BatchNumber,
ATransAnalAttribTable.GetJournalNumberDBName(),
transaction.JournalNumber,
ATransAnalAttribTable.GetTransactionNumberDBName(),
transaction.TransactionNumber);
DataView anaView = FMainDS.ATransAnalAttrib.DefaultView;
for (int i = 1; i <= maxNumValuesExport; i++)
{
if (i <= anaView.Count)
{
ATransAnalAttribRow ar = (ATransAnalAttribRow)anaView[i - 1].Row;
WriteStringQuoted(ar.AnalysisTypeCode, false);
WriteStringQuoted(ar.AnalysisAttributeValue, (i == maxNumValuesExport));
}
else
{
WriteStringQuoted("", false);
WriteStringQuoted("", (i == maxNumValuesExport));
}
}
}
// delete highlighted row/s
private void DeleteRecord(Object Sender, EventArgs e)
{
ATransactionRow RowToDelete = FMainDS.ATransaction.NewRowTyped();
RowToDelete.ItemArray = (object[])FPreviouslySelectedDetailRow.ItemArray.Clone();
this.DeleteATransaction();
if (grdDetails.Rows.Count <= 2)
{
btnOK.Enabled = false;
}
ATransAnalAttribTable TempTable = new ATransAnalAttribTable();
TempTable.Merge(FMainDS.ATransAnalAttrib);
foreach (ATransAnalAttribRow Row in TempTable.Rows)
{
if ((Row.RowState != DataRowState.Deleted) &&
(Row.LedgerNumber == RowToDelete.LedgerNumber) &&
(Row.BatchNumber == RowToDelete.BatchNumber) &&
(Row.JournalNumber == RowToDelete.JournalNumber))
{
if (Row.TransactionNumber == RowToDelete.TransactionNumber)
{
// delete row as no longer used
FMainDS.ATransAnalAttrib.Rows.Find(
new object[] { Row.LedgerNumber, Row.BatchNumber, Row.JournalNumber, Row.TransactionNumber,
Row.AnalysisTypeCode }).Delete();
}
else if (Row.TransactionNumber > RowToDelete.TransactionNumber)
{
// transaction number needs updated
((ATransAnalAttribRow)FMainDS.ATransAnalAttrib.Rows.Find(
new object[] { Row.LedgerNumber, Row.BatchNumber, Row.JournalNumber, Row.TransactionNumber,
Row.AnalysisTypeCode })).TransactionNumber -= 1;
}
}
}
foreach (ATransactionRow Row in FMainDS.ATransaction.Rows)
{
if ((Row.RowState != DataRowState.Deleted) &&
(Row.LedgerNumber == RowToDelete.LedgerNumber) &&
(Row.BatchNumber == RowToDelete.BatchNumber) &&
(Row.JournalNumber == RowToDelete.JournalNumber) &&
(Row.TransactionNumber > RowToDelete.TransactionNumber))
{
// transaction number needs updated
Row.TransactionNumber -= 1;
}
}
FPetraUtilsObject.DisableSaveButton();
}
/// <summary>
/// make sure the correct transaction number is assigned and the journal.lastTransactionNumber is updated
/// </summary>
/// <param name="ANewRow">returns the modified new transaction row</param>
/// <param name="ARefTransactionRow">this can be null; otherwise this is the transaction that the Attribute should belong to</param>
public void NewRowManual(ref ATransAnalAttribRow ANewRow, ATransactionRow ARefTransactionRow)
{
if (ARefTransactionRow == null)
{
ARefTransactionRow = GetTransactionRow();
}
ANewRow.LedgerNumber = ARefTransactionRow.LedgerNumber;
ANewRow.BatchNumber = ARefTransactionRow.BatchNumber;
ANewRow.JournalNumber = ARefTransactionRow.JournalNumber;
ANewRow.TransactionNumber = ARefTransactionRow.TransactionNumber;
}
private void CreateTransaction(string AMessage, string AAccount,
bool ADebitFlag, string ACostCentre, decimal Aamount)
{
ATransactionRow TransactionRow = null;
TransactionRow = F_GLDataset.ATransaction.NewRowTyped();
TransactionRow.LedgerNumber = F_journal.LedgerNumber;
TransactionRow.BatchNumber = F_journal.BatchNumber;
TransactionRow.JournalNumber = F_journal.JournalNumber;
TransactionRow.TransactionNumber = ++F_journal.LastTransactionNumber;
TransactionRow.AccountCode = AAccount;
TransactionRow.CostCentreCode = ACostCentre;
TransactionRow.Narrative = AMessage;
TransactionRow.Reference = "FX REVAL";
TransactionRow.DebitCreditIndicator = ADebitFlag;
TransactionRow.AmountInBaseCurrency = Aamount;
TransactionRow.TransactionAmount = Aamount;
TransactionRow.TransactionDate = F_batch.DateEffective;
F_GLDataset.ATransaction.Rows.Add(TransactionRow);
}
private void CreateTransaction(string AMessage, string AAccount,
bool ADebitFlag, string ACostCenter, decimal Aamount)
{
ATransactionRow transaction = null;
transaction = F_GLDataset.ATransaction.NewRowTyped();
transaction.LedgerNumber = F_journal.LedgerNumber;
transaction.BatchNumber = F_journal.BatchNumber;
transaction.JournalNumber = F_journal.JournalNumber;
transaction.TransactionNumber = ++F_journal.LastTransactionNumber;
transaction.AccountCode = AAccount;
transaction.CostCentreCode = ACostCenter;
transaction.Narrative = AMessage;
transaction.Reference = CommonAccountingTransactionTypesEnum.REVAL.ToString();
transaction.DebitCreditIndicator = ADebitFlag;
transaction.AmountInBaseCurrency = Aamount;
transaction.TransactionAmount = Aamount;
transaction.TransactionDate = F_batch.DateEffective;
F_GLDataset.ATransaction.Rows.Add(transaction);
}
/// <summary>
/// return the transaction rows that are part of the opposite part of the transaction, ie. debit or credit
/// </summary>
/// <param name="ARow"></param>
/// <param name="AOtherTransactions">other transactions in the same journal</param>
/// <returns></returns>
private static ATransactionRow[] GetOtherTransactions(ATransactionRow ARow, DataRowView[] AOtherTransactions)
{
SortedList <int, ATransactionRow>SortedByTransactionNumber = new SortedList <int, ATransactionRow>();
foreach (DataRowView rv in AOtherTransactions)
{
ATransactionRow r = (ATransactionRow)rv.Row;
SortedByTransactionNumber.Add(r.TransactionNumber, r);
}
List <ATransactionRow>BalancingTransactions = new List <ATransactionRow>();
decimal CurrentBalance = 0.0m;
bool RelevantSetOfTransactions = false;
foreach (ATransactionRow r in SortedByTransactionNumber.Values)
{
CurrentBalance += r.TransactionAmount * (r.DebitCreditIndicator ? -1 : 1);
if (r.TransactionNumber == ARow.TransactionNumber)
{
RelevantSetOfTransactions = true;
}
else if (r.DebitCreditIndicator != ARow.DebitCreditIndicator)
{
BalancingTransactions.Add(r);
}
if (CurrentBalance == 0.0m)
{
if (RelevantSetOfTransactions)
{
return BalancingTransactions.ToArray();
}
BalancingTransactions.Clear();
}
}
return null;
}
/// <summary>
/// return the transaction rows that are part of the opposite part of the transaction, ie. debit or credit
/// </summary>
/// <param name="ARow"></param>
/// <param name="AOtherTransactions">other transactions in the same journal</param>
/// <returns></returns>
private static ATransactionRow[] GetOtherTransactions(ATransactionRow ARow, DataRowView[] AOtherTransactions)
{
SortedList <int, ATransactionRow> SortedByTransactionNumber = new SortedList <int, ATransactionRow>();
foreach (DataRowView rv in AOtherTransactions)
{
ATransactionRow r = (ATransactionRow)rv.Row;
SortedByTransactionNumber.Add(r.TransactionNumber, r);
}
List <ATransactionRow> BalancingTransactions = new List <ATransactionRow>();
decimal CurrentBalance = 0.0m;
bool RelevantSetOfTransactions = false;
foreach (ATransactionRow r in SortedByTransactionNumber.Values)
{
CurrentBalance += r.TransactionAmount * (r.DebitCreditIndicator ? -1 : 1);
if (r.TransactionNumber == ARow.TransactionNumber)
{
RelevantSetOfTransactions = true;
}
else if (r.DebitCreditIndicator != ARow.DebitCreditIndicator)
{
BalancingTransactions.Add(r);
}
if (CurrentBalance == 0.0m)
{
if (RelevantSetOfTransactions)
{
return(BalancingTransactions.ToArray());
}
BalancingTransactions.Clear();
}
}
return(null);
}
//
// This will be called if the Fast Reports Wrapper loaded OK.
// Returns True if the data apparently loaded OK and the report should be printed.
private bool LoadReportData(TRptCalculator ACalc)
{
Shared.MReporting.TParameterList parameters = ACalc.GetParameters();
String LedgerFilter = "a_ledger_number_i=" + parameters.Get("param_ledger_number_i").ToInt32();
String AccountCodeFilter = ""; // Account Filter, as range or list:
String GlmAccountCodeFilter = "";
DataTable Balances = new DataTable();
ACalc.AddStringParameter("param_linked_partner_cc", ""); // I may want to use this later, for auto_email, but usually it's unused.
if (parameters.Get("param_rgrAccounts").ToString() == "AccountList")
{
String Filter = "'" + parameters.Get("param_account_codes") + "'";
Filter = Filter.Replace(",", "','");
AccountCodeFilter = "AND a_account_code_c in (" + Filter + ")";
GlmAccountCodeFilter = " AND glm.a_account_code_c in (" + Filter + ")";
}
if (parameters.Get("param_rgrAccounts").ToString() == "AccountRange")
{
AccountCodeFilter = "AND a_account_code_c BETWEEN '" + parameters.Get("param_account_code_start") + "' AND '" +
parameters.Get("param_account_code_end") + "'";
GlmAccountCodeFilter = " AND glm.a_account_code_c BETWEEN '" + parameters.Get("param_account_code_start") + "' AND '" +
parameters.Get("param_account_code_end") + "'";
}
String CostCentreFilter = ""; // Cost Centre Filter, as range or list:
String GlmCostCentreFilter = "";
if (parameters.Get("param_rgrCostCentres").ToString() == "CostCentreList")
{
String Filter = "'" + parameters.Get("param_cost_centre_codes") + "'";
Filter = Filter.Replace(",", "','");
CostCentreFilter = " AND a_cost_centre_code_c in (" + Filter + ")";
GlmCostCentreFilter = " AND glm.a_cost_centre_code_c in (" + Filter + ")";
}
if (parameters.Get("param_rgrCostCentres").ToString() == "CostCentreRange")
{
CostCentreFilter = " AND a_cost_centre_code_c BETWEEN '" + parameters.Get("param_cost_centre_code_start") +
"' AND '" + parameters.Get("param_cost_centre_code_end") + "'";
GlmCostCentreFilter = " AND glm.a_cost_centre_code_c BETWEEN '" + parameters.Get("param_cost_centre_code_start") +
"' AND '" + parameters.Get("param_cost_centre_code_end") + "'";
}
String TranctDateFilter = "a_transaction_date_d BETWEEN '" + parameters.Get("param_start_date").DateToString("yyyy-MM-dd") +
"' AND '" + parameters.Get("param_end_date").DateToString("yyyy-MM-dd") + "'";
String ReferenceFilter = "";
String AnalysisTypeFilter = "";
String GroupField = "a_account_code_c, a_cost_centre_code_c";
String Sortby = parameters.Get("param_sortby").ToString();
if (Sortby == "Cost Centre")
{
GroupField = "a_cost_centre_code_c, a_account_code_c";
}
if (Sortby == "Reference")
{
GroupField = "a_reference_c";
String FilterItem = parameters.Get("param_reference_start").ToString();
if (FilterItem != "")
{
ReferenceFilter = " AND a_reference_c >='" + FilterItem + "'";
}
FilterItem = parameters.Get("param_reference_end").ToString();
if (FilterItem != "")
{
ReferenceFilter += " AND a_reference_c <='" + FilterItem + "'";
}
}
if (Sortby == "Analysis Type")
{
GroupField = "a_analysis_type_code_c";
String FilterItem = parameters.Get("param_analyis_type_start").ToString();
if (FilterItem != "")
{
AnalysisTypeFilter = " AND a_analysis_type_code_c >='" + FilterItem + "'";
}
FilterItem = parameters.Get("param_analyis_type_end").ToString();
if (FilterItem != "")
{
AnalysisTypeFilter += " AND a_analysis_type_code_c <='" + FilterItem + "'";
}
}
parameters.Add("param_groupfield", GroupField);
String Csv = "";
Csv = StringHelper.AddCSV(Csv, "ALedger/SELECT * FROM a_ledger WHERE " + LedgerFilter);
Csv = StringHelper.AddCSV(
Csv,
"AAccount/SELECT * FROM a_account WHERE " + LedgerFilter + AccountCodeFilter +
" AND a_posting_status_l=true AND a_account_active_flag_l=true");
Csv = StringHelper.AddCSV(
Csv,
"ACostCentre/SELECT * FROM a_cost_centre WHERE " + LedgerFilter + CostCentreFilter +
" AND a_posting_cost_centre_flag_l=true AND a_cost_centre_active_flag_l=true");
Boolean InternationalCurrencySelected = parameters.Get("param_currency").ToString().StartsWith("Int");
String AmountField = InternationalCurrencySelected ? "a_amount_in_intl_currency_n" : "a_amount_in_base_currency_n";
if (Sortby == "Analysis Type") // To sort by analysis type, I need a different (and more horible) query:
{
Csv = StringHelper.AddCSV(
Csv,
"Transactions/" +
"SELECT a_transaction.a_account_code_c AS AccountCode," +
"a_transaction.a_cost_centre_code_c AS CostCentreCode," +
"a_transaction.a_transaction_date_d AS TransactionDate," +
"a_transaction." + AmountField + " AS Amount," +
"a_transaction.a_debit_credit_indicator_l AS Debit," +
"a_transaction.a_narrative_c AS Narrative," +
"a_transaction.a_reference_c AS Reference," +
"a_trans_anal_attrib.a_analysis_type_code_c AS AnalysisTypeCode," +
"a_analysis_type.a_analysis_type_description_c AS AnalysisTypeDescr," +
"a_trans_anal_attrib.a_analysis_attribute_value_c AS AnalysisValue" +
" FROM a_transaction, a_trans_anal_attrib, a_analysis_type" +
" WHERE a_transaction." + LedgerFilter +
" AND a_trans_anal_attrib.a_ledger_number_i = a_transaction.a_ledger_number_i " +
" AND a_trans_anal_attrib.a_batch_number_i = a_transaction.a_batch_number_i" +
" AND a_trans_anal_attrib.a_journal_number_i = a_transaction.a_journal_number_i" +
" AND a_trans_anal_attrib.a_transaction_number_i = a_transaction.a_transaction_number_i" +
" AND a_trans_anal_attrib.a_analysis_type_code_c = a_analysis_type.a_analysis_type_code_c" +
AnalysisTypeFilter +
AccountCodeFilter + CostCentreFilter + " AND " + TranctDateFilter +
" AND a_transaction_status_l=true AND NOT (a_system_generated_l=true AND a_narrative_c LIKE 'Year end re-allocation%')" +
" ORDER BY " + GroupField + ", a_transaction_date_d");
}
else
{
Csv = StringHelper.AddCSV(Csv, "Transactions/" +
"SELECT a_transaction.a_account_code_c AS AccountCode," +
"a_transaction.a_cost_centre_code_c AS CostCentreCode," +
"a_transaction.a_transaction_date_d AS TransactionDate," +
"a_transaction." + AmountField + " AS Amount," +
"a_journal.a_transaction_currency_c AS Currency," +
"a_transaction.a_debit_credit_indicator_l AS Debit," +
"a_transaction.a_narrative_c AS Narrative," +
"a_transaction.a_reference_c AS Reference," +
"'' AS AnalysisTypeCode," +
"'' AS AnalysisTypeDescr," +
"'' AS AnalysisValue" +
" FROM a_transaction, a_journal WHERE " +
" a_transaction." + LedgerFilter +
" AND a_transaction.a_ledger_number_i = a_journal.a_ledger_number_i " +
" AND a_transaction.a_batch_number_i = a_journal.a_batch_number_i " +
" AND a_transaction.a_journal_number_i = a_journal.a_journal_number_i " +
AccountCodeFilter +
CostCentreFilter + " AND " +
TranctDateFilter + ReferenceFilter +
" AND a_transaction_status_l=true AND NOT (a_system_generated_l=true AND a_narrative_c LIKE 'Year end re-allocation%')" +
" ORDER BY " + GroupField + ", a_transaction_date_d");
}
GLReportingTDS ReportDs = TRemote.MReporting.WebConnectors.GetReportingDataSet(Csv);
if ((this.IsDisposed) || // If the user has pressed Esc the form is closed!
(TRemote.MReporting.WebConnectors.DataTableGenerationWasCancelled()))
{
return(false);
}
//
// I want to include opening and closing balances for each Cost Centre / Account, in the selected currency.
// Following a revision in Oct 2014, this table is the master table, and the transactions are the slave.
Int32 Year = parameters.Get("param_year_i").ToInt32();
Balances = TRemote.MFinance.Reporting.WebConnectors.GetPeriodBalances(
LedgerFilter,
GlmAccountCodeFilter,
GlmCostCentreFilter,
Year,
Sortby,
ReportDs.Tables["Transactions"],
parameters.Get("param_start_period_i").ToInt32(),
parameters.Get("param_end_period_i").ToInt32(),
InternationalCurrencySelected
);
if ((this.IsDisposed) || (Balances == null))
{
return(false);
}
// My report doesn't need a ledger row - only the name of the ledger. And I need the currency formatter..
{
ALedgerRow Row = ReportDs.ALedger[0];
ACalc.AddStringParameter("param_ledger_name", Row.LedgerName);
ACalc.AddStringParameter("param_currency_formatter", "0,0.000");
}
if (TRemote.MReporting.WebConnectors.DataTableGenerationWasCancelled())
{
return(false);
}
//
// If I need to show Analysis Attributes, I need to get the rows that pertain to the Transactions I've selected above.
if (ReportDs.ATransaction.Rows.Count > 0)
{
DataView BatchSorted = new DataView(ReportDs.ATransaction);
BatchSorted.Sort = "a_batch_number_i";
ATransactionRow Row = (ATransactionRow)BatchSorted[0].Row;
Int32 FirstBatch = Row.BatchNumber;
Row = (ATransactionRow)BatchSorted[BatchSorted.Count - 1].Row;
Int32 LastBatch = Row.BatchNumber;
Csv = "";
Csv = StringHelper.AddCSV(
Csv,
"ATransAnalAttrib/SELECT * FROM a_trans_anal_attrib WHERE " + LedgerFilter +
" AND a_batch_number_i >= " + FirstBatch +
" AND a_batch_number_i <= " + LastBatch);
Csv = StringHelper.AddCSV(Csv, "AAnalysisType/SELECT * FROM a_analysis_type");
ReportDs.Merge(TRemote.MReporting.WebConnectors.GetReportingDataSet(Csv));
}
if (TRemote.MReporting.WebConnectors.DataTableGenerationWasCancelled())
{
return(false);
}
FPetraUtilsObject.FFastReportsPlugin.RegisterData(ReportDs.ATransAnalAttrib, "a_trans_anal_attrib");
FPetraUtilsObject.FFastReportsPlugin.RegisterData(ReportDs.AAnalysisType, "a_analysis_type");
FPetraUtilsObject.FFastReportsPlugin.RegisterData(ReportDs.AAccount, "a_account");
FPetraUtilsObject.FFastReportsPlugin.RegisterData(ReportDs.ACostCentre, "a_costCentre");
FPetraUtilsObject.FFastReportsPlugin.RegisterData(ReportDs.Tables["Transactions"], "Transactions");
FPetraUtilsObject.FFastReportsPlugin.RegisterData(Balances, "balances");
//
// For Account Detail reports that must be sent on email, one page at a time,
// I'm calling the FastReports plugin multiple times,
// and then I'm going to return false, which will prevent the default action using this dataset.
if ((parameters.Get("param_sortby").ToString() == "Cost Centre") &&
(parameters.Get("param_auto_email").ToBool()) &&
!parameters.Get("param_design_template").ToBool()
)
{
FPetraUtilsObject.FFastReportsPlugin.AutoEmailReports(ACalc, FLedgerNumber, CostCentreFilter);
return(false);
}
return(true);
}
private bool AllowInactiveFieldValues(int ABatchNumber, out int ANumInactiveValues)
{
bool RetVal = false;
TVerificationResultCollection VerificationResult = new TVerificationResultCollection();
string VerificationMessage = string.Empty;
DataView TransDV = new DataView(FMainDS.ATransaction);
DataView AttribDV = new DataView(FMainDS.ATransAnalAttrib);
int NumInactiveAccounts = 0;
int NumInactiveCostCentres = 0;
int NumInactiveAccountTypes = 0;
int NumInactiveAccountValues = 0;
try
{
//Check for inactive account or cost centre codes
TransDV.RowFilter = String.Format("{0}={1}",
ATransactionTable.GetBatchNumberDBName(),
ABatchNumber);
TransDV.Sort = String.Format("{0} ASC, {1} ASC",
ATransactionTable.GetJournalNumberDBName(),
ATransactionTable.GetTransactionNumberDBName());
foreach (DataRowView drv in TransDV)
{
ATransactionRow transRow = (ATransactionRow)drv.Row;
if (!AccountIsActive(transRow.AccountCode))
{
VerificationMessage += String.Format(" Account '{0}' in Journal:{1} Transaction:{2}.{3}",
transRow.AccountCode,
transRow.JournalNumber,
transRow.TransactionNumber,
Environment.NewLine);
NumInactiveAccounts++;
}
if (!CostCentreIsActive(transRow.CostCentreCode))
{
VerificationMessage += String.Format(" Cost Centre '{0}' in Journal:{1} Transaction:{2}.{3}",
transRow.CostCentreCode,
transRow.JournalNumber,
transRow.TransactionNumber,
Environment.NewLine);
NumInactiveCostCentres++;
}
}
//Check anlysis attributes
AttribDV.RowFilter = String.Format("{0}={1}",
ATransAnalAttribTable.GetBatchNumberDBName(),
ABatchNumber);
AttribDV.Sort = String.Format("{0} ASC, {1} ASC, {2} ASC",
ATransAnalAttribTable.GetJournalNumberDBName(),
ATransAnalAttribTable.GetTransactionNumberDBName(),
ATransAnalAttribTable.GetAnalysisTypeCodeDBName());
foreach (DataRowView drv2 in AttribDV)
{
ATransAnalAttribRow analAttribRow = (ATransAnalAttribRow)drv2.Row;
if (!AnalysisCodeIsActive(analAttribRow.AccountCode, analAttribRow.AnalysisTypeCode))
{
VerificationMessage += String.Format(" Analysis Code '{0}' in Journal:{1} Transaction:{2}.{3}",
analAttribRow.AnalysisTypeCode,
analAttribRow.JournalNumber,
analAttribRow.TransactionNumber,
Environment.NewLine);
NumInactiveAccountTypes++;
}
if (!AnalysisAttributeValueIsActive(analAttribRow.AnalysisTypeCode, analAttribRow.AnalysisAttributeValue))
{
VerificationMessage += String.Format(" Analysis Value '{0}' in Journal:{1} Transaction:{2}.{3}",
analAttribRow.AnalysisAttributeValue,
analAttribRow.JournalNumber,
analAttribRow.TransactionNumber,
Environment.NewLine);
NumInactiveAccountValues++;
}
}
}
catch (Exception ex)
{
TLogging.LogException(ex, Utilities.GetMethodSignature());
throw;
}
ANumInactiveValues = (NumInactiveAccounts + NumInactiveCostCentres + NumInactiveAccountTypes + NumInactiveAccountValues);
if (ANumInactiveValues > 0)
{
VerificationResult.Add(new TVerificationResult(string.Format(Catalog.GetString("Inactive Values:{0}"), Environment.NewLine),
VerificationMessage,
TResultSeverity.Resv_Noncritical));
StringBuilder errorMessages = new StringBuilder();
errorMessages.AppendFormat(Catalog.GetString("{0} inactive value(s) found in GL Batch {1}. Do you still want to post?{2}"),
ANumInactiveValues,
ABatchNumber,
Environment.NewLine);
foreach (TVerificationResult message in VerificationResult)
{
errorMessages.AppendFormat("{0}{1}",
Environment.NewLine,
message.ResultText);
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
RetVal = (extendedMessageBox.ShowDialog(errorMessages.ToString(),
Catalog.GetString("Post Batch"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbYesNo,
TFrmExtendedMessageBox.TIcon.embiQuestion) == TFrmExtendedMessageBox.TResult.embrYes);
}
else
{
RetVal = true;
}
return(RetVal);
}
public void TestBatchPostingRecalculations()
{
TVerificationResultCollection VerificationResult;
Int64 RecipientKey;
Int64 RealRecipientLedgerNumber;
Int64 FalseRecipientLedgerNumber;
const string REALCOSTCENTRECODE = "4300";
const string FALSECOSTCENTRECODE = "3500";
const string ACCOUNTCODE = "0100";
Int32 GiftBatchNumber;
//
// Arrange: Create all data needed for this test (Gift Details have 'fake' RecipientLedgerNumber and CostCentreCode)
//
TestBatchPostingRecalculations_Arrange(out RecipientKey, out RealRecipientLedgerNumber,
out FalseRecipientLedgerNumber, REALCOSTCENTRECODE, FALSECOSTCENTRECODE, out GiftBatchNumber);
//
// Act: Post the batch
//
bool result = TGiftTransactionWebConnector.PostGiftBatch(FLedgerNumber, GiftBatchNumber, out VerificationResult);
//
// Assert
//
// Initial Assert: Tests that the post returns positive
Assert.AreEqual(true,
result,
"TestBatchPostingRecalculations fail: Posting GiftBatch failed: " + VerificationResult.BuildVerificationResultString());
// Primary Assert: Chaeck that the gifts have the correct RecipientLedgerNumber, CostCentreCode and Account
TDBTransaction Transaction = null;
AGiftDetailRow PositiveGiftDetailRow = null;
AGiftDetailRow NegativeGiftDetailRow = null;
ATransactionRow TransactionRow = null;
Int32 GLBatchNumber = -1;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
delegate
{
PositiveGiftDetailRow = AGiftDetailAccess.LoadByPrimaryKey(FLedgerNumber, GiftBatchNumber, 1, 1, Transaction)[0];
NegativeGiftDetailRow = AGiftDetailAccess.LoadByPrimaryKey(FLedgerNumber, GiftBatchNumber, 2, 1, Transaction)[0];
GLBatchNumber = ALedgerAccess.LoadByPrimaryKey(FLedgerNumber, Transaction)[0].LastBatchNumber;
TransactionRow = ATransactionAccess.LoadByPrimaryKey(FLedgerNumber, GLBatchNumber, 1, 1, Transaction)[0];
});
Assert.IsNotNull(PositiveGiftDetailRow, "TestBatchPostingRecalculations fail: Obtaining PositiveGiftDetailRow from database failed");
Assert.IsNotNull(NegativeGiftDetailRow, "TestBatchPostingRecalculations fail: Obtaining NegativeGiftDetailRow from database failed");
Assert.IsNotNull(TransactionRow, "TestBatchPostingRecalculations fail: Obtaining Transaction from database failed");
Assert.AreEqual(RealRecipientLedgerNumber, PositiveGiftDetailRow.RecipientLedgerNumber,
"TestBatchPostingRecalculations fail: RecipientLedgerNumber for PositiveGiftDetailRow is incorrect");
Assert.AreEqual(FalseRecipientLedgerNumber, NegativeGiftDetailRow.RecipientLedgerNumber,
"TestBatchPostingRecalculations fail: RecipientLedgerNumber for NegativeGiftDetailRow is incorrect");
Assert.AreEqual(REALCOSTCENTRECODE, PositiveGiftDetailRow.CostCentreCode,
"TestBatchPostingRecalculations fail: CostCentreCode for PositiveGiftDetailRow is incorrect");
Assert.AreEqual(FALSECOSTCENTRECODE, NegativeGiftDetailRow.CostCentreCode,
"TestBatchPostingRecalculations fail: CostCentreCode for NegativeGiftDetailRow is incorrect");
Assert.AreEqual(ACCOUNTCODE, TransactionRow.AccountCode,
"TestBatchPostingRecalculations fail: AccountCode for PositiveGiftDetailRow is incorrect");
// Cleanup: Delete test records
bool SubmissionOK = true;
DBAccess.GDBAccessObj.GetNewOrExistingAutoTransaction(IsolationLevel.Serializable,
TEnforceIsolationLevel.eilMinimum,
ref Transaction,
ref SubmissionOK,
delegate
{
AProcessedFeeAccess.DeleteUsingTemplate(
new TSearchCriteria[] { new TSearchCriteria("a_ledger_number_i", FLedgerNumber),
new TSearchCriteria("a_batch_number_i", GiftBatchNumber) },
Transaction);
AGiftDetailAccess.DeleteRow(AGiftDetailTable.TableId, PositiveGiftDetailRow, Transaction);
AGiftDetailAccess.DeleteRow(AGiftDetailTable.TableId, NegativeGiftDetailRow, Transaction);
});
TPartnerWebConnector.DeletePartner(RecipientKey, out VerificationResult);
TPartnerWebConnector.DeletePartner(RealRecipientLedgerNumber, out VerificationResult);
TPartnerWebConnector.DeletePartner(FalseRecipientLedgerNumber, out VerificationResult);
}
/// <summary>
/// Re-show the specified row
/// </summary>
/// <param name="ACurrentBatch"></param>
/// <param name="AJournalToCancel"></param>
/// <param name="ARedisplay"></param>
public void PrepareJournalDataForCancelling(Int32 ACurrentBatch, Int32 AJournalToCancel, Boolean ARedisplay)
{
//This code will only be called when the Journal tab is active.
DataView JournalDV = new DataView(FMainDS.AJournal);
DataView TransDV = new DataView(FMainDS.ATransaction);
DataView TransAnalDV = new DataView(FMainDS.ATransAnalAttrib);
JournalDV.RowFilter = String.Format("{0}={1} And {2}={3}",
AJournalTable.GetBatchNumberDBName(),
ACurrentBatch,
AJournalTable.GetJournalNumberDBName(),
AJournalToCancel);
TransDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ATransactionTable.GetBatchNumberDBName(),
ACurrentBatch,
ATransactionTable.GetJournalNumberDBName(),
AJournalToCancel);
TransAnalDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ATransAnalAttribTable.GetBatchNumberDBName(),
ACurrentBatch,
ATransAnalAttribTable.GetJournalNumberDBName(),
AJournalToCancel);
//Work from lowest level up
if (TransAnalDV.Count > 0)
{
TransAnalDV.Sort = String.Format("{0}, {1}",
ATransAnalAttribTable.GetTransactionNumberDBName(),
ATransAnalAttribTable.GetAnalysisTypeCodeDBName());
foreach (DataRowView drv in TransAnalDV)
{
ATransAnalAttribRow transAnalRow = (ATransAnalAttribRow)drv.Row;
if (transAnalRow.RowState == DataRowState.Added)
{
//Do nothing
}
else if (transAnalRow.RowState != DataRowState.Unchanged)
{
transAnalRow.RejectChanges();
}
}
}
if (TransDV.Count > 0)
{
TransDV.Sort = String.Format("{0}", ATransactionTable.GetTransactionNumberDBName());
foreach (DataRowView drv in TransDV)
{
ATransactionRow transRow = (ATransactionRow)drv.Row;
if (transRow.RowState == DataRowState.Added)
{
//Do nothing
}
else if (transRow.RowState != DataRowState.Unchanged)
{
transRow.RejectChanges();
}
}
}
if (JournalDV.Count > 0)
{
GLBatchTDSAJournalRow journalRow = (GLBatchTDSAJournalRow)JournalDV[0].Row;
//No need to check for Added state as new journals are always saved
// on creation
if (journalRow.RowState != DataRowState.Unchanged)
{
journalRow.RejectChanges();
}
if (ARedisplay)
{
ShowDetails(journalRow);
}
}
if (TransDV.Count == 0)
{
//Load all related data for journal ready to delete/cancel
FMainDS.Merge(TRemote.MFinance.GL.WebConnectors.LoadATransactionAndRelatedTablesForJournal(FLedgerNumber, ACurrentBatch,
AJournalToCancel));
}
}
public static void GenerateHOSAReports(int ALedgerNumber,
int APeriodNumber,
int AIchNumber,
string ACurrencySelect,
out TVerificationResultCollection AVerificationResult
)
{
AVerificationResult = new TVerificationResultCollection();
//Begin the transaction
bool NewTransaction = false;
TDBTransaction DBTransaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, out NewTransaction);
ALedgerTable ALedger = ALedgerAccess.LoadByPrimaryKey(ALedgerNumber, DBTransaction);
AJournalTable AJournal = new AJournalTable();
ATransactionTable ATransaction = new ATransactionTable();
ACostCentreTable ACostCentre = new ACostCentreTable();
try
{
#if TODO
ALedgerRow LedgerRow = PostingDS.ALedger[0];
//Find the Ledger Name = Partner Short Name
PPartnerTable PartnerTable = PPartnerAccess.LoadByPrimaryKey(LedgerRow.PartnerKey, DBTransaction);
PPartnerRow PartnerRow = (PPartnerRow)PartnerTable.Rows[0];
string LedgerName = PartnerRow.PartnerShortName;
#endif
//
// Load the Journals, and Transactions for this period:
String JournalQuery = "SELECT PUB_a_journal.* FROM PUB_a_batch, PUB_a_journal WHERE " +
"PUB_a_batch.a_ledger_number_i = " + ALedgerNumber +
" AND PUB_a_batch.a_batch_year_i = " + ALedger[0].CurrentFinancialYear +
" AND PUB_a_batch.a_batch_period_i = " + APeriodNumber +
" AND PUB_a_batch.a_batch_status_c = 'Posted'" +
" AND PUB_a_batch.a_ledger_number_i = PUB_a_journal.a_ledger_number_i" +
" AND PUB_a_batch.a_batch_number_i = PUB_a_journal.a_batch_number_i";
DBAccess.GDBAccessObj.SelectDT(AJournal, JournalQuery, DBTransaction);
String TransactionQuery = "SELECT PUB_a_transaction.* FROM PUB_a_batch, PUB_a_transaction WHERE " +
"PUB_a_batch.a_ledger_number_i = " + ALedgerNumber +
" AND PUB_a_batch.a_batch_year_i = " + ALedger[0].CurrentFinancialYear +
" AND PUB_a_batch.a_batch_period_i = " + APeriodNumber +
" AND PUB_a_batch.a_batch_status_c = 'Posted'" +
" AND PUB_a_batch.a_ledger_number_i = PUB_a_transaction.a_ledger_number_i" +
" AND PUB_a_batch.a_batch_number_i = PUB_a_transaction.a_batch_number_i";
DBAccess.GDBAccessObj.SelectDT(ATransaction, TransactionQuery, DBTransaction);
String CostCentreQuery = "SELECT * FROM a_cost_centre WHERE " +
ACostCentreTable.GetLedgerNumberDBName() + " = " + ALedgerNumber +
" AND " + ACostCentreTable.GetPostingCostCentreFlagDBName() + " = True" +
" AND " + ACostCentreTable.GetCostCentreTypeDBName() + " LIKE '" + MFinanceConstants.FOREIGN_CC_TYPE + "'" +
" ORDER BY " + ACostCentreTable.GetCostCentreCodeDBName();
DBAccess.GDBAccessObj.SelectDT(ACostCentre, CostCentreQuery, DBTransaction);
//Iterate through the cost centres
foreach (ACostCentreRow CostCentreRow in ACostCentre.Rows)
{
bool TransactionExists = false;
//Iterate through the journals
foreach (AJournalRow JournalRow in AJournal.Rows)
{
int BatchNumber = JournalRow.BatchNumber;
int JournalNumber = JournalRow.JournalNumber;
#if TODO
String TransFilter =
ATransactionTable.GetBatchNumberDBName() + " = " + BatchNumber.ToString() +
" AND " + ATransactionTable.GetJournalNumberDBName() + " = " + JournalNumber.ToString() +
" AND " + ATransactionTable.GetCostCentreCodeDBName() + " = '" + CostCentreRow.CostCentreCode + "'" +
" AND (" + ATransactionTable.GetIchNumberDBName() + " = 0" +
" OR " + ATransactionTable.GetIchNumberDBName() + " = " + AIchNumber.ToString() +
")";
DataRow[] FoundTransRows = BatchDS.ATransaction.Select(TransFilter);
foreach (DataRow untypedTransRow in FoundTransRows)
{
ATransactionRow TransactionRow = (ATransactionRow)untypedTransRow;
TransactionExists = true;
string DefaultData = ALedgerNumber.ToString() + "," +
LedgerName + "," +
APeriodNumber.ToString() + "," +
APeriodNumber.ToString() + "," +
CostCentreRow.CostCentreCode + "," +
"" + "," +
"" + "," +
"" + "," +
"A" + "," +
LedgerRow.CurrentFinancialYear.ToString() + "," +
LedgerRow.CurrentPeriod.ToString() + "," +
MFinanceConstants.MAX_PERIODS.ToString() + "," +
"h" + "," +
ACurrency + "," +
AIchNumber.ToString();
string ReportTitle = "Home Office Stmt of Acct: " + CostCentreRow.CostCentreName;
//call code for gl2120p.p Produces Account Detail, Analysis Attribute and HOSA Reprint reports.
/* RUN sm9000.w ("gl2120p.p",
* lv_report_title_c,
* lv_default_data_c).*/
//TODO: call code to produce reports
break;
}
#endif
if (TransactionExists)
{
//only need to run above code once for 1 transaction per cost centre code
break; //goto next cost centre else try next journal
}
}
}
if (NewTransaction)
{
DBAccess.GDBAccessObj.RollbackTransaction();
}
}
catch (Exception Exp)
{
if (NewTransaction)
{
DBAccess.GDBAccessObj.RollbackTransaction();
}
TLogging.Log(Exp.Message);
TLogging.Log(Exp.StackTrace);
throw;
}
}
/// <summary>
/// Code to be run after the deletion process
/// </summary>
/// <param name="ARowToDelete">the row that was/was to be deleted</param>
/// <param name="AAllowDeletion">whether or not the user was permitted to delete</param>
/// <param name="ADeletionPerformed">whether or not the deletion was performed successfully</param>
/// <param name="ACompletionMessage">if specified, is the deletion completion message</param>
private void PostDeleteManual(ATransactionRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
if (ADeletionPerformed)
{
UpdateChangeableStatus();
if (!pnlDetails.Enabled)
{
ClearControls();
}
//Always update LastTransactionNumber first before updating totals
GLRoutines.UpdateJournalLastTransaction(ref FMainDS, ref FJournalRow);
UpdateTransactionTotals();
if (((TFrmGLBatch) this.ParentForm).SaveChanges())
{
//message to user
MessageBox.Show(ACompletionMessage,
"Deletion Successful",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
else
{
MessageBox.Show(Catalog.GetString("Error attempting to save after deleting a transaction!"),
"Deletion Unsuccessful",
MessageBoxButtons.OK,
MessageBoxIcon.Exclamation);
}
}
else if (!AAllowDeletion && (ACompletionMessage.Length > 0))
{
//message to user
MessageBox.Show(ACompletionMessage,
"Deletion not allowed",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else if (!ADeletionPerformed && (ACompletionMessage.Length > 0))
{
//message to user
MessageBox.Show(ACompletionMessage,
"Deletion failed",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
/// <summary>
/// Update the totals for the current journal (no exchange rate calculation at this point)
/// and set LastTransactionNumber
/// </summary>
/// <param name="AMainDS">ATransactions are filtered on current journal</param>
/// <param name="ACurrentJournal"></param>
public static void UpdateTotalsOfJournal(ref GLBatchTDS AMainDS,
ref GLBatchTDSAJournalRow ACurrentJournal)
{
if (ACurrentJournal == null)
{
return;
}
int LastTransactionNumber = 0;
decimal JournalDebitTotal = 0.0M;
decimal JournalDebitTotalBase = 0.0M;
decimal JournalCreditTotal = 0.0M;
decimal JournalCreditTotalBase = 0.0M;
if (DBNull.Value.Equals(ACurrentJournal[GLBatchTDSAJournalTable.ColumnJournalDebitTotalBaseId]))
{
ACurrentJournal.JournalDebitTotalBase = 0;
}
if (DBNull.Value.Equals(ACurrentJournal[GLBatchTDSAJournalTable.ColumnJournalCreditTotalBaseId]))
{
ACurrentJournal.JournalCreditTotalBase = 0;
}
DataView TransDataView = new DataView(AMainDS.ATransaction);
TransDataView.RowFilter = String.Format("{0}={1} And {2}={3}",
ATransactionTable.GetBatchNumberDBName(),
ACurrentJournal.BatchNumber,
ATransactionTable.GetJournalNumberDBName(),
ACurrentJournal.JournalNumber);
TransDataView.Sort = string.Format("{0} DESC",
ATransactionTable.GetTransactionNumberDBName());
// transactions are filtered for this journal; add up the total amounts
foreach (DataRowView drv in TransDataView)
{
ATransactionRow transRow = (ATransactionRow)drv.Row;
//on first recursion
if (transRow.TransactionNumber > LastTransactionNumber)
{
//Sort order will ensure this is the highest trans number on first pass
LastTransactionNumber = transRow.TransactionNumber;
}
if (transRow.DebitCreditIndicator)
{
JournalDebitTotal += transRow.TransactionAmount;
JournalDebitTotalBase += transRow.AmountInBaseCurrency;
}
else
{
JournalCreditTotal += transRow.TransactionAmount;
JournalCreditTotalBase += transRow.AmountInBaseCurrency;
}
}
if ((ACurrentJournal.JournalDebitTotal != JournalDebitTotal) ||
(ACurrentJournal.JournalDebitTotalBase != JournalDebitTotalBase) ||
(ACurrentJournal.JournalCreditTotal != JournalCreditTotal) ||
(ACurrentJournal.JournalCreditTotalBase != JournalCreditTotalBase))
{
ACurrentJournal.JournalDebitTotal = JournalDebitTotal;
ACurrentJournal.JournalDebitTotalBase = JournalDebitTotalBase;
ACurrentJournal.JournalCreditTotal = JournalCreditTotal;
ACurrentJournal.JournalCreditTotalBase = JournalCreditTotalBase;
}
if (ACurrentJournal.LastTransactionNumber != LastTransactionNumber)
{
ACurrentJournal.LastTransactionNumber = LastTransactionNumber;
}
}
private void GetDataForAmountFields(ATransactionRow ARow)
{
if (ARow == null)
{
return;
}
bool DebitCreditIndicator;
decimal TransactionAmount;
if ((txtDebitAmount.Text.Length == 0) && (txtDebitAmount.NumberValueDecimal.Value != 0))
{
txtDebitAmount.NumberValueDecimal = 0;
}
if ((txtCreditAmount.Text.Length == 0) && (txtCreditAmount.NumberValueDecimal.Value != 0))
{
txtCreditAmount.NumberValueDecimal = 0;
}
DebitCreditIndicator = (txtDebitAmount.NumberValueDecimal.Value > 0);
if (ARow.DebitCreditIndicator != DebitCreditIndicator)
{
ARow.DebitCreditIndicator = DebitCreditIndicator;
}
if (ARow.DebitCreditIndicator)
{
TransactionAmount = Math.Abs(txtDebitAmount.NumberValueDecimal.Value);
if (txtCreditAmount.NumberValueDecimal.Value != 0)
{
txtCreditAmount.NumberValueDecimal = 0;
}
}
else
{
TransactionAmount = Math.Abs(txtCreditAmount.NumberValueDecimal.Value);
}
if (ARow.TransactionAmount != TransactionAmount)
{
ARow.TransactionAmount = TransactionAmount;
}
}
private void ShowDetailsManual(ATransactionRow ARow)
{
grdDetails.TabStop = (ARow != null);
grdAnalAttributes.Enabled = (ARow != null);
if (ARow == null)
{
FTransactionNumber = -1;
ClearControls();
btnNew.Focus();
return;
}
FTransactionNumber = ARow.TransactionNumber;
if (ARow.DebitCreditIndicator)
{
txtDebitAmount.NumberValueDecimal = ARow.TransactionAmount;
txtCreditAmount.NumberValueDecimal = 0;
txtDebitAmountBase.NumberValueDecimal = ARow.AmountInBaseCurrency;
txtCreditAmountBase.NumberValueDecimal = 0;
}
else
{
txtDebitAmount.NumberValueDecimal = 0;
txtCreditAmount.NumberValueDecimal = ARow.TransactionAmount;
txtDebitAmountBase.NumberValueDecimal = 0;
txtCreditAmountBase.NumberValueDecimal = ARow.AmountInBaseCurrency;
}
RefreshAnalysisAttributesGrid();
UpdateChangeableStatus();
}
/// <summary>
/// Validates the GL Detail data.
/// </summary>
/// <param name="AContext">Context that describes where the data validation failed.</param>
/// <param name="ABatchRow">Manually added to bring over some GL Batch fields</param>
/// <param name="ARow">The <see cref="DataRow" /> which holds the the data against which the validation is run.</param>
/// <param name="AVerificationResultCollection">Will be filled with any <see cref="TVerificationResult" /> items if
/// data validation errors occur.</param>
/// <param name="AValidationCostCentreTable">REQUIRED for importing. A reference to a cost centre table so that inputs can be validated.</param>
/// <param name="AvalidationAccountTable">REQUIRED for importing. A reference to an account table so that inputs can be validated.</param>
/// <returns>True if the validation found no data validation errors, otherwise false.</returns>
public static bool ValidateGLDetailManual(object AContext, ABatchRow ABatchRow, ATransactionRow ARow,
ref TVerificationResultCollection AVerificationResultCollection,
ACostCentreTable AValidationCostCentreTable = null, AAccountTable AvalidationAccountTable = null)
{
DataColumn ValidationColumn;
TVerificationResult VerificationResult = null;
object ValidationContext;
int VerifResultCollAddedCount = 0;
// Don't validate deleted DataRows or non-unposted batches
if ((ABatchRow.BatchStatus != MFinanceConstants.BATCH_UNPOSTED) || (ARow.RowState == DataRowState.Deleted))
{
return(true);
}
bool isImporting = AContext.ToString().Contains("Importing");
// When used by the GUI TransactionAmount is not in the dictionary so had to pass the control directly
// But when importing we do have a dictionary entry
if (isImporting)
{
// 'GL amount must be non-zero and positive
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnTransactionAmountId];
if (true)
{
VerificationResult = TNumericalChecks.IsPositiveDecimal(ARow.TransactionAmount,
String.Empty,
AContext, ValidationColumn);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult))
{
VerifResultCollAddedCount++;
}
}
}
else
{
if (true)
{
// 'GL amount must be non-zero and positive
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnTransactionAmountId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
VerificationResult = TNumericalChecks.IsPositiveOrZeroDecimal(ARow.TransactionAmount,
"Amount of " + ValidationContext,
AContext, ValidationColumn);
if (VerificationResult != null)
{
VerificationResult.SuppressValidationToolTip = true;
}
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult))
{
VerifResultCollAddedCount++;
}
return(VerifResultCollAddedCount == 0);
}
}
// 'Narrative must not be empty
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnNarrativeId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (true)
{
VerificationResult = TStringChecks.StringMustNotBeEmpty(ARow.Narrative,
(isImporting) ? String.Empty : "Narrative of " + ValidationContext,
AContext, ValidationColumn);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult))
{
VerifResultCollAddedCount++;
}
}
// 'Entered From Date' must be valid
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnTransactionDateId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (true)
{
DateTime StartDatePeriod;
DateTime EndDatePeriod;
TSharedFinanceValidationHelper.GetValidPeriodDates(ARow.LedgerNumber, ABatchRow.BatchYear, 0, ABatchRow.BatchPeriod,
out StartDatePeriod,
out EndDatePeriod);
VerificationResult = (TScreenVerificationResult)TDateChecks.IsDateBetweenDates(ARow.TransactionDate,
StartDatePeriod,
EndDatePeriod,
(isImporting) ? String.Empty : "Transaction Date for " + ValidationContext.ToString(),
TDateBetweenDatesCheckType.dbdctUnspecific,
TDateBetweenDatesCheckType.dbdctUnspecific,
AContext,
ValidationColumn);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult))
{
VerifResultCollAddedCount++;
}
}
if (true)
{
// "Reference" is mandatory
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnReferenceId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (true)
{
VerificationResult = TStringChecks.StringMustNotBeEmpty(ARow.Reference,
(isImporting) ? String.Empty : "Reference of " + ValidationContext,
AContext, ValidationColumn);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult))
{
VerifResultCollAddedCount++;
}
}
}
// 'CostCentre' must be valid
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnCostCentreCodeId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (true)
{
if ((AValidationCostCentreTable != null) && !ARow.IsCostCentreCodeNull())
{
// Code must exist in the cost centre table
ACostCentreRow foundRow = (ACostCentreRow)AValidationCostCentreTable.Rows.Find(
new object[] { ARow.LedgerNumber, ARow.CostCentreCode });
if ((foundRow == null) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Cost centre code '{0}' does not exist."), ARow.CostCentreCode),
TResultSeverity.Resv_Critical)))
{
VerifResultCollAddedCount++;
}
// cost centre must be a posting cost centre
if ((foundRow != null) && !foundRow.PostingCostCentreFlag)
{
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Cost centre code '{0}' is not a posting cost centre."), ARow.CostCentreCode),
TResultSeverity.Resv_Critical)))
{
VerifResultCollAddedCount++;
}
}
//TODO: Maybe add a user preference to determine what to do with inactive values on importing
// cost centre must not be inactive
//if ((foundRow != null) && !foundRow.CostCentreActiveFlag)
//{
// if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
// new TVerificationResult(ValidationContext,
// String.Format(Catalog.GetString("Cost centre code '{0}' is an inactive cost centre."), ARow.CostCentreCode),
// TResultSeverity.Resv_Critical),
// ValidationColumn))
// {
// VerifResultCollAddedCount++;
// }
//}
}
}
// 'Account code' must be valid
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnAccountCodeId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (true)
{
if ((AvalidationAccountTable != null) && !ARow.IsAccountCodeNull())
{
// Code must exist in the account table
AAccountRow foundRow = (AAccountRow)AvalidationAccountTable.Rows.Find(
new object[] { ARow.LedgerNumber, ARow.AccountCode });
if ((foundRow == null) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Account code '{0}' does not exist."), ARow.AccountCode),
TResultSeverity.Resv_Critical)))
{
VerifResultCollAddedCount++;
}
// Account code must be a posting Account code
if ((foundRow != null) && !foundRow.PostingStatus)
{
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Account code '{0}' is not a posting account."), ARow.AccountCode),
TResultSeverity.Resv_Critical)))
{
VerifResultCollAddedCount++;
}
}
//TODO: Maybe add a user preference to determine what to do with inactive values on importing
// Account code must not be inactive
//if ((foundRow != null) && !foundRow.AccountActiveFlag)
//{
// if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
// new TVerificationResult(ValidationContext,
// String.Format(Catalog.GetString("Account code '{0}' is an inactive account."), ARow.AccountCode),
// TResultSeverity.Resv_Critical),
// ValidationColumn))
// {
// VerifResultCollAddedCount++;
// }
//}
}
}
return(VerifResultCollAddedCount == 0);
}
/// <summary>
/// Export all the Data of the batches array list to a String
/// </summary>
/// <param name="Abatches"></param>
/// <param name="ArequestParams"></param>
/// <param name="AexportString"></param>
/// <returns>false if batch does not exist at all</returns>
public bool ExportAllGLBatchData(ArrayList Abatches, Hashtable ArequestParams, out String AexportString)
{
FStringWriter = new StringWriter();
FMainDS = new GLBatchTDS();
FDelimiter = (String)ArequestParams["Delimiter"];
FLedgerNumber = (Int32)ArequestParams["ALedgerNumber"];
FDateFormatString = (String)ArequestParams["DateFormatString"];
FSummary = (bool)ArequestParams["Summary"];
FUseBaseCurrency = (bool)ArequestParams["bUseBaseCurrency"];
FBaseCurrency = (String)ArequestParams["BaseCurrency"];
FDateForSummary = (DateTime)ArequestParams["DateForSummary"];
String NumberFormat = (String)ArequestParams["NumberFormat"];
FCultureInfo = new CultureInfo(NumberFormat.Equals("American") ? "en-US" : "de-DE");
FTransactionsOnly = (bool)ArequestParams["TransactionsOnly"];
FDontSummarize = (bool)ArequestParams["bDontSummarize"];
FDontSummarizeAccount = (String)ArequestParams["DontSummarizeAccount"];
SortedDictionary <String, AJournalSummaryRow> sdSummary = new SortedDictionary <String, AJournalSummaryRow>();
TDBTransaction Transaction = new TDBTransaction();
TDataBase db = DBAccess.Connect("ExportAllGLBatchData");
db.ReadTransaction(ref Transaction,
delegate
{
UInt32 progressCounter = 0;
UInt32 progressJournalCounter = 0;
TProgressTracker.InitProgressTracker(DomainManager.GClientID.ToString(),
Catalog.GetString("Exporting GL Batches"),
100);
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
Catalog.GetString("Retrieving records"),
10);
while (Abatches.Count > 0)
{
Int32 ABatchNumber = (Int32)Abatches[0];
ABatchAccess.LoadByPrimaryKey(FMainDS, FLedgerNumber, ABatchNumber, Transaction);
AJournalAccess.LoadViaABatch(FMainDS, FLedgerNumber, ABatchNumber, Transaction);
foreach (AJournalRow journal in FMainDS.AJournal.Rows)
{
if (journal.BatchNumber.Equals(ABatchNumber) && journal.LedgerNumber.Equals(FLedgerNumber))
{
ATransactionAccess.LoadViaAJournal(FMainDS, journal.LedgerNumber,
journal.BatchNumber,
journal.JournalNumber,
Transaction);
}
}
foreach (ATransactionRow trans in FMainDS.ATransaction.Rows)
{
if (trans.BatchNumber.Equals(ABatchNumber) && trans.LedgerNumber.Equals(FLedgerNumber))
{
ATransAnalAttribAccess.LoadViaATransaction(FMainDS, trans.LedgerNumber,
trans.BatchNumber,
trans.JournalNumber,
trans.TransactionNumber,
Transaction);
}
}
Abatches.RemoveAt(0);
}
UInt32 counter = 0;
AJournalSummaryRow journalSummary = null;
foreach (ABatchRow batch in FMainDS.ABatch.Rows)
{
progressCounter = 0;
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
String.Format(Catalog.GetString("Batch {0}"), batch.BatchNumber),
20);
if (!FTransactionsOnly & !FSummary)
{
WriteBatchLine(batch);
}
//foreach (AJournalRow journal in journalDS.AJournal.Rows)
foreach (AJournalRow journal in FMainDS.AJournal.Rows)
{
if (journal.BatchNumber.Equals(batch.BatchNumber) && journal.LedgerNumber.Equals(batch.LedgerNumber))
{
progressJournalCounter = 0;
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
String.Format(Catalog.GetString("Batch {0}, Journal {1}"), batch.BatchNumber, journal.JournalNumber),
(progressCounter / 25 + 4) * 5 > 90 ? 90 : (progressCounter / 25 + 4) * 5);
if (FSummary)
{
String mapCurrency = FUseBaseCurrency ? FBaseCurrency : journal.TransactionCurrency;
decimal mapExchangeRateToBase = FUseBaseCurrency ? 1 : journal.ExchangeRateToBase;
if (!sdSummary.TryGetValue(mapCurrency, out journalSummary))
{
journalSummary = new AJournalSummaryRow();
sdSummary.Add(mapCurrency, journalSummary);
}
//overwrite always because we want to have the last
journalSummary.ExchangeRateToBase = mapExchangeRateToBase;
journalSummary.TransactionCurrency = mapCurrency;
}
else
{
if (!FTransactionsOnly)
{
WriteJournalLine(journal);
}
}
FMainDS.ATransaction.DefaultView.Sort = ATransactionTable.GetTransactionNumberDBName();
FMainDS.ATransaction.DefaultView.RowFilter =
String.Format("{0}={1} and {2}={3} and {4}={5}",
ATransactionTable.GetLedgerNumberDBName(),
journal.LedgerNumber,
ATransactionTable.GetBatchNumberDBName(),
journal.BatchNumber,
ATransactionTable.GetJournalNumberDBName(),
journal.JournalNumber);
foreach (DataRowView dv in FMainDS.ATransaction.DefaultView)
{
progressJournalCounter++;
if (++progressCounter % 25 == 0)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
String.Format(Catalog.GetString(
"Batch {0}, Journal {1} - {2}"), batch.BatchNumber, journal.JournalNumber,
progressJournalCounter),
(progressCounter / 25 + 4) * 5 > 90 ? 90 : (progressCounter / 25 + 4) * 5);
}
ATransactionRow transactionRow = (ATransactionRow)dv.Row;
if (FSummary)
{
ATransactionSummaryRow transactionSummary;
counter++;
String DictionaryKey = transactionRow.CostCentreCode + ";" + transactionRow.AccountCode;
int signum = transactionRow.DebitCreditIndicator ? 1 : -1;
bool bDontSummarizeAccount = FDontSummarize && FDontSummarizeAccount != null &&
FDontSummarizeAccount.Length > 0 &&
transactionRow.AccountCode.Equals(FDontSummarizeAccount);
if (bDontSummarizeAccount)
{
DictionaryKey += ";" + counter.ToString("X");
}
if (journalSummary.TransactionSummaries.TryGetValue(DictionaryKey, out transactionSummary))
{
transactionSummary.TransactionAmount += signum * transactionRow.TransactionAmount;
transactionSummary.AmountInBaseCurrency += signum * transactionRow.AmountInBaseCurrency;
}
else
{
transactionSummary = new ATransactionSummaryRow();
transactionSummary.CostCentreCode = transactionRow.CostCentreCode;
transactionSummary.AccountCode = transactionRow.AccountCode;
transactionSummary.TransactionAmount = signum * transactionRow.TransactionAmount;
transactionSummary.AmountInBaseCurrency = signum * transactionRow.AmountInBaseCurrency;
if (bDontSummarizeAccount)
{
transactionSummary.Narrative = transactionRow.Narrative;
transactionSummary.Reference = transactionRow.Reference;
}
else
{
transactionSummary.Narrative = summarizedData;
transactionSummary.Reference = "";
}
journalSummary.TransactionSummaries.Add(DictionaryKey, transactionSummary);
}
}
else
{
WriteTransactionLine(transactionRow);
}
}
}
}
}
if (FSummary)
{
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
Catalog.GetString("Summarising"),
95);
//To simplify matters this is always written even if there are no batches
if (!FTransactionsOnly)
{
// no batch summary line if only transactions are to be exported
WriteBatchSummaryLine();
}
foreach (KeyValuePair <string, AJournalSummaryRow> kvp in sdSummary)
{
if (!FTransactionsOnly)
{
// no journal summary line if only transactions are to be exported
WriteJournalSummaryLine(kvp.Value);
}
foreach (KeyValuePair <string, ATransactionSummaryRow> kvpt in kvp.Value.TransactionSummaries)
{
WriteTransactionSummaryLine(kvpt.Value);
}
}
}
TProgressTracker.SetCurrentState(DomainManager.GClientID.ToString(),
Catalog.GetString("GL batch export successful"),
100);
TProgressTracker.FinishJob(DomainManager.GClientID.ToString());
});
AexportString = FStringWriter.ToString();
return(true);
} // Export All GLBatch Data
/// <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(ATransactionRow ARowToDelete, ref string ACompletionMessage)
{
//Assign a default values
bool deletionSuccessful = false;
ACompletionMessage = string.Empty;
if (ARowToDelete == null)
{
return deletionSuccessful;
}
bool newRecord = (ARowToDelete.RowState == DataRowState.Added);
if (!newRecord && !((TFrmGLBatch) this.ParentForm).SaveChanges())
{
MessageBox.Show("Error in trying to save prior to deleting current transaction!");
return deletionSuccessful;
}
//Backup the Dataset for reversion purposes
GLBatchTDS FTempDS = (GLBatchTDS)FMainDS.Copy();
FTempDS.Merge(FMainDS);
int transactionNumberToDelete = ARowToDelete.TransactionNumber;
int lastTransactionNumber = FJournalRow.LastTransactionNumber;
FMainDS.EnforceConstraints = false;
try
{
this.Cursor = Cursors.WaitCursor;
// Delete on client side data through views that is already loaded. Data that is not
// loaded yet will be deleted with cascading delete on server side so we don't have
// to worry about this here.
FAnalysisAttributesLogic.SetTransAnalAttributeDefaultView(FMainDS, FActiveOnly, transactionNumberToDelete);
DataView attrView = FMainDS.ATransAnalAttrib.DefaultView;
if (attrView.Count > 0)
{
//Iterate through attributes and delete
ATransAnalAttribRow attrRowCurrent = null;
foreach (DataRowView gv in attrView)
{
attrRowCurrent = (ATransAnalAttribRow)gv.Row;
attrRowCurrent.Delete();
}
}
//Reduce those with higher transaction number by one
attrView.RowFilter = String.Format("{0} = {1} AND {2} = {3} AND {4} > {5}",
ATransAnalAttribTable.GetBatchNumberDBName(),
FBatchNumber,
ATransAnalAttribTable.GetJournalNumberDBName(),
FJournalNumber,
ATransAnalAttribTable.GetTransactionNumberDBName(),
transactionNumberToDelete);
// Delete the associated transaction analysis attributes
// if attributes do exist, and renumber those above
if (attrView.Count > 0)
{
//Iterate through higher number attributes and transaction numbers and reduce by one
ATransAnalAttribRow attrRowCurrent = null;
foreach (DataRowView gv in attrView)
{
attrRowCurrent = (ATransAnalAttribRow)gv.Row;
attrRowCurrent.TransactionNumber--;
}
}
//Bubble the transaction to delete to the top
DataView transView = new DataView(FMainDS.ATransaction);
transView.RowFilter = String.Format("{0}={1} AND {2}={3}",
ATransactionTable.GetBatchNumberDBName(),
FBatchNumber,
ATransactionTable.GetJournalNumberDBName(),
FJournalNumber);
transView.Sort = String.Format("{0} ASC",
ATransactionTable.GetTransactionNumberDBName());
ATransactionRow transRowToReceive = null;
ATransactionRow transRowToCopyDown = null;
ATransactionRow transRowCurrent = null;
int currentTransNo = 0;
foreach (DataRowView gv in transView)
{
transRowCurrent = (ATransactionRow)gv.Row;
currentTransNo = transRowCurrent.TransactionNumber;
if (currentTransNo > transactionNumberToDelete)
{
transRowToCopyDown = transRowCurrent;
//Copy column values down
for (int j = 4; j < transRowToCopyDown.Table.Columns.Count; j++)
{
//Update all columns except the pk fields that remain the same
if (!transRowToCopyDown.Table.Columns[j].ColumnName.EndsWith("_text"))
{
// Don't include the columns that the filter uses for numeric textual comparison
transRowToReceive[j] = transRowToCopyDown[j];
}
}
}
if (currentTransNo == transView.Count) //Last row which is the row to be deleted
{
//Mark last record for deletion
transRowCurrent.SubType = MFinanceConstants.MARKED_FOR_DELETION;
}
//transRowToReceive will become previous row for next recursion
transRowToReceive = transRowCurrent;
}
if (newRecord && (transRowCurrent.SubType == MFinanceConstants.MARKED_FOR_DELETION))
{
transRowCurrent.Delete();
}
FPreviouslySelectedDetailRow = null;
FPetraUtilsObject.SetChangedFlag();
//Try to save changes
if (!((TFrmGLBatch) this.ParentForm).SaveChanges())
{
throw new Exception("Unable to save after deleting a transaction!");
}
ACompletionMessage = String.Format(Catalog.GetString("Transaction no.: {0} deleted successfully."),
transactionNumberToDelete);
deletionSuccessful = true;
}
catch (Exception ex)
{
ACompletionMessage = ex.Message;
MessageBox.Show(ex.Message,
"Deletion Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
//Revert to previous state
FMainDS.Merge(FTempDS);
}
finally
{
FMainDS.EnforceConstraints = true;
SetTransactionDefaultView();
FFilterAndFindObject.ApplyFilter();
this.Cursor = Cursors.Default;
}
return deletionSuccessful;
}
private void ValidateDataDetailsManual(ATransactionRow ARow)
{
if ((ARow == null) || (GetBatchRow() == null) || !FIsUnposted)
{
return;
}
TVerificationResultCollection VerificationResultCollection = FPetraUtilsObject.VerificationResultCollection;
Control controlToPass = null;
//Local validation
if (((txtDebitAmount.NumberValueDecimal.Value == 0)
&& (txtCreditAmount.NumberValueDecimal.Value == 0))
|| (txtDebitAmount.NumberValueDecimal.Value < 0))
{
controlToPass = txtDebitAmount;
}
else if (txtCreditAmount.NumberValueDecimal.Value < 0)
{
controlToPass = txtCreditAmount;
}
else if (TSystemDefaults.GetSystemDefault(SharedConstants.SYSDEFAULT_GLREFMANDATORY, "no") == "yes")
{
controlToPass = txtDetailReference;
}
if ((controlToPass == null) || (controlToPass == txtDetailReference))
{
//This is needed because the above runs many times during setting up the form
VerificationResultCollection.Clear();
}
TSharedFinanceValidation_GL.ValidateGLDetailManual(this, FBatchRow, ARow, controlToPass, ref VerificationResultCollection,
FValidationControlsDict);
if ((FPreviouslySelectedDetailRow != null)
&& !FAnalysisAttributesLogic.AccountAnalysisAttributeCountIsCorrect(
FPreviouslySelectedDetailRow.TransactionNumber,
FPreviouslySelectedDetailRow.AccountCode,
FMainDS,
FIsUnposted))
{
DataColumn ValidationColumn;
TVerificationResult VerificationResult = null;
object ValidationContext;
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnAccountCodeId];
ValidationContext = "unused because of OverrideResultText";
// This code is only running because of failure, so cause an error to occur.
VerificationResult = TStringChecks.StringMustNotBeEmpty("",
ValidationContext.ToString(),
this, ValidationColumn, null);
VerificationResult.OverrideResultText(String.Format(
"A value must be entered for 'Analysis Attributes' for Account Code {0} in Transaction {1}.{2}{2}" +
"CLICK THE DOWN ARROW NEXT TO THE ACCOUNT CODE BOX TO OPEN THE LIST AND THEN RESELECT ACCOUNT CODE {0}",
ARow.AccountCode,
ARow.TransactionNumber,
Environment.NewLine));
// Handle addition/removal to/from TVerificationResultCollection
VerificationResultCollection.Auto_Add_Or_AddOrRemove(this, VerificationResult, ValidationColumn, true);
}
String ValueRequiredForType;
if ((FPreviouslySelectedDetailRow != null)
&& !FAnalysisAttributesLogic.AccountAnalysisAttributesValuesExist(
FPreviouslySelectedDetailRow.TransactionNumber,
FPreviouslySelectedDetailRow.AccountCode,
FMainDS,
out ValueRequiredForType,
FIsUnposted))
{
DataColumn ValidationColumn;
TVerificationResult VerificationResult = null;
object ValidationContext;
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnAccountCodeId];
ValidationContext = String.Format("Analysis code {0} for Account Code {1} in Transaction {2}",
ValueRequiredForType,
ARow.AccountCode,
ARow.TransactionNumber);
// This code is only running because of failure, so cause an error to occur.
VerificationResult = TStringChecks.StringMustNotBeEmpty("",
ValidationContext.ToString(),
this, ValidationColumn, null);
// Handle addition/removal to/from TVerificationResultCollection
VerificationResultCollection.Auto_Add_Or_AddOrRemove(this, VerificationResult, ValidationColumn, true);
}
}
private void ShowDetailsManual(ATransactionRow ARow)
{
grdDetails.TabStop = (ARow != null);
grdAnalAttributes.Enabled = (ARow != null);
if (ARow == null)
{
FTransactionNumber = -1;
ClearControls();
btnNew.Focus();
return;
}
FTransactionNumber = ARow.TransactionNumber;
if (ARow.DebitCreditIndicator)
{
txtDebitAmount.NumberValueDecimal = ARow.TransactionAmount;
txtCreditAmount.NumberValueDecimal = 0;
txtDebitAmountBase.NumberValueDecimal = ARow.AmountInBaseCurrency;
txtCreditAmountBase.NumberValueDecimal = 0;
}
else
{
txtDebitAmount.NumberValueDecimal = 0;
txtCreditAmount.NumberValueDecimal = ARow.TransactionAmount;
txtDebitAmountBase.NumberValueDecimal = 0;
txtCreditAmountBase.NumberValueDecimal = ARow.AmountInBaseCurrency;
}
if (FPetraUtilsObject.HasChanges && !FIsUnposted)
{
FPetraUtilsObject.HasChanges = false;
FPetraUtilsObject.DisableSaveButton();
}
RefreshAnalysisAttributesGrid();
}
private ATransactionRow AddATransaction(string AAccount,
string ACostCenter,
string ANarrativeMessage,
string AReferenceMessage,
bool AIsDebit,
decimal AAmountBaseCurrency,
decimal AAmountForeignCurrency,
bool ATransActionIsInForeign)
{
if (!blnReadyForTransaction)
{
EVerificationException terminate = new EVerificationException(
Catalog.GetString("You have to add a journal before you can add a transaction!"));
terminate.Context = "Common Accounting";
terminate.ErrorCode = "GL.CAT.06";
throw terminate;
}
if (AAccount.Trim().Length == 0)
{
throw new Exception("account code is empty");
}
if (FForeignJournal)
{
if (ATransActionIsInForeign)
{
TAccountInfo accountCheck =
new TAccountInfo(FLedgerInfo, AAccount);
if (accountCheck.IsValid)
{
if (accountCheck.ForeignCurrencyFlag)
{
if (!accountCheck.ForeignCurrencyCode.Equals(this.FForeignCurrencyInfo.CurrencyCode))
{
// This is a difficult error situation. Someone wants to account
// JYP-Currencies on a GBP-account in an EUR ledger.
string strMessage = Catalog.GetString("The ledger is defined in {0}, the account {1} is defined in " +
"{2} and you want to account something in {3}?");
strMessage = String.Format(strMessage,
FLedgerInfo.BaseCurrency,
AAccount,
accountCheck.ForeignCurrencyCode,
FForeignCurrencyInfo.CurrencyCode);
EVerificationException terminate = new EVerificationException(strMessage);
terminate.Context = "Common Accounting";
terminate.ErrorCode = "GL.CAT.07";
throw terminate;
}
}
}
}
}
ATransactionRow transRow = null;
transRow = FBatchTDS.ATransaction.NewRowTyped();
transRow.LedgerNumber = FJournalRow.LedgerNumber;
transRow.BatchNumber = FJournalRow.BatchNumber;
transRow.JournalNumber = FJournalRow.JournalNumber;
transRow.TransactionNumber = ++FJournalRow.LastTransactionNumber;
transRow.AccountCode = AAccount;
transRow.CostCentreCode = ACostCenter;
transRow.Narrative = ANarrativeMessage;
transRow.Reference = AReferenceMessage;
transRow.DebitCreditIndicator = AIsDebit;
transRow.AmountInBaseCurrency = AAmountBaseCurrency;
transRow.TransactionAmount = (ATransActionIsInForeign) ? AAmountForeignCurrency : AAmountBaseCurrency;
//
// The International currency calculation is changed to "Base -> International", because it's likely
// we won't have a "Transaction -> International" conversion rate defined.
//
transRow.AmountInIntlCurrency = GLRoutines.Multiply(transRow.AmountInBaseCurrency,
TExchangeRateTools.GetDailyExchangeRate(
FLedgerInfo.BaseCurrency,
FLedgerInfo.InternationalCurrency,
transRow.TransactionDate));
transRow.TransactionDate = FBatchRow.DateEffective;
FBatchTDS.ATransaction.Rows.Add(transRow);
if (AIsDebit)
{
FJournalRow.JournalDebitTotal += AAmountBaseCurrency;
}
else
{
FJournalRow.JournalCreditTotal += AAmountBaseCurrency;
}
return(transRow);
}
void WriteTransactionLine(ATransactionRow transaction)
{
if (!FTransactionsOnly)
{
WriteStringQuoted("T");
}
WriteStringQuoted(transaction.CostCentreCode);
WriteStringQuoted(transaction.AccountCode);
WriteStringQuoted(transaction.Narrative);
WriteStringQuoted(transaction.Reference);
WriteDate(transaction.TransactionDate);
decimal amount = (FUseBaseCurrency) ? transaction.AmountInBaseCurrency : transaction.TransactionAmount;
if (transaction.DebitCreditIndicator)
{
WriteCurrency(amount);
WriteCurrency(0);
}
else
{
WriteCurrency(0);
WriteCurrency(amount);
}
WriteAnalysisAttributesSuffix(transaction);
}
/// <summary>
/// Code to be run after the deletion process
/// </summary>
/// <param name="ARowToDelete">the row that was/was to be deleted</param>
/// <param name="AAllowDeletion">whether or not the user was permitted to delete</param>
/// <param name="ADeletionPerformed">whether or not the deletion was performed successfully</param>
/// <param name="ACompletionMessage">if specified, is the deletion completion message</param>
private void PostDeleteManual(ATransactionRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
if (ADeletionPerformed)
{
UpdateChangeableStatus();
if (!pnlDetails.Enabled)
{
ClearControls();
}
UpdateTransactionTotals();
((TFrmGLBatch) this.ParentForm).SaveChanges();
//message to user
MessageBox.Show(ACompletionMessage,
"Deletion Successful",
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
else if (!AAllowDeletion && (ACompletionMessage.Length > 0))
{
//message to user
MessageBox.Show(ACompletionMessage,
"Deletion not allowed",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else if (!ADeletionPerformed && (ACompletionMessage.Length > 0))
{
//message to user
MessageBox.Show(ACompletionMessage,
"Deletion failed",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
private bool PreDeleteManual(ATransactionRow ARowToDelete, ref string ADeletionQuestion)
{
bool allowDeletion = true;
if (FPreviouslySelectedDetailRow != null)
{
if (ARowToDelete.SystemGenerated)
{
MessageBox.Show(string.Format(Catalog.GetString(
"Transaction {0} cannot be deleted as it is a system generated transaction"), ARowToDelete.TransactionNumber),
Catalog.GetString("Delete Transaction"), MessageBoxButtons.OK, MessageBoxIcon.Information);
return false;
}
ADeletionQuestion = String.Format(Catalog.GetString("Are you sure you want to delete transaction no. {0} from Journal {1}?"),
ARowToDelete.TransactionNumber,
ARowToDelete.JournalNumber);
}
return allowDeletion;
}
/// <summary>
/// make sure the correct transaction number is assigned and the journal.lastTransactionNumber is updated
/// </summary>
/// <param name="ANewRow">returns the modified new transaction row</param>
/// <param name="ARefTransactionRow">this can be null; otherwise this is the transaction that the Attribute should belong to</param>
public void NewRowManual(ref ATransAnalAttribRow ANewRow, ATransactionRow ARefTransactionRow)
{
if (ARefTransactionRow == null)
{
ARefTransactionRow = GetTransactionRow();
}
ANewRow.LedgerNumber = ARefTransactionRow.LedgerNumber;
ANewRow.BatchNumber = ARefTransactionRow.BatchNumber;
ANewRow.JournalNumber = ARefTransactionRow.JournalNumber;
ANewRow.TransactionNumber = ARefTransactionRow.TransactionNumber;
}
private void ValidateDataDetailsManual(ATransactionRow ARow)
{
//Can be called from outside, so need to update fields
FBatchRow = GetBatchRow();
if (FBatchRow == null)
{
return;
}
FJournalRow = GetJournalRow();
if (FJournalRow != null)
{
FJournalNumber = FJournalRow.JournalNumber;
FJournalStatus = FJournalRow.JournalStatus;
}
FIsUnposted = (FBatchRow.BatchStatus == MFinanceConstants.BATCH_UNPOSTED);
if ((ARow == null) || (FBatchRow.BatchNumber != ARow.BatchNumber) || !FIsUnposted)
{
return;
}
TVerificationResultCollection VerificationResultCollection = FPetraUtilsObject.VerificationResultCollection;
Control controlToPass = null;
//Local validation
if (((txtDebitAmount.NumberValueDecimal.Value == 0)
&& (txtCreditAmount.NumberValueDecimal.Value == 0))
|| (txtDebitAmount.NumberValueDecimal.Value < 0))
{
controlToPass = txtDebitAmount;
}
else if (txtCreditAmount.NumberValueDecimal.Value < 0)
{
controlToPass = txtCreditAmount;
}
else if (TSystemDefaults.GetSystemDefault(SharedConstants.SYSDEFAULT_GLREFMANDATORY, "no") == "yes")
{
controlToPass = txtDetailReference;
}
else if ((VerificationResultCollection.Count == 1)
&& (VerificationResultCollection[0].ResultCode == CommonErrorCodes.ERR_INVALIDNUMBER))
{
//The amount controls register as invalid even when value is correct. Need to reset
// Verifications accordingly.
FPetraUtilsObject.VerificationResultCollection.Clear();
}
TSharedFinanceValidation_GL.ValidateGLDetailManual(this, FBatchRow, ARow, controlToPass, ref VerificationResultCollection,
FValidationControlsDict);
if ((FPreviouslySelectedDetailRow != null)
&& !FAnalysisAttributesLogic.AccountAnalysisAttributeCountIsCorrect(
FPreviouslySelectedDetailRow.TransactionNumber,
FPreviouslySelectedDetailRow.AccountCode,
FMainDS,
FIsUnposted))
{
DataColumn ValidationColumn;
TVerificationResult VerificationResult = null;
object ValidationContext;
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnAccountCodeId];
ValidationContext = "unused because of OverrideResultText";
// This code is only running because of failure, so cause an error to occur.
VerificationResult = TStringChecks.StringMustNotBeEmpty("",
ValidationContext.ToString(),
this, ValidationColumn, null);
VerificationResult.OverrideResultText(String.Format(
"A value must be entered for 'Analysis Attributes' for Account Code {0} in Transaction {1}.",
ARow.AccountCode,
ARow.TransactionNumber));
// Handle addition/removal to/from TVerificationResultCollection
VerificationResultCollection.Auto_Add_Or_AddOrRemove(this, VerificationResult, ValidationColumn, true);
}
String ValueRequiredForType;
if ((FPreviouslySelectedDetailRow != null)
&& !FAnalysisAttributesLogic.AccountAnalysisAttributesValuesExist(
FPreviouslySelectedDetailRow.TransactionNumber,
FPreviouslySelectedDetailRow.AccountCode,
FMainDS,
out ValueRequiredForType,
FIsUnposted))
{
DataColumn ValidationColumn;
TVerificationResult VerificationResult = null;
object ValidationContext;
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnAccountCodeId];
ValidationContext = String.Format("Analysis code {0} for Account Code {1} in Transaction {2}",
ValueRequiredForType,
ARow.AccountCode,
ARow.TransactionNumber);
// This code is only running because of failure, so cause an error to occur.
VerificationResult = TStringChecks.StringMustNotBeEmpty("",
ValidationContext.ToString(),
this, ValidationColumn, null);
// Handle addition/removal to/from TVerificationResultCollection
VerificationResultCollection.Auto_Add_Or_AddOrRemove(this, VerificationResult, ValidationColumn, true);
}
}
/// <summary>
/// Validates the GL Detail data.
/// </summary>
/// <param name="AContext">Context that describes where the data validation failed.</param>
/// <param name="ABatchRow">Manually added to bring over some GL Batch fields</param>
/// <param name="ARow">The <see cref="DataRow" /> which holds the the data against which the validation is run.</param>
/// <param name="AControl"></param>
/// <param name="AVerificationResultCollection">Will be filled with any <see cref="TVerificationResult" /> items if
/// data validation errors occur.</param>
/// <param name="AValidationControlsDict">A <see cref="TValidationControlsDict" /> containing the Controls that
/// display data that is about to be validated.</param>
/// <param name="AValidationCostCentreTable">REQUIRED for importing. A reference to a cost centre table so that inputs can be validated.</param>
/// <param name="AvalidationAccountTable">REQUIRED for importing. A reference to an account table so that inputs can be validated.</param>
/// <returns>True if the validation found no data validation errors, otherwise false.</returns>
public static bool ValidateGLDetailManual(object AContext, ABatchRow ABatchRow, ATransactionRow ARow, Control AControl,
ref TVerificationResultCollection AVerificationResultCollection, TValidationControlsDict AValidationControlsDict,
ACostCentreTable AValidationCostCentreTable = null, AAccountTable AvalidationAccountTable = null)
{
DataColumn ValidationColumn;
TValidationControlsData ValidationControlsData;
TVerificationResult VerificationResult = null;
object ValidationContext;
int VerifResultCollAddedCount = 0;
// Don't validate deleted DataRows or non-unposted batches
if ((ABatchRow.BatchStatus != MFinanceConstants.BATCH_UNPOSTED) || (ARow.RowState == DataRowState.Deleted))
{
return true;
}
bool isImporting = AContext.ToString().Contains("Importing");
// When used by the GUI TransactionAmount is not in the dictionary so had to pass the control directly
// But when importing we do have a dictionary entry
if (isImporting)
{
// 'GL amount must be non-zero and positive
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnTransactionAmountId];
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = TNumericalChecks.IsPositiveDecimal(ARow.TransactionAmount,
ValidationControlsData.ValidationControlLabel,
AContext, ValidationColumn, AControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
}
else
{
if ((AControl != null) && AControl.Name.EndsWith("Amount"))
{
// 'GL amount must be non-zero and positive
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnTransactionAmountId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
VerificationResult = TNumericalChecks.IsPositiveOrZeroDecimal(ARow.TransactionAmount,
"Amount of " + ValidationContext,
AContext, ValidationColumn, AControl);
if (VerificationResult != null)
{
VerificationResult.SuppressValidationToolTip = true;
}
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
return VerifResultCollAddedCount == 0;
}
}
// 'Narrative must not be empty
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnNarrativeId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = TStringChecks.StringMustNotBeEmpty(ARow.Narrative,
(isImporting) ? ValidationControlsData.ValidationControlLabel : "Narrative of " + ValidationContext,
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
// 'Entered From Date' must be valid
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnTransactionDateId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
DateTime StartDatePeriod;
DateTime EndDatePeriod;
TSharedFinanceValidationHelper.GetValidPeriodDates(ARow.LedgerNumber, ABatchRow.BatchYear, 0, ABatchRow.BatchPeriod,
out StartDatePeriod,
out EndDatePeriod);
VerificationResult = (TScreenVerificationResult)TDateChecks.IsDateBetweenDates(ARow.TransactionDate,
StartDatePeriod,
EndDatePeriod,
(isImporting) ? ValidationControlsData.ValidationControlLabel : "Transaction Date for " + ValidationContext.ToString(),
TDateBetweenDatesCheckType.dbdctUnspecific,
TDateBetweenDatesCheckType.dbdctUnspecific,
AContext,
ValidationColumn,
ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
if ((AControl != null) && AControl.Name.EndsWith("Reference"))
{
//TODO: Check if "Reference" is mandatory then make sure it is set
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnReferenceId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = TStringChecks.StringMustNotBeEmpty(ARow.Reference,
(isImporting) ? ValidationControlsData.ValidationControlLabel : "Reference of " + ValidationContext,
AContext, ValidationColumn, ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
}
// 'CostCentre' must be valid
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnCostCentreCodeId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if ((AValidationCostCentreTable != null) && !ARow.IsCostCentreCodeNull())
{
// Code must exist in the cost centre table
ACostCentreRow foundRow = (ACostCentreRow)AValidationCostCentreTable.Rows.Find(
new object[] { ARow.LedgerNumber, ARow.CostCentreCode });
if ((foundRow == null) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Cost centre code '{0}' does not exist."), ARow.CostCentreCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
// cost centre must be a posting cost centre
if ((foundRow != null) && !foundRow.PostingCostCentreFlag)
{
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Cost centre code '{0}' is not a posting cost centre."), ARow.CostCentreCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
// cost centre must not be inactive
if ((foundRow != null) && !foundRow.CostCentreActiveFlag)
{
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Cost centre code '{0}' is an inactive cost centre."), ARow.CostCentreCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
}
}
// 'Account code' must be valid
ValidationColumn = ARow.Table.Columns[ATransactionTable.ColumnAccountCodeId];
ValidationContext = String.Format("Transaction number {0} (batch:{1} journal:{2})",
ARow.TransactionNumber,
ARow.BatchNumber,
ARow.JournalNumber);
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
if ((AvalidationAccountTable != null) && !ARow.IsAccountCodeNull())
{
// Code must exist in the account table
AAccountRow foundRow = (AAccountRow)AvalidationAccountTable.Rows.Find(
new object[] { ARow.LedgerNumber, ARow.AccountCode });
if ((foundRow == null) && AVerificationResultCollection.Auto_Add_Or_AddOrRemove(
ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Account code '{0}' does not exist."), ARow.AccountCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
// Account code must be a posting Account code
if ((foundRow != null) && !foundRow.PostingStatus)
{
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Account code '{0}' is not a posting account."), ARow.AccountCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
// Account code must not be inactive
if ((foundRow != null) && !foundRow.AccountActiveFlag)
{
if (AVerificationResultCollection.Auto_Add_Or_AddOrRemove(ValidationContext,
new TVerificationResult(ValidationContext,
String.Format(Catalog.GetString("Account code '{0}' is an inactive account."), ARow.AccountCode),
TResultSeverity.Resv_Critical),
ValidationColumn))
{
VerifResultCollAddedCount++;
}
}
}
}
return VerifResultCollAddedCount == 0;
}
private void GetDetailDataFromControlsManual(ATransactionRow ARow)
{
if (ARow == null)
{
return;
}
Decimal OldTransactionAmount = ARow.TransactionAmount;
bool OldDebitCreditIndicator = ARow.DebitCreditIndicator;
GetDataForAmountFields(ARow);
if ((OldTransactionAmount != Convert.ToDecimal(ARow.TransactionAmount))
|| (OldDebitCreditIndicator != ARow.DebitCreditIndicator))
{
UpdateTransactionTotals();
}
// If combobox to set analysis attribute value has focus when save button is pressed then currently
// displayed value is not stored in database.
// --> move focus to different field so that grid accepts value for storing in database
if (FcmbAnalAttribValues.Control.Focused)
{
cmbDetailCostCentreCode.Focus();
}
}
private static void CheckTransactionAccountAndCostCentre(Int32 ALedgerNumber,
ref GLPostingTDS AAccountsAndCostCentresDS,
ref ATransactionRow ATransRow,
ref TVerificationResultCollection AVerificationResult)
{
// check for valid accounts and cost centres
if (AAccountsAndCostCentresDS.AAccount.Rows.Find(new object[] { ALedgerNumber, ATransRow.AccountCode }) == null)
{
AVerificationResult.Add(new TVerificationResult(
Catalog.GetString("Cannot save transaction"),
String.Format(Catalog.GetString("Invalid account code {0} in batch {1}, journal {2}, transaction {3}"),
ATransRow.AccountCode,
ATransRow.BatchNumber,
ATransRow.JournalNumber,
ATransRow.TransactionNumber),
TResultSeverity.Resv_Critical));
}
if (AAccountsAndCostCentresDS.ACostCentre.Rows.Find(new object[] { ALedgerNumber, ATransRow.CostCentreCode }) == null)
{
AVerificationResult.Add(new TVerificationResult(
Catalog.GetString("Cannot save transaction"),
String.Format(Catalog.GetString("Invalid cost centre code {0} in batch {1}, journal {2}, transaction {3}"),
ATransRow.CostCentreCode,
ATransRow.BatchNumber,
ATransRow.JournalNumber,
ATransRow.TransactionNumber),
TResultSeverity.Resv_Critical));
}
// AmountInBaseCurrency must be greater than 0.
// Transaction amount can be 0 if ForexGain.
if (ATransRow.AmountInBaseCurrency <= 0)
{
AVerificationResult.Add(new TVerificationResult(
Catalog.GetString("Cannot save transaction"),
String.Format(Catalog.GetString("Invalid amount in batch {0}, journal {1}, transaction {2}. " +
"Either the debit amount or the credit amount needs to be greater than 0."),
ATransRow.BatchNumber,
ATransRow.JournalNumber,
ATransRow.TransactionNumber),
TResultSeverity.Resv_Critical));
}
}
public static Int32 CreateGLBatch(BankImportTDS AMainDS,
Int32 ALedgerNumber,
Int32 AStatementKey,
Int32 AGLBatchNumber,
out TVerificationResultCollection AVerificationResult)
{
AMainDS.AEpTransaction.DefaultView.RowFilter =
String.Format("{0}={1}",
AEpTransactionTable.GetStatementKeyDBName(),
AStatementKey);
AMainDS.AEpStatement.DefaultView.RowFilter =
String.Format("{0}={1}",
AEpStatementTable.GetStatementKeyDBName(),
AStatementKey);
AEpStatementRow stmt = (AEpStatementRow)AMainDS.AEpStatement.DefaultView[0].Row;
AVerificationResult = null;
Int32 DateEffectivePeriodNumber, DateEffectiveYearNumber;
TDBTransaction Transaction = DBAccess.GDBAccessObj.BeginTransaction(IsolationLevel.ReadCommitted);
if (!TFinancialYear.IsValidPostingPeriod(ALedgerNumber, stmt.Date, out DateEffectivePeriodNumber, out DateEffectiveYearNumber,
Transaction))
{
string msg = String.Format(Catalog.GetString("Cannot create a GL batch for date {0} since it is not in an open period of the ledger."),
stmt.Date.ToShortDateString());
TLogging.Log(msg);
AVerificationResult = new TVerificationResultCollection();
AVerificationResult.Add(new TVerificationResult(Catalog.GetString("Creating GL Batch"), msg, TResultSeverity.Resv_Critical));
DBAccess.GDBAccessObj.RollbackTransaction();
return(-1);
}
Int32 BatchYear, BatchPeriod;
// if DateEffective is outside the range of open periods, use the most fitting date
DateTime DateEffective = stmt.Date;
TFinancialYear.GetLedgerDatePostingPeriod(ALedgerNumber, ref DateEffective, out BatchYear, out BatchPeriod, Transaction, true);
ALedgerTable LedgerTable = ALedgerAccess.LoadByPrimaryKey(ALedgerNumber, Transaction);
DBAccess.GDBAccessObj.RollbackTransaction();
GLBatchTDS GLDS = TGLTransactionWebConnector.CreateABatch(ALedgerNumber);
ABatchRow glbatchRow = GLDS.ABatch[0];
glbatchRow.BatchPeriod = BatchPeriod;
glbatchRow.DateEffective = DateEffective;
glbatchRow.BatchDescription = String.Format(Catalog.GetString("bank import for date {0}"), stmt.Date.ToShortDateString());
decimal HashTotal = 0.0M;
decimal DebitTotal = 0.0M;
decimal CreditTotal = 0.0M;
// TODO: support several journals
// TODO: support several currencies, support other currencies than the base currency
AJournalRow gljournalRow = GLDS.AJournal.NewRowTyped();
gljournalRow.LedgerNumber = glbatchRow.LedgerNumber;
gljournalRow.BatchNumber = glbatchRow.BatchNumber;
gljournalRow.JournalNumber = glbatchRow.LastJournal + 1;
gljournalRow.TransactionCurrency = LedgerTable[0].BaseCurrency;
glbatchRow.LastJournal++;
gljournalRow.JournalPeriod = glbatchRow.BatchPeriod;
gljournalRow.DateEffective = glbatchRow.DateEffective;
gljournalRow.JournalDescription = glbatchRow.BatchDescription;
gljournalRow.SubSystemCode = CommonAccountingSubSystemsEnum.GL.ToString();
gljournalRow.TransactionTypeCode = CommonAccountingTransactionTypesEnum.STD.ToString();
gljournalRow.ExchangeRateToBase = 1.0m;
GLDS.AJournal.Rows.Add(gljournalRow);
foreach (DataRowView dv in AMainDS.AEpTransaction.DefaultView)
{
AEpTransactionRow transactionRow = (AEpTransactionRow)dv.Row;
DataView v = AMainDS.AEpMatch.DefaultView;
v.RowFilter = AEpMatchTable.GetActionDBName() + " = '" + MFinanceConstants.BANK_STMT_STATUS_MATCHED_GL + "' and " +
AEpMatchTable.GetMatchTextDBName() + " = '" + transactionRow.MatchText + "'";
if (v.Count > 0)
{
AEpMatchRow match = (AEpMatchRow)v[0].Row;
ATransactionRow trans = GLDS.ATransaction.NewRowTyped();
trans.LedgerNumber = glbatchRow.LedgerNumber;
trans.BatchNumber = glbatchRow.BatchNumber;
trans.JournalNumber = gljournalRow.JournalNumber;
trans.TransactionNumber = gljournalRow.LastTransactionNumber + 1;
trans.AccountCode = match.AccountCode;
trans.CostCentreCode = match.CostCentreCode;
trans.Reference = match.Reference;
trans.Narrative = match.Narrative;
trans.TransactionDate = transactionRow.DateEffective;
if (transactionRow.TransactionAmount < 0)
{
trans.AmountInBaseCurrency = -1 * transactionRow.TransactionAmount;
trans.TransactionAmount = -1 * transactionRow.TransactionAmount;
trans.DebitCreditIndicator = true;
DebitTotal += trans.AmountInBaseCurrency;
}
else
{
trans.AmountInBaseCurrency = transactionRow.TransactionAmount;
trans.TransactionAmount = transactionRow.TransactionAmount;
trans.DebitCreditIndicator = false;
CreditTotal += trans.AmountInBaseCurrency;
}
GLDS.ATransaction.Rows.Add(trans);
gljournalRow.LastTransactionNumber++;
// add one transaction for the bank as well
trans = GLDS.ATransaction.NewRowTyped();
trans.LedgerNumber = glbatchRow.LedgerNumber;
trans.BatchNumber = glbatchRow.BatchNumber;
trans.JournalNumber = gljournalRow.JournalNumber;
trans.TransactionNumber = gljournalRow.LastTransactionNumber + 1;
trans.AccountCode = stmt.BankAccountCode;
trans.CostCentreCode = TLedgerInfo.GetStandardCostCentre(ALedgerNumber);
trans.Reference = match.Reference;
trans.Narrative = match.Narrative;
trans.TransactionDate = transactionRow.DateEffective;
if (transactionRow.TransactionAmount < 0)
{
trans.AmountInBaseCurrency = -1 * transactionRow.TransactionAmount;
trans.TransactionAmount = -1 * transactionRow.TransactionAmount;
trans.DebitCreditIndicator = false;
CreditTotal += trans.AmountInBaseCurrency;
}
else
{
trans.AmountInBaseCurrency = transactionRow.TransactionAmount;
trans.TransactionAmount = transactionRow.TransactionAmount;
trans.DebitCreditIndicator = true;
DebitTotal += trans.AmountInBaseCurrency;
}
GLDS.ATransaction.Rows.Add(trans);
gljournalRow.LastTransactionNumber++;
}
}
gljournalRow.JournalDebitTotal = DebitTotal;
gljournalRow.JournalCreditTotal = CreditTotal;
glbatchRow.BatchDebitTotal = DebitTotal;
glbatchRow.BatchCreditTotal = CreditTotal;
glbatchRow.BatchControlTotal = HashTotal;
TVerificationResultCollection VerificationResult;
TSubmitChangesResult result = TGLTransactionWebConnector.SaveGLBatchTDS(ref GLDS,
out VerificationResult);
if (result == TSubmitChangesResult.scrOK)
{
return(glbatchRow.BatchNumber);
}
TLogging.Log("Problems storing GL Batch");
return(-1);
}
private static bool UpdateJournalTotals(ref GLBatchTDS AMainDS,
ref GLBatchTDSAJournalRow ACurrentJournal)
{
#region Validate Arguments
if (AMainDS == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString("Function:{0} - The GL Batch dataset is null!"),
Utilities.GetMethodName(true)));
}
else if (ACurrentJournal == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString(
"Function:{0} - The Journal row does not exist or is empty!"),
Utilities.GetMethodName(true)));
}
else if (ACurrentJournal.JournalStatus != MFinanceConstants.BATCH_UNPOSTED)
{
TLogging.Log(String.Format("Function:{0} - Tried to update totals for non-Unposted Batch:{1} and Journal:{2}",
Utilities.GetMethodName(true),
ACurrentJournal.BatchNumber,
ACurrentJournal.JournalNumber));
return(false);
}
#endregion Validate Arguments
bool AmountsUpdated = false;
decimal JournalDebitTotal = 0.0M;
decimal JournalDebitTotalBase = 0.0M;
decimal JournalCreditTotal = 0.0M;
decimal JournalCreditTotalBase = 0.0M;
if (ACurrentJournal.IsJournalDebitTotalBaseNull()) //DBNull.Value.Equals(ACurrentJournal[GLBatchTDSAJournalTable.ColumnJournalDebitTotalBaseId])
{
ACurrentJournal.JournalDebitTotalBase = 0;
AmountsUpdated = true;
}
if (ACurrentJournal.IsJournalCreditTotalBaseNull()) //DBNull.Value.Equals(ACurrentJournal[GLBatchTDSAJournalTable.ColumnJournalCreditTotalBaseId])
{
ACurrentJournal.JournalCreditTotalBase = 0;
AmountsUpdated = true;
}
DataView TransDV = new DataView(AMainDS.ATransaction);
TransDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ATransactionTable.GetBatchNumberDBName(),
ACurrentJournal.BatchNumber,
ATransactionTable.GetJournalNumberDBName(),
ACurrentJournal.JournalNumber);
if ((TransDV.Count == 0) && (ACurrentJournal.LastTransactionNumber > 0))
{
//do not update totals as no transactions loaded as yet so no need to update journal total
return(AmountsUpdated);
}
// transactions are filtered for this journal; add up the total amounts
foreach (DataRowView drv in TransDV)
{
ATransactionRow transRow = (ATransactionRow)drv.Row;
if (transRow.DebitCreditIndicator)
{
JournalDebitTotal += transRow.TransactionAmount;
JournalDebitTotalBase += transRow.AmountInBaseCurrency;
}
else
{
JournalCreditTotal += transRow.TransactionAmount;
JournalCreditTotalBase += transRow.AmountInBaseCurrency;
}
}
if ((ACurrentJournal.JournalDebitTotal != JournalDebitTotal) ||
(ACurrentJournal.JournalDebitTotalBase != JournalDebitTotalBase) ||
(ACurrentJournal.JournalCreditTotal != JournalCreditTotal) ||
(ACurrentJournal.JournalCreditTotalBase != JournalCreditTotalBase))
{
ACurrentJournal.JournalDebitTotal = JournalDebitTotal;
ACurrentJournal.JournalDebitTotalBase = JournalDebitTotalBase;
ACurrentJournal.JournalCreditTotal = JournalCreditTotal;
ACurrentJournal.JournalCreditTotalBase = JournalCreditTotalBase;
AmountsUpdated = true;
}
return(AmountsUpdated);
}
void WriteAnalysisAttributesSuffix(ATransactionRow transaction)
{
FMainDS.ATransAnalAttrib.DefaultView.Sort = ATransAnalAttribTable.GetAnalysisTypeCodeDBName();
FMainDS.ATransAnalAttrib.DefaultView.RowFilter =
String.Format("{0}={1} and {2}={3} and {4}={5} and {6}={7}",
ATransAnalAttribTable.GetLedgerNumberDBName(),
transaction.LedgerNumber,
ATransAnalAttribTable.GetBatchNumberDBName(),
transaction.BatchNumber,
ATransAnalAttribTable.GetJournalNumberDBName(),
transaction.JournalNumber,
ATransAnalAttribTable.GetTransactionNumberDBName(),
transaction.TransactionNumber);
DataView anaView = FMainDS.ATransAnalAttrib.DefaultView;
for (int i = 1; i <= maxNumValuesExport; i++)
{
if (i <= anaView.Count)
{
ATransAnalAttribRow ar = (ATransAnalAttribRow)anaView[i - 1].Row;
WriteStringQuoted(ar.AnalysisTypeCode, false);
WriteStringQuoted(ar.AnalysisAttributeValue, (i == maxNumValuesExport));
}
else
{
WriteStringQuoted("", false);
WriteStringQuoted("", (i == maxNumValuesExport));
}
}
}
private bool PreDeleteManual(ATransactionRow ARowToDelete, ref string ADeletionQuestion)
{
bool allowDeletion = true;
if (FPreviouslySelectedDetailRow != null)
{
ADeletionQuestion = String.Format(Catalog.GetString("Are you sure you want to delete transaction no. {0} from Journal {1}?"),
ARowToDelete.TransactionNumber,
ARowToDelete.JournalNumber);
}
return allowDeletion;
}
