private GatewayComponent GetGatewayComponent(RockContext rockContext, FinancialGateway gateway)
{
if (gateway != null)
{
gateway.LoadAttributes(rockContext);
return(gateway.GetGatewayComponent());
}
return(null);
}
/// <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();
}
private GatewayComponent GetGatewayComponent( RockContext rockContext, FinancialGateway gateway )
{
if ( gateway != null )
{
gateway.LoadAttributes( rockContext );
var gatewayComponent = gateway.GetGatewayComponent();
if ( gatewayComponent != null )
{
var threeStepGateway = gatewayComponent as ThreeStepGatewayComponent;
if ( threeStepGateway != null )
{
_using3StepGateway = true;
Step2IFrameUrl = ResolveRockUrl( threeStepGateway.Step2FormUrl );
}
}
return gatewayComponent;
}
return null;
}
/// <summary>
/// Safely load entities that have not yet been assigned a non-null value based on the arguments.
/// </summary>
private void LoadEntities()
{
if (_automatedPaymentArgs.ScheduledTransactionId.HasValue && _financialScheduledTransaction == null)
{
_financialScheduledTransaction = _financialScheduledTransactionService.Queryable()
.AsNoTracking()
.Include(s => s.TransactionFrequencyValue)
.FirstOrDefault(s => s.Id == _automatedPaymentArgs.ScheduledTransactionId.Value);
}
if (_authorizedPerson == null)
{
_authorizedPerson = _personAliasService.GetPersonNoTracking(_automatedPaymentArgs.AuthorizedPersonAliasId);
}
if (_financialGateway == null)
{
_financialGateway = _financialGatewayService.GetNoTracking(_automatedPaymentArgs.AutomatedGatewayId);
}
if (_financialGateway != null && _automatedGatewayComponent == null)
{
_automatedGatewayComponent = _financialGateway.GetGatewayComponent();
}
if (_financialAccounts == null)
{
var accountIds = _automatedPaymentArgs.AutomatedPaymentDetails.Select(d => d.AccountId).ToList();
_financialAccounts = _financialAccountService.GetByIds(accountIds).AsNoTracking().ToDictionary(fa => fa.Id, fa => fa);
}
if (_authorizedPerson != null && _financialPersonSavedAccount == null && _financialGateway != null)
{
// Pick the correct saved account based on args or default for the user
var financialGatewayId = _financialGateway.Id;
var savedAccounts = _financialPersonSavedAccountService
.GetByPersonId(_authorizedPerson.Id)
.AsNoTracking()
.Where(sa => sa.FinancialGatewayId == financialGatewayId)
.Include(sa => sa.FinancialPaymentDetail)
.OrderByDescending(sa => sa.CreatedDateTime ?? DateTime.MinValue)
.ToList();
if (_automatedPaymentArgs.FinancialPersonSavedAccountId.HasValue)
{
// If there is an indicated saved account to use, don't assume any other saved account even with a schedule
var savedAccountId = _automatedPaymentArgs.FinancialPersonSavedAccountId.Value;
_financialPersonSavedAccount = savedAccounts.FirstOrDefault(sa => sa.Id == savedAccountId);
}
else
{
// If there is a schedule and no indicated saved account to use, try to use payment info associated with the schedule
if (_financialScheduledTransaction != null)
{
_financialPersonSavedAccount =
// sa.ReferenceNumber == fst.TransactionCode
savedAccounts.FirstOrDefault(sa => !string.IsNullOrEmpty(sa.ReferenceNumber) && sa.ReferenceNumber == _financialScheduledTransaction.TransactionCode) ??
// sa.GatewayPersonIdentifier == fst.TransactionCode
savedAccounts.FirstOrDefault(sa => !string.IsNullOrEmpty(sa.GatewayPersonIdentifier) && sa.GatewayPersonIdentifier == _financialScheduledTransaction.TransactionCode) ??
// sa.FinancialPaymentDetailId == fst.FinancialPaymentDetailId
savedAccounts.FirstOrDefault(sa => sa.FinancialPaymentDetailId.HasValue && sa.FinancialPaymentDetailId == _financialScheduledTransaction.FinancialPaymentDetailId) ??
// sa.TransactionCode == fst.TransactionCode
savedAccounts.FirstOrDefault(sa => !string.IsNullOrEmpty(sa.TransactionCode) && sa.TransactionCode == _financialScheduledTransaction.TransactionCode);
}
if (_financialPersonSavedAccount == null)
{
// Use the default or first if no default
_financialPersonSavedAccount =
savedAccounts.FirstOrDefault(sa => sa.IsDefault) ??
savedAccounts.FirstOrDefault();
}
}
}
if (_financialPersonSavedAccount != null && _referencePaymentInfo == null)
{
_referencePaymentInfo = _financialPersonSavedAccount.GetReferencePayment();
}
if (_transactionType == null)
{
_transactionType = DefinedValueCache.Get(_automatedPaymentArgs.TransactionTypeGuid ?? SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid());
}
if (_financialSource == null)
{
_financialSource = DefinedValueCache.Get(_automatedPaymentArgs.FinancialSourceGuid ?? SystemGuid.DefinedValue.FINANCIAL_SOURCE_TYPE_WEBSITE.AsGuid());
}
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Init" /> event.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnInit( EventArgs e )
{
base.OnInit( e );
if ( !Page.IsPostBack )
{
lPanelTitle1.Text = GetAttributeValue( "PanelTitle" );
lPanelTitle2.Text = GetAttributeValue( "PanelTitle" );
lContributionInfoTitle.Text = GetAttributeValue( "ContributionInfoTitle" );
lPersonalInfoTitle.Text = GetAttributeValue( "PersonalInfoTitle" );
lPaymentInfoTitle.Text = GetAttributeValue( "PaymentInfoTitle" );
lConfirmationTitle.Text = GetAttributeValue( "ConfirmationTitle" );
lSuccessTitle.Text = GetAttributeValue( "SuccessTitle" );
lSaveAcccountTitle.Text = GetAttributeValue( "SaveAccountTitle" );
}
// Enable payment options based on the configured gateways
bool ccEnabled = false;
bool achEnabled = false;
GatewayComponent ccGatewayComponent = null;
GatewayComponent achGatewayComponent = null;
var supportedFrequencies = new List<DefinedValueCache>();
_showCommmentEntry = GetAttributeValue( "EnableCommentEntry" ).AsBoolean();
txtCommentEntry.Label = GetAttributeValue( "CommentEntryLabel" );
txtCommentEntry.Visible = _showCommmentEntry;
using ( var rockContext = new RockContext() )
{
// If impersonation is allowed, and a valid person key was used, set the target to that person
if ( GetAttributeValue( "Impersonation" ).AsBooleanOrNull() ?? false )
{
string personKey = PageParameter( "Person" );
if ( !string.IsNullOrWhiteSpace( personKey ) )
{
TargetPerson = new PersonService( rockContext ).GetByUrlEncodedKey( personKey );
}
}
if ( TargetPerson == null )
{
TargetPerson = CurrentPerson;
}
var financialGatewayService = new FinancialGatewayService( rockContext );
Guid? ccGatewayGuid = GetAttributeValue( "CCGateway" ).AsGuidOrNull();
if ( ccGatewayGuid.HasValue )
{
_ccGateway = financialGatewayService.Get( ccGatewayGuid.Value );
if ( _ccGateway != null )
{
_ccGateway.LoadAttributes( rockContext );
ccGatewayComponent = _ccGateway.GetGatewayComponent();
if ( ccGatewayComponent != null )
{
ccEnabled = true;
txtCardFirstName.Visible = ccGatewayComponent.SplitNameOnCard;
txtCardLastName.Visible = ccGatewayComponent.SplitNameOnCard;
txtCardName.Visible = !ccGatewayComponent.SplitNameOnCard;
mypExpiration.MinimumYear = RockDateTime.Now.Year;
}
}
}
Guid? achGatewayGuid = GetAttributeValue( "ACHGateway" ).AsGuidOrNull();
if ( achGatewayGuid.HasValue )
{
_achGateway = financialGatewayService.Get( achGatewayGuid.Value );
if ( _achGateway != null )
{
_achGateway.LoadAttributes( rockContext );
achGatewayComponent = _achGateway.GetGatewayComponent();
achEnabled = achGatewayComponent != null;
}
}
}
hfCurrentPage.Value = "1";
RockPage page = Page as RockPage;
if ( page != null )
{
page.PageNavigate += page_PageNavigate;
}
if ( ccEnabled || achEnabled )
{
if ( ccEnabled )
{
supportedFrequencies = ccGatewayComponent.SupportedPaymentSchedules;
hfPaymentTab.Value = "CreditCard";
}
else
{
supportedFrequencies = achGatewayComponent.SupportedPaymentSchedules;
hfPaymentTab.Value = "ACH";
}
if ( ccEnabled && achEnabled )
{
phPills.Visible = true;
// If CC and ACH gateways are different, only allow frequencies supported by both payment gateways (if different)
if ( ccGatewayComponent.TypeId != _achGateway.TypeId )
{
supportedFrequencies = ccGatewayComponent.SupportedPaymentSchedules
.Where( c =>
achGatewayComponent.SupportedPaymentSchedules
.Select( a => a.Id )
.Contains( c.Id ) )
.ToList();
}
divCCPaymentInfo.AddCssClass( "tab-pane" );
divACHPaymentInfo.AddCssClass( "tab-pane" );
}
divCCPaymentInfo.Visible = ccEnabled;
divACHPaymentInfo.Visible = achEnabled;
if ( supportedFrequencies.Any() )
{
bool allowScheduled = GetAttributeValue( "AllowScheduled" ).AsBoolean();
if ( allowScheduled )
{
_showRepeatingOptions = true;
var oneTimeFrequency = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.TRANSACTION_FREQUENCY_ONE_TIME );
divRepeatingPayments.Visible = true;
btnFrequency.DataSource = supportedFrequencies;
btnFrequency.DataBind();
// If gateway didn't specifically support one-time, add it anyway for immediate gifts
if ( !supportedFrequencies.Where( f => f.Id == oneTimeFrequency.Id ).Any() )
{
btnFrequency.Items.Insert( 0, new ListItem( oneTimeFrequency.Value, oneTimeFrequency.Id.ToString() ) );
}
btnFrequency.SelectedValue = oneTimeFrequency.Id.ToString();
dtpStartDate.SelectedDate = RockDateTime.Today;
}
}
// Display Options
btnAddAccount.Title = GetAttributeValue( "AddAccountText" );
bool displayEmail = GetAttributeValue( "DisplayEmail" ).AsBoolean();
txtEmail.Visible = displayEmail;
tdEmailConfirm.Visible = displayEmail;
tdEmailReceipt.Visible = displayEmail;
bool displayPhone = GetAttributeValue( "DisplayPhone" ).AsBoolean();
pnbPhone.Visible = displayPhone;
tdPhoneConfirm.Visible = displayPhone;
tdPhoneReceipt.Visible = displayPhone;
FluidLayout = GetAttributeValue( "LayoutStyle" ) == "Fluid";
BindSavedAccounts();
if ( rblSavedCC.Items.Count > 0 )
{
rblSavedCC.Items[0].Selected = true;
rblSavedCC.Visible = true;
divNewCard.Style[HtmlTextWriterStyle.Display] = "none";
}
else
{
rblSavedCC.Visible = false;
divNewCard.Style[HtmlTextWriterStyle.Display] = "block";
}
if ( rblSavedAch.Items.Count > 0 )
{
rblSavedAch.Items[0].Selected = true;
rblSavedAch.Visible = true;
divNewBank.Style[HtmlTextWriterStyle.Display] = "none";
}
else
{
rblSavedAch.Visible = false;
divNewCard.Style[HtmlTextWriterStyle.Display] = "block";
}
RegisterScript();
// Resolve the text field merge fields
var configValues = new Dictionary<string, object>();
phConfirmationHeader.Controls.Add( new LiteralControl( GetAttributeValue( "ConfirmationHeader" ).ResolveMergeFields( configValues ) ) );
phConfirmationFooter.Controls.Add( new LiteralControl( GetAttributeValue( "ConfirmationFooter" ).ResolveMergeFields( configValues ) ) );
phSuccessHeader.Controls.Add( new LiteralControl( GetAttributeValue( "SuccessHeader" ).ResolveMergeFields( configValues ) ) );
phSuccessFooter.Controls.Add( new LiteralControl( GetAttributeValue( "SuccessFooter" ).ResolveMergeFields( configValues ) ) );
//// Temp values for testing...
/*
txtCreditCard.Text = "5105105105105100";
txtCVV.Text = "023";
txtBankName.Text = "Test Bank";
txtRoutingNumber.Text = "111111118";
txtAccountNumber.Text = "1111111111";
*/
}
}