/// <summary>
/// Handles the GridReorder event of the rGridTransactions control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="GridReorderEventArgs"/> instance containing the event data.</param>
private void rGridTransactions_GridReorder(object sender, GridReorderEventArgs e)
{
var batchService = new Rock.Model.FinancialTransactionService();
var queryable = batchService.Queryable();
List <Rock.Model.FinancialTransaction> items = queryable.ToList();
batchService.Reorder(items, e.OldIndex, e.NewIndex, CurrentPersonId);
BindGrid();
}
/// <summary>
/// Handles the SaveClick event of the dlgReassign control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void dlgReassign_SaveClick( object sender, EventArgs e )
{
if ( _canEdit && _person != null )
{
int? personAliasId = ppReassign.PersonAliasId;
var txnsSelected = new List<int>();
gTransactions.SelectedKeys.ToList().ForEach( b => txnsSelected.Add( b.ToString().AsInteger() ) );
if ( txnsSelected.Any() && personAliasId.HasValue )
{
var rockContext = new RockContext();
var txnService = new FinancialTransactionService( rockContext );
var txnsToUpdate = txnService.Queryable( "AuthorizedPersonAlias.Person" )
.Where( t => txnsSelected.Contains( t.Id ) )
.ToList();
foreach ( var txn in txnsToUpdate )
{
txn.AuthorizedPersonAliasId = personAliasId.Value;
}
rockContext.SaveChanges();
}
}
HideDialog();
BindGrid();
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
RockContext rockContext = new RockContext();
FinancialTransactionService transService = new FinancialTransactionService( rockContext );
// get list of selected accounts
List<int> selectedAccountIds = cblAccounts.Items.Cast<ListItem>()
.Where( i => i.Selected == true )
.Select( i => int.Parse( i.Value ) ).ToList();
var qry = transService.Queryable("TransactionDetails.Account")
.Where( t => t.TransactionDetails.Any( d => selectedAccountIds.Contains( d.AccountId ) )
&& t.AuthorizedPerson.GivingGroupId == CurrentPerson.GivingGroupId );
if (drpFilterDates.LowerValue.HasValue) {
qry = qry.Where(t => t.TransactionDateTime.Value >= drpFilterDates.LowerValue.Value);
}
if ( drpFilterDates.UpperValue.HasValue )
{
var lastDate = drpFilterDates.UpperValue.Value.AddDays( 1 ); // add one day to ensure we get all transactions till midnight
qry = qry.Where( t => t.TransactionDateTime.Value < lastDate );
}
gTransactions.DataSource = qry.ToList();
gTransactions.DataBind();
// get account totals
Dictionary<string, decimal> accountTotals = new Dictionary<string, decimal>();
foreach ( var transaction in qry.ToList() )
{
foreach ( var transactionDetail in transaction.TransactionDetails )
{
if ( accountTotals.Keys.Contains( transactionDetail.Account.Name ) )
{
accountTotals[transactionDetail.Account.Name] += transactionDetail.Amount;
}
else
{
accountTotals.Add( transactionDetail.Account.Name, transactionDetail.Amount );
}
}
}
if ( accountTotals.Count > 0 )
{
pnlSummary.Visible = true;
foreach ( var key in accountTotals.Keys )
{
lAccountSummary.Text += String.Format( "<li>{0}: ${1}</li>", key, accountTotals[key] );
}
}
else
{
pnlSummary.Visible = false;
}
}
/// <summary>
/// Processes the payments and returns a summary in HTML format
/// </summary>
/// <param name="gateway">The gateway.</param>
/// <param name="batchNamePrefix">The batch name prefix.</param>
/// <param name="payments">The payments.</param>
/// <param name="batchUrlFormat">The batch URL format.</param>
/// <param name="receiptEmail">The receipt email.</param>
/// <param name="failedPaymentEmail">The failed payment email.</param>
/// <param name="failedPaymentWorkflowType">Type of the failed payment workflow.</param>
/// <param name="verboseLogging">If <c>true</c> then additional details will be logged.</param>
/// <returns></returns>
public static string ProcessPayments(FinancialGateway gateway, string batchNamePrefix, List <Payment> payments, string batchUrlFormat,
Guid?receiptEmail, Guid?failedPaymentEmail, Guid?failedPaymentWorkflowType, bool verboseLogging)
{
int totalPayments = 0;
int totalAlreadyDownloaded = 0;
// If there is a payment without a transaction, but has one of the following status, don't report it as a 'unmatched' transaction.
// If they have one of these statuses, and can't be matched, the user probably closed the browser or walked away before completing the transaction.
string[] ignorableUnMatchedStatuses = new string[2] {
"in_progress", "abandoned"
};
List <Payment> paymentsWithoutTransaction = new List <Payment>();
int totalAdded = 0;
int totalReversals = 0;
int totalFailures = 0;
int totalStatusChanges = 0;
var batchSummary = new Dictionary <Guid, List <Decimal> >();
var newTransactionsForReceiptEmails = new List <FinancialTransaction>();
var failedPayments = new List <FinancialTransaction>();
var contributionTxnType = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid());
int?defaultAccountId = null;
using (var rockContext2 = new RockContext())
{
defaultAccountId = new FinancialAccountService(rockContext2).Queryable()
.Where(a =>
a.IsActive &&
!a.ParentAccountId.HasValue &&
(!a.StartDate.HasValue || a.StartDate.Value <= RockDateTime.Now) &&
(!a.EndDate.HasValue || a.EndDate.Value >= RockDateTime.Now)
)
.OrderBy(a => a.Order)
.Select(a => a.Id)
.FirstOrDefault();
}
var batchTxnChanges = new Dictionary <Guid, List <string> >();
var batchBatchChanges = new Dictionary <Guid, List <string> >();
var scheduledTransactionIds = new List <int>();
List <FinancialTransaction> transactionsWithAttributes = new List <FinancialTransaction>();
foreach (var payment in payments.Where(p => p.Amount > 0.0M))
{
using (var rockContext = new RockContext())
{
totalPayments++;
var financialTransactionService = new FinancialTransactionService(rockContext);
FinancialTransaction originalTxn = null;
List <FinancialTransaction> txns = null;
// Find existing payments with same transaction code as long as it is not blank.
if (payment.TransactionCode.IsNotNullOrWhiteSpace())
{
txns = financialTransactionService
.Queryable("TransactionDetails")
.Where(t =>
t.FinancialGatewayId.HasValue &&
t.FinancialGatewayId.Value == gateway.Id &&
t.TransactionCode == payment.TransactionCode)
.ToList();
originalTxn = txns.Any() ? txns.OrderBy(t => t.Id).First() : null;
}
FinancialScheduledTransaction scheduledTransaction = null;
// We don't want to match a blank schedule ID, so if we don't have one then scheduledTransaction will stay NULL
if (payment.GatewayScheduleId.IsNotNullOrWhiteSpace())
{
scheduledTransaction = new FinancialScheduledTransactionService(rockContext).GetByScheduleId(payment.GatewayScheduleId, gateway.Id);
}
// Calculate whether a transaction needs to be added
var txnAmount = CalculateTransactionAmount(payment, txns);
if (txnAmount != 0.0M || (payment.IsFailure && originalTxn == null && scheduledTransaction != null))
{
// Verify that the payment is for an existing scheduled transaction, or has the same transaction code as an existing payment
if (scheduledTransaction != null || originalTxn != null)
{
var transaction = new FinancialTransaction();
transaction.Guid = Guid.NewGuid();
transaction.TransactionCode = payment.TransactionCode;
transaction.TransactionDateTime = payment.TransactionDateTime;
transaction.Status = payment.Status;
transaction.IsSettled = payment.IsSettled;
transaction.SettledGroupId = payment.SettledGroupId;
transaction.SettledDate = payment.SettledDate;
transaction.StatusMessage = payment.StatusMessage;
transaction.FinancialPaymentDetail = new FinancialPaymentDetail();
if (payment.ForeignKey.IsNotNullOrWhiteSpace())
{
transaction.ForeignKey = payment.ForeignKey;
}
FinancialPaymentDetail financialPaymentDetail = null;
List <ITransactionDetail> originalTxnDetails = new List <ITransactionDetail>();
if (scheduledTransaction != null)
{
scheduledTransactionIds.Add(scheduledTransaction.Id);
if (payment.ScheduleActive.HasValue)
{
scheduledTransaction.IsActive = payment.ScheduleActive.Value;
}
transaction.ScheduledTransactionId = scheduledTransaction.Id;
transaction.AuthorizedPersonAliasId = scheduledTransaction.AuthorizedPersonAliasId;
transaction.SourceTypeValueId = scheduledTransaction.SourceTypeValueId;
financialPaymentDetail = scheduledTransaction.FinancialPaymentDetail;
scheduledTransaction.ScheduledTransactionDetails.ToList().ForEach(d => originalTxnDetails.Add(d));
}
else
{
transaction.AuthorizedPersonAliasId = originalTxn.AuthorizedPersonAliasId;
transaction.SourceTypeValueId = originalTxn.SourceTypeValueId;
financialPaymentDetail = originalTxn.FinancialPaymentDetail;
originalTxn.TransactionDetails.ToList().ForEach(d => originalTxnDetails.Add(d));
}
transaction.FinancialGatewayId = gateway.Id;
transaction.TransactionTypeValueId = contributionTxnType.Id;
if (txnAmount < 0.0M)
{
transaction.Summary = "Reversal created for previous transaction(s) to correct the total transaction amount." + Environment.NewLine;
}
// Set the attributes of the transaction
if (payment.Attributes != null && payment.Attributes.Count > 0)
{
transaction.LoadAttributes();
foreach (var attribute in payment.Attributes)
{
transaction.SetAttributeValue(attribute.Key, attribute.Value);
}
transactionsWithAttributes.Add(transaction);
}
var currencyTypeValue = payment.CurrencyTypeValue;
var creditCardTypevalue = payment.CreditCardTypeValue;
if (financialPaymentDetail != null)
{
if (currencyTypeValue == null && financialPaymentDetail.CurrencyTypeValueId.HasValue)
{
currencyTypeValue = DefinedValueCache.Get(financialPaymentDetail.CurrencyTypeValueId.Value);
}
if (creditCardTypevalue == null && financialPaymentDetail.CreditCardTypeValueId.HasValue)
{
creditCardTypevalue = DefinedValueCache.Get(financialPaymentDetail.CreditCardTypeValueId.Value);
}
transaction.FinancialPaymentDetail.AccountNumberMasked = financialPaymentDetail.AccountNumberMasked;
transaction.FinancialPaymentDetail.NameOnCard = financialPaymentDetail.NameOnCard;
transaction.FinancialPaymentDetail.ExpirationMonth = financialPaymentDetail.ExpirationMonth;
transaction.FinancialPaymentDetail.ExpirationYear = financialPaymentDetail.ExpirationYear;
transaction.FinancialPaymentDetail.BillingLocationId = financialPaymentDetail.BillingLocationId;
if (financialPaymentDetail.GatewayPersonIdentifier.IsNullOrWhiteSpace())
{
// if Rock doesn't have the GatewayPersonIdentifier, get it from the downloaded payment (if it has a value)
transaction.FinancialPaymentDetail.GatewayPersonIdentifier = payment.GatewayPersonIdentifier;
}
else
{
transaction.FinancialPaymentDetail.GatewayPersonIdentifier = financialPaymentDetail.GatewayPersonIdentifier;
}
transaction.FinancialPaymentDetail.FinancialPersonSavedAccountId = financialPaymentDetail.FinancialPersonSavedAccountId;
}
if (currencyTypeValue != null)
{
transaction.FinancialPaymentDetail.CurrencyTypeValueId = currencyTypeValue.Id;
}
if (creditCardTypevalue != null)
{
transaction.FinancialPaymentDetail.CreditCardTypeValueId = creditCardTypevalue.Id;
}
// Try to allocate the amount of the transaction based on the current scheduled transaction accounts
decimal remainingAmount = Math.Abs(txnAmount);
foreach (var detail in originalTxnDetails.Where(d => d.Amount != 0.0M))
{
if (remainingAmount <= 0.0M)
{
// If there's no amount left, break out of details
break;
}
var transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = detail.AccountId;
transactionDetail.EntityTypeId = detail.EntityTypeId;
transactionDetail.EntityId = detail.EntityId;
transactionDetail.FeeCoverageAmount = detail.FeeCoverageAmount;
if (detail.Amount <= remainingAmount)
{
// If the configured amount for this account is less than or equal to the remaining
// amount, allocate the configured amount
transactionDetail.Amount = detail.Amount;
remainingAmount -= detail.Amount;
}
else
{
// If the configured amount is greater than the remaining amount, only allocate
// the remaining amount
transaction.Summary += "Note: Downloaded transaction amount was less than the configured allocation amounts for the Scheduled Transaction.";
transactionDetail.Amount = remainingAmount;
transactionDetail.Summary = "Note: The downloaded amount was not enough to apply the configured amount to this account.";
remainingAmount = 0.0M;
}
transaction.TransactionDetails.Add(transactionDetail);
}
// If there's still amount left after allocating based on current config, add the remainder
// to the account that was configured for the most amount
if (remainingAmount > 0.0M)
{
transaction.Summary += "Note: Downloaded transaction amount was greater than the configured allocation amounts for the Scheduled Transaction.";
var transactionDetail = transaction.TransactionDetails
.OrderByDescending(d => d.Amount)
.FirstOrDefault();
if (transactionDetail == null && defaultAccountId.HasValue)
{
transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = defaultAccountId.Value;
transaction.TransactionDetails.Add(transactionDetail);
}
if (transactionDetail != null)
{
transactionDetail.Amount += remainingAmount;
transactionDetail.Summary = "Note: Extra amount was applied to this account.";
}
}
// If the amount to apply was negative, update all details to be negative (absolute value was used when allocating to accounts)
if (txnAmount < 0.0M)
{
foreach (var txnDetail in transaction.TransactionDetails)
{
txnDetail.Amount = 0 - txnDetail.Amount;
}
}
// Get the batch
var batchService = new FinancialBatchService(rockContext);
var batch = batchService.Get(
batchNamePrefix,
string.Empty,
currencyTypeValue,
creditCardTypevalue,
transaction.TransactionDateTime.Value,
gateway.GetBatchTimeOffset(),
gateway.BatchDayOfWeek);
if (batch.Id == 0)
{
// get a batch Id
rockContext.SaveChanges();
}
transaction.BatchId = batch.Id;
financialTransactionService.Add(transaction);
batchService.IncrementControlAmount(batch.Id, transaction.TotalAmount, null);
if (receiptEmail.HasValue && txnAmount > 0.0M)
{
newTransactionsForReceiptEmails.Add(transaction);
}
if (
payment.IsFailure &&
(
(txnAmount == 0.0M && scheduledTransaction != null && originalTxn == null) ||
(txnAmount < 0.0M && originalTxn != null)
))
{
failedPayments.Add(transaction);
}
// Add summary
if (!batchSummary.ContainsKey(batch.Guid))
{
batchSummary.Add(batch.Guid, new List <Decimal>());
}
batchSummary[batch.Guid].Add(txnAmount);
totalAdded++;
if (txnAmount < 0.0M)
{
totalReversals++;
}
else if (txnAmount == 0.0M)
{
totalFailures++;
}
}
else
{
// If the payment can't be matched (and we aren't ignoring it due to its status), add it to the payment without a transactions that we'll report.
if (!ignorableUnMatchedStatuses.Contains(payment.Status, System.StringComparer.OrdinalIgnoreCase))
{
paymentsWithoutTransaction.Add(payment);
}
}
}
else
{
totalAlreadyDownloaded++;
}
if (txns != null)
{
foreach (var txn in txns
.Where(t =>
t.Status != payment.Status ||
t.StatusMessage != payment.StatusMessage ||
t.IsSettled != payment.IsSettled ||
t.SettledGroupId != payment.SettledGroupId ||
t.SettledDate != payment.SettledDate))
{
txn.IsSettled = payment.IsSettled;
txn.SettledGroupId = payment.SettledGroupId;
txn.SettledDate = payment.SettledDate;
txn.Status = payment.Status;
txn.StatusMessage = payment.StatusMessage;
totalStatusChanges++;
}
}
rockContext.SaveChanges();
}
}
if (transactionsWithAttributes.Count > 0)
{
foreach (var transaction in transactionsWithAttributes)
{
using (var rockContext3 = new RockContext())
{
transaction.SaveAttributeValues(rockContext3);
rockContext3.SaveChanges();
}
}
}
// Queue a transaction to update the status of all affected scheduled transactions
var updatePaymentStatusTxn = new UpdatePaymentStatusTransaction(gateway.Id, scheduledTransactionIds);
RockQueue.TransactionQueue.Enqueue(updatePaymentStatusTxn);
if (receiptEmail.HasValue && newTransactionsForReceiptEmails.Any())
{
// Queue a transaction to send receipts
var newTransactionIds = newTransactionsForReceiptEmails.Select(t => t.Id).ToList();
var sendPaymentReceiptsTxn = new SendPaymentReceipts(receiptEmail.Value, newTransactionIds);
RockQueue.TransactionQueue.Enqueue(sendPaymentReceiptsTxn);
}
// Queue transactions to launch failed payment workflow
if (failedPayments.Any())
{
if (failedPaymentEmail.HasValue)
{
// Queue a transaction to send payment failure
var newTransactionIds = failedPayments.Select(t => t.Id).ToList();
var sendPaymentFailureTxn = new SendPaymentReceipts(failedPaymentEmail.Value, newTransactionIds);
RockQueue.TransactionQueue.Enqueue(sendPaymentFailureTxn);
}
if (failedPaymentWorkflowType.HasValue)
{
// Queue a transaction to launch workflow
var workflowDetails = failedPayments.Select(p => new LaunchWorkflowDetails(p)).ToList();
var launchWorkflowsTxn = new LaunchWorkflowsTransaction(failedPaymentWorkflowType.Value, workflowDetails);
RockQueue.TransactionQueue.Enqueue(launchWorkflowsTxn);
}
}
StringBuilder sb = new StringBuilder();
sb.AppendFormat("<li>{0} {1} downloaded.</li>", totalPayments.ToString("N0"),
(totalPayments == 1 ? "payment" : "payments"));
if (totalAlreadyDownloaded > 0)
{
sb.AppendFormat("<li>{0} {1} previously downloaded and {2} already been added.</li>", totalAlreadyDownloaded.ToString("N0"),
(totalAlreadyDownloaded == 1 ? "payment was" : "payments were"),
(totalAlreadyDownloaded == 1 ? "has" : "have"));
}
if (totalStatusChanges > 0)
{
sb.AppendFormat("<li>{0} {1} previously downloaded but had a change of status.</li>", totalStatusChanges.ToString("N0"),
(totalStatusChanges == 1 ? "payment was" : "payments were"));
}
if (paymentsWithoutTransaction.Any())
{
var scheduledPaymentList = paymentsWithoutTransaction.Where(a => a.GatewayScheduleId.IsNotNullOrWhiteSpace()).Select(a => a.GatewayScheduleId).ToList();
if (scheduledPaymentList.Any())
{
if (verboseLogging)
{
sb.Append($@"<li>The following {scheduledPaymentList.Count.ToString( "N0" )} gateway payments could not be matched to an existing scheduled payment profile:
<pre>{scheduledPaymentList.AsDelimited( "\n" )}</pre>
</li>");
}
else
{
sb.Append($"<li>{scheduledPaymentList.Count.ToString( "N0" )} gateway payments could not be matched to an existing scheduled payment profile.</li>");
}
}
var previousTransactionList = paymentsWithoutTransaction.Where(a => a.GatewayScheduleId.IsNullOrWhiteSpace()).Select(a => a.TransactionCode).ToList();
if (previousTransactionList.Any())
{
if (verboseLogging)
{
sb.Append($@"<li>The following {previousTransactionList.Count.ToString( "N0" )} gateway payments could not be matched to a previous transaction:
<pre>{previousTransactionList.AsDelimited( "\n" )}</pre>
</li>");
}
else
{
sb.Append($"<li>{previousTransactionList.Count.ToString( "N0" )} gateway payments could not be matched to a previous transaction.</li>");
}
}
}
sb.AppendFormat("<li>{0} {1} added.</li>", totalAdded.ToString("N0"),
(totalAdded == 1 ? "new payment was" : "new payments were"));
if (totalReversals > 0)
{
sb.AppendFormat("<li>{0} {1} added as a reversal to a previous transaction.</li>", totalReversals.ToString("N0"),
(totalReversals == 1 ? "payment was" : "payments were"));
}
if (totalFailures > 0)
{
sb.AppendFormat("<li>{0} {1} recorded as a failed transaction.</li>", totalFailures.ToString("N0"),
(totalFailures == 1 ? "payment was" : "payments were"));
}
using (var rockContext = new RockContext())
{
var batches = new FinancialBatchService(rockContext)
.Queryable().AsNoTracking()
.Where(b => batchSummary.Keys.Contains(b.Guid))
.ToList();
foreach (var batchItem in batchSummary)
{
int items = batchItem.Value.Count;
if (items > 0)
{
var batch = batches
.Where(b => b.Guid.Equals(batchItem.Key))
.FirstOrDefault();
string batchName = string.Format("'{0} ({1})'", batch.Name, batch.BatchStartDateTime.Value.ToString("d"));
if (!string.IsNullOrWhiteSpace(batchUrlFormat))
{
batchName = string.Format("<a href='{0}'>{1}</a>", string.Format(batchUrlFormat, batch.Id), batchName);
}
decimal sum = batchItem.Value.Sum();
string summaryformat = items == 1 ?
"<li>{0} transaction of {1} was added to the {2} batch.</li>" :
"<li>{0} transactions totaling {1} were added to the {2} batch</li>";
sb.AppendFormat(summaryformat, items.ToString("N0"), sum.FormatAsCurrency(), batchName);
}
}
}
return(sb.ToString());
}
/// <summary>
/// Processes the payments.
/// </summary>
/// <param name="gateway">The gateway.</param>
/// <param name="batchNamePrefix">The batch name prefix.</param>
/// <param name="payments">The payments.</param>
/// <param name="batchUrlFormat">The batch URL format.</param>
/// <param name="receiptEmail">The receipt email.</param>
/// <returns></returns>
public static string ProcessPayments( FinancialGateway gateway, string batchNamePrefix, List<Payment> payments, string batchUrlFormat = "", Guid? receiptEmail = null )
{
int totalPayments = 0;
int totalAlreadyDownloaded = 0;
int totalNoScheduledTransaction = 0;
int totalAdded = 0;
int totalReversals = 0;
int totalStatusChanges = 0;
var batches = new List<FinancialBatch>();
var batchSummary = new Dictionary<Guid, List<Decimal>>();
var initialControlAmounts = new Dictionary<Guid, decimal>();
var txnPersonNames = new Dictionary<Guid, string>();
var gatewayComponent = gateway.GetGatewayComponent();
var newTransactions = new List<FinancialTransaction>();
using ( var rockContext = new RockContext() )
{
var accountService = new FinancialAccountService( rockContext );
var txnService = new FinancialTransactionService( rockContext );
var batchService = new FinancialBatchService( rockContext );
var scheduledTxnService = new FinancialScheduledTransactionService( rockContext );
var contributionTxnType = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid() );
var defaultAccount = accountService.Queryable()
.Where( a =>
a.IsActive &&
!a.ParentAccountId.HasValue &&
( !a.StartDate.HasValue || a.StartDate.Value <= RockDateTime.Now ) &&
( !a.EndDate.HasValue || a.EndDate.Value >= RockDateTime.Now )
)
.OrderBy( a => a.Order )
.FirstOrDefault();
var batchTxnChanges = new Dictionary<Guid, List<string>>();
var batchBatchChanges = new Dictionary<Guid, List<string>>();
var scheduledTransactionIds = new List<int>();
foreach ( var payment in payments.Where( p => p.Amount > 0.0M ) )
{
totalPayments++;
var scheduledTransaction = scheduledTxnService.GetByScheduleId( payment.GatewayScheduleId, gateway.Id );
if ( scheduledTransaction != null )
{
// Find existing payments with same transaction code
var txns = txnService
.Queryable( "TransactionDetails" )
.Where( t => t.TransactionCode == payment.TransactionCode )
.ToList();
// Calculate whether a transaction needs to be added
var txnAmount = CalculateTransactionAmount( payment, txns );
if ( txnAmount != 0.0M )
{
scheduledTransactionIds.Add( scheduledTransaction.Id );
if ( payment.ScheduleActive.HasValue )
{
scheduledTransaction.IsActive = payment.ScheduleActive.Value;
}
var transaction = new FinancialTransaction();
transaction.FinancialPaymentDetail = new FinancialPaymentDetail();
transaction.Guid = Guid.NewGuid();
transaction.TransactionCode = payment.TransactionCode;
transaction.TransactionDateTime = payment.TransactionDateTime;
transaction.Status = payment.Status;
transaction.StatusMessage = payment.StatusMessage;
transaction.ScheduledTransactionId = scheduledTransaction.Id;
transaction.AuthorizedPersonAliasId = scheduledTransaction.AuthorizedPersonAliasId;
transaction.SourceTypeValueId = scheduledTransaction.SourceTypeValueId;
txnPersonNames.Add( transaction.Guid, scheduledTransaction.AuthorizedPersonAlias.Person.FullName );
transaction.FinancialGatewayId = gateway.Id;
transaction.TransactionTypeValueId = contributionTxnType.Id;
if ( txnAmount < 0.0M )
{
transaction.Summary = "Reversal for previous transaction that failed during processing." + Environment.NewLine;
}
var currencyTypeValue = payment.CurrencyTypeValue;
var creditCardTypevalue = payment.CreditCardTypeValue;
if ( scheduledTransaction.FinancialPaymentDetail != null )
{
if ( currencyTypeValue == null && scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.HasValue )
{
currencyTypeValue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.Value );
}
if ( creditCardTypevalue == null && scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.HasValue )
{
creditCardTypevalue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.Value );
}
transaction.FinancialPaymentDetail.AccountNumberMasked = scheduledTransaction.FinancialPaymentDetail.AccountNumberMasked;
transaction.FinancialPaymentDetail.NameOnCardEncrypted = scheduledTransaction.FinancialPaymentDetail.NameOnCardEncrypted;
transaction.FinancialPaymentDetail.ExpirationMonthEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationMonthEncrypted;
transaction.FinancialPaymentDetail.ExpirationYearEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationYearEncrypted;
transaction.FinancialPaymentDetail.BillingLocationId = scheduledTransaction.FinancialPaymentDetail.BillingLocationId;
}
if ( currencyTypeValue != null )
{
transaction.FinancialPaymentDetail.CurrencyTypeValueId = currencyTypeValue.Id;
}
if ( creditCardTypevalue != null )
{
transaction.FinancialPaymentDetail.CreditCardTypeValueId = creditCardTypevalue.Id;
}
// Try to allocate the amount of the transaction based on the current scheduled transaction accounts
decimal remainingAmount = Math.Abs( txnAmount );
foreach ( var detail in scheduledTransaction.ScheduledTransactionDetails.Where( d => d.Amount != 0.0M ) )
{
var transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = detail.AccountId;
if ( detail.Amount <= remainingAmount )
{
// If the configured amount for this account is less than or equal to the remaining
// amount, allocate the configured amount
transactionDetail.Amount = detail.Amount;
remainingAmount -= detail.Amount;
}
else
{
// If the configured amount is greater than the remaining amount, only allocate
// the remaining amount
transaction.Summary += "Note: Downloaded transaction amount was less than the configured allocation amounts for the Scheduled Transaction.";
transactionDetail.Amount = remainingAmount;
transactionDetail.Summary = "Note: The downloaded amount was not enough to apply the configured amount to this account.";
remainingAmount = 0.0M;
}
transaction.TransactionDetails.Add( transactionDetail );
if ( remainingAmount <= 0.0M )
{
// If there's no amount left, break out of details
break;
}
}
// If there's still amount left after allocating based on current config, add the remainder
// to the account that was configured for the most amount
if ( remainingAmount > 0.0M )
{
transaction.Summary += "Note: Downloaded transaction amount was greater than the configured allocation amounts for the Scheduled Transaction.";
var transactionDetail = transaction.TransactionDetails
.OrderByDescending( d => d.Amount )
.FirstOrDefault();
if ( transactionDetail == null && defaultAccount != null )
{
transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = defaultAccount.Id;
transaction.TransactionDetails.Add( transactionDetail );
}
if ( transactionDetail != null )
{
transactionDetail.Amount += remainingAmount;
transactionDetail.Summary = "Note: Extra amount was applied to this account.";
}
}
// If the amount to apply was negative, update all details to be negative (absolute value was used when allocating to accounts)
if ( txnAmount < 0.0M )
{
foreach ( var txnDetail in transaction.TransactionDetails )
{
txnDetail.Amount = 0 - txnDetail.Amount;
}
}
// Get the batch
var batch = batchService.Get(
batchNamePrefix,
currencyTypeValue,
creditCardTypevalue,
transaction.TransactionDateTime.Value,
gateway.GetBatchTimeOffset(),
batches );
var batchChanges = new List<string>();
if ( batch.Id != 0 )
{
initialControlAmounts.AddOrIgnore( batch.Guid, batch.ControlAmount );
}
batch.ControlAmount += transaction.TotalAmount;
batch.Transactions.Add( transaction );
if ( txnAmount > 0.0M && receiptEmail.HasValue )
{
newTransactions.Add( transaction );
}
// Add summary
if ( !batchSummary.ContainsKey( batch.Guid ) )
{
batchSummary.Add( batch.Guid, new List<Decimal>() );
}
batchSummary[batch.Guid].Add( txnAmount );
if ( txnAmount > 0.0M )
{
totalAdded++;
}
else
{
totalReversals++;
}
}
else
{
totalAlreadyDownloaded++;
foreach ( var txn in txns.Where( t => t.Status != payment.Status || t.StatusMessage != payment.StatusMessage ) )
{
txn.Status = payment.Status;
txn.StatusMessage = payment.StatusMessage;
totalStatusChanges++;
}
}
}
else
{
totalNoScheduledTransaction++;
}
}
rockContext.SaveChanges();
// Queue a transaction to update the status of all affected scheduled transactions
var updatePaymentStatusTxn = new Rock.Transactions.UpdatePaymentStatusTransaction( gateway.Id, scheduledTransactionIds );
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( updatePaymentStatusTxn );
if ( receiptEmail.HasValue )
{
// Queue a transaction to send receipts
var newTransactionIds = newTransactions.Select( t => t.Id ).ToList();
var sendPaymentReceiptsTxn = new Rock.Transactions.SendPaymentReceipts( receiptEmail.Value, newTransactionIds );
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( sendPaymentReceiptsTxn );
}
}
StringBuilder sb = new StringBuilder();
sb.AppendFormat( "<li>{0} {1} downloaded.</li>", totalPayments.ToString( "N0" ),
( totalPayments == 1 ? "payment" : "payments" ) );
if ( totalAlreadyDownloaded > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded and {2} already been added.</li>", totalAlreadyDownloaded.ToString( "N0" ),
( totalAlreadyDownloaded == 1 ? "payment was" : "payments were" ),
( totalAlreadyDownloaded == 1 ? "has" : "have" ) );
}
if ( totalStatusChanges > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded but had a change of status.</li>", totalStatusChanges.ToString( "N0" ),
( totalStatusChanges == 1 ? "payment was" : "payments were" ) );
}
if ( totalNoScheduledTransaction > 0 )
{
sb.AppendFormat( "<li>{0} {1} could not be matched to an existing scheduled payment profile.</li>", totalNoScheduledTransaction.ToString( "N0" ),
( totalNoScheduledTransaction == 1 ? "payment" : "payments" ) );
}
sb.AppendFormat( "<li>{0} {1} successfully added.</li>", totalAdded.ToString( "N0" ),
( totalAdded == 1 ? "payment was" : "payments were" ) );
if ( totalReversals > 0 )
{
sb.AppendFormat( "<li>{0} {1} added as a reversal to a previous transaction.</li>", totalReversals.ToString( "N0" ),
( totalReversals == 1 ? "payment was" : "payments were" ) );
}
foreach ( var batchItem in batchSummary )
{
int items = batchItem.Value.Count;
if ( items > 0 )
{
var batch = batches
.Where( b => b.Guid.Equals( batchItem.Key ) )
.FirstOrDefault();
string batchName = string.Format( "'{0} ({1})'", batch.Name, batch.BatchStartDateTime.Value.ToString( "d" ) );
if ( !string.IsNullOrWhiteSpace( batchUrlFormat ) )
{
batchName = string.Format( "<a href='{0}'>{1}</a>", string.Format( batchUrlFormat, batch.Id ), batchName );
}
decimal sum = batchItem.Value.Sum();
string summaryformat = items == 1 ?
"<li>{0} transaction of {1} was added to the {2} batch.</li>" :
"<li>{0} transactions totaling {1} were added to the {2} batch</li>";
sb.AppendFormat( summaryformat, items.ToString( "N0" ), sum.FormatAsCurrency(), batchName );
}
}
return sb.ToString();
}
/// <summary>
/// Navigates to the next (or previous) transaction to edit
/// </summary>
private void NavigateToTransaction( Direction direction )
{
// put a lock around the entire NavigateToTransaction logic so that the navigation and "other person editing" logic will work consistently even if multiple people are editing the same batch
lock ( transactionMatchingLockObject )
{
hfDoFadeIn.Value = "1";
nbSaveError.Visible = false;
int? fromTransactionId = hfTransactionId.Value.AsIntegerOrNull();
int? toTransactionId = null;
List<int> historyList = hfBackNextHistory.Value.Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).AsIntegerList().Where( a => a > 0 ).ToList();
int position = hfHistoryPosition.Value.AsIntegerOrNull() ?? -1;
if ( direction == Direction.Prev )
{
position--;
}
else
{
position++;
}
if ( historyList.Count > position )
{
if ( position >= 0 )
{
toTransactionId = historyList[position];
}
else
{
// if we trying to go previous when we are already at the start of the list, wrap around to the last item in the list
toTransactionId = historyList.Last();
position = historyList.Count - 1;
}
}
hfHistoryPosition.Value = position.ToString();
int batchId = hfBatchId.Value.AsInteger();
var rockContext = new RockContext();
var financialPersonBankAccountService = new FinancialPersonBankAccountService( rockContext );
var financialTransactionService = new FinancialTransactionService( rockContext );
var qryTransactionsToMatch = financialTransactionService.Queryable()
.Where( a => a.AuthorizedPersonAliasId == null && a.ProcessedByPersonAliasId == null );
if ( batchId != 0 )
{
qryTransactionsToMatch = qryTransactionsToMatch.Where( a => a.BatchId == batchId );
}
// if a specific transactionId was specified (because we are navigating thru history), load that one. Otherwise, if a batch is specified, get the first unmatched transaction in that batch
if ( toTransactionId.HasValue )
{
qryTransactionsToMatch = financialTransactionService
.Queryable( "AuthorizedPersonAlias.Person,ProcessedByPersonAlias.Person" )
.Where( a => a.Id == toTransactionId );
}
if ( historyList.Any() && !toTransactionId.HasValue )
{
// since we are looking for a transaction we haven't viewed or matched yet, look for the next one in the database that we haven't seen yet
qryTransactionsToMatch = qryTransactionsToMatch.Where( a => !historyList.Contains( a.Id ) );
}
qryTransactionsToMatch = qryTransactionsToMatch.OrderBy( a => a.CreatedDateTime ).ThenBy( a => a.Id );
FinancialTransaction transactionToMatch = qryTransactionsToMatch.FirstOrDefault();
if ( transactionToMatch == null )
{
// we exhausted the transactions that aren't processed and aren't in our history list, so remove those those restrictions and show all transactions that haven't been matched yet
var qryRemainingTransactionsToMatch = financialTransactionService
.Queryable( "AuthorizedPersonAlias.Person,ProcessedByPersonAlias.Person" )
.Where( a => a.AuthorizedPersonAliasId == null );
if ( batchId != 0 )
{
qryRemainingTransactionsToMatch = qryRemainingTransactionsToMatch.Where( a => a.BatchId == batchId );
}
// get the first transaction that we haven't visited yet, or the next one we have visited after one we are on, or simple the first unmatched one
transactionToMatch = qryRemainingTransactionsToMatch.Where( a => a.Id > fromTransactionId && !historyList.Contains( a.Id ) ).FirstOrDefault()
?? qryRemainingTransactionsToMatch.Where( a => a.Id > fromTransactionId ).FirstOrDefault()
?? qryRemainingTransactionsToMatch.FirstOrDefault();
if ( transactionToMatch != null )
{
historyList.Add( transactionToMatch.Id );
position = historyList.LastIndexOf( transactionToMatch.Id );
hfHistoryPosition.Value = position.ToString();
}
}
else
{
if ( !toTransactionId.HasValue )
{
historyList.Add( transactionToMatch.Id );
}
}
nbNoUnmatchedTransactionsRemaining.Visible = transactionToMatch == null;
pnlEdit.Visible = transactionToMatch != null;
nbIsInProcess.Visible = false;
if ( transactionToMatch != null )
{
if ( transactionToMatch.ProcessedByPersonAlias != null )
{
if ( transactionToMatch.AuthorizedPersonAliasId.HasValue )
{
nbIsInProcess.Text = string.Format( "Warning. This transaction was matched by {0} at {1} ({2})", transactionToMatch.ProcessedByPersonAlias.Person, transactionToMatch.ProcessedDateTime.ToString(), transactionToMatch.ProcessedDateTime.ToRelativeDateString() );
nbIsInProcess.Visible = true;
}
else
{
// display a warning if some other user has this marked as InProcess (and it isn't matched)
if ( transactionToMatch.ProcessedByPersonAliasId != CurrentPersonAliasId )
{
nbIsInProcess.Text = string.Format( "Warning. This transaction is getting processed by {0} as of {1} ({2})", transactionToMatch.ProcessedByPersonAlias.Person, transactionToMatch.ProcessedDateTime.ToString(), transactionToMatch.ProcessedDateTime.ToRelativeDateString() );
nbIsInProcess.Visible = true;
}
}
}
// Unless somebody else is processing it, immediately mark the transaction as getting processed by the current person so that other potentional transaction matching sessions will know that it is currently getting looked at
if ( !transactionToMatch.ProcessedByPersonAliasId.HasValue )
{
transactionToMatch.ProcessedByPersonAlias = null;
transactionToMatch.ProcessedByPersonAliasId = CurrentPersonAliasId;
transactionToMatch.ProcessedDateTime = RockDateTime.Now;
rockContext.SaveChanges();
}
hfTransactionId.Value = transactionToMatch.Id.ToString();
// get the first 2 images (should be no more than 2, but just in case)
var transactionImages = transactionToMatch.Images.OrderBy( a => a.Order ).Take( 2 ).ToList();
ddlIndividual.Items.Clear();
ddlIndividual.Items.Add( new ListItem( null, null ) );
// clear any previously shown badges
ddlIndividual.Attributes.Remove( "disabled" );
badgeIndividualCount.InnerText = "";
// if this transaction has a CheckMicrParts, try to find matching person(s)
string checkMicrHashed = null;
if ( !string.IsNullOrWhiteSpace( transactionToMatch.CheckMicrParts ) )
{
try
{
var checkMicrClearText = Encryption.DecryptString( transactionToMatch.CheckMicrParts );
var parts = checkMicrClearText.Split( '_' );
if ( parts.Length >= 2 )
{
checkMicrHashed = FinancialPersonBankAccount.EncodeAccountNumber( parts[0], parts[1] );
}
}
catch
{
// intentionally ignore exception when decripting CheckMicrParts since we'll be checking for null below
}
}
hfCheckMicrHashed.Value = checkMicrHashed;
if ( !string.IsNullOrWhiteSpace( checkMicrHashed ) )
{
var matchedPersons = financialPersonBankAccountService.Queryable().Where( a => a.AccountNumberSecured == checkMicrHashed ).Select( a => a.PersonAlias.Person ).Distinct();
foreach ( var person in matchedPersons.OrderBy( a => a.LastName ).ThenBy( a => a.NickName ) )
{
ddlIndividual.Items.Add( new ListItem( person.FullNameReversed, person.Id.ToString() ) );
}
}
bool requiresMicr =
transactionToMatch.FinancialPaymentDetail != null &&
transactionToMatch.FinancialPaymentDetail.CurrencyTypeValue != null &&
transactionToMatch.FinancialPaymentDetail.CurrencyTypeValue.Guid == Rock.SystemGuid.DefinedValue.CURRENCY_TYPE_CHECK.AsGuid();
// if this is a check, and the MICR could not be accurately read, show the warning
nbBadMicrWarning.Visible = requiresMicr && transactionToMatch.MICRStatus == MICRStatus.Fail;
if ( ddlIndividual.Items.Count == 2 )
{
// only one person (and the None selection) are in the list, so init to the person
ddlIndividual.SelectedIndex = 1;
}
else
{
// either zero or multiple people are in the list, so default to none so they are forced to choose
ddlIndividual.SelectedIndex = 0;
}
if ( transactionToMatch.AuthorizedPersonAlias != null && transactionToMatch.AuthorizedPersonAlias.Person != null )
{
var person = transactionToMatch.AuthorizedPersonAlias.Person;
// if the drop down does not contains the AuthorizedPerson of this transaction, add them to the drop down
// note, this can easily happen for non-check transactions
if ( !ddlIndividual.Items.OfType<ListItem>().Any( a => a.Value == person.Id.ToString() ) )
{
ddlIndividual.Items.Add( new ListItem( person.FullNameReversed, person.Id.ToString() ) );
}
ddlIndividual.SelectedValue = person.Id.ToString();
}
if ( ddlIndividual.Items.Count != 1 )
{
badgeIndividualCount.InnerText = ( ddlIndividual.Items.Count - 1 ).ToStringSafe();
}
else
{
ddlIndividual.Attributes["disabled"] = "disabled";
_focusControl = ppSelectNew;
}
ddlIndividual_SelectedIndexChanged( null, null );
ppSelectNew.SetValue( null );
if ( transactionToMatch.TransactionDetails.Any() )
{
cbTotalAmount.Text = transactionToMatch.TotalAmount.ToString();
}
else
{
cbTotalAmount.Text = string.Empty;
}
// update accountboxes
foreach ( var accountBox in rptAccounts.ControlsOfTypeRecursive<CurrencyBox>() )
{
accountBox.Text = string.Empty;
}
foreach ( var detail in transactionToMatch.TransactionDetails )
{
var accountBox = rptAccounts.ControlsOfTypeRecursive<CurrencyBox>().Where( a => a.Attributes["data-account-id"].AsInteger() == detail.AccountId ).FirstOrDefault();
if ( accountBox != null )
{
accountBox.Text = detail.Amount.ToString();
}
}
if ( transactionToMatch.Images.Any() )
{
var primaryImage = transactionToMatch.Images
.OrderBy( i => i.Order )
.FirstOrDefault();
imgPrimary.ImageUrl = string.Format( "~/GetImage.ashx?id={0}", primaryImage.BinaryFileId );
imgPrimary.Visible = true;
nbNoTransactionImageWarning.Visible = false;
rptrImages.DataSource = transactionToMatch.Images
.Where( i => !i.Id.Equals( primaryImage.Id ) )
.OrderBy( i => i.Order )
.ToList();
rptrImages.DataBind();
}
else
{
imgPrimary.Visible = false;
rptrImages.DataSource = null;
rptrImages.DataBind();
nbNoTransactionImageWarning.Visible = true;
}
}
else
{
hfTransactionId.Value = string.Empty;
}
// display how many unmatched transactions are remaining
var qryTransactionCount = financialTransactionService.Queryable();
if ( batchId != 0 )
{
qryTransactionCount = qryTransactionCount.Where( a => a.BatchId == batchId );
}
// get count of transactions that haven't been matched (not including the one we are currently editing)
int currentTranId = hfTransactionId.Value.AsInteger();
int matchedRemainingCount = qryTransactionCount.Count( a => a.AuthorizedPersonAliasId != null && a.Id != currentTranId );
int totalBatchItemCount = qryTransactionCount.Count();
int percentComplete = (int)Math.Round( (double)(100 * matchedRemainingCount) / totalBatchItemCount );
lProgressBar.Text = String.Format( @"<div class='progress'>
<div class='progress-bar progress-bar-info' role='progressbar' aria-valuenow='{0}' aria-valuemin='0' aria-valuemax='100' style='width: {0}%;'>
{0}%
</div>
</div>", percentComplete);
hfBackNextHistory.Value = historyList.AsDelimited( "," );
if ( _focusControl == null )
{
_focusControl = rptAccounts.ControlsOfTypeRecursive<Rock.Web.UI.Controls.CurrencyBox>().FirstOrDefault();
}
}
}
/// <summary>
/// Handles the SaveClick event of the mdAccountsPersonalFilter control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void mdAccountsPersonalFilter_SaveClick( object sender, EventArgs e )
{
var selectedAccountIdList = apPersonalAccounts.SelectedValuesAsInt().ToList();
var selectedAccountGuidList = new FinancialAccountService( new RockContext() ).GetByIds( selectedAccountIdList ).Select( a => a.Guid ).ToList();
string keyPrefix = string.Format( "transaction-matching-{0}-", this.BlockId );
this.SetUserPreference( keyPrefix + "account-list", selectedAccountGuidList.AsDelimited( "," ) );
mdAccountsPersonalFilter.Hide();
LoadDropDowns();
// Reload the transaction amounts after changing the displayed accounts.
int? transactionId = hfTransactionId.Value.AsIntegerOrNull();
if (transactionId.HasValue)
{
using (var rockContext = new RockContext())
{
var financialTransactionService = new FinancialTransactionService(rockContext);
var txn = financialTransactionService.Queryable().Where(t => t.Id == transactionId).SingleOrDefault();
foreach (var detail in txn.TransactionDetails)
{
var accountBox = rptAccounts.ControlsOfTypeRecursive<CurrencyBox>().Where(a => a.Attributes["data-account-id"].AsInteger() == detail.AccountId).FirstOrDefault();
if (accountBox != null)
{
accountBox.Text = detail.Amount.ToString();
}
}
}
}
}
/// <summary>
/// Shows the financial batch summary.
/// </summary>
/// <param name="batch">The financial batch.</param>
private void ShowReadonlyDetails( FinancialBatch batch )
{
SetEditMode( false );
if ( batch != null )
{
hfBatchId.SetValue( batch.Id );
SetHeadingInfo( batch, batch.Name );
string campusName = string.Empty;
if ( batch.CampusId.HasValue )
{
var campus = CampusCache.Read( batch.CampusId.Value );
if ( campus != null )
{
campusName = campus.ToString();
}
}
var rockContext = new RockContext();
var financialTransactionService = new FinancialTransactionService( rockContext );
var batchTransactions = financialTransactionService.Queryable().Where( a => a.BatchId.HasValue && a.BatchId.Value == batch.Id );
var financialTransactionDetailService = new FinancialTransactionDetailService( rockContext );
var qryTransactionDetails = financialTransactionDetailService.Queryable().Where( a => a.Transaction.BatchId == batch.Id );
decimal txnTotal = qryTransactionDetails.Select( a => (decimal?)a.Amount ).Sum() ?? 0;
decimal variance = txnTotal - batch.ControlAmount;
string amountFormat = string.Format(
"{0} / {1} / " + ( variance == 0.0M ? "{2}" : "<span class='label label-danger'>{2}</span>" ),
txnTotal.FormatAsCurrency(),
batch.ControlAmount.FormatAsCurrency(),
variance.FormatAsCurrency() );
lDetails.Text = new DescriptionList()
.Add( "Date Range", new DateRange( batch.BatchStartDateTime, batch.BatchEndDateTime ).ToString( "g" ) )
.Add( "Transaction / Control / Variance", amountFormat )
.Add( "Accounting Code", batch.AccountingSystemCode )
.Add( "Notes", batch.Note )
.Html;
// Account Summary
gAccounts.DataSource = qryTransactionDetails
.GroupBy( d => new
{
AccountId = d.AccountId,
AccountName = d.Account.Name
} )
.Select( s => new
{
Id = s.Key.AccountId,
Name = s.Key.AccountName,
Amount = s.Sum( a => (decimal?)a.Amount ) ?? 0.0M
} )
.OrderBy( s => s.Name )
.ToList();
gAccounts.DataBind();
// Currency Summary
gCurrencyTypes.DataSource = batchTransactions
.GroupBy( c => new
{
CurrencyTypeValueId = c.FinancialPaymentDetailId.HasValue ? c.FinancialPaymentDetail.CurrencyTypeValueId : 0,
} )
.Select( s => new
{
CurrencyTypeValueId = s.Key.CurrencyTypeValueId,
Amount = s.Sum( a => (decimal?)a.TransactionDetails.Sum( t => t.Amount ) ) ?? 0.0M
} )
.ToList()
.Select( s => new
{
Id = s.CurrencyTypeValueId,
Name = DefinedValueCache.GetName( s.CurrencyTypeValueId ),
Amount = s.Amount
} ).OrderBy( a => a.Name ).ToList();
gCurrencyTypes.DataBind();
}
}
/// <summary>
/// Handles the Click event of the btnNext control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnNext_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
var financialTransactionService = new FinancialTransactionService( rockContext );
var financialTransactionDetailService = new FinancialTransactionDetailService( rockContext );
var financialPersonBankAccountService = new FinancialPersonBankAccountService( rockContext );
int txnId = hfTransactionId.Value.AsInteger();
var financialTransaction = financialTransactionService
.Queryable( "AuthorizedPersonAlias.Person,ProcessedByPersonAlias.Person" )
.FirstOrDefault( t => t.Id == txnId );
// set the AuthorizedPersonId (the person who wrote the check, for example) to the if the SelectNew person (if selected) or person selected in the drop down (if there is somebody selected)
int? authorizedPersonId = ppSelectNew.PersonId ?? ddlIndividual.SelectedValue.AsIntegerOrNull();
var accountNumberSecured = hfCheckMicrHashed.Value;
if ( cbTotalAmount.Text.AsDecimalOrNull().HasValue && !authorizedPersonId.HasValue )
{
nbSaveError.Text = "Transaction must be matched to a person when the amount is specified.";
nbSaveError.Visible = true;
return;
}
// if the transaction was previously matched, but user unmatched it, save it as an unmatched transaction and clear out the detail records (we don't want an unmatched transaction to have detail records)
if ( financialTransaction != null &&
financialTransaction.AuthorizedPersonAliasId.HasValue &&
!authorizedPersonId.HasValue )
{
financialTransaction.AuthorizedPersonAliasId = null;
foreach ( var detail in financialTransaction.TransactionDetails )
{
financialTransactionDetailService.Delete( detail );
}
rockContext.SaveChanges();
// if the transaction was unmatched, clear out the ProcessedBy fields since we didn't match the transaction and are moving on to process another transaction
MarkTransactionAsNotProcessedByCurrentUser( hfTransactionId.Value.AsInteger() );
}
// if the transaction is matched to somebody, attempt to save it. Otherwise, if the transaction was previously matched, but user unmatched it, save it as an unmatched transaction
if ( financialTransaction != null && authorizedPersonId.HasValue )
{
bool requiresMicr = financialTransaction.CurrencyTypeValue.Guid == Rock.SystemGuid.DefinedValue.CURRENCY_TYPE_CHECK.AsGuid();
if ( requiresMicr && string.IsNullOrWhiteSpace( accountNumberSecured ) )
{
// should be showing already, but just in case
nbNoMicrWarning.Visible = true;
return;
}
if ( cbTotalAmount.Text.AsDecimalOrNull() == null )
{
nbSaveError.Text = "Total amount must be allocated to accounts.";
nbSaveError.Visible = true;
return;
}
int? personAliasId = new PersonAliasService( rockContext ).GetPrimaryAliasId( authorizedPersonId.Value );
// if this transaction has an accountnumber associated with it (in other words, it's a scanned check), ensure there is a financialPersonBankAccount record
if ( !string.IsNullOrWhiteSpace( accountNumberSecured ) )
{
var financialPersonBankAccount = financialPersonBankAccountService.Queryable().Where( a => a.AccountNumberSecured == accountNumberSecured && a.PersonAlias.PersonId == authorizedPersonId.Value ).FirstOrDefault();
if ( financialPersonBankAccount == null )
{
if ( personAliasId.HasValue )
{
financialPersonBankAccount = new FinancialPersonBankAccount();
financialPersonBankAccount.PersonAliasId = personAliasId.Value;
financialPersonBankAccount.AccountNumberSecured = accountNumberSecured;
var checkMicrClearText = Encryption.DecryptString( financialTransaction.CheckMicrEncrypted );
var parts = checkMicrClearText.Split( '_' );
if ( parts.Length >= 2 )
{
financialPersonBankAccount.AccountNumberMasked = parts[1].Masked();
}
financialPersonBankAccountService.Add( financialPersonBankAccount );
}
}
}
if ( personAliasId.HasValue )
{
financialTransaction.AuthorizedPersonAliasId = personAliasId;
}
// just in case this transaction is getting re-edited either by the same user, or somebody else, clean out any existing TransactionDetail records
foreach ( var detail in financialTransaction.TransactionDetails.ToList() )
{
financialTransactionDetailService.Delete( detail );
}
foreach ( var accountBox in rptAccounts.ControlsOfTypeRecursive<CurrencyBox>() )
{
var amount = accountBox.Text.AsDecimalOrNull();
if ( amount.HasValue && amount.Value >= 0 )
{
var financialTransactionDetail = new FinancialTransactionDetail();
financialTransactionDetail.TransactionId = financialTransaction.Id;
financialTransactionDetail.AccountId = accountBox.Attributes["data-account-id"].AsInteger();
financialTransactionDetail.Amount = amount.Value;
financialTransactionDetailService.Add( financialTransactionDetail );
}
}
financialTransaction.ProcessedByPersonAliasId = this.CurrentPersonAlias.Id;
financialTransaction.ProcessedDateTime = RockDateTime.Now;
rockContext.SaveChanges();
}
else
{
// if the transaction was not matched, clear out the ProcessedBy fields since we didn't match the transaction and are moving on to process another transaction
MarkTransactionAsNotProcessedByCurrentUser( hfTransactionId.Value.AsInteger() );
}
NavigateToTransaction( Direction.Next );
}
public void RaisePostBackEvent( string eventArgument )
{
if ( _batch != null )
{
if ( eventArgument == "MoveTransactions" &&
_ddlMove != null &&
_ddlMove.SelectedValue != null &&
!String.IsNullOrWhiteSpace( _ddlMove.SelectedValue ) )
{
var txnsSelected = new List<int>();
gTransactions.SelectedKeys.ToList().ForEach( b => txnsSelected.Add( b.ToString().AsInteger() ) );
if ( txnsSelected.Any() )
{
var rockContext = new RockContext();
var batchService = new FinancialBatchService( rockContext );
var newBatch = batchService.Get( _ddlMove.SelectedValue.AsInteger() );
var oldBatch = batchService.Get( _batch.Id );
if ( newBatch != null && newBatch.Status == BatchStatus.Open )
{
var txnService = new FinancialTransactionService( rockContext );
var txnsToUpdate = txnService.Queryable()
.Where( t => txnsSelected.Contains( t.Id ) )
.ToList();
foreach ( var txn in txnsToUpdate )
{
txn.BatchId = newBatch.Id;
oldBatch.ControlAmount -= txn.TotalAmount;
newBatch.ControlAmount += txn.TotalAmount;
}
rockContext.SaveChanges();
var pageRef = new Rock.Web.PageReference( RockPage.PageId );
pageRef.Parameters = new Dictionary<string, string>();
pageRef.Parameters.Add( "batchid", newBatch.Id.ToString() );
string newBatchLink = string.Format( "<a href='{0}'>{1}</a>",
pageRef.BuildUrl(), newBatch.Name );
RockPage.UpdateBlocks( "~/Blocks/Finance/BatchDetail.ascx" );
nbResult.Text = string.Format( "{0} transactions were moved to the '{1}' batch.",
txnsToUpdate.Count().ToString( "N0" ), newBatchLink );
nbResult.NotificationBoxType = NotificationBoxType.Success;
nbResult.Visible = true;
}
else
{
nbResult.Text = string.Format( "The selected batch does not exist, or is no longer open." );
nbResult.NotificationBoxType = NotificationBoxType.Danger;
nbResult.Visible = true;
}
}
else
{
nbResult.Text = string.Format( "There were not any transactions selected." );
nbResult.NotificationBoxType = NotificationBoxType.Warning;
nbResult.Visible = true;
}
}
_ddlMove.SelectedIndex = 0;
}
BindGrid();
}
/// <summary>
/// Navigates to the next transaction in the list.
/// </summary>
private void ShowNextButton( int transactionId, int? batchId )
{
if ( batchId == null || ! batchId.HasValue || batchId == 0 )
{
lbNext.Visible = false;
return;
}
lbNext.Visible = true;
var rockContext = new RockContext();
var financialTransactionService = new FinancialTransactionService( rockContext );
var qryTransactionsToMatch = financialTransactionService.Queryable()
.Where( a => a.BatchId == batchId );
var nextFinancialTransaction = qryTransactionsToMatch.Where( a => a.Id > transactionId ).Take( 1 ).FirstOrDefault();
if ( nextFinancialTransaction != null )
{
var qryParam = new Dictionary<string, string>();
qryParam.Add( "batchId", hfBatchId.Value );
qryParam.Add( "transactionId", nextFinancialTransaction.Id.ToStringSafe() );
lbNext.NavigateUrl = new PageReference( CurrentPageReference.PageId, 0, qryParam ).BuildUrl();
}
else
{
lbNext.AddCssClass( "disabled" );
}
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
RockContext rockContext = new RockContext();
FinancialTransactionService transService = new FinancialTransactionService( rockContext );
string currentPersonGivingId = CurrentPerson.GivingId;
var qry = transService.Queryable( "TransactionDetails.Account,FinancialPaymentDetail" )
.Where( t =>
t.TransactionDetails.Any(d => d.AccountId != 263) &&
t.AuthorizedPersonAlias != null &&
t.AuthorizedPersonAlias.Person != null &&
t.AuthorizedPersonAlias.Person.GivingId == currentPersonGivingId );
if (drpFilterDates.LowerValue.HasValue) {
qry = qry.Where(t => t.TransactionDateTime.Value >= drpFilterDates.LowerValue.Value);
}
if ( drpFilterDates.UpperValue.HasValue )
{
var lastDate = drpFilterDates.UpperValue.Value.AddDays( 1 ); // add one day to ensure we get all transactions till midnight
qry = qry.Where( t => t.TransactionDateTime.Value < lastDate );
}
var txns = qry.ToList();
// get account totals
Dictionary<string, decimal> accountTotals = new Dictionary<string, decimal>();
foreach ( var transaction in txns )
{
foreach ( var transactionDetail in transaction.TransactionDetails )
{
if ( accountTotals.Keys.Contains( transactionDetail.Account.Name ) )
{
accountTotals[transactionDetail.Account.Name] += transactionDetail.Amount;
}
else
{
accountTotals.Add( transactionDetail.Account.Name, transactionDetail.Amount );
}
}
}
lAccountSummary.Text = string.Empty;
if ( accountTotals.Count > 0 )
{
pnlSummary.Visible = true;
foreach ( var key in accountTotals.Keys )
{
lAccountSummary.Text += String.Format( "<li>{0}: {2}{1}</li>", key, accountTotals[key], GlobalAttributesCache.Value( "CurrencySymbol" ) );
}
}
else
{
pnlSummary.Visible = false;
}
gTransactions.EntityTypeId = EntityTypeCache.Read<FinancialTransaction>().Id;
gTransactions.DataSource = txns.Select( t => new
{
t.Id,
t.TransactionDateTime,
CurrencyType = FormatCurrencyType( t ),
Summary = FormatSummary( t ),
t.TotalAmount
} ).ToList();
gTransactions.DataBind();
}
/// <summary>
/// Navigates to the next (or previous) transaction to edit
/// </summary>
private void NavigateToTransaction( Direction direction )
{
hfDoFadeIn.Value = "1";
nbSaveError.Visible = false;
int? fromTransactionId = hfTransactionId.Value.AsIntegerOrNull();
int? toTransactionId = null;
List<int> historyList = hfBackNextHistory.Value.Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).Select( a => a.AsInteger() ).Where( a => a > 0 ).ToList();
int position = hfHistoryPosition.Value.AsIntegerOrNull() ?? -1;
if ( direction == Direction.Prev )
{
position--;
}
else
{
position++;
}
if ( historyList.Count > position )
{
if ( position >= 0 )
{
toTransactionId = historyList[position];
}
else
{
// if we trying to go previous when we are already at the start of the list, wrap around to the last item in the list
toTransactionId = historyList.Last();
position = historyList.Count - 1;
}
}
hfHistoryPosition.Value = position.ToString();
int batchId = hfBatchId.Value.AsInteger();
var rockContext = new RockContext();
var financialPersonBankAccountService = new FinancialPersonBankAccountService( rockContext );
var financialTransactionService = new FinancialTransactionService( rockContext );
var qryTransactionsToMatch = financialTransactionService.Queryable()
.Where( a => a.AuthorizedPersonId == null && a.ProcessedByPersonAliasId == null );
if ( batchId != 0 )
{
qryTransactionsToMatch = qryTransactionsToMatch.Where( a => a.BatchId == batchId );
}
// display how many unmatched and unviewed transactions are remaining
var qryRemainingTransactionsCount = financialTransactionService.Queryable().Where( a => a.AuthorizedPersonId == null );
if ( batchId != 0 )
{
qryRemainingTransactionsCount = qryRemainingTransactionsCount.Where( a => a.BatchId == batchId );
}
hlUnmatchedRemaining.Text = qryRemainingTransactionsCount.Count().ToString();
// if a specific transactionId was specified (because we are navigating thru history), load that one. Otherwise, if a batch is specified, get the first unmatched transaction in that batch
if ( toTransactionId.HasValue )
{
qryTransactionsToMatch = financialTransactionService.Queryable().Where( a => a.Id == toTransactionId );
}
if ( historyList.Any() && !toTransactionId.HasValue )
{
// since we are looking for a transaction we haven't viewed or matched yet, look for the next one in the database that we haven't seen yet
qryTransactionsToMatch = qryTransactionsToMatch.Where( a => !historyList.Contains( a.Id ) );
}
qryTransactionsToMatch = qryTransactionsToMatch.OrderBy( a => a.CreatedDateTime ).ThenBy( a => a.Id );
FinancialTransaction transactionToMatch = qryTransactionsToMatch.FirstOrDefault();
if ( transactionToMatch == null )
{
// we exhausted the transactions that aren't processed and aren't in our history list, so remove those those restrictions and show all transactions that haven't been matched yet
var qryRemainingTransactionsToMatch = financialTransactionService.Queryable().Where( a => a.AuthorizedPersonId == null );
if ( batchId != 0 )
{
qryRemainingTransactionsToMatch = qryRemainingTransactionsToMatch.Where( a => a.BatchId == batchId );
}
// get the first transaction that we haven't visited yet, or the next one we have visited after one we are on, or simple the first unmatched one
transactionToMatch = qryRemainingTransactionsToMatch.Where( a => a.Id > fromTransactionId && !historyList.Contains( a.Id ) ).FirstOrDefault()
?? qryRemainingTransactionsToMatch.Where( a => a.Id > fromTransactionId ).FirstOrDefault()
?? qryRemainingTransactionsToMatch.FirstOrDefault();
if ( transactionToMatch != null )
{
historyList.Add( transactionToMatch.Id );
position = historyList.LastIndexOf( transactionToMatch.Id );
hfHistoryPosition.Value = position.ToString();
}
}
else
{
if ( !toTransactionId.HasValue )
{
historyList.Add( transactionToMatch.Id );
}
}
nbNoUnmatchedTransactionsRemaining.Visible = transactionToMatch == null;
pnlEdit.Visible = transactionToMatch != null;
nbIsInProcess.Visible = false;
if ( transactionToMatch != null )
{
if ( transactionToMatch.ProcessedByPersonAlias != null )
{
if ( transactionToMatch.AuthorizedPersonId.HasValue )
{
nbIsInProcess.Text = string.Format( "Warning. This check was matched by {0} at {1} ({2})", transactionToMatch.ProcessedByPersonAlias, transactionToMatch.ProcessedDateTime.ToString(), transactionToMatch.ProcessedDateTime.ToRelativeDateString() );
nbIsInProcess.Visible = true;
}
else
{
// display a warning if some other user has this marked as InProcess (and it isn't matched)
if ( transactionToMatch.ProcessedByPersonAliasId != this.CurrentPersonAlias.Id )
{
nbIsInProcess.Text = string.Format( "Warning. This check is getting processed by {0} as of {1} ({2})", transactionToMatch.ProcessedByPersonAlias, transactionToMatch.ProcessedDateTime.ToString(), transactionToMatch.ProcessedDateTime.ToRelativeDateString() );
nbIsInProcess.Visible = true;
}
}
}
// Unless somebody else is processing it, immediately mark the transaction as getting processed by the current person so that other potentional check matching sessions will know that it is currently getting looked at
if ( !transactionToMatch.ProcessedByPersonAliasId.HasValue )
{
transactionToMatch.ProcessedByPersonAlias = null;
transactionToMatch.ProcessedByPersonAliasId = this.CurrentPersonAlias.Id;
transactionToMatch.ProcessedDateTime = RockDateTime.Now;
rockContext.SaveChanges();
}
hfTransactionId.Value = transactionToMatch.Id.ToString();
int frontImageTypeId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.TRANSACTION_IMAGE_TYPE_CHECK_FRONT.AsGuid() ).Id;
int backImageTypeId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.TRANSACTION_IMAGE_TYPE_CHECK_BACK.AsGuid() ).Id;
var frontImage = transactionToMatch.Images.Where( a => a.TransactionImageTypeValueId == frontImageTypeId ).FirstOrDefault();
var backImage = transactionToMatch.Images.Where( a => a.TransactionImageTypeValueId == backImageTypeId ).FirstOrDefault();
string checkMicrHashed = null;
if ( !string.IsNullOrWhiteSpace( transactionToMatch.CheckMicrEncrypted ) )
{
try
{
var checkMicrClearText = Encryption.DecryptString( transactionToMatch.CheckMicrEncrypted );
var parts = checkMicrClearText.Split( '_' );
if ( parts.Length >= 2 )
{
checkMicrHashed = FinancialPersonBankAccount.EncodeAccountNumber( parts[0], parts[1] );
}
}
catch
{
// intentionally ignore exception when decripting CheckMicrEncrypted since we'll be checking for null below
}
}
hfCheckMicrHashed.Value = checkMicrHashed;
if ( !string.IsNullOrWhiteSpace( checkMicrHashed ) )
{
var matchedPersons = financialPersonBankAccountService.Queryable().Where( a => a.AccountNumberSecured == checkMicrHashed ).Select( a => a.Person );
ddlIndividual.Items.Clear();
ddlIndividual.Items.Add( new ListItem( null, null ) );
foreach ( var person in matchedPersons.OrderBy( a => a.LastName ).ThenBy( a => a.NickName ) )
{
ddlIndividual.Items.Add( new ListItem( person.FullNameReversed, person.Id.ToString() ) );
}
}
nbNoMicrWarning.Visible = string.IsNullOrWhiteSpace( checkMicrHashed );
if ( ddlIndividual.Items.Count == 2 )
{
// only one person (and the None selection) are in the list, so init to the person
ddlIndividual.SelectedIndex = 1;
}
else
{
// either zero or multiple people are in the list, so default to none so they are forced to choose
ddlIndividual.SelectedIndex = 0;
}
ddlIndividual_SelectedIndexChanged( null, null );
string frontCheckUrl = string.Empty;
string backCheckUrl = string.Empty;
if ( frontImage != null )
{
frontCheckUrl = string.Format( "~/GetImage.ashx?id={0}", frontImage.BinaryFileId.ToString() );
}
if ( backImage != null )
{
backCheckUrl = string.Format( "~/GetImage.ashx?id={0}", backImage.BinaryFileId.ToString() );
}
if ( transactionToMatch.AuthorizedPersonId.HasValue )
{
ddlIndividual.SelectedValue = transactionToMatch.AuthorizedPersonId.ToString();
}
ppSelectNew.SetValue( null );
if ( transactionToMatch.TransactionDetails.Any() )
{
cbTotalAmount.Text = transactionToMatch.TotalAmount.ToString();
}
else
{
cbTotalAmount.Text = string.Empty;
}
// update accountboxes
foreach ( var accountBox in rptAccounts.ControlsOfTypeRecursive<CurrencyBox>() )
{
accountBox.Text = string.Empty;
}
foreach ( var detail in transactionToMatch.TransactionDetails )
{
var accountBox = rptAccounts.ControlsOfTypeRecursive<CurrencyBox>().Where( a => a.Attributes["data-account-id"].AsInteger() == detail.AccountId ).FirstOrDefault();
if ( accountBox != null )
{
accountBox.Text = detail.Amount.ToString();
}
}
imgCheck.Visible = !string.IsNullOrEmpty( frontCheckUrl ) || !string.IsNullOrEmpty( backCheckUrl );
imgCheckOtherSideThumbnail.Visible = imgCheck.Visible;
nbNoCheckImageWarning.Visible = !imgCheck.Visible;
imgCheck.ImageUrl = frontCheckUrl;
imgCheckOtherSideThumbnail.ImageUrl = backCheckUrl;
}
else
{
hfTransactionId.Value = string.Empty;
}
hfBackNextHistory.Value = historyList.AsDelimited( "," );
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad( EventArgs e )
{
base.OnLoad( e );
// initialize DoFadeIn to "0" so it only gets set to "1" when navigating thru transaction images
hfDoFadeIn.Value = "0";
if ( !Page.IsPostBack )
{
hfBackNextHistory.Value = string.Empty;
LoadDropDowns();
ShowDetail( PageParameter( "BatchId" ).AsInteger() );
}
// Display Payment Detail Attributes
int? transactionId = hfTransactionId.Value.AsIntegerOrNull();
if (transactionId.HasValue)
{
using (var rockContext = new RockContext())
{
var financialTransactionService = new FinancialTransactionService(rockContext);
var txn = financialTransactionService.Queryable().Where(t => t.Id == transactionId).SingleOrDefault();
DisplayPaymentDetailAttributeControls(txn);
}
}
}
/// <summary>
/// When implemented by a class, enables a server control to process an event raised when a form is posted to the server.
/// </summary>
/// <param name="eventArgument">A <see cref="T:System.String" /> that represents an optional event argument to be passed to the event handler.</param>
public void RaisePostBackEvent( string eventArgument )
{
if ( _canEdit && _batch != null )
{
if ( eventArgument == "MoveTransactions" &&
_ddlMove != null &&
_ddlMove.SelectedValue != null &&
!String.IsNullOrWhiteSpace( _ddlMove.SelectedValue ) )
{
var txnsSelected = new List<int>();
gTransactions.SelectedKeys.ToList().ForEach( b => txnsSelected.Add( b.ToString().AsInteger() ) );
if ( txnsSelected.Any() )
{
var rockContext = new RockContext();
var batchService = new FinancialBatchService( rockContext );
var newBatch = batchService.Get( _ddlMove.SelectedValue.AsInteger() );
var oldBatch = batchService.Get( _batch.Id );
if ( oldBatch != null && newBatch != null && newBatch.Status == BatchStatus.Open )
{
var txnService = new FinancialTransactionService( rockContext );
var txnsToUpdate = txnService.Queryable( "AuthorizedPersonAlias.Person" )
.Where( t => txnsSelected.Contains( t.Id ) )
.ToList();
decimal oldBatchControlAmount = oldBatch.ControlAmount;
decimal newBatchControlAmount = newBatch.ControlAmount;
foreach ( var txn in txnsToUpdate )
{
string caption = ( txn.AuthorizedPersonAlias != null && txn.AuthorizedPersonAlias.Person != null ) ?
txn.AuthorizedPersonAlias.Person.FullName :
string.Format( "Transaction: {0}", txn.Id );
var changes = new List<string>();
History.EvaluateChange( changes, "Batch",
string.Format( "{0} (Id:{1})", oldBatch.Name, oldBatch.Id ),
string.Format( "{0} (Id:{1})", newBatch.Name, newBatch.Id ) );
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(),
oldBatch.Id,
changes,
caption,
typeof( FinancialTransaction ),
txn.Id,
false
);
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(),
newBatch.Id,
changes,
caption,
typeof( FinancialTransaction ),
txn.Id, false
);
txn.BatchId = newBatch.Id;
oldBatchControlAmount -= txn.TotalAmount;
newBatchControlAmount += txn.TotalAmount;
}
var oldBatchChanges = new List<string>();
History.EvaluateChange( oldBatchChanges, "Control Amount", oldBatch.ControlAmount.FormatAsCurrency(), oldBatchControlAmount.FormatAsCurrency() );
oldBatch.ControlAmount = oldBatchControlAmount;
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_BATCH.AsGuid(),
oldBatch.Id,
oldBatchChanges,
false
);
var newBatchChanges = new List<string>();
History.EvaluateChange( newBatchChanges, "Control Amount", newBatch.ControlAmount.FormatAsCurrency(), newBatchControlAmount.FormatAsCurrency() );
newBatch.ControlAmount = newBatchControlAmount;
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_BATCH.AsGuid(),
newBatch.Id,
newBatchChanges,
false
);
rockContext.SaveChanges();
var pageRef = new Rock.Web.PageReference( RockPage.PageId );
pageRef.Parameters = new Dictionary<string, string>();
pageRef.Parameters.Add( "batchid", newBatch.Id.ToString() );
string newBatchLink = string.Format( "<a href='{0}'>{1}</a>",
pageRef.BuildUrl(), newBatch.Name );
RockPage.UpdateBlocks( "~/Blocks/Finance/BatchDetail.ascx" );
nbResult.Text = string.Format( "{0} transactions were moved to the '{1}' batch.",
txnsToUpdate.Count().ToString( "N0" ), newBatchLink );
nbResult.NotificationBoxType = NotificationBoxType.Success;
nbResult.Visible = true;
}
else
{
nbResult.Text = string.Format( "The selected batch does not exist, or is no longer open." );
nbResult.NotificationBoxType = NotificationBoxType.Danger;
nbResult.Visible = true;
}
}
else
{
nbResult.Text = string.Format( "There were not any transactions selected." );
nbResult.NotificationBoxType = NotificationBoxType.Warning;
nbResult.Visible = true;
}
}
_ddlMove.SelectedIndex = 0;
}
BindGrid();
}
/// <summary>
/// Gets the warnings.
/// </summary>
/// <returns></returns>
private List<string> GetWarnings( FinancialBatch batch )
{
var warningList = new List<string>();
if ( batch.Status == BatchStatus.Open )
{
var transactionService = new FinancialTransactionService( new RockContext() );
var transactionList = transactionService.Queryable().Where( trans => trans.BatchId == batch.Id && trans.AuthorizedPersonId == null ).ToList();
if ( transactionList.Count > 0 )
{
warningList.Add( "UNTIED" );
}
}
return warningList;
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
RockContext rockContext = new RockContext();
FinancialTransactionService transService = new FinancialTransactionService( rockContext );
var qry = transService.Queryable( "TransactionDetails.Account,FinancialPaymentDetail" );
string currentPersonGivingId = CurrentPerson.GivingId;
qry = qry.Where( t => t.AuthorizedPersonAlias != null &&
t.AuthorizedPersonAlias.Person != null &&
t.AuthorizedPersonAlias.Person.GivingId == currentPersonGivingId );
// if the Account Checkboxlist is visible, filter to what was selected. Otherwise, show all the accounts that the person contributed to
if ( cblAccounts.Visible )
{
// get list of selected accounts
List<int> selectedAccountIds = cblAccounts.Items.Cast<ListItem>()
.Where( i => i.Selected == true )
.Select( i => int.Parse( i.Value ) ).ToList();
qry = qry.Where( t => t.TransactionDetails.Any( d => selectedAccountIds.Contains( d.AccountId ) ) );
}
if ( drpFilterDates.LowerValue.HasValue )
{
qry = qry.Where( t => t.TransactionDateTime.Value >= drpFilterDates.LowerValue.Value );
}
if ( drpFilterDates.UpperValue.HasValue )
{
var lastDate = drpFilterDates.UpperValue.Value.AddDays( 1 ); // add one day to ensure we get all transactions till midnight
qry = qry.Where( t => t.TransactionDateTime.Value < lastDate );
}
// Transaction Types
var transactionTypeValueIdList = GetAttributeValue( "TransactionTypes" ).SplitDelimitedValues().AsGuidList().Select( a => DefinedValueCache.Read( a ) ).Where( a => a != null ).Select( a => a.Id ).ToList();
if ( transactionTypeValueIdList.Any() )
{
qry = qry.Where( t => transactionTypeValueIdList.Contains( t.TransactionTypeValueId ) );
}
qry = qry.OrderByDescending( a => a.TransactionDateTime );
var txns = qry.ToList();
// get account totals
Dictionary<string, decimal> accountTotals = new Dictionary<string, decimal>();
foreach ( var transaction in txns )
{
foreach ( var transactionDetail in transaction.TransactionDetails )
{
if ( accountTotals.Keys.Contains( transactionDetail.Account.Name ) )
{
accountTotals[transactionDetail.Account.Name] += transactionDetail.Amount;
}
else
{
accountTotals.Add( transactionDetail.Account.Name, transactionDetail.Amount );
}
}
}
lAccountSummary.Text = string.Empty;
if ( accountTotals.Count > 0 )
{
pnlSummary.Visible = true;
foreach ( var key in accountTotals.Keys )
{
lAccountSummary.Text += string.Format( "<li>{0}: {2}{1}</li>", key, accountTotals[key], GlobalAttributesCache.Value( "CurrencySymbol" ) );
}
}
else
{
pnlSummary.Visible = false;
}
gTransactions.EntityTypeId = EntityTypeCache.Read<FinancialTransaction>().Id;
gTransactions.DataSource = txns.Select( t => new
{
t.Id,
t.TransactionDateTime,
CurrencyType = FormatCurrencyType( t ),
Summary = FormatSummary( t ),
t.TotalAmount
} ).ToList();
gTransactions.DataBind();
}
/// <summary>
/// Handles the Click event of the btnNext control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void btnNext_Click( object sender, EventArgs e )
{
var changes = new List<string>();
var rockContext = new RockContext();
var financialTransactionService = new FinancialTransactionService( rockContext );
var financialTransactionDetailService = new FinancialTransactionDetailService( rockContext );
var financialPersonBankAccountService = new FinancialPersonBankAccountService( rockContext );
int txnId = hfTransactionId.Value.AsInteger();
var financialTransaction = financialTransactionService
.Queryable( "AuthorizedPersonAlias.Person,ProcessedByPersonAlias.Person" )
.FirstOrDefault( t => t.Id == txnId );
// set the AuthorizedPersonId (the person who wrote the check, for example) to the if the SelectNew person (if selected) or person selected in the drop down (if there is somebody selected)
int? authorizedPersonId = ppSelectNew.PersonId ?? ddlIndividual.SelectedValue.AsIntegerOrNull();
var accountNumberSecured = hfCheckMicrHashed.Value;
if ( cbTotalAmount.Text.AsDecimalOrNull().HasValue && !authorizedPersonId.HasValue )
{
nbSaveError.Text = "Transaction must be matched to a person when the amount is specified.";
nbSaveError.Visible = true;
return;
}
// if the transaction was previously matched, but user unmatched it, save it as an unmatched transaction and clear out the detail records (we don't want an unmatched transaction to have detail records)
if ( financialTransaction != null &&
financialTransaction.AuthorizedPersonAliasId.HasValue &&
!authorizedPersonId.HasValue )
{
financialTransaction.AuthorizedPersonAliasId = null;
foreach ( var detail in financialTransaction.TransactionDetails )
{
History.EvaluateChange( changes, detail.Account != null ? detail.Account.Name : "Unknown", detail.Amount.ToString( "C2" ), string.Empty );
financialTransactionDetailService.Delete( detail );
}
changes.Add( "Unmatched transaction" );
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(),
financialTransaction.BatchId.Value,
changes,
string.Format( "Transaction Id: {0}", financialTransaction.Id ),
typeof( FinancialTransaction ),
financialTransaction.Id,
false
);
rockContext.SaveChanges();
// if the transaction was unmatched, clear out the ProcessedBy fields since we didn't match the transaction and are moving on to process another transaction
MarkTransactionAsNotProcessedByCurrentUser( hfTransactionId.Value.AsInteger() );
}
// if the transaction is matched to somebody, attempt to save it. Otherwise, if the transaction was previously matched, but user unmatched it, save it as an unmatched transaction
if ( financialTransaction != null && authorizedPersonId.HasValue )
{
bool requiresMicr =
financialTransaction.FinancialPaymentDetail != null &&
financialTransaction.FinancialPaymentDetail.CurrencyTypeValue != null &&
financialTransaction.FinancialPaymentDetail.CurrencyTypeValue.Guid == Rock.SystemGuid.DefinedValue.CURRENCY_TYPE_CHECK.AsGuid();
if ( cbTotalAmount.Text.AsDecimalOrNull() == null )
{
nbSaveError.Text = "Total amount must be allocated to accounts.";
nbSaveError.Visible = true;
return;
}
var personAlias = new PersonAliasService( rockContext ).GetPrimaryAlias( authorizedPersonId.Value );
int? personAliasId = personAlias != null ? personAlias.Id : (int?)null;
// if this transaction has an accountnumber associated with it (in other words, it's a valid scanned check), ensure there is a financialPersonBankAccount record
if ( financialTransaction.MICRStatus == MICRStatus.Success && !string.IsNullOrWhiteSpace( accountNumberSecured ) )
{
var financialPersonBankAccount = financialPersonBankAccountService.Queryable().Where( a => a.AccountNumberSecured == accountNumberSecured && a.PersonAlias.PersonId == authorizedPersonId.Value ).FirstOrDefault();
if ( financialPersonBankAccount == null )
{
if ( personAliasId.HasValue )
{
financialPersonBankAccount = new FinancialPersonBankAccount();
financialPersonBankAccount.PersonAliasId = personAliasId.Value;
financialPersonBankAccount.AccountNumberSecured = accountNumberSecured;
var checkMicrClearText = Encryption.DecryptString( financialTransaction.CheckMicrParts );
var parts = checkMicrClearText.Split( '_' );
if ( parts.Length >= 2 )
{
financialPersonBankAccount.AccountNumberMasked = parts[1].Masked();
}
financialPersonBankAccountService.Add( financialPersonBankAccount );
}
}
}
string prevPerson = ( financialTransaction.AuthorizedPersonAlias != null && financialTransaction.AuthorizedPersonAlias.Person != null ) ?
financialTransaction.AuthorizedPersonAlias.Person.FullName : string.Empty;
string newPerson = string.Empty;
if ( personAliasId.HasValue )
{
newPerson = personAlias.Person.FullName;
financialTransaction.AuthorizedPersonAliasId = personAliasId;
}
History.EvaluateChange( changes, "Person", prevPerson, newPerson );
// just in case this transaction is getting re-edited either by the same user, or somebody else, clean out any existing TransactionDetail records
foreach ( var detail in financialTransaction.TransactionDetails.ToList() )
{
financialTransactionDetailService.Delete( detail );
History.EvaluateChange( changes, detail.Account != null ? detail.Account.Name : "Unknown", detail.Amount.ToString( "C2" ), string.Empty );
}
foreach ( var accountBox in rptAccounts.ControlsOfTypeRecursive<CurrencyBox>() )
{
var amount = accountBox.Text.AsDecimalOrNull();
if ( amount.HasValue && amount.Value >= 0 )
{
var financialTransactionDetail = new FinancialTransactionDetail();
financialTransactionDetail.TransactionId = financialTransaction.Id;
financialTransactionDetail.AccountId = accountBox.Attributes["data-account-id"].AsInteger();
financialTransactionDetail.Amount = amount.Value;
financialTransactionDetailService.Add( financialTransactionDetail );
History.EvaluateChange( changes, accountBox.Label, 0.0M.ToString( "C2" ), amount.Value.ToString( "C2" ) );
}
}
financialTransaction.ProcessedByPersonAliasId = this.CurrentPersonAlias.Id;
financialTransaction.ProcessedDateTime = RockDateTime.Now;
changes.Add( "Matched transaction" );
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_TRANSACTION.AsGuid(),
financialTransaction.BatchId.Value,
changes,
personAlias != null && personAlias.Person != null ? personAlias.Person.FullName : string.Format( "Transaction Id: {0}", financialTransaction.Id ),
typeof( FinancialTransaction ),
financialTransaction.Id,
false
);
rockContext.SaveChanges();
}
else
{
// if the transaction was not matched, clear out the ProcessedBy fields since we didn't match the transaction and are moving on to process another transaction
MarkTransactionAsNotProcessedByCurrentUser( hfTransactionId.Value.AsInteger() );
}
NavigateToTransaction( Direction.Next );
}
/// <summary>
/// Processes the payments.
/// </summary>
/// <param name="gateway">The gateway.</param>
/// <param name="batchNamePrefix">The batch name prefix.</param>
/// <param name="payments">The payments.</param>
/// <param name="batchUrlFormat">The batch URL format.</param>
/// <param name="receiptEmail">The receipt email.</param>
/// <returns></returns>
public static string ProcessPayments( FinancialGateway gateway, string batchNamePrefix, List<Payment> payments, string batchUrlFormat = "", Guid? receiptEmail = null )
{
int totalPayments = 0;
int totalAlreadyDownloaded = 0;
int totalNoScheduledTransaction = 0;
int totalAdded = 0;
int totalReversals = 0;
int totalStatusChanges = 0;
var batches = new List<FinancialBatch>();
var batchSummary = new Dictionary<Guid, List<Decimal>>();
var initialControlAmounts = new Dictionary<Guid, decimal>();
var txnPersonNames = new Dictionary<Guid, string>();
var gatewayComponent = gateway.GetGatewayComponent();
var newTransactions = new List<FinancialTransaction>();
using ( var rockContext = new RockContext() )
{
var accountService = new FinancialAccountService( rockContext );
var txnService = new FinancialTransactionService( rockContext );
var batchService = new FinancialBatchService( rockContext );
var scheduledTxnService = new FinancialScheduledTransactionService( rockContext );
var contributionTxnType = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid() );
var defaultAccount = accountService.Queryable()
.Where( a =>
a.IsActive &&
!a.ParentAccountId.HasValue &&
( !a.StartDate.HasValue || a.StartDate.Value <= RockDateTime.Now ) &&
( !a.EndDate.HasValue || a.EndDate.Value >= RockDateTime.Now )
)
.OrderBy( a => a.Order )
.FirstOrDefault();
var batchTxnChanges = new Dictionary<Guid, List<string>>();
var batchBatchChanges = new Dictionary<Guid, List<string>>();
var scheduledTransactionIds = new List<int>();
foreach ( var payment in payments.Where( p => p.Amount > 0.0M ) )
{
totalPayments++;
var scheduledTransaction = scheduledTxnService.GetByScheduleId( payment.GatewayScheduleId );
if ( scheduledTransaction != null )
{
// Find existing payments with same transaction code
var txns = txnService
.Queryable( "TransactionDetails" )
.Where( t => t.TransactionCode == payment.TransactionCode )
.ToList();
// Calculate whether a transaction needs to be added
var txnAmount = CalculateTransactionAmount( payment, txns );
if ( txnAmount != 0.0M )
{
scheduledTransactionIds.Add( scheduledTransaction.Id );
if ( payment.ScheduleActive.HasValue )
{
scheduledTransaction.IsActive = payment.ScheduleActive.Value;
}
var transaction = new FinancialTransaction();
transaction.FinancialPaymentDetail = new FinancialPaymentDetail();
transaction.Guid = Guid.NewGuid();
transaction.TransactionCode = payment.TransactionCode;
transaction.TransactionDateTime = payment.TransactionDateTime;
transaction.Status = payment.Status;
transaction.StatusMessage = payment.StatusMessage;
transaction.ScheduledTransactionId = scheduledTransaction.Id;
transaction.AuthorizedPersonAliasId = scheduledTransaction.AuthorizedPersonAliasId;
transaction.SourceTypeValueId = scheduledTransaction.SourceTypeValueId;
txnPersonNames.Add( transaction.Guid, scheduledTransaction.AuthorizedPersonAlias.Person.FullName );
transaction.FinancialGatewayId = gateway.Id;
transaction.TransactionTypeValueId = contributionTxnType.Id;
if ( txnAmount < 0.0M )
{
transaction.Summary = "Reversal for previous transaction that failed during processing." + Environment.NewLine;
}
var currencyTypeValue = payment.CurrencyTypeValue;
var creditCardTypevalue = payment.CreditCardTypeValue;
if ( scheduledTransaction.FinancialPaymentDetail != null )
{
if ( currencyTypeValue == null && scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.HasValue )
{
currencyTypeValue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CurrencyTypeValueId.Value );
}
if ( creditCardTypevalue == null && scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.HasValue )
{
creditCardTypevalue = DefinedValueCache.Read( scheduledTransaction.FinancialPaymentDetail.CreditCardTypeValueId.Value );
}
transaction.FinancialPaymentDetail.AccountNumberMasked = scheduledTransaction.FinancialPaymentDetail.AccountNumberMasked;
transaction.FinancialPaymentDetail.NameOnCardEncrypted = scheduledTransaction.FinancialPaymentDetail.NameOnCardEncrypted;
transaction.FinancialPaymentDetail.ExpirationMonthEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationMonthEncrypted;
transaction.FinancialPaymentDetail.ExpirationYearEncrypted = scheduledTransaction.FinancialPaymentDetail.ExpirationYearEncrypted;
transaction.FinancialPaymentDetail.BillingLocationId = scheduledTransaction.FinancialPaymentDetail.BillingLocationId;
}
if ( currencyTypeValue != null )
{
transaction.FinancialPaymentDetail.CurrencyTypeValueId = currencyTypeValue.Id;
}
if ( creditCardTypevalue != null )
{
transaction.FinancialPaymentDetail.CreditCardTypeValueId = creditCardTypevalue.Id;
}
// Try to allocate the amount of the transaction based on the current scheduled transaction accounts
decimal remainingAmount = Math.Abs( txnAmount );
foreach ( var detail in scheduledTransaction.ScheduledTransactionDetails.Where( d => d.Amount != 0.0M ) )
{
var transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = detail.AccountId;
if ( detail.Amount <= remainingAmount )
{
// If the configured amount for this account is less than or equal to the remaining
// amount, allocate the configured amount
transactionDetail.Amount = detail.Amount;
remainingAmount -= detail.Amount;
}
else
{
// If the configured amount is greater than the remaining amount, only allocate
// the remaining amount
transaction.Summary += "Note: Downloaded transaction amount was less than the configured allocation amounts for the Scheduled Transaction.";
transactionDetail.Amount = remainingAmount;
transactionDetail.Summary = "Note: The downloaded amount was not enough to apply the configured amount to this account.";
remainingAmount = 0.0M;
}
transaction.TransactionDetails.Add( transactionDetail );
if ( remainingAmount <= 0.0M )
{
// If there's no amount left, break out of details
break;
}
}
// If there's still amount left after allocating based on current config, add the remainder
// to the account that was configured for the most amount
if ( remainingAmount > 0.0M )
{
transaction.Summary += "Note: Downloaded transaction amount was greater than the configured allocation amounts for the Scheduled Transaction.";
var transactionDetail = transaction.TransactionDetails
.OrderByDescending( d => d.Amount )
.FirstOrDefault();
if ( transactionDetail == null && defaultAccount != null )
{
transactionDetail = new FinancialTransactionDetail();
transactionDetail.AccountId = defaultAccount.Id;
transaction.TransactionDetails.Add( transactionDetail );
}
if ( transactionDetail != null )
{
transactionDetail.Amount += remainingAmount;
transactionDetail.Summary = "Note: Extra amount was applied to this account.";
}
}
// If the amount to apply was negative, update all details to be negative (absolute value was used when allocating to accounts)
if ( txnAmount < 0.0M )
{
foreach ( var txnDetail in transaction.TransactionDetails )
{
txnDetail.Amount = 0 - txnDetail.Amount;
}
}
// Get the batch
var batch = batchService.Get(
batchNamePrefix,
currencyTypeValue,
creditCardTypevalue,
transaction.TransactionDateTime.Value,
gateway.GetBatchTimeOffset(),
batches );
var batchChanges = new List<string>();
if ( batch.Id != 0 )
{
initialControlAmounts.AddOrIgnore( batch.Guid, batch.ControlAmount );
}
batch.ControlAmount += transaction.TotalAmount;
batch.Transactions.Add( transaction );
if ( txnAmount > 0.0M && receiptEmail.HasValue )
{
newTransactions.Add( transaction );
}
// Add summary
if ( !batchSummary.ContainsKey( batch.Guid ) )
{
batchSummary.Add( batch.Guid, new List<Decimal>() );
}
batchSummary[batch.Guid].Add( txnAmount );
if ( txnAmount > 0.0M )
{
totalAdded++;
}
else
{
totalReversals++;
}
}
else
{
totalAlreadyDownloaded++;
foreach ( var txn in txns.Where( t => t.Status != payment.Status || t.StatusMessage != payment.StatusMessage ) )
{
txn.Status = payment.Status;
txn.StatusMessage = payment.StatusMessage;
totalStatusChanges++;
}
}
}
else
{
totalNoScheduledTransaction++;
}
}
rockContext.SaveChanges();
// Queue a transaction to update the status of all affected scheduled transactions
var updatePaymentStatusTxn = new Rock.Transactions.UpdatePaymentStatusTransaction( gateway.Id, scheduledTransactionIds );
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( updatePaymentStatusTxn );
if ( receiptEmail.HasValue )
{
// Queue a transaction to send receipts
var newTransactionIds = newTransactions.Select( t => t.Id ).ToList();
var sendPaymentReceiptsTxn = new Rock.Transactions.SendPaymentReceipts( receiptEmail.Value, newTransactionIds );
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( sendPaymentReceiptsTxn );
}
}
StringBuilder sb = new StringBuilder();
sb.AppendFormat( "<li>{0} {1} downloaded.</li>", totalPayments.ToString( "N0" ),
( totalPayments == 1 ? "payment" : "payments" ) );
if ( totalAlreadyDownloaded > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded and {2} already been added.</li>", totalAlreadyDownloaded.ToString( "N0" ),
( totalAlreadyDownloaded == 1 ? "payment was" : "payments were" ),
( totalAlreadyDownloaded == 1 ? "has" : "have" ) );
}
if ( totalStatusChanges > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded but had a change of status.</li>", totalStatusChanges.ToString( "N0" ),
( totalStatusChanges == 1 ? "payment was" : "payments were" ) );
}
if ( totalNoScheduledTransaction > 0 )
{
sb.AppendFormat( "<li>{0} {1} could not be matched to an existing scheduled payment profile.</li>", totalNoScheduledTransaction.ToString( "N0" ),
( totalNoScheduledTransaction == 1 ? "payment" : "payments" ) );
}
sb.AppendFormat( "<li>{0} {1} successfully added.</li>", totalAdded.ToString( "N0" ),
( totalAdded == 1 ? "payment was" : "payments were" ) );
if ( totalReversals > 0 )
{
sb.AppendFormat( "<li>{0} {1} added as a reversal to a previous transaction.</li>", totalReversals.ToString( "N0" ),
( totalReversals == 1 ? "payment was" : "payments were" ) );
}
if ( totalStatusChanges > 0 )
{
sb.AppendFormat( "<li>{0} {1} previously downloaded but had a change of status.</li>", totalStatusChanges.ToString( "N0" ),
( totalStatusChanges == 1 ? "payment was" : "payments were" ) );
}
foreach ( var batchItem in batchSummary )
{
int items = batchItem.Value.Count;
if ( items > 0 )
{
var batch = batches
.Where( b => b.Guid.Equals( batchItem.Key ) )
.FirstOrDefault();
string batchName = string.Format( "'{0} ({1})'", batch.Name, batch.BatchStartDateTime.Value.ToString( "d" ) );
if ( !string.IsNullOrWhiteSpace( batchUrlFormat ) )
{
batchName = string.Format( "<a href='{0}'>{1}</a>", string.Format( batchUrlFormat, batch.Id ), batchName );
}
decimal sum = batchItem.Value.Sum();
string summaryformat = items == 1 ?
"<li>{0} transaction of {1} was added to the {2} batch.</li>" :
"<li>{0} transactions totaling {1} were added to the {2} batch</li>";
sb.AppendFormat( summaryformat, items.ToString( "N0" ), sum.FormatAsCurrency(), batchName );
}
}
return sb.ToString();
}
/// <summary>
/// Handles the Delete event of the gBatchList control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="RowEventArgs"/> instance containing the event data.</param>
protected void gBatchList_Delete( object sender, RowEventArgs e )
{
var rockContext = new RockContext();
var batchService = new FinancialBatchService( rockContext );
var transactionService = new FinancialTransactionService( rockContext );
var batch = batchService.Get( e.RowKeyId );
if ( batch != null )
{
if ( UserCanEdit || batch.IsAuthorized( Rock.Security.Authorization.EDIT, CurrentPerson ) )
{
string errorMessage;
if ( !batchService.CanDelete( batch, out errorMessage ) )
{
mdGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
rockContext.WrapTransaction( () =>
{
foreach ( var txn in transactionService.Queryable()
.Where( t => t.BatchId == batch.Id ) )
{
transactionService.Delete( txn );
}
HistoryService.SaveChanges(
rockContext,
typeof( FinancialBatch ),
Rock.SystemGuid.Category.HISTORY_FINANCIAL_BATCH.AsGuid(),
batch.Id,
new List<string> { "Deleted the batch" } );
batchService.Delete( batch );
rockContext.SaveChanges();
} );
}
}
BindGrid();
}
