/// <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(ARecurringBatchRow ARowToDelete, ref string ACompletionMessage)
{
int BatchNumber = ARowToDelete.BatchNumber;
// 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.
ACompletionMessage = String.Format(Catalog.GetString("Batch no.: {0} deleted successfully."),
BatchNumber);
// Delete the associated recurring transaction analysis attributes
DataView viewRecurringTransAnalAttrib = new DataView(FMainDS.ARecurringTransAnalAttrib);
viewRecurringTransAnalAttrib.RowFilter = String.Format("{0} = {1} AND {2} = {3}",
ARecurringTransAnalAttribTable.GetLedgerNumberDBName(),
FLedgerNumber,
ARecurringTransAnalAttribTable.GetBatchNumberDBName(),
BatchNumber);
foreach (DataRowView row in viewRecurringTransAnalAttrib)
{
row.Delete();
}
// Delete the associated recurring transactions
DataView viewRecurringTransaction = new DataView(FMainDS.ARecurringTransaction);
viewRecurringTransaction.RowFilter = String.Format("{0} = {1} AND {2} = {3}",
ARecurringTransactionTable.GetLedgerNumberDBName(),
FLedgerNumber,
ARecurringTransactionTable.GetBatchNumberDBName(),
BatchNumber);
foreach (DataRowView row in viewRecurringTransaction)
{
row.Delete();
}
// Delete the associated recurring journals
DataView viewRecurringJournal = new DataView(FMainDS.ARecurringJournal);
viewRecurringJournal.RowFilter = String.Format("{0} = {1} AND {2} = {3}",
ARecurringJournalTable.GetLedgerNumberDBName(),
FLedgerNumber,
ARecurringJournalTable.GetBatchNumberDBName(),
BatchNumber);
foreach (DataRowView row in viewRecurringJournal)
{
row.Delete();
}
// Delete the recurring batch row.
ARowToDelete.Delete();
UpdateRecordNumberDisplay();
return(true);
}
private void CurrencyCodeChanged(object sender, EventArgs e)
{
if (FPreviouslySelectedDetailRow == null)
{
return;
}
FCurrencyCodeForJournals = cmbDetailTransactionCurrency.GetSelectedString();
DataView CurrentJournalsDV = new DataView(FMainDS.ARecurringJournal);
CurrentJournalsDV.RowFilter = string.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber);
if (CurrentJournalsDV.Count > 1)
{
foreach (DataRowView drv in CurrentJournalsDV)
{
ARecurringJournalRow rjr = (ARecurringJournalRow)drv.Row;
rjr.TransactionCurrency = FCurrencyCodeForJournals;
}
}
}
/// <summary>
/// update the journal header fields from a batch
/// </summary>
/// <param name="ABatchRowToUpdate"></param>
public void UpdateHeaderTotals(ARecurringBatchRow ABatchRowToUpdate)
{
decimal SumDebits = 0.0M;
decimal SumCredits = 0.0M;
DataView JournalDV = new DataView(FMainDS.ARecurringJournal);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
ABatchRowToUpdate.BatchNumber);
JournalDV.RowStateFilter = DataViewRowState.CurrentRows;
foreach (DataRowView v in JournalDV)
{
ARecurringJournalRow r = (ARecurringJournalRow)v.Row;
SumCredits += r.JournalCreditTotal;
SumDebits += r.JournalDebitTotal;
}
FPetraUtilsObject.DisableDataChangedEvent();
txtDebit.NumberValueDecimal = SumDebits;
txtCredit.NumberValueDecimal = SumCredits;
txtControl.NumberValueDecimal = ABatchRowToUpdate.BatchControlTotal;
FPetraUtilsObject.EnableDataChangedEvent();
}
private void LoadJournals()
{
FMainDS.Merge(TRemote.MFinance.GL.WebConnectors.LoadARecurringJournal(FLedgerNumber, FBatchNumber));
DataView JournalDV = new DataView(FMainDS.ARecurringJournal);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber);
//Populate the dictionary with all journal currencies
if (JournalDV.Count > 0)
{
string currencyCode = string.Empty;
decimal exchangeRate = 0;
foreach (DataRowView drv in JournalDV)
{
ARecurringJournalRow jr = (ARecurringJournalRow)drv.Row;
currencyCode = jr.TransactionCurrency;
exchangeRate = (currencyCode == FBaseCurrencyCode) ? 1 : 0;
if (!FExchangeRateDictionary.ContainsKey(currencyCode))
{
FExchangeRateDictionary.Add(currencyCode, exchangeRate);
}
jr.ExchangeRateToBase = exchangeRate;
}
}
SelectRowInGrid(1);
}
/// <summary>
/// Calculate the base amount for the transactions, and update the totals for the journals and the current batch
/// </summary>
/// <param name="AMainDS"></param>
/// <param name="ACurrentBatchRow"></param>
/// <param name="ACurrentJournalNumber"></param>
/// <returns>false if no change to batch totals</returns>
public static bool UpdateRecurringBatchTotals(ref GLBatchTDS AMainDS,
ref ARecurringBatchRow ACurrentBatchRow, Int32 ACurrentJournalNumber = 0)
{
#region Validate Arguments
if (AMainDS == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString(
"Function:{0} - The Recurring GL Batch dataset is null!"),
Utilities.GetMethodName(true)));
}
else if (ACurrentBatchRow == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString(
"Function:{0} - The Recurring GL Batch data row is null!"),
Utilities.GetMethodName(true)));
}
#endregion Validate Arguments
bool AmountsUpdated = false;
decimal BatchDebitTotal = 0.0m;
decimal BatchCreditTotal = 0.0m;
DataView JournalDV = new DataView(AMainDS.ARecurringJournal);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
ACurrentBatchRow.BatchNumber);
foreach (DataRowView journalView in JournalDV)
{
GLBatchTDSARecurringJournalRow journalRow = (GLBatchTDSARecurringJournalRow)journalView.Row;
if (((ACurrentJournalNumber > 0) && (ACurrentJournalNumber == journalRow.JournalNumber)) ||
(ACurrentJournalNumber == 0))
{
if ((UpdateRecurringJournalTotals(ref AMainDS, ref journalRow)))
{
AmountsUpdated = true;
}
}
BatchDebitTotal += journalRow.JournalDebitTotal;
BatchCreditTotal += journalRow.JournalCreditTotal;
}
if ((ACurrentBatchRow.BatchDebitTotal != BatchDebitTotal) ||
(ACurrentBatchRow.BatchCreditTotal != BatchCreditTotal))
{
ACurrentBatchRow.BatchDebitTotal = BatchDebitTotal;
ACurrentBatchRow.BatchCreditTotal = BatchCreditTotal;
AmountsUpdated = true;
}
return(AmountsUpdated);
}
/// <summary>
/// Update the specified Recurring Batch's LastJournal number. Assumes all necessary data is loaded for Batch
/// </summary>
/// <param name="AMainDS"></param>
/// <param name="ACurrentBatchRow"></param>
/// <param name="AIncludeJournals"></param>
/// <returns>false if no change to batch totals</returns>
public static bool UpdateRecurringBatchLastJournal(ref GLBatchTDS AMainDS,
ref ARecurringBatchRow ACurrentBatchRow, Boolean AIncludeJournals = false)
{
#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 (ACurrentBatchRow == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString(
"Function:{0} - The Recurring GL Batch data row is null!"),
Utilities.GetMethodName(true)));
}
#endregion Validate Arguments
bool RowUpdated = false;
int ActualLastJournalNumber = 0;
DataView JournalDV = new DataView(AMainDS.ARecurringJournal);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
ACurrentBatchRow.BatchNumber);
//Highest Journal number first
JournalDV.Sort = String.Format("{0} DESC",
ARecurringJournalTable.GetJournalNumberDBName());
foreach (DataRowView journalView in JournalDV)
{
GLBatchTDSARecurringJournalRow journalRow = (GLBatchTDSARecurringJournalRow)journalView.Row;
//Run once only
if (ActualLastJournalNumber == 0)
{
ActualLastJournalNumber = journalRow.JournalNumber;
}
if (AIncludeJournals && UpdateRecurringJournalLastTransaction(ref AMainDS, ref journalRow))
{
RowUpdated = true;
}
}
if (ACurrentBatchRow.LastJournal != ActualLastJournalNumber)
{
ACurrentBatchRow.BeginEdit();
ACurrentBatchRow.LastJournal = ActualLastJournalNumber;
ACurrentBatchRow.EndEdit();
RowUpdated = true;
}
return(RowUpdated);
}
private void SetJournalDefaultView()
{
string DVRowFilter = string.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber);
FMainDS.ARecurringJournal.DefaultView.RowFilter = DVRowFilter;
FMainDS.ARecurringJournal.DefaultView.Sort = String.Format("{0} DESC",
ARecurringJournalTable.GetJournalNumberDBName()
);
FFilterAndFindObject.FilterPanelControls.SetBaseFilter(DVRowFilter, true);
FFilterAndFindObject.CurrentActiveFilter = DVRowFilter;
}
/// <summary>
/// Delete journal data from current recurring GL Batch
/// </summary>
/// <param name="ABatchNumber"></param>
public void DeleteRecurringJournalData(Int32 ABatchNumber)
{
DataView JournalDV = new DataView(FMainDS.ARecurringTransAnalAttrib);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
ABatchNumber);
JournalDV.Sort = String.Format("{0} DESC", ARecurringJournalTable.GetJournalNumberDBName());
foreach (DataRowView dr in JournalDV)
{
dr.Delete();
}
}
private void LoadJournalsForCurrentRecurringBatch()
{
if (FPreviouslySelectedDetailRow == null)
{
return;
}
//Current Batch number
Int32 BatchNumber = FPreviouslySelectedDetailRow.BatchNumber;
if (FMainDS.ARecurringJournal != null)
{
FMainDS.ARecurringJournal.DefaultView.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
BatchNumber);
if (FMainDS.ARecurringJournal.DefaultView.Count == 0)
{
((TFrmRecurringGLBatch)this.ParentForm).LoadJournals(FPreviouslySelectedDetailRow);
}
}
}
private void SetBatchLastJournalNumber()
{
DataView JournalDV = new DataView(FMainDS.ARecurringJournal);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber);
JournalDV.Sort = String.Format("{0} DESC",
ARecurringJournalTable.GetJournalNumberDBName()
);
if (JournalDV.Count > 0)
{
ARecurringJournalRow jrnlRow = (ARecurringJournalRow)JournalDV[0].Row;
GetBatchRow().LastJournal = jrnlRow.JournalNumber;
}
else
{
GetBatchRow().LastJournal = 0;
}
}
private void SetCurrencyControls()
{
FBaseCurrencyCode = FMainDS.ALedger[0].BaseCurrency;
DataView JournalDV = new DataView(FMainDS.ARecurringJournal);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber);
if (JournalDV.Count == 0)
{
//Submitting an empty batch
FCurrencyCode = FBaseCurrencyCode;
}
else
{
// All Journals in a recurring batch have the same currency code
ARecurringJournalRow jr = (ARecurringJournalRow)JournalDV[0].Row;
FCurrencyCode = jr.TransactionCurrency;
}
txtCurrencyCodeFrom.Text = FCurrencyCode;
txtCurrencyCodeTo.Text = FBaseCurrencyCode;
if (FCurrencyCode == FBaseCurrencyCode)
{
txtExchangeRateToBase.Enabled = false;
txtExchangeRateToBase.BackColor = Color.LightPink;
}
else
{
txtExchangeRateToBase.Enabled = true;
txtExchangeRateToBase.BackColor = Color.Empty;
}
LookupCurrencyExchangeRates(DateTime.Now);
}
/// <summary>
/// Calculate the base amount for the transactions, and update the totals for the journals and the current batch
/// </summary>
/// <param name="AMainDS"></param>
/// <param name="ACurrentBatch"></param>
public static void UpdateTotalsOfRecurringBatch(ref GLBatchTDS AMainDS,
ARecurringBatchRow ACurrentBatch)
{
ACurrentBatch.BatchDebitTotal = 0.0m;
ACurrentBatch.BatchCreditTotal = 0.0m;
DataView jnlDataView = new DataView(AMainDS.ARecurringJournal);
jnlDataView.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
ACurrentBatch.BatchNumber);
foreach (DataRowView journalView in jnlDataView)
{
GLBatchTDSARecurringJournalRow journalRow = (GLBatchTDSARecurringJournalRow)journalView.Row;
UpdateTotalsOfRecurringJournal(ref AMainDS, ref journalRow);
ACurrentBatch.BatchDebitTotal += journalRow.JournalDebitTotal;
ACurrentBatch.BatchCreditTotal += journalRow.JournalCreditTotal;
}
}
private void SetRateForSameCurrency(String ACurrencyCode, Decimal AExchangeRate, Int32 ARecurringJournalNumber)
{
DataView JournalCurrencyDV = new DataView(FMainDS.ARecurringJournal);
JournalCurrencyDV.RowFilter = string.Format("{0}={1} And {2}<>{3} And {4}='{5}'",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringJournalTable.GetJournalNumberDBName(),
ARecurringJournalNumber,
ARecurringJournalTable.GetTransactionCurrencyDBName(),
ACurrencyCode);
if (JournalCurrencyDV.Count > 0)
{
foreach (DataRowView drv in JournalCurrencyDV)
{
ARecurringJournalRow jr = (ARecurringJournalRow)drv.Row;
jr.ExchangeRateToBase = AExchangeRate;
}
}
SaveChanges();
}
/// <summary>
/// Undo all changes to the specified batch ready to cancel it.
/// This avoids unecessary validation errors when cancelling.
/// </summary>
/// <param name="ACurrentBatch"></param>
/// <param name="AJournalToDelete"></param>
/// <param name="ARedisplay"></param>
public void PrepareJournalDataForDeleting(Int32 ACurrentBatch, Int32 AJournalToDelete, Boolean ARedisplay)
{
//This code will only be called when the Batch tab is active.
DataView JournalDV = new DataView(FMainDS.ARecurringJournal);
DataView TransDV = new DataView(FMainDS.ARecurringTransaction);
DataView TransAnalDV = new DataView(FMainDS.ARecurringTransAnalAttrib);
JournalDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ARecurringJournalTable.GetBatchNumberDBName(),
ACurrentBatch,
ARecurringJournalTable.GetJournalNumberDBName(),
AJournalToDelete);
TransDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ARecurringTransactionTable.GetBatchNumberDBName(),
ACurrentBatch,
ARecurringTransactionTable.GetJournalNumberDBName(),
AJournalToDelete);
TransAnalDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ARecurringTransAnalAttribTable.GetBatchNumberDBName(),
ACurrentBatch,
ARecurringTransAnalAttribTable.GetJournalNumberDBName(),
AJournalToDelete);
//Work from lowest level up
if (TransAnalDV.Count > 0)
{
TransAnalDV.Sort = String.Format("{0}, {1}, {2}",
ARecurringTransAnalAttribTable.GetJournalNumberDBName(),
ARecurringTransAnalAttribTable.GetTransactionNumberDBName(),
ARecurringTransAnalAttribTable.GetAnalysisTypeCodeDBName());
foreach (DataRowView drv in TransAnalDV)
{
ARecurringTransAnalAttribRow transAnalRow = (ARecurringTransAnalAttribRow)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}, {1}",
ARecurringTransactionTable.GetJournalNumberDBName(),
ARecurringTransactionTable.GetTransactionNumberDBName());
foreach (DataRowView drv in TransDV)
{
ARecurringTransactionRow transRow = (ARecurringTransactionRow)drv.Row;
if (transRow.RowState == DataRowState.Added)
{
//Do nothing
}
else if (transRow.RowState != DataRowState.Unchanged)
{
transRow.RejectChanges();
}
}
}
if (JournalDV.Count > 0)
{
GLBatchTDSARecurringJournalRow journalRow = (GLBatchTDSARecurringJournalRow)JournalDV[0].Row;
//No need to check for Added state as new batches 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 batch ready to delete/cancel
FMainDS.Merge(TRemote.MFinance.GL.WebConnectors.LoadARecurringTransactionAndRelatedTablesForJournal(FLedgerNumber, ACurrentBatch,
AJournalToDelete));
}
}
private static bool CanSubsystemBeDeactivated(Int32 ALedgerNumber, String ASubsystemCode)
{
#region Validate Arguments
if (ALedgerNumber <= 0)
{
throw new EFinanceSystemInvalidLedgerNumberException(String.Format(Catalog.GetString(
"Function:{0} - The Ledger number must be greater than 0!"),
Utilities.GetMethodName(true)), ALedgerNumber);
}
else if (ASubsystemCode.Length == 0)
{
throw new ArgumentException(String.Format(Catalog.GetString("Function:{0} - The Subsystem code is empty!"),
Utilities.GetMethodName(true)));
}
#endregion Validate Arguments
Boolean Result = false;
TDBTransaction Transaction = null;
try
{
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum, ref Transaction,
delegate
{
if (ASubsystemCode == CommonAccountingSubSystemsEnum.GR.ToString())
{
// for gift processing don't allow to deactivate if 'Posted' or 'Unposted' gift batches exist
AGiftBatchTable TemplateGiftBatchTable;
AGiftBatchRow TemplateGiftBatchRow;
StringCollection TemplateGiftBatchOperators;
TemplateGiftBatchTable = new AGiftBatchTable();
TemplateGiftBatchRow = TemplateGiftBatchTable.NewRowTyped(false);
TemplateGiftBatchRow.LedgerNumber = ALedgerNumber;
TemplateGiftBatchRow.BatchStatus = MFinanceConstants.BATCH_POSTED;
TemplateGiftBatchOperators = new StringCollection();
TemplateGiftBatchOperators.Add("=");
if (AGiftBatchAccess.CountUsingTemplate(TemplateGiftBatchRow, TemplateGiftBatchOperators, Transaction) == 0)
{
Result = true;
}
if (!Result)
{
TemplateGiftBatchRow.BatchStatus = MFinanceConstants.BATCH_UNPOSTED;
if (AGiftBatchAccess.CountUsingTemplate(TemplateGiftBatchRow, TemplateGiftBatchOperators, Transaction) == 0)
{
Result = true;
}
}
}
if (!Result)
{
AJournalTable TemplateJournalTable;
AJournalRow TemplateJournalRow;
StringCollection TemplateJournalOperators;
TemplateJournalTable = new AJournalTable();
TemplateJournalRow = TemplateJournalTable.NewRowTyped(false);
TemplateJournalRow.LedgerNumber = ALedgerNumber;
TemplateJournalRow.SubSystemCode = ASubsystemCode;
TemplateJournalOperators = new StringCollection();
TemplateJournalOperators.Add("=");
ARecurringJournalTable TemplateRJournalTable;
ARecurringJournalRow TemplateRJournalRow;
StringCollection TemplateRJournalOperators;
TemplateRJournalTable = new ARecurringJournalTable();
TemplateRJournalRow = TemplateRJournalTable.NewRowTyped(false);
TemplateRJournalRow.LedgerNumber = ALedgerNumber;
TemplateRJournalRow.SubSystemCode = ASubsystemCode;
TemplateRJournalOperators = new StringCollection();
TemplateRJournalOperators.Add("=");
// do not allow to deactivate subsystem if journals already exist
if ((AJournalAccess.CountUsingTemplate(TemplateJournalRow, TemplateJournalOperators, Transaction) == 0)
&& (ARecurringJournalAccess.CountUsingTemplate(TemplateRJournalRow, TemplateRJournalOperators, Transaction) == 0))
{
Result = true;
}
}
});
}
catch (Exception ex)
{
TLogging.Log(String.Format("Method:{0} - Unexpected error!{1}{1}{2}",
Utilities.GetMethodSignature(),
Environment.NewLine,
ex.Message));
throw ex;
}
return Result;
}
public static TSubmitChangesResult SaveData(string ATablename,
ref TTypedDataTable ASubmitTable,
out TVerificationResultCollection AVerificationResult)
{
TDBTransaction SubmitChangesTransaction = null;
bool SubmissionOK = false;
TTypedDataTable SubmitTable = ASubmitTable;
TVerificationResultCollection VerificationResult = null;
// TODO: check write permissions
if (ASubmitTable != null)
{
VerificationResult = new TVerificationResultCollection();
DBAccess.GDBAccessObj.BeginAutoTransaction(IsolationLevel.Serializable, ref SubmitChangesTransaction, ref SubmissionOK,
delegate
{
try
{
if (ATablename == AAccountingPeriodTable.GetTableDBName())
{
AAccountingPeriodAccess.SubmitChanges((AAccountingPeriodTable)SubmitTable, SubmitChangesTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.AccountingPeriodList.ToString());
}
else if (ATablename == ACurrencyTable.GetTableDBName())
{
ACurrencyAccess.SubmitChanges((ACurrencyTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == ADailyExchangeRateTable.GetTableDBName())
{
ADailyExchangeRateAccess.SubmitChanges((ADailyExchangeRateTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == ACorporateExchangeRateTable.GetTableDBName())
{
ACorporateExchangeRateAccess.SubmitChanges((ACorporateExchangeRateTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == ACurrencyLanguageTable.GetTableDBName())
{
ACurrencyLanguageAccess.SubmitChanges((ACurrencyLanguageTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == AFeesPayableTable.GetTableDBName())
{
AFeesPayableAccess.SubmitChanges((AFeesPayableTable)SubmitTable, SubmitChangesTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.FeesPayableList.ToString());
}
else if (ATablename == AFeesReceivableTable.GetTableDBName())
{
AFeesReceivableAccess.SubmitChanges((AFeesReceivableTable)SubmitTable, SubmitChangesTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.FeesReceivableList.ToString());
}
else if (ATablename == AGiftBatchTable.GetTableDBName())
{
// This method is called from ADailyExchangeRate Setup - please do not remove
// The method is not required for changes made to the gift batch screens, which use a TDS
AGiftBatchAccess.SubmitChanges((AGiftBatchTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == AJournalTable.GetTableDBName())
{
// This method is called from ADailyExchangeRate Setup - please do not remove
// The method is not required for changes made to the journal screens, which use a TDS
AJournalAccess.SubmitChanges((AJournalTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == ARecurringJournalTable.GetTableDBName())
{
// This method is called from Submit Recurring GL Batch form - please do not remove
// The method is not required for changes made to the journal screens, which use a TDS
ARecurringJournalAccess.SubmitChanges((ARecurringJournalTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == ALedgerTable.GetTableDBName())
{
// This method is called from ADailyExchangeRate Testing - please do not remove
ALedgerAccess.SubmitChanges((ALedgerTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == AAnalysisTypeTable.GetTableDBName())
{
AAnalysisTypeAccess.SubmitChanges((AAnalysisTypeTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == ASuspenseAccountTable.GetTableDBName())
{
ASuspenseAccountAccess.SubmitChanges((ASuspenseAccountTable)SubmitTable, SubmitChangesTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.SuspenseAccountList.ToString());
}
else if (ATablename == PcAttendeeTable.GetTableDBName())
{
PcAttendeeAccess.SubmitChanges((PcAttendeeTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PcConferenceTable.GetTableDBName())
{
PcConferenceAccess.SubmitChanges((PcConferenceTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PcConferenceCostTable.GetTableDBName())
{
PcConferenceCostAccess.SubmitChanges((PcConferenceCostTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PcEarlyLateTable.GetTableDBName())
{
PcEarlyLateAccess.SubmitChanges((PcEarlyLateTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PcSupplementTable.GetTableDBName())
{
PcSupplementAccess.SubmitChanges((PcSupplementTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PcDiscountTable.GetTableDBName())
{
PcDiscountAccess.SubmitChanges((PcDiscountTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PInternationalPostalTypeTable.GetTableDBName())
{
ValidateInternationalPostalType(ref VerificationResult, SubmitTable);
ValidateInternationalPostalTypeManual(ref VerificationResult, SubmitTable);
if (TVerificationHelper.IsNullOrOnlyNonCritical(VerificationResult))
{
PInternationalPostalTypeAccess.SubmitChanges((PInternationalPostalTypeTable)SubmitTable, SubmitChangesTransaction);
}
}
else if (ATablename == PtApplicationTypeTable.GetTableDBName())
{
PtApplicationTypeAccess.SubmitChanges((PtApplicationTypeTable)SubmitTable, SubmitChangesTransaction);
// mark dependent lists for needing to be refreshed since there was a change in base list
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheablePersonTablesEnum.EventApplicationTypeList.ToString());
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheablePersonTablesEnum.FieldApplicationTypeList.ToString());
}
else if (ATablename == PFormTable.GetTableDBName())
{
PFormAccess.SubmitChanges((PFormTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PFormalityTable.GetTableDBName())
{
PFormalityAccess.SubmitChanges((PFormalityTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PMailingTable.GetTableDBName())
{
PMailingAccess.SubmitChanges((PMailingTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PPartnerGiftDestinationTable.GetTableDBName())
{
PPartnerGiftDestinationAccess.SubmitChanges((PPartnerGiftDestinationTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == PmDocumentTypeTable.GetTableDBName())
{
PmDocumentTypeAccess.SubmitChanges((PmDocumentTypeTable)SubmitTable, SubmitChangesTransaction);
}
else if (ATablename == SGroupTable.GetTableDBName())
{
SGroupAccess.SubmitChanges((SGroupTable)SubmitTable, SubmitChangesTransaction);
}
else
{
throw new EOPAppException("TCommonDataReader.SaveData: unknown table '" + ATablename + "'");
}
SubmissionOK = true;
}
catch (Exception Exc)
{
VerificationResult.Add(
new TVerificationResult(null, "Cannot SubmitChanges:" + Environment.NewLine +
Exc.Message, "UNDEFINED", TResultSeverity.Resv_Critical));
}
});
}
ASubmitTable = SubmitTable;
AVerificationResult = VerificationResult;
if ((AVerificationResult != null) &&
(AVerificationResult.Count > 0))
{
// Downgrade TScreenVerificationResults to TVerificationResults in order to allow
// Serialisation (needed for .NET Remoting).
TVerificationResultCollection.DowngradeScreenVerificationResults(AVerificationResult);
return(AVerificationResult.HasCriticalErrors ? TSubmitChangesResult.scrError : TSubmitChangesResult.scrOK);
}
return(TSubmitChangesResult.scrOK);
}
private Boolean LoadAllBatchData(int ABatchNumber = 0)
{
bool RetVal = false;
DataView JournalDV = new DataView(FMainDS.ARecurringJournal);
DataView TransDV = new DataView(FMainDS.ARecurringTransaction);
bool NoJournalRows = true;
bool NoTransRows = true;
if ((ABatchNumber == 0) && (FPreviouslySelectedDetailRow != null))
{
ABatchNumber = FPreviouslySelectedDetailRow.BatchNumber;
}
else if (ABatchNumber == 0)
{
return(RetVal);
}
try
{
// now load journals/transactions for this batch, if necessary, so we know if exchange rate needs to be set in case of different currency
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
FSelectedBatchNumber);
TransDV.RowFilter = String.Format("{0}={1}",
ARecurringTransactionTable.GetBatchNumberDBName(),
FSelectedBatchNumber);
if (JournalDV.Count == 0)
{
FMainDS.Merge(TRemote.MFinance.GL.WebConnectors.LoadARecurringJournalAndContent(FLedgerNumber, FSelectedBatchNumber));
}
else if (TransDV.Count == 0)
{
FMainDS.Merge(TRemote.MFinance.GL.WebConnectors.LoadARecurringTransactionAndContent(FLedgerNumber, FSelectedBatchNumber));
}
NoJournalRows = (JournalDV.Count == 0);
NoTransRows = (TransDV.Count == 0);
if (NoJournalRows && NoTransRows)
{
if (MessageBox.Show(String.Format(Catalog.GetString("The recurring gl batch {0} is empty. Do you still want to submit?"),
FPreviouslySelectedDetailRow.BatchNumber),
Catalog.GetString("Submit Empty Batch"), MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
{
return(RetVal);
}
}
else if (!NoJournalRows && NoTransRows)
{
if (MessageBox.Show(String.Format(Catalog.GetString(
"The recurring gl batch {0} contains empty journals. Do you still want to submit?"),
FPreviouslySelectedDetailRow.BatchNumber),
Catalog.GetString("Submit Empty Journals"), MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
{
return(RetVal);
}
}
else if (NoJournalRows && !NoTransRows)
{
MessageBox.Show(String.Format(Catalog.GetString(
"The recurring gl batch {0} contains orphaned transactions. PLEASE DELETE THE RECURRING BATCH AND RECREATE!"),
FPreviouslySelectedDetailRow.BatchNumber),
Catalog.GetString("Orphaned Data"), MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return(RetVal);
}
RetVal = true;
}
catch (Exception)
{
throw;
}
return(RetVal);
}
private static TSubmitChangesResult SaveRecurringGLBatchTDS(ref GLBatchTDS AInspectDS)
{
Int32 LedgerNumber;
Int32 BatchNumber;
Int32 JournalNumber;
Int32 TransactionNumber;
Int32 Counter;
bool recurrBatchTableInDataSet = (AInspectDS.ARecurringBatch != null);
bool recurrJournalTableInDataSet = (AInspectDS.ARecurringJournal != null);
bool recurrTransactionTableInDataSet = (AInspectDS.ARecurringTransaction != null);
bool recurrTransAnalTableInDataSet = (AInspectDS.ARecurringTransAnalAttrib != null);
TSubmitChangesResult SubmissionResult = new TSubmitChangesResult();
ARecurringJournalTable JournalTable = new ARecurringJournalTable();
ARecurringJournalRow TemplateJournalRow = JournalTable.NewRowTyped(false);
ARecurringTransactionTable TransactionTable = new ARecurringTransactionTable();
ARecurringTransactionRow TemplateTransactionRow = TransactionTable.NewRowTyped(false);
ARecurringTransAnalAttribTable TransAnalAttribTable = new ARecurringTransAnalAttribTable();
ARecurringTransAnalAttribRow TemplateTransAnalAttribRow = TransAnalAttribTable.NewRowTyped(false);
GLBatchTDS DeletedDS = new GLBatchTDS();
ARecurringTransAnalAttribTable DeletedTransAnalAttribTable;
// in this method we also think about deleted batches, journals, transactions where subsequent information
// had not been loaded yet: a type of cascading delete is being used (real cascading delete currently does
// not go down the number of levels needed).
TDBTransaction Transaction = null;
GLBatchTDS InspectDS = AInspectDS;
DBAccess.GDBAccessObj.GetNewOrExistingAutoReadTransaction(IsolationLevel.Serializable,
ref Transaction,
delegate
{
if (recurrBatchTableInDataSet)
{
foreach (ARecurringBatchRow batch in InspectDS.ARecurringBatch.Rows)
{
if (batch.RowState == DataRowState.Deleted)
{
// need to use this way of retrieving data from deleted rows
LedgerNumber = (Int32)batch[ARecurringBatchTable.ColumnLedgerNumberId, DataRowVersion.Original];
BatchNumber = (Int32)batch[ARecurringBatchTable.ColumnBatchNumberId, DataRowVersion.Original];
// load all depending journals, transactions and attributes and make sure they are also deleted via the dataset
TemplateTransAnalAttribRow.LedgerNumber = LedgerNumber;
TemplateTransAnalAttribRow.BatchNumber = BatchNumber;
DeletedTransAnalAttribTable =
ARecurringTransAnalAttribAccess.LoadUsingTemplate(TemplateTransAnalAttribRow, Transaction);
for (Counter = DeletedTransAnalAttribTable.Count - 1; Counter >= 0; Counter--)
{
DeletedTransAnalAttribTable.Rows[Counter].Delete();
}
InspectDS.Merge(DeletedTransAnalAttribTable);
TemplateTransactionRow.LedgerNumber = LedgerNumber;
TemplateTransactionRow.BatchNumber = BatchNumber;
ARecurringTransactionAccess.LoadUsingTemplate(DeletedDS, TemplateTransactionRow, Transaction);
for (Counter = DeletedDS.ARecurringTransaction.Count - 1; Counter >= 0; Counter--)
{
DeletedDS.ARecurringTransaction.Rows[Counter].Delete();
}
InspectDS.Merge(DeletedDS.ARecurringTransaction);
TemplateJournalRow.LedgerNumber = LedgerNumber;
TemplateJournalRow.BatchNumber = BatchNumber;
ARecurringJournalAccess.LoadUsingTemplate(DeletedDS, TemplateJournalRow, Transaction);
for (Counter = DeletedDS.ARecurringJournal.Count - 1; Counter >= 0; Counter--)
{
DeletedDS.ARecurringJournal.Rows[Counter].Delete();
}
InspectDS.Merge(DeletedDS.ARecurringJournal);
}
}
}
if (recurrJournalTableInDataSet)
{
foreach (ARecurringJournalRow journal in InspectDS.ARecurringJournal.Rows)
{
if (journal.RowState == DataRowState.Deleted)
{
// need to use this way of retrieving data from deleted rows
LedgerNumber = (Int32)journal[ARecurringJournalTable.ColumnLedgerNumberId, DataRowVersion.Original];
BatchNumber = (Int32)journal[ARecurringJournalTable.ColumnBatchNumberId, DataRowVersion.Original];
JournalNumber = (Int32)journal[ARecurringJournalTable.ColumnJournalNumberId, DataRowVersion.Original];
// load all depending transactions and attributes and make sure they are also deleted via the dataset
TemplateTransAnalAttribRow.LedgerNumber = LedgerNumber;
TemplateTransAnalAttribRow.BatchNumber = BatchNumber;
TemplateTransAnalAttribRow.JournalNumber = JournalNumber;
DeletedTransAnalAttribTable =
ARecurringTransAnalAttribAccess.LoadUsingTemplate(TemplateTransAnalAttribRow, Transaction);
for (Counter = DeletedTransAnalAttribTable.Count - 1; Counter >= 0; Counter--)
{
DeletedTransAnalAttribTable.Rows[Counter].Delete();
}
InspectDS.Merge(DeletedTransAnalAttribTable);
TemplateTransactionRow.LedgerNumber = LedgerNumber;
TemplateTransactionRow.BatchNumber = BatchNumber;
TemplateTransactionRow.JournalNumber = JournalNumber;
ARecurringTransactionAccess.LoadUsingTemplate(DeletedDS, TemplateTransactionRow, Transaction);
for (Counter = DeletedDS.ARecurringTransaction.Count - 1; Counter >= 0; Counter--)
{
DeletedDS.ARecurringTransaction.Rows[Counter].Delete();
}
InspectDS.Merge(DeletedDS.ARecurringTransaction);
}
}
}
if (recurrTransactionTableInDataSet)
{
foreach (ARecurringTransactionRow transaction in InspectDS.ARecurringTransaction.Rows)
{
if (transaction.RowState == DataRowState.Deleted)
{
// need to use this way of retrieving data from deleted rows
LedgerNumber = (Int32)transaction[ARecurringTransactionTable.ColumnLedgerNumberId, DataRowVersion.Original];
BatchNumber = (Int32)transaction[ARecurringTransactionTable.ColumnBatchNumberId, DataRowVersion.Original];
JournalNumber = (Int32)transaction[ARecurringTransactionTable.ColumnJournalNumberId, DataRowVersion.Original];
TransactionNumber = (Int32)transaction[ARecurringTransactionTable.ColumnTransactionNumberId, DataRowVersion.Original];
// load all depending transactions and attributes and make sure they are also deleted via the dataset
TemplateTransAnalAttribRow.LedgerNumber = LedgerNumber;
TemplateTransAnalAttribRow.BatchNumber = BatchNumber;
TemplateTransAnalAttribRow.JournalNumber = JournalNumber;
TemplateTransAnalAttribRow.TransactionNumber = TransactionNumber;
DeletedTransAnalAttribTable =
ARecurringTransAnalAttribAccess.LoadUsingTemplate(TemplateTransAnalAttribRow, Transaction);
for (Counter = DeletedTransAnalAttribTable.Count - 1; Counter >= 0; Counter--)
{
DeletedTransAnalAttribTable.Rows[Counter].Delete();
}
InspectDS.Merge(DeletedTransAnalAttribTable);
}
}
}
});
// now submit the changes
GLBatchTDSAccess.SubmitChanges(AInspectDS);
SubmissionResult = TSubmitChangesResult.scrOK;
if (recurrTransactionTableInDataSet)
{
//Accept deletion of Attributes to allow deletion of transactions
if (recurrTransAnalTableInDataSet)
{
AInspectDS.ARecurringTransAnalAttrib.AcceptChanges();
}
AInspectDS.ARecurringTransaction.AcceptChanges();
if (AInspectDS.ARecurringTransaction.Count > 0)
{
ARecurringTransactionRow tranR = (ARecurringTransactionRow)AInspectDS.ARecurringTransaction.Rows[0];
Int32 currentLedger = tranR.LedgerNumber;
Int32 currentBatch = tranR.BatchNumber;
Int32 currentJournal = tranR.JournalNumber;
Int32 transToDelete = 0;
try
{
//Check if any records have been marked for deletion
DataRow[] foundTransactionForDeletion = AInspectDS.ARecurringTransaction.Select(String.Format("{0} = '{1}'",
ARecurringTransactionTable.GetSubTypeDBName(),
MFinanceConstants.MARKED_FOR_DELETION));
if (foundTransactionForDeletion.Length > 0)
{
ARecurringTransactionRow transRowClient = null;
for (int i = 0; i < foundTransactionForDeletion.Length; i++)
{
transRowClient = (ARecurringTransactionRow)foundTransactionForDeletion[i];
transToDelete = transRowClient.TransactionNumber;
TLogging.Log(String.Format("Recurring transaction to Delete: {0} from Journal: {1} in Batch: {2}",
transToDelete,
currentJournal,
currentBatch));
transRowClient.Delete();
}
//save changes
GLBatchTDSAccess.SubmitChanges(AInspectDS);
SubmissionResult = TSubmitChangesResult.scrOK;
}
}
catch (Exception ex)
{
TLogging.Log("Saving DataSet: " + ex.Message);
TLogging.Log(String.Format("Error trying to save transaction: {0} in Journal: {1}, Batch: {2}",
transToDelete,
currentJournal,
currentBatch
));
SubmissionResult = TSubmitChangesResult.scrError;
}
}
}
return SubmissionResult;
}
private int GetChangedRecordCountManual(out string AMessage)
{
// For GL Batch we will get some mix of batches, journals and transactions
// Only check relevant tables.
List <string> TablesToCheck = new List <string>();
TablesToCheck.Add(FMainDS.ARecurringBatch.TableName);
TablesToCheck.Add(FMainDS.ARecurringJournal.TableName);
TablesToCheck.Add(FMainDS.ARecurringTransaction.TableName);
TablesToCheck.Add(FMainDS.ARecurringTransAnalAttrib.TableName);
List <Tuple <string, int> > TableAndCountList = new List <Tuple <string, int> >();
int AllChangesCount = 0;
if (FMainDS.HasChanges())
{
// Work out how many changes in each table
foreach (DataTable dt in FMainDS.GetChanges().Tables)
{
string currentTableName = dt.TableName;
if ((dt != null) &&
TablesToCheck.Contains(currentTableName) &&
(dt.Rows.Count > 0))
{
int tableChangesCount = 0;
DataTable dtChanges = dt.GetChanges();
foreach (DataRow dr in dtChanges.Rows)
{
if (DataUtilities.DataRowColumnsHaveChanged(dr))
{
tableChangesCount++;
AllChangesCount++;
}
}
if (tableChangesCount > 0)
{
TableAndCountList.Add(new Tuple <string, int>(currentTableName, tableChangesCount));
}
}
}
}
// Now build up a sensible message
AMessage = String.Empty;
if (TableAndCountList.Count > 0)
{
int nBatches = 0;
int nJournals = 0;
int nTransactions = 0;
foreach (Tuple <string, int> TableAndCount in TableAndCountList)
{
if (TableAndCount.Item1.Equals(ARecurringBatchTable.GetTableName()))
{
nBatches = TableAndCount.Item2;
}
else if (TableAndCount.Item1.Equals(ARecurringJournalTable.GetTableName()))
{
nJournals = TableAndCount.Item2;
}
else if (TableAndCount.Item2 > nTransactions)
{
nTransactions = TableAndCount.Item2;
}
}
AMessage = Catalog.GetString(" You have made changes to ");
string strBatches = String.Empty;
string strJournals = String.Empty;
string strTransactions = String.Empty;
if (nBatches > 0)
{
strBatches = String.Format("{0} recurring {1}",
nBatches,
Catalog.GetPluralString("batch", "batches", nBatches));
}
if (nJournals > 0)
{
strJournals = String.Format("{0} {1}",
nJournals,
Catalog.GetPluralString("journal", "journals", nJournals));
}
if (nTransactions > 0)
{
strTransactions = String.Format("{0} {1}",
nTransactions,
Catalog.GetPluralString("transaction", "transactions", nTransactions));
}
bool bGotAll = (nBatches > 0) && (nJournals > 0) && (nTransactions > 0);
if (nBatches > 0)
{
AMessage += strBatches;
}
if (nJournals > 0)
{
if (bGotAll)
{
AMessage += ", ";
}
else if (nBatches > 0)
{
AMessage += " and ";
}
AMessage += strJournals;
}
if (nTransactions > 0)
{
if ((nBatches > 0) || (nJournals > 0))
{
AMessage += " and ";
}
AMessage += strTransactions;
}
AMessage += Environment.NewLine + Catalog.GetString("(some of the changes may include related background items)");
AMessage += Environment.NewLine;
AMessage += String.Format(TFrmPetraEditUtils.StrConsequenceIfNotSaved, Environment.NewLine);
}
return(AllChangesCount);
}
public static TSubmitChangesResult SaveData(string ATablename,
ref TTypedDataTable ASubmitTable, out TVerificationResultCollection AVerificationResult,
TDBTransaction AWriteTransaction)
{
AVerificationResult = null;
// TODO: check write permissions
string context = string.Format("SaveData {0}", SharedConstants.MODULE_ACCESS_MANAGER);
if (ASubmitTable != null)
{
AVerificationResult = new TVerificationResultCollection();
try
{
if (ATablename == AAccountingPeriodTable.GetTableDBName())
{
AAccountingPeriodAccess.SubmitChanges((AAccountingPeriodTable)ASubmitTable, AWriteTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.AccountingPeriodList.ToString());
}
else if (ATablename == ACurrencyTable.GetTableDBName())
{
ACurrencyAccess.SubmitChanges((ACurrencyTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == ADailyExchangeRateTable.GetTableDBName())
{
TSecurityChecks.CheckUserModulePermissions(
string.Format("AND({0},{1})", SharedConstants.PETRAGROUP_FINANCE1, SharedConstants.PETRAMODULE_FINEXRATE),
context);
ADailyExchangeRateAccess.SubmitChanges((ADailyExchangeRateTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == ACorporateExchangeRateTable.GetTableDBName())
{
// AlanP: I don't think this is used any more. There is a TDS Save method instead
ACorporateExchangeRateAccess.SubmitChanges((ACorporateExchangeRateTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == ACurrencyLanguageTable.GetTableDBName())
{
ACurrencyLanguageAccess.SubmitChanges((ACurrencyLanguageTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == AFeesPayableTable.GetTableDBName())
{
AFeesPayableAccess.SubmitChanges((AFeesPayableTable)ASubmitTable, AWriteTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.FeesPayableList.ToString());
}
else if (ATablename == AFeesReceivableTable.GetTableDBName())
{
AFeesReceivableAccess.SubmitChanges((AFeesReceivableTable)ASubmitTable, AWriteTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.FeesReceivableList.ToString());
}
else if (ATablename == AGiftBatchTable.GetTableDBName())
{
// This method is called from ADailyExchangeRate Setup - please do not remove
// The method is not required for changes made to the gift batch screens, which use a TDS
AGiftBatchAccess.SubmitChanges((AGiftBatchTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == AJournalTable.GetTableDBName())
{
// This method is called from ADailyExchangeRate Setup - please do not remove
// The method is not required for changes made to the journal screens, which use a TDS
AJournalAccess.SubmitChanges((AJournalTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == ARecurringJournalTable.GetTableDBName())
{
// This method is called from Submit Recurring GL Batch form - please do not remove
// The method is not required for changes made to the journal screens, which use a TDS
ARecurringJournalAccess.SubmitChanges((ARecurringJournalTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == ALedgerTable.GetTableDBName())
{
// This method is called from ADailyExchangeRate Testing - please do not remove
ALedgerAccess.SubmitChanges((ALedgerTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == AAnalysisTypeTable.GetTableDBName())
{
AAnalysisTypeAccess.SubmitChanges((AAnalysisTypeTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == ASuspenseAccountTable.GetTableDBName())
{
ASuspenseAccountAccess.SubmitChanges((ASuspenseAccountTable)ASubmitTable, AWriteTransaction);
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheableFinanceTablesEnum.SuspenseAccountList.ToString());
}
else if (ATablename == PcAttendeeTable.GetTableDBName())
{
PcAttendeeAccess.SubmitChanges((PcAttendeeTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PcConferenceTable.GetTableDBName())
{
PcConferenceAccess.SubmitChanges((PcConferenceTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PcConferenceCostTable.GetTableDBName())
{
PcConferenceCostAccess.SubmitChanges((PcConferenceCostTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PcEarlyLateTable.GetTableDBName())
{
PcEarlyLateAccess.SubmitChanges((PcEarlyLateTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PcSupplementTable.GetTableDBName())
{
PcSupplementAccess.SubmitChanges((PcSupplementTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PcDiscountTable.GetTableDBName())
{
PcDiscountAccess.SubmitChanges((PcDiscountTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PInternationalPostalTypeTable.GetTableDBName())
{
ValidateInternationalPostalType(ref AVerificationResult, ASubmitTable);
ValidateInternationalPostalTypeManual(ref AVerificationResult, ASubmitTable);
if (TVerificationHelper.IsNullOrOnlyNonCritical(AVerificationResult))
{
PInternationalPostalTypeAccess.SubmitChanges((PInternationalPostalTypeTable)ASubmitTable, AWriteTransaction);
}
}
else if (ATablename == PtApplicationTypeTable.GetTableDBName())
{
PtApplicationTypeAccess.SubmitChanges((PtApplicationTypeTable)ASubmitTable, AWriteTransaction);
// mark dependent lists for needing to be refreshed since there was a change in base list
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheablePersonTablesEnum.EventApplicationTypeList.ToString());
TCacheableTablesManager.GCacheableTablesManager.MarkCachedTableNeedsRefreshing(
TCacheablePersonTablesEnum.FieldApplicationTypeList.ToString());
}
else if (ATablename == PFormTable.GetTableDBName())
{
PFormAccess.SubmitChanges((PFormTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PFormalityTable.GetTableDBName())
{
PFormalityAccess.SubmitChanges((PFormalityTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PMailingTable.GetTableDBName())
{
PMailingAccess.SubmitChanges((PMailingTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PPartnerGiftDestinationTable.GetTableDBName())
{
PPartnerGiftDestinationAccess.SubmitChanges((PPartnerGiftDestinationTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == PmDocumentTypeTable.GetTableDBName())
{
PmDocumentTypeAccess.SubmitChanges((PmDocumentTypeTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == SGroupTable.GetTableDBName())
{
SGroupAccess.SubmitChanges((SGroupTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == SSystemDefaultsTable.GetTableDBName())
{
SSystemDefaultsAccess.SubmitChanges((SSystemDefaultsTable)ASubmitTable, AWriteTransaction);
}
else if (ATablename == SSystemDefaultsGuiTable.GetTableDBName())
{
SSystemDefaultsGuiAccess.SubmitChanges((SSystemDefaultsGuiTable)ASubmitTable, AWriteTransaction);
}
else
{
throw new EOPAppException("TCommonDataReader.SaveData: unknown table '" + ATablename + "'");
}
}
catch (Exception Exc)
{
AVerificationResult.Add(
new TVerificationResult(null, "Cannot SubmitChanges:" + Environment.NewLine +
Exc.Message, "UNDEFINED", TResultSeverity.Resv_Critical));
}
}
if ((AVerificationResult != null) &&
(AVerificationResult.Count > 0))
{
// Downgrade TScreenVerificationResults to TVerificationResults in order to allow
// Serialisation (needed for .NET Remoting).
TVerificationResultCollection.DowngradeScreenVerificationResults(AVerificationResult);
return(AVerificationResult.HasCriticalErrors ? TSubmitChangesResult.scrError : TSubmitChangesResult.scrOK);
}
return(TSubmitChangesResult.scrOK);
}
private int GetChangedRecordCountManual(out string AMessage)
{
// For GL Batch we will get some mix of batches, journals and transactions
List <Tuple <string, int> > TableAndCountList = new List <Tuple <string, int> >();
int allChangesCount = 0;
// Work out how many changes in each table
foreach (DataTable dt in FMainDS.Tables)
{
if (dt != null)
{
int tableChangesCount = 0;
foreach (DataRow dr in dt.Rows)
{
if (dr.RowState != DataRowState.Unchanged)
{
tableChangesCount++;
allChangesCount++;
}
}
if (tableChangesCount > 0)
{
TableAndCountList.Add(new Tuple <string, int>(dt.TableName, tableChangesCount));
}
}
}
// Now build up a sensible message
AMessage = String.Empty;
if (TableAndCountList.Count > 0)
{
int nBatches = 0;
int nJournals = 0;
int nTransactions = 0;
foreach (Tuple <string, int> TableAndCount in TableAndCountList)
{
if (TableAndCount.Item1.Equals(ARecurringBatchTable.GetTableName()))
{
nBatches = TableAndCount.Item2;
}
else if (TableAndCount.Item1.Equals(ARecurringJournalTable.GetTableName()))
{
nJournals = TableAndCount.Item2;
}
else if (TableAndCount.Item2 > nTransactions)
{
nTransactions = TableAndCount.Item2;
}
}
AMessage = Catalog.GetString(" You have made changes to ");
string strBatches = String.Empty;
string strJournals = String.Empty;
string strTransactions = String.Empty;
if (nBatches > 0)
{
strBatches = String.Format("{0} {1}",
nBatches,
Catalog.GetPluralString("batch", "batches", nBatches));
}
if (nJournals > 0)
{
strJournals = String.Format("{0} {1}",
nJournals,
Catalog.GetPluralString("journal", "journals", nJournals));
}
if (nTransactions > 0)
{
strTransactions = String.Format("{0} {1}",
nTransactions,
Catalog.GetPluralString("transaction", "transactions", nTransactions));
}
bool bGotAll = (nBatches > 0) && (nJournals > 0) && (nTransactions > 0);
if (nBatches > 0)
{
AMessage += strBatches;
}
if (nJournals > 0)
{
if (bGotAll)
{
AMessage += ", ";
}
else if (nBatches > 0)
{
AMessage += " and ";
}
AMessage += strJournals;
}
if (nTransactions > 0)
{
if ((nBatches > 0) || (nJournals > 0))
{
AMessage += " and ";
}
AMessage += strTransactions;
}
AMessage += Environment.NewLine;
AMessage += String.Format(TFrmPetraEditUtils.StrConsequenceIfNotSaved, Environment.NewLine);
}
return(allChangesCount);
}
/// <summary>
/// this submits the given Batch number
/// Each line starts with a type specifier, B for batch, J for journal, T for transaction
/// </summary>
private void SubmitBatch(object sender, EventArgs e)
{
String SubmitErrorMessage = string.Empty;
String ErrorMessageTitle = "Submit Recurring Batch " + FBatchNumber.ToString();
if ((dtpEffectiveDate.Date < FStartDateCurrentPeriod) ||
(dtpEffectiveDate.Date > FEndDateLastForwardingPeriod))
{
SubmitErrorMessage =
String.Format(Catalog.GetString("The batch date is outside the allowed posting period start/end date range: {0} to {1}"),
FStartDateCurrentPeriod.ToShortDateString(),
FEndDateLastForwardingPeriod.ToShortDateString());
MessageBox.Show(SubmitErrorMessage, ErrorMessageTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
dtpEffectiveDate.Focus();
dtpEffectiveDate.SelectAll();
return;
}
// Check for any non-set exchange rates:
DataView JournalDV = new DataView(FMainDS.ARecurringJournal);
JournalDV.RowFilter = String.Format("{0}={1}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber);
if (JournalDV.Count > 0)
{
string currencyCode = string.Empty;
bool isForeignCurrency = false;
foreach (DataRowView drv in JournalDV)
{
ARecurringJournalRow jr = (ARecurringJournalRow)drv.Row;
currencyCode = jr.TransactionCurrency;
isForeignCurrency = (currencyCode != FBaseCurrencyCode);
if (isForeignCurrency && (jr.ExchangeRateToBase <= 0))
{
if (SubmitErrorMessage.Length == 0)
{
SubmitErrorMessage = Catalog.GetString("The following foreign currency Journals need a valid exchange rate:") +
Environment.NewLine;
}
SubmitErrorMessage += string.Format("{0}Journal no.: {1:00} requires a rate for {2} to {3}",
Environment.NewLine,
jr.JournalNumber,
jr.TransactionCurrency,
FBaseCurrencyCode);
}
else if (isForeignCurrency)
{
FExchangeRateDictionary[currencyCode] = jr.ExchangeRateToBase;
}
}
if (SubmitErrorMessage.Length > 0)
{
MessageBox.Show(SubmitErrorMessage, ErrorMessageTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
}
Hashtable requestParams = new Hashtable();
requestParams.Add("ALedgerNumber", FLedgerNumber);
requestParams.Add("ABatchNumber", FBatchNumber);
requestParams.Add("AEffectiveDate", dtpEffectiveDate.Date.Value);
requestParams.Add("AExchangeRateIntlToBase", FExchangeRateIntlToBase);
TVerificationResultCollection Verifications = new TVerificationResultCollection();
Int32 NewGLBatchNumber = TRemote.MFinance.GL.WebConnectors.SubmitRecurringGLBatch(ref FMainDS,
requestParams,
ref FExchangeRateDictionary,
ref Verifications);
if (NewGLBatchNumber > 0)
{
MessageBox.Show(String.Format(Catalog.GetString("Your Recurring GL Batch was submitted successfully as new GL Batch: {0}!"),
NewGLBatchNumber),
Catalog.GetString("Success"),
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
else
{
string errorMessages = String.Empty;
foreach (TVerificationResult verif in Verifications)
{
errorMessages += "[" + verif.ResultContext + "] " +
verif.ResultTextCaption + ": " +
verif.ResultText + Environment.NewLine;
}
MessageBox.Show(errorMessages, Catalog.GetString("Recurring GL Batch Submit failed"),
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
Close();
}
/// <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(ARecurringBatchRow ARowToDelete, ref string ACompletionMessage)
{
//Assign default value(s)
bool DeletionSuccessful = false;
if (ARowToDelete == null)
{
return(DeletionSuccessful);
}
int BatchNumber = ARowToDelete.BatchNumber;
//Backup the Dataset for reversion purposes
GLBatchTDS BackupMainDS = (GLBatchTDS)FMainDS.Copy();
BackupMainDS.Merge(FMainDS);
if (ARowToDelete.RowState != DataRowState.Added)
{
//Reject any changes which may fail validation
ARowToDelete.RejectChanges();
ShowDetails(ARowToDelete);
}
try
{
this.Cursor = Cursors.WaitCursor;
ACompletionMessage = String.Format(Catalog.GetString("Batch no.: {0} deleted successfully."),
BatchNumber);
// Delete the associated recurring transaction analysis attributes
DataView viewRecurringTransAnalAttrib = new DataView(FMainDS.ARecurringTransAnalAttrib);
viewRecurringTransAnalAttrib.RowFilter = String.Format("{0}={1} AND {2}={3}",
ARecurringTransAnalAttribTable.GetLedgerNumberDBName(),
FLedgerNumber,
ARecurringTransAnalAttribTable.GetBatchNumberDBName(),
BatchNumber);
foreach (DataRowView row in viewRecurringTransAnalAttrib)
{
row.Delete();
}
// Delete the associated recurring transactions
DataView viewRecurringTransaction = new DataView(FMainDS.ARecurringTransaction);
viewRecurringTransaction.RowFilter = String.Format("{0}={1} AND {2}={3}",
ARecurringTransactionTable.GetLedgerNumberDBName(),
FLedgerNumber,
ARecurringTransactionTable.GetBatchNumberDBName(),
BatchNumber);
foreach (DataRowView row in viewRecurringTransaction)
{
row.Delete();
}
// Delete the associated recurring journals
DataView viewRecurringJournal = new DataView(FMainDS.ARecurringJournal);
viewRecurringJournal.RowFilter = String.Format("{0}={1} AND {2}={3}",
ARecurringJournalTable.GetLedgerNumberDBName(),
FLedgerNumber,
ARecurringJournalTable.GetBatchNumberDBName(),
BatchNumber);
foreach (DataRowView row in viewRecurringJournal)
{
row.Delete();
}
// Delete the recurring batch row.
ARowToDelete.Delete();
DeletionSuccessful = true;
}
catch (Exception ex)
{
ACompletionMessage = ex.Message;
MessageBox.Show(ACompletionMessage,
"Deletion Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
//Revert to previous state
FMainDS.Merge(BackupMainDS);
}
finally
{
this.Cursor = Cursors.Default;
}
UpdateRecordNumberDisplay();
return(DeletionSuccessful);
}
private void ProcessNewlyAddedJournalRowForDeletion(int AJournalNumberToDelete)
{
GLBatchTDS BackupDS = (GLBatchTDS)FMainDS.Copy();
BackupDS.Merge(FMainDS);
try
{
// Delete the associated recurring transaction analysis attributes
DataView attributesDV = new DataView(FMainDS.ARecurringTransAnalAttrib);
attributesDV.RowFilter = string.Format("{0}={1} And {2}={3}",
ARecurringTransAnalAttribTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringTransAnalAttribTable.GetJournalNumberDBName(),
AJournalNumberToDelete
);
foreach (DataRowView attrDRV in attributesDV)
{
ARecurringTransAnalAttribRow attrRow = (ARecurringTransAnalAttribRow)attrDRV.Row;
attrRow.Delete();
}
// Delete the associated recurring transactions
DataView transactionsDV = new DataView(FMainDS.ARecurringTransaction);
transactionsDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ARecurringTransactionTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringTransactionTable.GetJournalNumberDBName(),
AJournalNumberToDelete
);
foreach (DataRowView transDRV in transactionsDV)
{
ARecurringTransactionRow tranRow = (ARecurringTransactionRow)transDRV.Row;
tranRow.Delete();
}
// Delete the recurring journal
DataView journalDV = new DataView(FMainDS.ARecurringJournal);
journalDV.RowFilter = String.Format("{0}={1} And {2}={3}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringJournalTable.GetJournalNumberDBName(),
AJournalNumberToDelete
);
foreach (DataRowView journalDRV in journalDV)
{
ARecurringJournalRow jrnlRow = (ARecurringJournalRow)journalDRV.Row;
jrnlRow.Delete();
}
//Renumber the journals, transactions and attributes
DataView attributesDV2 = new DataView(FMainDS.ARecurringTransAnalAttrib);
attributesDV2.RowFilter = string.Format("{0}={1} And {2}>{3}",
ARecurringTransAnalAttribTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringTransAnalAttribTable.GetJournalNumberDBName(),
AJournalNumberToDelete);
attributesDV2.Sort = String.Format("{0} ASC", ARecurringTransAnalAttribTable.GetJournalNumberDBName());
foreach (DataRowView attrDRV in attributesDV2)
{
ARecurringTransAnalAttribRow attrRow = (ARecurringTransAnalAttribRow)attrDRV.Row;
attrRow.JournalNumber--;
}
DataView transactionsDV2 = new DataView(FMainDS.ARecurringTransaction);
transactionsDV2.RowFilter = string.Format("{0}={1} And {2}>{3}",
ARecurringTransactionTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringTransactionTable.GetJournalNumberDBName(),
AJournalNumberToDelete);
transactionsDV2.Sort = String.Format("{0} ASC", ARecurringTransactionTable.GetJournalNumberDBName());
foreach (DataRowView transDRV in transactionsDV2)
{
ARecurringTransactionRow tranRow = (ARecurringTransactionRow)transDRV.Row;
tranRow.JournalNumber--;
}
DataView journalDV2 = new DataView(FMainDS.ARecurringJournal);
journalDV2.RowFilter = string.Format("{0}={1} And {2}>{3}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringJournalTable.GetJournalNumberDBName(),
AJournalNumberToDelete);
journalDV2.Sort = String.Format("{0} ASC", ARecurringJournalTable.GetJournalNumberDBName());
foreach (DataRowView jrnlDRV in journalDV2)
{
ARecurringJournalRow jrnlRow = (ARecurringJournalRow)jrnlDRV.Row;
jrnlRow.JournalNumber--;
}
}
catch (Exception ex)
{
FMainDS.Merge(BackupDS);
TLogging.LogException(ex, Utilities.GetMethodSignature());
throw;
}
}
private void RenumberJournals()
{
bool JournalsRenumbered = false;
DataView JrnlView = new DataView(FMainDS.ARecurringJournal);
DataView TransView = new DataView(FMainDS.ARecurringTransaction);
DataView AttrView = new DataView(FMainDS.ARecurringTransAnalAttrib);
//Reduce all trans and journal data by 1 in JournalNumber field
//Reduce those with higher transaction number by one
JrnlView.RowFilter = String.Format("{0}={1} AND {2}>{3}",
ARecurringJournalTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringJournalTable.GetJournalNumberDBName(),
FJournalNumberToDelete);
JrnlView.Sort = String.Format("{0} ASC",
ARecurringJournalTable.GetJournalNumberDBName());
JournalsRenumbered = (JrnlView.Count > 0);
// Delete the associated transaction analysis attributes
// if attributes do exist, and renumber those above
foreach (DataRowView jV in JrnlView)
{
GLBatchTDSARecurringJournalRow jrnlRowCurrent = (GLBatchTDSARecurringJournalRow)jV.Row;
int currentJnrlNumber = jrnlRowCurrent.JournalNumber;
//Copy current row down to fill gap and then delete it
GLBatchTDSARecurringJournalRow newJrnlRow = FMainDS.ARecurringJournal.NewRowTyped(true);
newJrnlRow.ItemArray = jrnlRowCurrent.ItemArray;
//reduce journal number by 1 in the new row
newJrnlRow.JournalNumber--;
FMainDS.ARecurringJournal.Rows.Add(newJrnlRow);
//Process Transactions
TransView.RowFilter = String.Format("{0}={1} AND {2}={3}",
ARecurringTransactionTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringTransactionTable.GetJournalNumberDBName(),
currentJnrlNumber);
TransView.Sort = String.Format("{0} ASC, {1} ASC",
ARecurringTransactionTable.GetJournalNumberDBName(),
ARecurringTransactionTable.GetTransactionNumberDBName());
//Iterate through higher number attributes and transaction numbers and reduce by one
ARecurringTransactionRow transRowCurrent = null;
foreach (DataRowView gv in TransView)
{
transRowCurrent = (ARecurringTransactionRow)gv.Row;
GLBatchTDSARecurringTransactionRow newTransRow = FMainDS.ARecurringTransaction.NewRowTyped(true);
newTransRow.ItemArray = transRowCurrent.ItemArray;
//reduce journal number by 1 in the new row
newTransRow.JournalNumber--;
FMainDS.ARecurringTransaction.Rows.Add(newTransRow);
//Repeat process for attributes that belong to current transaction
AttrView.RowFilter = String.Format("{0}={1} And {2}={3} And {4}={5}",
ARecurringTransAnalAttribTable.GetBatchNumberDBName(),
FBatchNumber,
ARecurringTransAnalAttribTable.GetJournalNumberDBName(),
currentJnrlNumber,
ARecurringTransAnalAttribTable.GetTransactionNumberDBName(),
transRowCurrent.TransactionNumber);
AttrView.Sort = String.Format("{0} ASC, {1} ASC, {2} ASC",
ARecurringTransAnalAttribTable.GetJournalNumberDBName(),
ARecurringTransAnalAttribTable.GetTransactionNumberDBName(),
ARecurringTransAnalAttribTable.GetAnalysisTypeCodeDBName());
// 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
ARecurringTransAnalAttribRow attrRowCurrent = null;
foreach (DataRowView rV in AttrView)
{
attrRowCurrent = (ARecurringTransAnalAttribRow)rV.Row;
ARecurringTransAnalAttribRow newAttrRow = FMainDS.ARecurringTransAnalAttrib.NewRowTyped(true);
newAttrRow.ItemArray = attrRowCurrent.ItemArray;
//reduce journal number by 1
newAttrRow.JournalNumber--;
FMainDS.ARecurringTransAnalAttrib.Rows.Add(newAttrRow);
attrRowCurrent.Delete();
}
}
transRowCurrent.Delete();
}
jrnlRowCurrent.Delete();
}
if (JournalsRenumbered)
{
FPetraUtilsObject.SetChangedFlag();
}
//Need to refresh FPreviouslySelectedDetailRow else it points to a deleted row
SelectRowInGrid(grdDetails.GetFirstHighlightedRowIndex());
}
private static bool CanSubsystemBeDeactivated(Int32 ALedgerNumber, String ASubsystemCode)
{
Boolean NewTransaction;
Boolean Result = false;
TDBTransaction Transaction = DBAccess.GDBAccessObj.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted,
TEnforceIsolationLevel.eilMinimum, out NewTransaction);
if (ASubsystemCode == CommonAccountingSubSystemsEnum.GR.ToString())
{
// for gift processing don't allow to deactivate if 'Posted' or 'Unposted' gift batches exist
AGiftBatchTable TemplateGiftBatchTable;
AGiftBatchRow TemplateGiftBatchRow;
StringCollection TemplateGiftBatchOperators;
TemplateGiftBatchTable = new AGiftBatchTable();
TemplateGiftBatchRow = TemplateGiftBatchTable.NewRowTyped(false);
TemplateGiftBatchRow.LedgerNumber = ALedgerNumber;
TemplateGiftBatchRow.BatchStatus = MFinanceConstants.BATCH_POSTED;
TemplateGiftBatchOperators = new StringCollection();
TemplateGiftBatchOperators.Add("=");
if (AGiftBatchAccess.CountUsingTemplate(TemplateGiftBatchRow, TemplateGiftBatchOperators, Transaction) == 0)
{
Result = true;
}
if (!Result)
{
TemplateGiftBatchRow.BatchStatus = MFinanceConstants.BATCH_UNPOSTED;
if (AGiftBatchAccess.CountUsingTemplate(TemplateGiftBatchRow, TemplateGiftBatchOperators, Transaction) == 0)
{
Result = true;
}
}
}
if (!Result)
{
AJournalTable TemplateJournalTable;
AJournalRow TemplateJournalRow;
StringCollection TemplateJournalOperators;
TemplateJournalTable = new AJournalTable();
TemplateJournalRow = TemplateJournalTable.NewRowTyped(false);
TemplateJournalRow.LedgerNumber = ALedgerNumber;
TemplateJournalRow.SubSystemCode = ASubsystemCode;
TemplateJournalOperators = new StringCollection();
TemplateJournalOperators.Add("=");
ARecurringJournalTable TemplateRJournalTable;
ARecurringJournalRow TemplateRJournalRow;
StringCollection TemplateRJournalOperators;
TemplateRJournalTable = new ARecurringJournalTable();
TemplateRJournalRow = TemplateRJournalTable.NewRowTyped(false);
TemplateRJournalRow.LedgerNumber = ALedgerNumber;
TemplateRJournalRow.SubSystemCode = ASubsystemCode;
TemplateRJournalOperators = new StringCollection();
TemplateRJournalOperators.Add("=");
// do not allow to deactivate subsystem if journals already exist
if ((AJournalAccess.CountUsingTemplate(TemplateJournalRow, TemplateJournalOperators, Transaction) == 0)
&& (ARecurringJournalAccess.CountUsingTemplate(TemplateRJournalRow, TemplateRJournalOperators, Transaction) == 0))
{
Result = true;
}
}
if (NewTransaction)
{
DBAccess.GDBAccessObj.RollbackTransaction();
}
return Result;
}
