/// <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(ARecurringGiftBatchRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
/*Code to execute after the delete has occurred*/
if (ADeletionPerformed && (ACompletionMessage.Length > 0))
{
//causes saving issues
//UpdateLedgerTableSettings();
if (((TFrmRecurringGiftBatch)this.ParentForm).SaveChanges())
{
MessageBox.Show(ACompletionMessage, Catalog.GetString("Deletion Completed"));
}
else
{
MessageBox.Show("Unable to save after deletion of batch! Try saving manually and closing and reopening the form.");
}
}
else if (!AAllowDeletion)
{
//message to user
}
else if (!ADeletionPerformed)
{
//message to user
}
UpdateChangeableStatus();
((TFrmRecurringGiftBatch)ParentForm).EnableTransactions((grdDetails.Rows.Count > 1));
SelectRowInGrid(grdDetails.GetFirstHighlightedRowIndex());
}
private void ValidateDataDetailsManual(ARecurringGiftBatchRow ARow)
{
if (ARow == null)
{
return;
}
TVerificationResultCollection VerificationResultCollection = FPetraUtilsObject.VerificationResultCollection;
//Hash total special case in view of the textbox handling
ParseHashTotal(ARow);
TSharedFinanceValidation_Gift.ValidateRecurringGiftBatchManual(this, ARow, ref VerificationResultCollection,
FValidationControlsDict);
//TODO: remove this once database definition is set for Batch Description to be NOT NULL
// Description is mandatory then make sure it is set
if (txtDetailBatchDescription.Text.Length == 0)
{
DataColumn ValidationColumn;
TVerificationResult VerificationResult = null;
object ValidationContext;
ValidationColumn = ARow.Table.Columns[ARecurringGiftBatchTable.ColumnBatchDescriptionId];
ValidationContext = String.Format("Recurring Batch number {0}",
ARow.BatchNumber);
VerificationResult = TStringChecks.StringMustNotBeEmpty(ARow.BatchDescription,
"Description of " + ValidationContext,
this, ValidationColumn, null);
// Handle addition/removal to/from TVerificationResultCollection
VerificationResultCollection.Auto_Add_Or_AddOrRemove(this, VerificationResult, ValidationColumn, true);
}
}
/// <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>
public void PostDeleteManual(ARecurringGiftBatchRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
/*Code to execute after the delete has occurred*/
if (ADeletionPerformed && (ACompletionMessage.Length > 0))
{
if (FMyForm.SaveChangesManual())
{
MessageBox.Show(ACompletionMessage, Catalog.GetString("Deletion Completed"));
}
else
{
MessageBox.Show(Catalog.GetString(
"Unable to save after deletion of batch! Try saving manually and closing and reopening the form."));
}
}
else if (!AAllowDeletion)
{
//message to user
}
else if (!ADeletionPerformed)
{
//message to user
}
}
private void PostDeleteManual(ARecurringGiftBatchRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
FDeleteLogicObject.PostDeleteManual(ARowToDelete,
AAllowDeletion,
ADeletionPerformed,
ACompletionMessage);
if (ADeletionPerformed)
{
//Reset row to fire events
SelectRowInGrid(FDeletedBatchRowIndex);
UpdateRecordNumberDisplay();
//If no row exists in current view after cancellation
if (grdDetails.Rows.Count < 2)
{
UpdateChangeableStatus();
}
// ((TFrmRecurringGiftBatch)ParentForm).EnableTransactions((grdDetails.Rows.Count > 1));
//SelectRowInGrid(FDeletedBatchRowIndex > 0 ? FDeletedBatchRowIndex : 1);
}
}
/// <summary>
/// Call this to change the accounts being shown in the accounts combobox (used when changing the Recurring Gift type)
/// </summary>
/// <param name="AActiveOnly"></param>
/// <param name="ABankAccountOnly"></param>
/// <param name="ALblBankAccountCode"></param>
/// <param name="ARow"></param>
public void SetupAccountCombo(bool AActiveOnly,
bool ABankAccountOnly,
ref System.Windows.Forms.Label ALblBankAccountCode,
ARecurringGiftBatchRow ARow)
{
FCmbBankAccountCode.Clear();
TFinanceControls.InitialiseAccountList(ref FCmbBankAccountCode,
FLedgerNumber,
true,
false,
AActiveOnly,
ABankAccountOnly,
true,
FAccountTable);
if (ABankAccountOnly)
{
ALblBankAccountCode.Text = Catalog.GetString("Bank Account:");
}
else
{
ALblBankAccountCode.Text = Catalog.GetString("Account Code:");
}
if (ARow != null)
{
FCmbBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1);
}
}
/// <summary>
/// Check if batch columns have actually changed
/// </summary>
/// <param name="ARecurringBatchRow"></param>
/// <returns></returns>
public bool BatchColumnsHaveChanged(ARecurringGiftBatchRow ARecurringBatchRow)
{
bool RetVal = false;
if (ARecurringBatchRow.RowState != DataRowState.Unchanged)
{
bool columnValueChanged = false;
for (int i = 0; i < FMainDS.ARecurringGiftBatch.Columns.Count; i++)
{
string originalValue = ARecurringBatchRow[i, DataRowVersion.Original].ToString();
string currentValue = ARecurringBatchRow[i, DataRowVersion.Current].ToString();
if (originalValue != currentValue)
{
columnValueChanged = true;
break;
}
}
if (!columnValueChanged)
{
ARecurringBatchRow.RejectChanges();
}
RetVal = columnValueChanged;
}
return(RetVal);
}
private bool DeleteRowManual(ARecurringGiftBatchRow ARowToDelete, ref string ACompletionMessage)
{
bool DeletionSuccessful = false;
if (ARowToDelete == null)
{
return(false);
}
//Notify of deletion process
TFrmRecurringGiftBatch MainForm = (TFrmRecurringGiftBatch)this.ParentForm;
try
{
MainForm.FCurrentGiftBatchAction = TExtraGiftBatchChecks.GiftBatchAction.DELETING;
FDeletedBatchRowIndex = grdDetails.GetFirstHighlightedRowIndex();
DeletionSuccessful = FDeleteLogicObject.DeleteRowManual(ARowToDelete, ref FPreviouslySelectedDetailRow, ref ACompletionMessage);
}
finally
{
MainForm.FCurrentGiftBatchAction = TExtraGiftBatchChecks.GiftBatchAction.NONE;
}
return(DeletionSuccessful);
}
/// create new recurring gift info
public static ARecurringGiftBatchRow CreateNewRecurringGiftInfo(Int64 APartnerKey, ref GiftBatchTDS AGiftDS)
{
ALedgerAccess.LoadAll(AGiftDS, DBAccess.GDBAccessObj.Transaction);
AGiftDS = TGiftTransactionWebConnector.CreateARecurringGiftBatch(AGiftDS.ALedger[0].LedgerNumber);
// Create a new RecurringGiftBatch
ARecurringGiftBatchRow Batch = AGiftDS.ARecurringGiftBatch[0];
Batch.BankAccountCode = "6000";
Batch.CurrencyCode = "EUR";
// Create a new RecurringGift record
ARecurringGiftRow RecurringGift = AGiftDS.ARecurringGift.NewRowTyped();
RecurringGift.LedgerNumber = Batch.LedgerNumber;
RecurringGift.BatchNumber = Batch.BatchNumber;
RecurringGift.GiftTransactionNumber = 1;
RecurringGift.DonorKey = APartnerKey;
AGiftDS.ARecurringGift.Rows.Add(RecurringGift);
// Create a new RecurringGiftDetail record
ARecurringGiftDetailRow RecurringGiftDetail = AGiftDS.ARecurringGiftDetail.NewRowTyped();
RecurringGiftDetail.LedgerNumber = Batch.LedgerNumber;
RecurringGiftDetail.BatchNumber = Batch.BatchNumber;
RecurringGiftDetail.GiftTransactionNumber = 1;
RecurringGiftDetail.MotivationGroupCode = "GIFT";
RecurringGiftDetail.MotivationDetailCode = "SUPPORT";
RecurringGiftDetail.RecipientKey = APartnerKey;
RecurringGiftDetail.RecipientLedgerNumber = APartnerKey;
AGiftDS.ARecurringGiftDetail.Rows.Add(RecurringGiftDetail);
return(Batch);
}
/// <summary>
/// Switch to the given tab
/// </summary>
/// <param name="ATab"></param>
/// <param name="AAllowRepeatEvent"></param>
public void SelectTab(eGiftTabs ATab, bool AAllowRepeatEvent = false)
{
if (ATab == eGiftTabs.Batches)
{
if ((FPreviouslySelectedTab == eGiftTabs.Batches) && !AAllowRepeatEvent)
{
//Repeat event
return;
}
FPreviouslySelectedTab = eGiftTabs.Batches;
FPetraUtilsObject.RestoreAdditionalWindowPositionProperties();
this.tabGiftBatch.SelectedTab = this.tpgRecurringBatches;
this.tpgRecurringTransactions.Enabled = (ucoRecurringBatches.GetSelectedDetailRow() != null);
this.ucoRecurringBatches.SetFocusToGrid();
}
else if (ATab == eGiftTabs.Transactions)
{
if ((FPreviouslySelectedTab == eGiftTabs.Transactions) && !AAllowRepeatEvent)
{
//Repeat event
return;
}
if (this.tpgRecurringTransactions.Enabled)
{
FPreviouslySelectedTab = eGiftTabs.Transactions;
// Note!! This call may result in this (SelectTab) method being called again (but no new transactions will be loaded the second time)
this.tabGiftBatch.SelectedTab = this.tpgRecurringTransactions;
ARecurringGiftBatchRow SelectedRow = ucoRecurringBatches.GetSelectedDetailRow();
// If there's only one GiftBatch row, I'll not require that the user has selected it!
if (FMainDS.ARecurringGiftBatch.Rows.Count == 1)
{
SelectedRow = FMainDS.ARecurringGiftBatch[0];
}
if (SelectedRow != null)
{
try
{
this.Cursor = Cursors.WaitCursor;
LoadTransactions(SelectedRow.LedgerNumber,
SelectedRow.BatchNumber);
}
finally
{
this.Cursor = Cursors.Default;
}
}
ucoRecurringTransactions.FocusGrid();
}
}
}
private int GetDataTableRowIndexByPrimaryKeys(int ALedgerNumber, int ABatchNumber)
{
int rowPos = 0;
bool batchFound = false;
foreach (DataRowView rowView in FMainDS.ARecurringGiftBatch.DefaultView)
{
ARecurringGiftBatchRow row = (ARecurringGiftBatchRow)rowView.Row;
if ((row.LedgerNumber == ALedgerNumber) && (row.BatchNumber == ABatchNumber))
{
batchFound = true;
break;
}
rowPos++;
}
if (!batchFound)
{
rowPos = 0;
}
//remember grid is out of sync with DataView by 1 because of grid header rows
return(rowPos + 1);
}
private void RefreshBankAccountAndCostCentreFilters(bool AActiveOnly, ARecurringGiftBatchRow ARow = null)
{
if (FActiveOnly != AActiveOnly)
{
FActiveOnly = AActiveOnly;
FAccountAndCostCentreLogicObject.RefreshBankAccountAndCostCentreFilters(AActiveOnly, ARow);
}
}
private void SetupAccountAndCostCentreCombos(bool AActiveOnly = true, ARecurringGiftBatchRow ARow = null)
{
if (!FBatchLoaded || (FActiveOnly != AActiveOnly))
{
FActiveOnly = AActiveOnly;
FAccountAndCostCentreLogicObject.SetupAccountAndCostCentreCombos(AActiveOnly, ARow);
}
}
/// <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(ARecurringGiftBatchRow ARowToDelete, ref string ACompletionMessage)
{
bool deletionSuccessful = false;
int batchNumber = ARowToDelete.BatchNumber;
bool newBatch = (ARowToDelete.RowState == DataRowState.Added);
// first save any changes
if (!((TFrmRecurringGiftBatch)FPetraUtilsObject.GetForm()).SaveChangesManual(TExtraGiftBatchChecks.GiftBatchAction.DELETING))
{
return(false);
}
try
{
ACompletionMessage = String.Format(Catalog.GetString("Batch no.: {0} deleted successfully."),
batchNumber);
//clear any transactions currently being editied in the Transaction Tab
((TFrmRecurringGiftBatch)ParentForm).GetTransactionsControl().ClearCurrentSelection();
if (!newBatch)
{
//Load tables afresh
FMainDS.Merge(TRemote.MFinance.Gift.WebConnectors.LoadRecurringGiftTransactionsForBatch(FLedgerNumber, batchNumber));
FMainDS.AcceptChanges();
}
((TFrmRecurringGiftBatch)ParentForm).GetTransactionsControl().DeleteCurrentRecurringBatchGiftData(batchNumber);
//Affect a change in the batch row, required by deletion process.
ARowToDelete.DateModified = DateTime.Now;
// Delete the recurring batch row.
ARowToDelete.Delete();
//FMainDS.AcceptChanges();
FPreviouslySelectedDetailRow = null;
deletionSuccessful = true;
}
catch (Exception ex)
{
ACompletionMessage = ex.Message;
MessageBox.Show(ex.Message,
"Deletion Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
UpdateRecordNumberDisplay();
return(deletionSuccessful);
}
/// <summary>
/// Refreshes the filters on the combo boxes
/// </summary>
/// <param name="AActiveOnly"></param>
/// <param name="ARow"></param>
public void RefreshBankAccountAndCostCentreFilters(bool AActiveOnly, ARecurringGiftBatchRow ARow)
{
FCmbBankAccountCode.Filter = TFinanceControls.PrepareAccountFilter(true, false, AActiveOnly, true, "");
FCmbCostCentreCode.Filter = TFinanceControls.PrepareCostCentreFilter(true, false, AActiveOnly, true);
if (ARow != null)
{
FCmbCostCentreCode.SetSelectedString(ARow.BankCostCentre, -1);
FCmbBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1);
}
}
private bool DeleteRowManual(ARecurringGiftBatchRow ARowToDelete, ref string ACompletionMessage)
{
bool RetVal = false;
FDeletedBatchRowIndex = grdDetails.GetFirstHighlightedRowIndex();
RetVal = FDeleteLogicObject.DeleteRowManual(ARowToDelete, ref FPreviouslySelectedDetailRow, ref ACompletionMessage);
UpdateRecordNumberDisplay();
return(RetVal);
}
/// <summary>
/// Call this to do initial set up the Bank account and cost centre combo boxes
/// </summary>
/// <param name="AActiveOnly"></param>
/// <param name="ARow"></param>
public void SetupAccountAndCostCentreCombos(bool AActiveOnly, ARecurringGiftBatchRow ARow)
{
FCmbCostCentreCode.Clear();
FCmbBankAccountCode.Clear();
TFinanceControls.InitialiseAccountList(ref FCmbBankAccountCode, FLedgerNumber, true, false, AActiveOnly, true, true, FAccountTable);
TFinanceControls.InitialiseCostCentreList(ref FCmbCostCentreCode, FLedgerNumber, true, false, AActiveOnly, true, true, FCostCentreTable);
if (ARow != null)
{
FCmbCostCentreCode.SetSelectedString(ARow.BankCostCentre, -1);
FCmbBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1);
}
}
private void ValidateDataDetailsManual(ARecurringGiftBatchRow ARow)
{
if (ARow == null)
{
return;
}
TVerificationResultCollection VerificationResultCollection = FPetraUtilsObject.VerificationResultCollection;
//Hash total special case in view of the textbox handling
ParseHashTotal(ARow);
TSharedFinanceValidation_Gift.ValidateRecurringGiftBatchManual(this, ARow, ref VerificationResultCollection,
FValidationControlsDict);
}
/// <summary>
/// Implementation of the interface member
/// </summary>
/// <param name="AContext">The context that identifies the column for which an image is to be evaluated</param>
/// <param name="ADataRowView">The data containing the column of interest. You will evaluate whether this column contains data that should have the image or not.</param>
/// <returns>True if the image should be displayed in the current context</returns>
public bool EvaluateBoundImage(BoundGridImage.AnnotationContextEnum AContext, DataRowView ADataRowView)
{
ARecurringGiftBatchRow row = (ARecurringGiftBatchRow)ADataRowView.Row;
switch (AContext)
{
case BoundGridImage.AnnotationContextEnum.AccountCode:
return(!FAccountAndCostCentreLogicObject.AccountIsActive(row.BankAccountCode));
case BoundGridImage.AnnotationContextEnum.CostCentreCode:
return(!FAccountAndCostCentreLogicObject.CostCentreIsActive(row.BankCostCentre));
}
return(false);
}
/// <summary>
/// Re-show the specified row
/// </summary>
/// <param name="AModifiedBatchRow"></param>
/// <param name="ARedisplay"></param>
public void UndoModifiedBatchRow(ARecurringGiftBatchRow AModifiedBatchRow, bool ARedisplay)
{
//Check if new row or not
if (AModifiedBatchRow.RowState == DataRowState.Added)
{
return;
}
AModifiedBatchRow.RejectChanges();
if (ARedisplay)
{
ShowDetails(AModifiedBatchRow);
}
}
/// <summary>
/// create a new batch with a consecutive batch number in the ledger
/// for call inside a server function
/// for performance reasons submitting (save the data in the database) is done later (not here)
/// </summary>
/// <param name="AMainDS"></param>
/// <param name="ATransaction"></param>
/// <param name="ALedgerNumber"></param>
/// <returns>the new gift batch row</returns>
public static ARecurringGiftBatchRow CreateANewRecurringGiftBatchRow(ref GiftBatchTDS AMainDS,
ref TDBTransaction ATransaction,
Int32 ALedgerNumber)
{
#region Validate Arguments
if (AMainDS == null)
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString(
"Function:{0} - The Gift Batch dataset is NULL!"),
Utilities.GetMethodName(true)));
}
else if (ATransaction == null)
{
throw new EFinanceSystemDBTransactionNullException(String.Format(Catalog.GetString(
"Function:{0} - Database Transaction must not be NULL!"),
Utilities.GetMethodName(true)));
}
else if (ALedgerNumber <= 0)
{
throw new EFinanceSystemInvalidLedgerNumberException(String.Format(Catalog.GetString(
"Function:{0} - The Ledger number must be greater than 0!"),
Utilities.GetMethodName(true)), ALedgerNumber);
}
#endregion Validate Arguments
TLedgerInfo info = new TLedgerInfo(ALedgerNumber, ATransaction.DataBaseObj);
ALedgerAccess.LoadByPrimaryKey(AMainDS, ALedgerNumber, ATransaction);
if ((AMainDS.ALedger == null) || (AMainDS.ALedger.Count == 0))
{
throw new EFinanceSystemDataObjectNullOrEmptyException(String.Format(Catalog.GetString(
"Function:{0} - The Ledger table is NULL or is empty!"),
Utilities.GetMethodName(true)));
}
ARecurringGiftBatchRow NewRow = AMainDS.ARecurringGiftBatch.NewRowTyped(true);
NewRow.LedgerNumber = ALedgerNumber;
NewRow.BatchNumber = ++AMainDS.ALedger[0].LastRecGiftBatchNumber;
NewRow.BatchDescription = Catalog.GetString("Please enter recurring batch description");
NewRow.BankAccountCode = info.GetDefaultBankAccount();
NewRow.BankCostCentre = info.GetStandardCostCentre();
NewRow.CurrencyCode = AMainDS.ALedger[0].BaseCurrency;
AMainDS.ARecurringGiftBatch.Rows.Add(NewRow);
return(NewRow);
}
private void ParseHashTotal(ARecurringGiftBatchRow ARow)
{
decimal correctHashValue;
if ((txtDetailHashTotal.NumberValueDecimal == null) || !txtDetailHashTotal.NumberValueDecimal.HasValue)
{
correctHashValue = 0m;
}
else
{
correctHashValue = txtDetailHashTotal.NumberValueDecimal.Value;
}
txtDetailHashTotal.NumberValueDecimal = correctHashValue;
ARow.HashTotal = correctHashValue;
}
private void RefreshBankAccountAndCostCentreFilters(bool AActiveOnly, ARecurringGiftBatchRow ARow = null)
{
if (FActiveOnly != AActiveOnly)
{
FActiveOnly = AActiveOnly;
cmbDetailBankAccountCode.Filter = TFinanceControls.PrepareAccountFilter(true, false, AActiveOnly, true, "");
cmbDetailBankCostCentre.Filter = TFinanceControls.PrepareCostCentreFilter(true, false, AActiveOnly, true);
if (ARow != null)
{
cmbDetailBankCostCentre.SetSelectedString(ARow.BankCostCentre, -1);
cmbDetailBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1);
}
}
}
/// create new recurring gift info
public static ARecurringGiftBatchRow CreateNewRecurringGiftInfo(Int64 APartnerKey, ref GiftBatchTDS AGiftDS, TDataBase ADataBase = null)
{
TDataBase db = DBAccess.Connect("CreateNewRecurringGiftInfo", ADataBase);
bool NewTransaction;
TDBTransaction Transaction = db.GetNewOrExistingTransaction(IsolationLevel.ReadCommitted, out NewTransaction);
ALedgerAccess.LoadAll(AGiftDS, Transaction);
AGiftDS = TGiftTransactionWebConnector.CreateARecurringGiftBatch(AGiftDS.ALedger[0].LedgerNumber, db);
if (NewTransaction)
{
Transaction.Rollback();
}
// Create a new RecurringGiftBatch
ARecurringGiftBatchRow Batch = AGiftDS.ARecurringGiftBatch[0];
Batch.BankAccountCode = "6000";
Batch.CurrencyCode = "EUR";
// Create a new RecurringGift record
ARecurringGiftRow RecurringGift = AGiftDS.ARecurringGift.NewRowTyped();
RecurringGift.LedgerNumber = Batch.LedgerNumber;
RecurringGift.BatchNumber = Batch.BatchNumber;
RecurringGift.GiftTransactionNumber = 1;
RecurringGift.DonorKey = APartnerKey;
AGiftDS.ARecurringGift.Rows.Add(RecurringGift);
// Create a new RecurringGiftDetail record
ARecurringGiftDetailRow RecurringGiftDetail = AGiftDS.ARecurringGiftDetail.NewRowTyped();
RecurringGiftDetail.LedgerNumber = Batch.LedgerNumber;
RecurringGiftDetail.BatchNumber = Batch.BatchNumber;
RecurringGiftDetail.GiftTransactionNumber = 1;
RecurringGiftDetail.MotivationGroupCode = "GIFT";
RecurringGiftDetail.MotivationDetailCode = "SUPPORT";
RecurringGiftDetail.RecipientKey = 43000000;
RecurringGiftDetail.RecipientLedgerNumber = APartnerKey;
RecurringGiftDetail.GiftAmount = 10;
AGiftDS.ARecurringGiftDetail.Rows.Add(RecurringGiftDetail);
return(Batch);
}
private void SetupAccountAndCostCentreCombos(bool AActiveOnly = true, ARecurringGiftBatchRow ARow = null)
{
if (!FBatchLoaded || (FActiveOnly != AActiveOnly))
{
FActiveOnly = AActiveOnly;
cmbDetailBankCostCentre.Clear();
cmbDetailBankAccountCode.Clear();
TFinanceControls.InitialiseAccountList(ref cmbDetailBankAccountCode, FLedgerNumber, true, false, AActiveOnly, true, true);
TFinanceControls.InitialiseCostCentreList(ref cmbDetailBankCostCentre, FLedgerNumber, true, false, AActiveOnly, true, true);
if (ARow != null)
{
cmbDetailBankCostCentre.SetSelectedString(ARow.BankCostCentre, -1);
cmbDetailBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1);
}
}
}
private void PostDeleteManual(ARecurringGiftBatchRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
FDeleteLogicObject.PostDeleteManual(ARowToDelete,
AAllowDeletion,
ADeletionPerformed,
ACompletionMessage);
if (ADeletionPerformed)
{
UpdateChangeableStatus();
((TFrmRecurringGiftBatch)ParentForm).EnableTransactions((grdDetails.Rows.Count > 1));
SelectRowInGrid(FDeletedBatchRowIndex > 0 ? FDeletedBatchRowIndex : 1);
}
}
private void ShowDetailsManual(ARecurringGiftBatchRow ARow)
{
((TFrmRecurringGiftBatch)ParentForm).EnableTransactions(ARow != null);
if (ARow == null)
{
FSelectedBatchNumber = -1;
UpdateChangeableStatus();
txtDetailHashTotal.CurrencyCode = String.Empty;
return;
}
if (!FSubmitLogicObject.SubmittingInProgress)
{
bool activeOnly = false;
RefreshBankAccountAndCostCentreFilters(activeOnly, ARow);
}
FLedgerNumber = ARow.LedgerNumber;
FSelectedBatchNumber = ARow.BatchNumber;
FPetraUtilsObject.DetailProtectedMode = false;
UpdateChangeableStatus();
RefreshCurrencyRelatedControls();
//Check for inactive cost centre and/or account codes
if (!cmbDetailBankCostCentre.SetSelectedString(ARow.BankCostCentre, -1))
{
MessageBox.Show(String.Format(Catalog.GetString("Batch {0} - the Cost Centre: '{1}' is no longer active and so cannot be used."),
ARow.BatchNumber,
ARow.BankCostCentre),
Catalog.GetString("Recurring Gift Batch"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
if (!cmbDetailBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1))
{
MessageBox.Show(String.Format(Catalog.GetString("Batch {0} - the Bank Account: '{1}' is no longer active and so cannot be used."),
ARow.BatchNumber,
ARow.BankAccountCode),
Catalog.GetString("Recurring Gift Batch"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void ParseHashTotal(ARecurringGiftBatchRow ARow)
{
decimal CorrectHashValue = 0m;
if ((txtDetailHashTotal.NumberValueDecimal != null) && txtDetailHashTotal.NumberValueDecimal.HasValue)
{
CorrectHashValue = txtDetailHashTotal.NumberValueDecimal.Value;
}
else
{
ARow.HashTotal = 0m;
}
if (ARow.HashTotal != CorrectHashValue)
{
ARow.HashTotal = CorrectHashValue;
txtDetailHashTotal.NumberValueDecimal = CorrectHashValue;
FPetraUtilsObject.SetChangedFlag();
}
}
/// <summary>
/// Update the dictionary that stores all unposted batches
/// and whether or not they have been warned about inactive
/// fields
/// </summary>
/// <param name="ABatchNumberToExclude"></param>
public void UpdateRecurringBatchDictionary(int ABatchNumberToExclude = 0)
{
if (ABatchNumberToExclude > 0)
{
FRecurringBatchesVerifiedOnSavingDict.Remove(ABatchNumberToExclude);
}
DataView BatchDV = new DataView(FMainDS.ARecurringGiftBatch);
foreach (DataRowView bRV in BatchDV)
{
ARecurringGiftBatchRow br = (ARecurringGiftBatchRow)bRV.Row;
int currentBatch = br.BatchNumber;
if ((currentBatch != ABatchNumberToExclude) && !FRecurringBatchesVerifiedOnSavingDict.ContainsKey(currentBatch))
{
FRecurringBatchesVerifiedOnSavingDict.Add(br.BatchNumber, false);
}
}
}
/// <summary>
/// create a new batch with a consecutive batch number in the ledger
/// for call inside a server function
/// for performance reasons submitting (save the data in the database) is done later (not here)
/// </summary>
/// <param name="MainDS"></param>
/// <param name="Transaction"></param>
/// <param name="LedgerTable"></param>
/// <param name="ALedgerNumber"></param>
/// <returns>the new gift batch row</returns>
public static ARecurringGiftBatchRow CreateANewRecurringGiftBatchRow(ref GiftBatchTDS MainDS,
ref TDBTransaction Transaction,
ref ALedgerTable LedgerTable,
Int32 ALedgerNumber)
{
GiftBatchTDS Temp = new GiftBatchTDS();
ARecurringGiftBatchAccess.LoadViaALedger(Temp, LedgerTable[0].LedgerNumber, Transaction);
DataView RecurringGiftBatchDV = new DataView(Temp.ARecurringGiftBatch);
RecurringGiftBatchDV.RowFilter = string.Empty;
RecurringGiftBatchDV.Sort = string.Format("{0} DESC",
ARecurringGiftBatchTable.GetBatchNumberDBName());
//Recurring batch numbers can be reused so check each time for current highest number
if (RecurringGiftBatchDV.Count > 0)
{
LedgerTable[0].LastRecGiftBatchNumber = (int)(RecurringGiftBatchDV[0][ARecurringGiftBatchTable.GetBatchNumberDBName()]);
}
else
{
LedgerTable[0].LastRecGiftBatchNumber = 0;
}
ARecurringGiftBatchRow NewRow = MainDS.ARecurringGiftBatch.NewRowTyped(true);
NewRow.LedgerNumber = ALedgerNumber;
NewRow.BatchNumber = ++LedgerTable[0].LastRecGiftBatchNumber;
NewRow.BatchDescription = Catalog.GetString("Please enter recurring batch description");
NewRow.BankAccountCode = TLedgerInfo.GetDefaultBankAccount(ALedgerNumber);
NewRow.BankCostCentre = TLedgerInfo.GetStandardCostCentre(ALedgerNumber);
NewRow.CurrencyCode = LedgerTable[0].BaseCurrency;
MainDS.ARecurringGiftBatch.Rows.Add(NewRow);
return(NewRow);
}
/// <summary>
/// load the gifts into the grid
/// </summary>
/// <param name="ALedgerNumber"></param>
/// <param name="ABatchNumber"></param>
/// <returns>True if new gift transactions were loaded, false if transactions had been loaded already.</returns>
public bool LoadRecurringGifts(Int32 ALedgerNumber, Int32 ABatchNumber)
{
FBatchRow = GetCurrentRecurringBatchRow();
if ((FBatchRow == null) && (GetAnyRecurringBatchRow(ABatchNumber) == null))
{
MessageBox.Show(String.Format("Cannot load transactions for Gift Batch {0} as the batch is not currently loaded!", ABatchNumber));
return false;
}
//Reset Batch method of payment variable
FBatchMethodOfPayment = ((TFrmRecurringGiftBatch)ParentForm).GetBatchControl().MethodOfPaymentCode;
bool firstLoad = (FLedgerNumber == -1);
if (firstLoad)
{
InitialiseControls();
}
//Check if the same batch is selected, so no need to apply filter
if ((FLedgerNumber == ALedgerNumber) && (FBatchNumber == ABatchNumber))
{
//Same as previously selected
if (GetSelectedRowIndex() > 0)
{
GetDetailsFromControls(GetSelectedDetailRow());
}
UpdateControlsProtection();
//TODO check if next line is needed.
//SetTextBoxOverlayOnKeyMinistryCombo();
return false;
}
//New set of transactions to be loaded
FTransactionsLoaded = false;
grdDetails.SuspendLayout();
FSuppressListChanged = true;
FLedgerNumber = ALedgerNumber;
FBatchNumber = ABatchNumber;
//Apply new filter
FPreviouslySelectedDetailRow = null;
grdDetails.DataSource = null;
// if this form is readonly, then we need all codes, because old codes might have been used
if (firstLoad || (FActiveOnly != this.Enabled))
{
FActiveOnly = this.Enabled;
TFinanceControls.InitialiseMotivationGroupList(ref cmbDetailMotivationGroupCode, FLedgerNumber, FActiveOnly);
TFinanceControls.InitialiseMotivationDetailList(ref cmbDetailMotivationDetailCode, FLedgerNumber, FActiveOnly);
TFinanceControls.InitialiseMethodOfGivingCodeList(ref cmbDetailMethodOfGivingCode, FActiveOnly);
TFinanceControls.InitialiseMethodOfPaymentCodeList(ref cmbDetailMethodOfPaymentCode, FActiveOnly);
TFinanceControls.InitialisePMailingList(ref cmbDetailMailingCode, FActiveOnly);
}
// This sets the incomplete filter but does check the panel enabled state
ShowData();
// This sets the main part of the filter but excluding the additional items set by the user GUI
// It gets the right sort order
SetGiftDetailDefaultView();
// only load from server if there are no transactions loaded yet for this batch
// otherwise we would overwrite transactions that have already been modified
if (FMainDS.ARecurringGiftDetail.DefaultView.Count == 0)
{
LoadGiftDataForBatch(ALedgerNumber, ABatchNumber);
}
// Now we set the full filter
FFilterAndFindObject.ApplyFilter();
UpdateRecordNumberDisplay();
FFilterAndFindObject.SetRecordNumberDisplayProperties();
SelectRowInGrid(1);
UpdateControlsProtection();
FSuppressListChanged = false;
grdDetails.ResumeLayout();
UpdateTotals();
if ((FPreviouslySelectedDetailRow != null))
{
bool disableSave = (FBatchRow.RowState == DataRowState.Unchanged && !FPetraUtilsObject.HasChanges);
if (disableSave && FPetraUtilsObject.HasChanges && !((TFrmRecurringGiftBatch)ParentForm).BatchColumnsHaveChanged(FBatchRow))
{
FPetraUtilsObject.DisableSaveButton();
}
}
FTransactionsLoaded = true;
return true;
}
private void ValidateDataDetailsManual(ARecurringGiftDetailRow ARow)
{
FBatchRow = GetRecurringBatchRow();
if ((ARow == null) || (FBatchRow == null) || (FBatchRow.BatchNumber != ARow.BatchNumber))
{
return;
}
TVerificationResultCollection VerificationResultCollection = FPetraUtilsObject.VerificationResultCollection;
TSharedFinanceValidation_Gift.ValidateRecurringGiftDetailManual(this, ARow, ref VerificationResultCollection,
FValidationControlsDict, Convert.ToInt64(txtDetailRecipientLedgerNumber.Text));
//It is necessary to validate the unbound control for date entered. This requires us to pass the control.
ARecurringGiftRow giftRow = GetRecurringGiftRow(ARow.GiftTransactionNumber);
TSharedFinanceValidation_Gift.ValidateRecurringGiftManual(this,
giftRow,
ref VerificationResultCollection,
FValidationControlsDict);
}
/// <summary>
/// Validates the Recurring Gift Batch data.
/// </summary>
/// <param name="AContext">Context that describes where the data validation failed.</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="AValidationControlsDict">A <see cref="TValidationControlsDict" /> containing the Controls that
/// display data that is about to be validated.</param>
/// <returns>True if the validation found no data validation errors, otherwise false.</returns>
public static bool ValidateRecurringGiftBatchManual(object AContext, ARecurringGiftBatchRow ARow,
ref TVerificationResultCollection AVerificationResultCollection, TValidationControlsDict AValidationControlsDict)
{
DataColumn ValidationColumn;
TValidationControlsData ValidationControlsData;
TVerificationResult VerificationResult;
object ValidationContext;
int VerifResultCollAddedCount = 0;
// Don't validate deleted DataRows
if (ARow.RowState == DataRowState.Deleted)
{
return true;
}
// Description cannot be empty
ValidationColumn = ARow.Table.Columns[ARecurringGiftBatchTable.ColumnBatchDescriptionId];
ValidationContext = String.Format("Description in Recurring Batch no.: {0}", ARow.BatchNumber); //ARow.BankAccountCode;
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = (TScreenVerificationResult)TStringChecks.StringMustNotBeEmpty(ARow.BatchDescription,
ValidationContext.ToString(),
AContext,
ValidationColumn,
ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if ((VerificationResult != null)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
// A Bank Account Code must be selected
ValidationColumn = ARow.Table.Columns[ARecurringGiftBatchTable.ColumnBankAccountCodeId];
ValidationContext = String.Format("Bank Account in Recurring Batch no.: {0}", ARow.BatchNumber); //ARow.BankAccountCode;
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = (TScreenVerificationResult)TStringChecks.StringMustNotBeEmpty(ARow.BankAccountCode,
ValidationContext.ToString(),
AContext,
ValidationColumn,
ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if ((VerificationResult != null)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
// A Bank Cost Centre Code must be selected
ValidationColumn = ARow.Table.Columns[ARecurringGiftBatchTable.ColumnBankCostCentreId];
ValidationContext = String.Format("Cost Centre in Recurring Batch no.: {0}", ARow.BatchNumber); //ARow.BankCostCentre;
if (AValidationControlsDict.TryGetValue(ValidationColumn, out ValidationControlsData))
{
VerificationResult = (TScreenVerificationResult)TStringChecks.StringMustNotBeEmpty(ARow.BankCostCentre,
ValidationContext.ToString(),
AContext,
ValidationColumn,
ValidationControlsData.ValidationControl);
// Handle addition/removal to/from TVerificationResultCollection
if ((VerificationResult != null)
&& AVerificationResultCollection.Auto_Add_Or_AddOrRemove(AContext, VerificationResult, ValidationColumn, true))
{
VerifResultCollAddedCount++;
}
}
return VerifResultCollAddedCount == 0;
}
private void UpdateControlsProtection(ARecurringGiftDetailRow ARow)
{
bool firstIsEnabled = (ARow != null) && (ARow.DetailNumber == 1);
bool pnlDetailsEnabledState = false;
chkDetailActive.Enabled = firstIsEnabled;
txtDetailDonorKey.Enabled = firstIsEnabled;
cmbDetailMethodOfGivingCode.Enabled = firstIsEnabled;
cmbDetailMethodOfPaymentCode.Enabled = firstIsEnabled && !BatchHasMethodOfPayment();
txtDetailReference.Enabled = firstIsEnabled;
cmbDetailReceiptLetterCode.Enabled = firstIsEnabled;
if (FBatchRow == null)
{
FBatchRow = GetCurrentRecurringBatchRow();
}
if (ARow == null)
{
PnlDetailsProtected = true;
}
else
{
PnlDetailsProtected = (ARow != null
&& ARow.GiftAmount < 0
); // taken from old petra
}
pnlDetailsEnabledState = (!PnlDetailsProtected && grdDetails.Rows.Count > 1);
pnlDetails.Enabled = pnlDetailsEnabledState;
btnDelete.Enabled = pnlDetailsEnabledState;
}
/// <summary>
/// update the transaction method payment from outside
/// </summary>
public void UpdateMethodOfPayment(bool ACalledLocally)
{
Int32 LedgerNumber;
Int32 BatchNumber;
if (ACalledLocally)
{
cmbDetailMethodOfPaymentCode.SetSelectedString(FBatchMethodOfPayment);
return;
}
if (!((TFrmRecurringGiftBatch) this.ParentForm).GetBatchControl().FBatchLoaded)
{
return;
}
FBatchRow = GetCurrentRecurringBatchRow();
if (FBatchRow == null)
{
FBatchRow = ((TFrmRecurringGiftBatch) this.ParentForm).GetBatchControl().GetSelectedDetailRow();
}
FBatchMethodOfPayment = ((TFrmRecurringGiftBatch) this.ParentForm).GetBatchControl().MethodOfPaymentCode;
LedgerNumber = FBatchRow.LedgerNumber;
BatchNumber = FBatchRow.BatchNumber;
if (!LoadGiftDataForBatch(LedgerNumber, BatchNumber))
{
return;
}
if ((FLedgerNumber == LedgerNumber) || (FBatchNumber == BatchNumber))
{
//Rows already active in transaction tab. Need to set current row ac code below will not update selected row
if (FPreviouslySelectedDetailRow != null)
{
FPreviouslySelectedDetailRow.MethodOfPaymentCode = FBatchMethodOfPayment;
cmbDetailMethodOfPaymentCode.SetSelectedString(FBatchMethodOfPayment);
}
}
//Update all transactions
foreach (ARecurringGiftRow recurringGiftRow in FMainDS.ARecurringGift.Rows)
{
if (recurringGiftRow.BatchNumber.Equals(BatchNumber) && recurringGiftRow.LedgerNumber.Equals(LedgerNumber)
&& (recurringGiftRow.MethodOfPaymentCode != FBatchMethodOfPayment))
{
recurringGiftRow.MethodOfPaymentCode = FBatchMethodOfPayment;
}
}
}
private void ShowDetailsManual(ARecurringGiftBatchRow ARow)
{
((TFrmRecurringGiftBatch)ParentForm).EnableTransactions(ARow != null);
if (ARow == null)
{
FSelectedBatchNumber = -1;
UpdateChangeableStatus();
return;
}
RefreshBankAccountAndCostCentreFilters(FActiveOnly, ARow);
FLedgerNumber = ARow.LedgerNumber;
FSelectedBatchNumber = ARow.BatchNumber;
FPetraUtilsObject.DetailProtectedMode = false;
UpdateChangeableStatus();
RefreshCurrencyControls(FPreviouslySelectedDetailRow.CurrencyCode);
//Check for inactive cost centre and/or account codes
if (!cmbDetailBankCostCentre.SetSelectedString(ARow.BankCostCentre, -1))
{
MessageBox.Show(String.Format(Catalog.GetString("Batch {0} - the Cost Centre: '{1}' is no longer active and so cannot be used."),
ARow.BatchNumber,
ARow.BankCostCentre),
Catalog.GetString("Recurring Gift Batch"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
if (!cmbDetailBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1))
{
MessageBox.Show(String.Format(Catalog.GetString("Batch {0} - the Bank Account: '{1}' is no longer active and so cannot be used."),
ARow.BatchNumber,
ARow.BankAccountCode),
Catalog.GetString("Recurring Gift Batch"), MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
/// <summary>
/// Refresh the dataset for this form
/// </summary>
public void RefreshData()
{
if ((FMainDS != null) && (FMainDS.ARecurringGiftDetail != null))
{
FMainDS.ARecurringGiftDetail.Rows.Clear();
}
FBatchRow = GetCurrentRecurringBatchRow();
if (FBatchRow != null)
{
LoadRecurringGifts(FBatchRow.LedgerNumber, FBatchRow.BatchNumber);
}
}
private void ParseHashTotal(ARecurringGiftBatchRow ARow)
{
decimal correctHashValue;
if ((txtDetailHashTotal.NumberValueDecimal == null) || !txtDetailHashTotal.NumberValueDecimal.HasValue)
{
correctHashValue = 0m;
}
else
{
correctHashValue = txtDetailHashTotal.NumberValueDecimal.Value;
}
txtDetailHashTotal.NumberValueDecimal = correctHashValue;
ARow.HashTotal = correctHashValue;
}
private void RefreshBankAccountAndCostCentreFilters(bool AActiveOnly, ARecurringGiftBatchRow ARow = null)
{
if (FActiveOnly != AActiveOnly)
{
FActiveOnly = AActiveOnly;
cmbDetailBankAccountCode.Filter = TFinanceControls.PrepareAccountFilter(true, false, AActiveOnly, true, "");
cmbDetailBankCostCentre.Filter = TFinanceControls.PrepareCostCentreFilter(true, false, AActiveOnly, true);
if (ARow != null)
{
cmbDetailBankCostCentre.SetSelectedString(ARow.BankCostCentre, -1);
cmbDetailBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1);
}
}
}
/// <summary>
/// Check if batch columns have actually changed
/// </summary>
/// <param name="ARecurringBatchRow"></param>
/// <returns></returns>
public bool BatchColumnsHaveChanged(ARecurringGiftBatchRow ARecurringBatchRow)
{
bool RetVal = false;
if (ARecurringBatchRow.RowState != DataRowState.Unchanged)
{
bool columnValueChanged = false;
for (int i = 0; i < FMainDS.ARecurringGiftBatch.Columns.Count; i++)
{
string originalValue = ARecurringBatchRow[i, DataRowVersion.Original].ToString();
string currentValue = ARecurringBatchRow[i, DataRowVersion.Current].ToString();
if (originalValue != currentValue)
{
columnValueChanged = true;
break;
}
}
if (!columnValueChanged)
{
ARecurringBatchRow.RejectChanges();
}
RetVal = columnValueChanged;
}
return RetVal;
}
/// <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(ARecurringGiftBatchRow ARowToDelete, ref string ACompletionMessage)
{
bool DeletionSuccessful = false;
if (ARowToDelete == null)
{
return DeletionSuccessful;
}
int BatchNumber = ARowToDelete.BatchNumber;
ACompletionMessage = string.Empty;
bool RowToDeleteIsNew = (ARowToDelete.RowState == DataRowState.Added);
//Backup the Dataset for reversion purposes
GiftBatchTDS BackupMainDS = (GiftBatchTDS)FMainDS.Copy();
BackupMainDS.Merge(FMainDS);
if (!RowToDeleteIsNew)
{
//Return modified row to last saved state to avoid validation failures
ARowToDelete.RejectChanges();
ShowDetails(ARowToDelete);
if (!((TFrmRecurringGiftBatch)FPetraUtilsObject.GetForm()).SaveChangesManual(TExtraGiftBatchChecks.GiftBatchAction.DELETING))
{
MessageBox.Show(Catalog.GetString("Error in trying to save prior to deleting current recurring gift batch!"),
Catalog.GetString("Deletion Error"),
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return DeletionSuccessful;
}
}
try
{
this.Cursor = Cursors.WaitCursor;
ACompletionMessage = String.Format(Catalog.GetString("Batch no.: {0} deleted successfully."),
BatchNumber);
//clear any transactions currently being editied in the Transaction Tab
((TFrmRecurringGiftBatch)ParentForm).GetTransactionsControl().ClearCurrentSelection();
if (!RowToDeleteIsNew)
{
//Load tables afresh
FMainDS.Merge(TRemote.MFinance.Gift.WebConnectors.LoadRecurringGiftTransactionsForBatch(FLedgerNumber, BatchNumber));
}
((TFrmRecurringGiftBatch)ParentForm).GetTransactionsControl().DeleteCurrentRecurringBatchGiftData(BatchNumber);
// Delete the recurring batch row.
ARowToDelete.Delete();
FPreviouslySelectedDetailRow = null;
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 SetupAccountAndCostCentreCombos(bool AActiveOnly = true, ARecurringGiftBatchRow ARow = null)
{
if (!FBatchLoaded || (FActiveOnly != AActiveOnly))
{
FActiveOnly = AActiveOnly;
cmbDetailBankCostCentre.Clear();
cmbDetailBankAccountCode.Clear();
TFinanceControls.InitialiseAccountList(ref cmbDetailBankAccountCode, FLedgerNumber, true, false, AActiveOnly, true, true);
TFinanceControls.InitialiseCostCentreList(ref cmbDetailBankCostCentre, FLedgerNumber, true, false, AActiveOnly, true, true);
if (ARow != null)
{
cmbDetailBankCostCentre.SetSelectedString(ARow.BankCostCentre, -1);
cmbDetailBankAccountCode.SetSelectedString(ARow.BankAccountCode, -1);
}
}
}
/// <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(ARecurringGiftBatchRow ARowToDelete, ref string ACompletionMessage)
{
bool deletionSuccessful = false;
int batchNumber = ARowToDelete.BatchNumber;
bool newBatch = (ARowToDelete.RowState == DataRowState.Added);
// first save any changes
if (!((TFrmRecurringGiftBatch)FPetraUtilsObject.GetForm()).SaveChangesManual(TExtraGiftBatchChecks.GiftBatchAction.DELETING))
{
return false;
}
try
{
ACompletionMessage = String.Format(Catalog.GetString("Batch no.: {0} deleted successfully."),
batchNumber);
//clear any transactions currently being editied in the Transaction Tab
((TFrmRecurringGiftBatch)ParentForm).GetTransactionsControl().ClearCurrentSelection();
if (!newBatch)
{
//Load tables afresh
FMainDS.Merge(TRemote.MFinance.Gift.WebConnectors.LoadRecurringGiftTransactionsForBatch(FLedgerNumber, batchNumber));
FMainDS.AcceptChanges();
}
((TFrmRecurringGiftBatch)ParentForm).GetTransactionsControl().DeleteCurrentRecurringBatchGiftData(batchNumber);
//Affect a change in the batch row, required by deletion process.
ARowToDelete.DateModified = DateTime.Now;
// Delete the recurring batch row.
ARowToDelete.Delete();
//FMainDS.AcceptChanges();
FPreviouslySelectedDetailRow = null;
deletionSuccessful = true;
}
catch (Exception ex)
{
ACompletionMessage = ex.Message;
MessageBox.Show(ex.Message,
"Deletion Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
UpdateRecordNumberDisplay();
return deletionSuccessful;
}
private void ValidateDataDetailsManual(ARecurringGiftBatchRow ARow)
{
if (ARow == null)
{
return;
}
TVerificationResultCollection VerificationResultCollection = FPetraUtilsObject.VerificationResultCollection;
//Hash total special case in view of the textbox handling
ParseHashTotal(ARow);
TSharedFinanceValidation_Gift.ValidateRecurringGiftBatchManual(this, ARow, ref VerificationResultCollection,
FValidationControlsDict);
}
/// <summary>
/// Main method to Submit a specified batch
/// </summary>
/// <param name="ACurrentRecurringBatchRow">The batch row to Submit</param>
/// <param name="AWarnOfInactiveValues">True means user is warned if inactive values exist</param>
/// <param name="ADonorZeroIsValid"></param>
/// <param name="ARecipientZeroIsValid"></param>
/// <returns>True if the batch was successfully Submited</returns>
public bool SubmitBatch(ARecurringGiftBatchRow ACurrentRecurringBatchRow,
bool AWarnOfInactiveValues = true,
bool ADonorZeroIsValid = false,
bool ARecipientZeroIsValid = false)
{
if (ACurrentRecurringBatchRow == null)
{
return(false);
}
FSelectedBatchNumber = ACurrentRecurringBatchRow.BatchNumber;
//Make sure that all control data is in dataset
FMyForm.GetLatestControlData();
//Copy all batch data to new table
GiftBatchTDSARecurringGiftDetailTable RecurringBatchGiftDetails = new GiftBatchTDSARecurringGiftDetailTable();
//Filter ARecurringGiftDetail
DataView RecurringGiftDetailDV = new DataView(FMainDS.ARecurringGiftDetail);
RecurringGiftDetailDV.RowFilter = string.Format("{0}={1}",
ARecurringGiftDetailTable.GetBatchNumberDBName(),
FSelectedBatchNumber);
RecurringGiftDetailDV.Sort = string.Format("{0} ASC, {1} ASC, {2} ASC",
ARecurringGiftDetailTable.GetBatchNumberDBName(),
ARecurringGiftDetailTable.GetGiftTransactionNumberDBName(),
ARecurringGiftDetailTable.GetDetailNumberDBName());
foreach (DataRowView dRV in RecurringGiftDetailDV)
{
GiftBatchTDSARecurringGiftDetailRow rGBR = (GiftBatchTDSARecurringGiftDetailRow)dRV.Row;
RecurringBatchGiftDetails.Rows.Add((object[])rGBR.ItemArray.Clone());
}
//Save and check for inactive values and ex-workers and anonymous gifts
if (FPetraUtilsObject.HasChanges)
{
//Keep this conditional check separate from the one above so that it only gets called
// when necessary and doesn't result in the executon of the same method
if (!FMyForm.SaveChangesForSubmitting(RecurringBatchGiftDetails))
{
return(false);
}
}
else
{
//This has to be called here because if there are no changes then the DataSavingValidating
// method which calls the method below, will not run.
if (!FMyForm.GetBatchControl().AllowInactiveFieldValues(TExtraGiftBatchChecks.GiftBatchAction.SUBMITTING) ||
FMyForm.GiftHasExWorkerOrAnon(RecurringBatchGiftDetails)
)
{
return(false);
}
}
//Check hash total validity
if ((ACurrentRecurringBatchRow.HashTotal != 0) &&
(ACurrentRecurringBatchRow.BatchTotal != ACurrentRecurringBatchRow.HashTotal))
{
MessageBox.Show(String.Format(Catalog.GetString(
"The recurring gift batch total ({0}) for batch {1} does not equal the hash total ({2})."),
StringHelper.FormatUsingCurrencyCode(ACurrentRecurringBatchRow.BatchTotal, ACurrentRecurringBatchRow.CurrencyCode),
ACurrentRecurringBatchRow.BatchNumber,
StringHelper.FormatUsingCurrencyCode(ACurrentRecurringBatchRow.HashTotal, ACurrentRecurringBatchRow.CurrencyCode)),
"Submit Recurring Gift Batch");
FMyForm.GetBatchControl().Controls["txtDetailHashTotal"].Focus();
FMyForm.GetBatchControl().Controls["txtDetailHashTotal"].Select();
return(false);
}
//Check for zero Donors or Recipients
if (!ADonorZeroIsValid)
{
DataView recurringBatchGiftDV = new DataView(FMainDS.ARecurringGift);
recurringBatchGiftDV.RowFilter = string.Format("{0}={1} And {2}=0",
ARecurringGiftTable.GetBatchNumberDBName(),
FSelectedBatchNumber,
ARecurringGiftTable.GetDonorKeyDBName());
int numDonorZeros = recurringBatchGiftDV.Count;
if (numDonorZeros > 0)
{
string messageListOfOffendingGifts =
String.Format(Catalog.GetString(
"Recurring Gift Batch {0} contains {1} gift detail(s) with Donor 0000000. Please fix before posting!{2}{2}"),
FSelectedBatchNumber,
numDonorZeros,
Environment.NewLine);
string listOfOffendingRows = string.Empty;
listOfOffendingRows += "Gift" + Environment.NewLine;
listOfOffendingRows += "------------";
foreach (DataRowView drv in recurringBatchGiftDV)
{
ARecurringGiftRow giftRow = (ARecurringGiftRow)drv.Row;
listOfOffendingRows += String.Format("{0}{1:0000}",
Environment.NewLine,
giftRow.GiftTransactionNumber);
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
extendedMessageBox.ShowDialog((messageListOfOffendingGifts + listOfOffendingRows),
Catalog.GetString("Submit Batch Error"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiWarning);
return(false);
}
}
if (!ARecipientZeroIsValid)
{
DataView recurringBatchGiftDetailsDV = new DataView(FMainDS.ARecurringGiftDetail);
recurringBatchGiftDetailsDV.RowFilter = string.Format("{0}={1} And {2}=0",
ARecurringGiftDetailTable.GetBatchNumberDBName(),
FSelectedBatchNumber,
ARecurringGiftDetailTable.GetRecipientKeyDBName());
int numRecipientZeros = recurringBatchGiftDetailsDV.Count;
if (numRecipientZeros > 0)
{
string messageListOfOffendingGifts =
String.Format(Catalog.GetString(
"Recurring Gift Batch {0} contains {1} gift detail(s) with Recipient 0000000. Please fix before posting!{2}{2}"),
FSelectedBatchNumber,
numRecipientZeros,
Environment.NewLine);
string listOfOffendingRows = string.Empty;
listOfOffendingRows += "Gift Detail" + Environment.NewLine;
listOfOffendingRows += "-------------------";
foreach (DataRowView drv in recurringBatchGiftDetailsDV)
{
ARecurringGiftDetailRow giftDetailRow = (ARecurringGiftDetailRow)drv.Row;
listOfOffendingRows += String.Format("{0}{1:0000} {2:00}",
Environment.NewLine,
giftDetailRow.GiftTransactionNumber,
giftDetailRow.DetailNumber);
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FMyForm);
extendedMessageBox.ShowDialog((messageListOfOffendingGifts + listOfOffendingRows),
Catalog.GetString("Submit Batch Error"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbOK,
TFrmExtendedMessageBox.TIcon.embiWarning);
return(false);
}
}
//Check for inactive KeyMinistries
DataTable GiftsWithInactiveKeyMinistries;
if (TRemote.MFinance.Gift.WebConnectors.InactiveKeyMinistriesFoundInBatch(FLedgerNumber, FSelectedBatchNumber,
out GiftsWithInactiveKeyMinistries, true))
{
int numInactiveValues = GiftsWithInactiveKeyMinistries.Rows.Count;
string listOfOffendingRows =
String.Format(Catalog.GetString(
"{0} inactive key ministries found in Recurring Gift Batch {1}. Do you still want to submit?{2}{2}"),
numInactiveValues,
FSelectedBatchNumber,
Environment.NewLine);
listOfOffendingRows += "Gift Detail Recipient KeyMinistry" + Environment.NewLine;
listOfOffendingRows += "-------------------------------------------------------------------------------";
foreach (DataRow dr in GiftsWithInactiveKeyMinistries.Rows)
{
listOfOffendingRows += String.Format("{0}{1:0000} {2:00} {3:00000000000} {4}",
Environment.NewLine,
dr[0],
dr[1],
dr[2],
dr[3]);
}
TFrmExtendedMessageBox extendedMessageBox = new TFrmExtendedMessageBox(FPetraUtilsObject.GetForm());
if (extendedMessageBox.ShowDialog(listOfOffendingRows.ToString(),
Catalog.GetString("Submit Batch"), string.Empty,
TFrmExtendedMessageBox.TButtons.embbYesNo,
TFrmExtendedMessageBox.TIcon.embiWarning) != TFrmExtendedMessageBox.TResult.embrYes)
{
return(false);
}
}
TFrmRecurringGiftBatchSubmit SubmitForm = new TFrmRecurringGiftBatchSubmit(FPetraUtilsObject.GetForm());
try
{
FMyForm.ShowInTaskbar = false;
SubmitForm.MainDS = FMainDS;
SubmitForm.BatchRow = ACurrentRecurringBatchRow;
SubmitForm.ShowDialog();
}
finally
{
SubmitForm.Dispose();
FMyForm.ShowInTaskbar = true;
}
return(true);
}
/// <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(ARecurringGiftBatchRow ARowToDelete,
bool AAllowDeletion,
bool ADeletionPerformed,
string ACompletionMessage)
{
/*Code to execute after the delete has occurred*/
if (ADeletionPerformed && (ACompletionMessage.Length > 0))
{
//causes saving issues
//UpdateLedgerTableSettings();
if (((TFrmRecurringGiftBatch) this.ParentForm).SaveChangesManual())
{
MessageBox.Show(ACompletionMessage, Catalog.GetString("Deletion Completed"));
}
else
{
MessageBox.Show("Unable to save after deletion of batch! Try saving manually and closing and reopening the form.");
}
}
else if (!AAllowDeletion)
{
//message to user
}
else if (!ADeletionPerformed)
{
//message to user
}
UpdateChangeableStatus();
((TFrmRecurringGiftBatch)ParentForm).EnableTransactions((grdDetails.Rows.Count > 1));
SelectRowInGrid(grdDetails.GetFirstHighlightedRowIndex());
}
