public string GenerateKey(string userId, string password)
{
var et = new ElementTree();
var root = et.Element("GenerateKey");
et.SubElement(root, "mid").Text(MerchantId);
et.SubElement(root, "userID").Text(userId);
et.SubElement(root, "password").Text(password);
et.SubElement(root, "transactionKey", TransactionKey);
string rawResponse = DoTransaction(et.ToString(root));
var response = ElementTree.Parse(rawResponse).Get("GenerateKeyResponse");
if (response.GetValue <string>("status").Equals("PASS"))
{
TransactionKey = response.GetValue <string>("transactionKey");
return(TransactionKey);
}
else
{
string responseCode = response.GetValue <string>("responseCode");
string responseMessage = response.GetValue <string>("responseMessage");
throw new GatewayException("Failed to generate transaction key for the given credentials", responseCode, responseMessage);
}
}
private Element BuildAddress(ElementTree et, Address address)
{
if (address == null)
{
return(null);
}
var code = address.PostalCode;
if (!string.IsNullOrEmpty(code) && !code.Contains("|"))
{
code = string.Format("{0}|{1}", address.PostalCode, address.StreetAddress1);
if (address.Country == "GB")
{
var encStreetAddress = string.IsNullOrEmpty(address.StreetAddress1) ? "" : Regex.Replace(address.StreetAddress1, "[^0-9]", "");
code = string.Format("{0}|{1}", Regex.Replace(address.PostalCode, "[^0-9]", ""), encStreetAddress);
}
}
var addressNode = et.Element("address").Set("type", address.Type == AddressType.Billing ? "billing" : "shipping");
et.SubElement(addressNode, "code").Text(code);
et.SubElement(addressNode, "country").Text(address.Country);
return(addressNode);
}
private void HydrateDocumentUploadData(ElementTree xml, Element xmlTrans, TransactionType transType, DocumentUploadData docUploadData)
{
var docNameTag = transType == TransactionType.UploadDocumentChargeback ? "DocumentName" : "documentName";
var docTypeTag = transType == TransactionType.UploadDocumentChargeback ? "DocType" : "docType";
xml.SubElement(xmlTrans, docNameTag, docUploadData.DocumentName);
xml.SubElement(xmlTrans, "TransactionReference", docUploadData.TransactionReference);
xml.SubElement(xmlTrans, "DocCategory", docUploadData.DocCategory);
xml.SubElement(xmlTrans, docTypeTag, docUploadData.DocType);
xml.SubElement(xmlTrans, "Document", docUploadData.Document);
}
private void HydrateFlashFundsPaymentCardData(ElementTree xml, Element xmlTrans, FlashFundsPaymentCardData cardData)
{
xml.SubElement(xmlTrans, "ccNum", cardData.CreditCard.Number);
xml.SubElement(xmlTrans, "expDate", cardData.CreditCard.ShortExpiry);
xml.SubElement(xmlTrans, "CVV2", cardData.CreditCard.Cvn);
xml.SubElement(xmlTrans, "cardholderName", cardData.CreditCard.CardHolderName);
xml.SubElement(xmlTrans, "addr", cardData.CardholderAddress.StreetAddress1);
xml.SubElement(xmlTrans, "city", cardData.CardholderAddress.City);
xml.SubElement(xmlTrans, "state", cardData.CardholderAddress.State);
xml.SubElement(xmlTrans, "zip", cardData.CardholderAddress.PostalCode);
xml.SubElement(xmlTrans, "country", cardData.CardholderAddress.Country);
}
private string BuildEnvelope(ElementTree et, Element transaction)
{
var envelope = et.Element("soap:Envelope");
var body = et.SubElement(envelope, "soap:Body");
body.Append(transaction);
return(et.ToString(envelope));
}
private void HydrateAccountRenewDetails(ElementTree xml, Element xmlTrans, RenewAccountData renewalAccountData)
{
xml.SubElement(xmlTrans, "tier", renewalAccountData.Tier);
xml.SubElement(xmlTrans, "CVV2", renewalAccountData.CreditCard.Cvn);
xml.SubElement(xmlTrans, "ccNum", renewalAccountData.CreditCard.Number);
xml.SubElement(xmlTrans, "expDate", renewalAccountData.CreditCard.ShortExpiry);
xml.SubElement(xmlTrans, "zip", renewalAccountData.ZipCode);
xml.SubElement(xmlTrans, "PaymentBankAccountNumber", renewalAccountData.PaymentBankAccountNumber);
xml.SubElement(xmlTrans, "PaymentBankRoutingNumber", renewalAccountData.PaymentBankRoutingNumber);
xml.SubElement(xmlTrans, "PaymentBankAccountType", renewalAccountData.PaymentBankAccountType);
}
private void HydrateMailAddress(ElementTree xml, Element xmlTrans, Address mailingAddressInfo)
{
xml.SubElement(xmlTrans, "mailAddr", mailingAddressInfo.StreetAddress1);
xml.SubElement(xmlTrans, "mailApt", mailingAddressInfo.StreetAddress2);
xml.SubElement(xmlTrans, "mailAddr3", mailingAddressInfo.StreetAddress3);
xml.SubElement(xmlTrans, "mailCity", mailingAddressInfo.City);
xml.SubElement(xmlTrans, "mailCountry", mailingAddressInfo.Country);
xml.SubElement(xmlTrans, "mailState", mailingAddressInfo.State);
xml.SubElement(xmlTrans, "mailZip", mailingAddressInfo.PostalCode);
}
internal override TerminalResponse ManageTransaction(TerminalManageBuilder builder)
{
ElementTree et = new ElementTree();
var transactionType = MapTransactionType(builder.TransactionType);
Element request = et.Element("SIP");
et.SubElement(request, "Version").Text("1.0");
et.SubElement(request, "ECRId").Text("1004");
et.SubElement(request, "Request").Text(MapTransactionType(builder.TransactionType));
if (builder.TransactionType == TransactionType.Capture)
{
et.SubElement(request, "RequestId", builder.ReferenceNumber);
}
et.SubElement(request, "TransactionId", builder.TransactionId);
if (builder.Gratuity != null)
{
et.SubElement(request, "TipAmount").Text(builder.Gratuity.ToNumericCurrencyString());
}
var response = SendMessage <SipDeviceResponse>(et.ToString(request), transactionType);
return(response);
}
internal string BuildManageTransaction(TerminalManageBuilder builder)
{
int requestId = builder.ReferenceNumber;
if (requestId == default(int) && RequestIdProvider != null)
{
requestId = RequestIdProvider.GetRequestId();
}
ElementTree et = new ElementTree();
var transactionType = MapTransactionType(builder.TransactionType);
Element request = et.Element("SIP");
et.SubElement(request, "Version").Text("1.0");
et.SubElement(request, "ECRId").Text("1004");
et.SubElement(request, "Request").Text(MapTransactionType(builder.TransactionType));
if ((builder.TransactionType == TransactionType.Capture) || (builder.TransactionType == TransactionType.Void))
{
et.SubElement(request, "RequestId", requestId);
}
et.SubElement(request, "TransactionId", builder.TransactionId);
if (builder.Gratuity != null)
{
et.SubElement(request, "TipAmount").Text(builder.Gratuity.ToNumericCurrencyString());
}
return(et.ToString(request));
}
private void HydrateDeviceData(ElementTree xml, Element xmlTrans, DeviceData deviceData)
{
var devices = xml.SubElement(xmlTrans, "Devices");
if (deviceData.Devices.Count > 0)
{
foreach (DeviceInfo deviceInfo in deviceData.Devices)
{
var device = xml.SubElement(devices, "Device");
xml.SubElement(device, "Name", deviceInfo.Name);
xml.SubElement(device, "Quantity", deviceInfo.Quantity == null ? 0 : deviceInfo.Quantity);
if (deviceInfo.Attributes != null)
{
if (deviceInfo.Attributes.Count > 0)
{
var attributes = xml.SubElement(device, "Attributes");
foreach (DeviceAttributeInfo attributeInfo in deviceInfo.Attributes)
{
var item = xml.SubElement(attributes, "Item");
item.Set("Name", attributeInfo.Name);
item.Set("Value", attributeInfo.Value);
}
}
}
}
}
}
public string BuildRequest <T>(T builder) where T : TransactionBuilder <Transaction>
{
var et = new ElementTree();
Element transaction = et.Element(_root);
foreach (var element in BuildRequestMap(builder))
{
et.SubElement(transaction, element, this[element]);
}
return(et.ToString(transaction));
}
public Transaction ProcessPayFac(PayFacBuilder builder)
{
UpdateGatewaySettings(builder);
var et = new ElementTree();
var request = et.Element("XMLRequest");
// Credentials
et.SubElement(request, "certStr", CertStr);
et.SubElement(request, "termid", TermID);
et.SubElement(request, "class", "partner");
//Transaction
var xmlTrans = et.SubElement(request, "XMLTrans");
et.SubElement(xmlTrans, "transType", MapRequestType(builder));
// Account Details
HydrateAccountDetails(et, xmlTrans, builder);
var response = DoTransaction(et.ToString(request));
return(MapResponse(builder, response));
}
private Element BuildCustomer(ElementTree et, Customer customer)
{
var payer = et.Element("payer")
.Set("ref", customer.Key ?? GenerationUtils.GenerateRecurringKey())
.Set("type", "Retail");
et.SubElement(payer, "title", customer.Title);
et.SubElement(payer, "firstname", customer.FirstName);
et.SubElement(payer, "surname", customer.LastName);
et.SubElement(payer, "company", customer.Company);
if (customer.Address != null)
{
var address = et.SubElement(payer, "address");
et.SubElement(address, "line1", customer.Address.StreetAddress1);
et.SubElement(address, "line2", customer.Address.StreetAddress2);
et.SubElement(address, "line3", customer.Address.StreetAddress3);
et.SubElement(address, "city", customer.Address.City);
et.SubElement(address, "county", customer.Address.Province);
et.SubElement(address, "postcode", customer.Address.PostalCode);
var country = et.SubElement(address, "country", customer.Address.Country);
if (country != null)
{
country.Set("code", customer.Address.CountryCode);
}
}
var phone = et.SubElement(payer, "phonenumbers");
et.SubElement(phone, "home", customer.HomePhone);
et.SubElement(phone, "work", customer.WorkPhone);
et.SubElement(phone, "fax", customer.Fax);
et.SubElement(phone, "mobile", customer.MobilePhone);
et.SubElement(payer, "email", customer.Email);
// comments
return(payer);
}
public Transaction ProcessAuthorization(AuthorizationBuilder builder)
{
var et = new ElementTree();
string timestamp = builder.Timestamp ?? GenerationUtils.GenerateTimestamp();
string orderId = builder.OrderId ?? GenerationUtils.GenerateOrderId();
string transactionType = MapAuthRequestType(builder);
if (builder.PaymentMethod is CreditCardData)
{
var card = builder.PaymentMethod as CreditCardData;
if (builder.TransactionModifier == TransactionModifier.EncryptedMobile)
{
if (card.Token == null || card.MobileType == null)
{
throw new BuilderException("Token and MobileType can not be null");
}
if (card.MobileType == MobilePaymentMethodType.GOOGLEPAY.ToString() && (builder.Amount == null || builder.Currency == null))
{
throw new BuilderException("Amount and Currency can not be null for capture.");
}
}
}
if (builder.PaymentMethod is AlternatePaymentMethod)
{
var apm = builder.PaymentMethod as AlternatePaymentMethod;
if (apm.ReturnUrl == null || apm.StatusUpdateUrl == null || apm.AccountHolderName == null || apm.Country == null || apm.Descriptor == null)
{
throw new BuilderException("PaymentMethod, ReturnUrl, StatusUpdateUrl, AccountHolderName, Country, Descriptor can not be null ");
}
}
// Build Request
var request = et.Element("request")
.Set("timestamp", timestamp)
.Set("type", transactionType);
et.SubElement(request, "merchantid").Text(MerchantId);
et.SubElement(request, "account", AccountId);
et.SubElement(request, "channel", Channel);
if (builder.Amount.HasValue)
{
et.SubElement(request, "amount").Text(builder.Amount.ToNumericCurrencyString()).Set("currency", builder.Currency);
}
// This needs to be figured out based on txn type and set to 0, 1 or MULTI
if (builder.TransactionType == TransactionType.Sale || builder.TransactionType == TransactionType.Auth)
{
var autoSettle = builder.TransactionType == TransactionType.Sale ? "1" : builder.MultiCapture == true ? "MULTI" : "0";
et.SubElement(request, "autosettle").Set("flag", autoSettle);
}
et.SubElement(request, "orderid", orderId);
// Hydrate the payment data fields
if (builder.PaymentMethod is CreditCardData)
{
var card = builder.PaymentMethod as CreditCardData;
if (builder.TransactionModifier == TransactionModifier.EncryptedMobile)
{
et.SubElement(request, "mobile", card.MobileType);
et.SubElement(request, "token", card.Token);
}
else
{
var cardElement = et.SubElement(request, "card");
et.SubElement(cardElement, "number", card.Number);
et.SubElement(cardElement, "expdate", card.ShortExpiry);
et.SubElement(cardElement, "chname").Text(card.CardHolderName);
et.SubElement(cardElement, "type", card.CardType.ToUpper());
if (card.Cvn != null)
{
var cvnElement = et.SubElement(cardElement, "cvn");
et.SubElement(cvnElement, "number", card.Cvn);
et.SubElement(cvnElement, "presind", (int)card.CvnPresenceIndicator);
}
}
// mpi
if (card.ThreeDSecure != null)
{
var mpi = et.SubElement(request, "mpi");
et.SubElement(mpi, "cavv", card.ThreeDSecure.Cavv);
et.SubElement(mpi, "xid", card.ThreeDSecure.Xid);
et.SubElement(mpi, "eci", card.ThreeDSecure.Eci);
}
// issueno
string hash = string.Empty;
if (builder.TransactionType == TransactionType.Verify)
{
hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, card.Number);
}
else
{
if (builder.TransactionModifier == TransactionModifier.EncryptedMobile && card.MobileType == MobilePaymentMethodType.APPLEPAY)
{
hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, "", "", card.Token);
}
else if (builder.TransactionModifier == TransactionModifier.EncryptedMobile && card.MobileType == MobilePaymentMethodType.GOOGLEPAY)
{
hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, builder.Amount.ToNumericCurrencyString(), builder.Currency, card.Token);
}
else
{
hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, builder.Amount.ToNumericCurrencyString(), builder.Currency, card.Number);
}
}
et.SubElement(request, "sha1hash").Text(hash);
}
else if (builder.PaymentMethod is AlternatePaymentMethod)
{
var apm = builder.PaymentMethod as AlternatePaymentMethod;
et.SubElement(request, "paymentmethod", apm.AlternativePaymentMethodType);
var paymentmethoddetails = et.SubElement(request, "paymentmethoddetails");
et.SubElement(paymentmethoddetails, "returnurl", apm.ReturnUrl);
et.SubElement(paymentmethoddetails, "statusupdateurl", apm.StatusUpdateUrl);
et.SubElement(paymentmethoddetails, "descriptor", apm.Descriptor);
et.SubElement(paymentmethoddetails, "country", apm.Country);
et.SubElement(paymentmethoddetails, "accountholdername", apm.AccountHolderName);
// issueno
string hash = string.Empty;
hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, builder.Amount.ToNumericCurrencyString(), builder.Currency, apm.AlternativePaymentMethodType.ToString());
et.SubElement(request, "sha1hash").Text(hash);
}
if (builder.PaymentMethod is RecurringPaymentMethod)
{
var recurring = builder.PaymentMethod as RecurringPaymentMethod;
et.SubElement(request, "payerref").Text(recurring.CustomerKey);
et.SubElement(request, "paymentmethod").Text(recurring.Key ?? recurring.Id);
if (!string.IsNullOrEmpty(builder.Cvn))
{
var paymentData = et.SubElement(request, "paymentdata");
var cvn = et.SubElement(paymentData, "cvn");
et.SubElement(cvn, "number").Text(builder.Cvn);
}
string hash = string.Empty;
if (builder.TransactionType == TransactionType.Verify)
{
hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, recurring.CustomerKey);
}
else
{
hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, builder.Amount.ToNumericCurrencyString(), builder.Currency, recurring.CustomerKey);
}
et.SubElement(request, "sha1hash").Text(hash);
}
else
{
// TODO: Token Processing
//et.SubElement(request, "sha1hash", GenerateHash(order, token));
}
// refund hash
if (builder.TransactionType == TransactionType.Refund)
{
et.SubElement(request, "refundhash", GenerationUtils.GenerateHash(RefundPassword) ?? string.Empty);
}
// TODO: needs to be multiple
if (builder.Description != null)
{
var comments = et.SubElement(request, "comments");
et.SubElement(comments, "comment", builder.Description).Set("id", "1");
}
// fraudfilter
if (builder.RecurringType != null || builder.RecurringSequence != null)
{
et.SubElement(request, "recurring")
.Set("type", builder.RecurringType.ToString().ToLower())
.Set("sequence", builder.RecurringSequence.ToString().ToLower());
}
// tssinfo
if (builder.CustomerId != null || builder.ProductId != null || builder.CustomerId != null || builder.ClientTransactionId != null || builder.BillingAddress != null || builder.ShippingAddress != null)
{
var tssInfo = et.SubElement(request, "tssinfo");
et.SubElement(tssInfo, "custnum", builder.CustomerId);
et.SubElement(tssInfo, "prodid", builder.ProductId);
et.SubElement(tssInfo, "varref", builder.ClientTransactionId);
et.SubElement(tssInfo, "custipaddress", builder.CustomerIpAddress);
if (builder.BillingAddress != null)
{
tssInfo.Append(BuildAddress(et, builder.BillingAddress));
}
if (builder.ShippingAddress != null)
{
tssInfo.Append(BuildAddress(et, builder.ShippingAddress));
}
}
var response = DoTransaction(et.ToString(request));
var mapResponse = MapResponse(response, MapAcceptedCodes(transactionType));
if (builder.MultiCapture)
{
mapResponse.MultiCapture = builder.MultiCapture;
}
return(mapResponse);
}
public TResult ProcessRecurring <TResult>(RecurringBuilder <TResult> builder) where TResult : class
{
var et = new ElementTree();
string timestamp = GenerationUtils.GenerateTimestamp();
string orderId = builder.OrderId ?? GenerationUtils.GenerateOrderId();
// Build Request
var request = et.Element("request")
.Set("type", MapRecurringRequestType(builder))
.Set("timestamp", timestamp);
et.SubElement(request, "merchantid").Text(MerchantId);
et.SubElement(request, "account", AccountId);
et.SubElement(request, "orderid", orderId);
if (builder.TransactionType == TransactionType.Create || builder.TransactionType == TransactionType.Edit)
{
if (builder.Entity is Customer)
{
var customer = builder.Entity as Customer;
request.Append(BuildCustomer(et, customer));
et.SubElement(request, "sha1hash").Text(GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, null, null, customer.Key));
}
else if (builder.Entity is RecurringPaymentMethod)
{
var payment = builder.Entity as RecurringPaymentMethod;
var cardElement = et.SubElement(request, "card");
et.SubElement(cardElement, "ref").Text(payment.Key ?? payment.Id);
et.SubElement(cardElement, "payerref").Text(payment.CustomerKey);
if (payment.PaymentMethod != null)
{
var card = payment.PaymentMethod as CreditCardData;
string expiry = card.ShortExpiry;
et.SubElement(cardElement, "number").Text(card.Number);
et.SubElement(cardElement, "expdate").Text(expiry);
et.SubElement(cardElement, "chname").Text(card.CardHolderName);
et.SubElement(cardElement, "type").Text(card.CardType);
string sha1hash = string.Empty;
if (builder.TransactionType == TransactionType.Create)
{
sha1hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, null, null, payment.CustomerKey, card.CardHolderName, card.Number);
}
else
{
sha1hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, payment.CustomerKey, payment.Key ?? payment.Id, expiry, card.Number);
}
et.SubElement(request, "sha1hash").Text(sha1hash);
}
}
}
else if (builder.TransactionType == TransactionType.Delete)
{
if (builder.Entity is RecurringPaymentMethod)
{
var payment = builder.Entity as RecurringPaymentMethod;
var cardElement = et.SubElement(request, "card");
et.SubElement(cardElement, "ref").Text(payment.Key ?? payment.Id);
et.SubElement(cardElement, "payerref").Text(payment.CustomerKey);
string sha1hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, payment.CustomerKey, payment.Key ?? payment.Id);
et.SubElement(request, "sha1hash").Text(sha1hash);
}
}
var response = DoTransaction(et.ToString(request));
return(MapRecurringResponse <TResult>(response, builder));
}
public Transaction ManageTransaction(ManagementBuilder builder)
{
var et = new ElementTree();
string timestamp = GenerationUtils.GenerateTimestamp();
string orderId = builder.OrderId ?? GenerationUtils.GenerateOrderId();
string transactionType = MapManageRequestType(builder);
// Build Request
var request = et.Element("request")
.Set("timestamp", timestamp)
.Set("type", transactionType);
et.SubElement(request, "merchantid").Text(MerchantId);
et.SubElement(request, "account", AccountId);
et.SubElement(request, "channel", Channel);
et.SubElement(request, "orderid", orderId);
et.SubElement(request, "pasref", builder.TransactionId);
if (builder.Amount.HasValue)
{
var amtElement = et.SubElement(request, "amount", builder.Amount.ToNumericCurrencyString());
if (!builder.MultiCapture)
{
amtElement.Set("currency", builder.Currency);
}
}
else if (builder.TransactionType == TransactionType.Capture)
{
throw new BuilderException("Amount cannot be null for capture.");
}
// Capture Authcode
if (builder.TransactionType == TransactionType.Capture && builder.MultiCapture == true)
{
et.SubElement(request, "authcode").Text(builder.AuthorizationCode);
}
et.SubElement(request, "channel", Channel);
et.SubElement(request, "orderid", orderId);
et.SubElement(request, "pasref", builder.TransactionId);
// Check is APM for Refund
if (builder.AlternativePaymentType != null)
{
et.SubElement(request, "paymentmethod", builder.AlternativePaymentType);
}
// payer authentication response
if (builder.TransactionType == TransactionType.VerifySignature)
{
et.SubElement(request, "pares", builder.PayerAuthenticationResponse);
}
// reason code
if (builder.ReasonCode != null)
{
et.SubElement(request, "reasoncode").Text(builder.ReasonCode.ToString());
}
// TODO: needs to be multiple
if (builder.Description != null)
{
var comments = et.SubElement(request, "comments");
et.SubElement(comments, "comment", builder.Description).Set("id", "1");
}
et.SubElement(request, "sha1hash", GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, orderId, builder.Amount.ToNumericCurrencyString(), builder.Currency, builder.AlternativePaymentType != null?builder.AlternativePaymentType.ToString():null));
// rebate hash
if (builder.TransactionType == TransactionType.Refund)
{
if (builder.AuthorizationCode != null)
{
et.SubElement(request, "authcode").Text(builder.AuthorizationCode);
}
et.SubElement(request, "refundhash", GenerationUtils.GenerateHash(builder.AlternativePaymentType != null ? RefundPassword : RebatePassword));
}
var response = DoTransaction(et.ToString(request));
return(MapResponse(response, MapAcceptedCodes(transactionType)));
}
private void HydrateSignificantOwnerData(ElementTree xml, Element xmlTrans, SignificantOwnerData significantOwnerData)
{
xml.SubElement(xmlTrans, "AuthorizedSignerFirstName", significantOwnerData.AuthorizedSignerFirstName);
xml.SubElement(xmlTrans, "AuthorizedSignerLastName", significantOwnerData.AuthorizedSignerLastName);
xml.SubElement(xmlTrans, "AuthorizedSignerTitle", significantOwnerData.AuthorizedSignerTitle);
xml.SubElement(xmlTrans, "SignificantOwnerFirstName", significantOwnerData.SignificantOwner.FirstName);
xml.SubElement(xmlTrans, "SignificantOwnerLastName", significantOwnerData.SignificantOwner.LastName);
xml.SubElement(xmlTrans, "SignificantOwnerSSN", significantOwnerData.SignificantOwner.SSN);
xml.SubElement(xmlTrans, "SignificantOwnerDateOfBirth", significantOwnerData.SignificantOwner.DateOfBirth);
xml.SubElement(xmlTrans, "SignificantOwnerStreetAddress", significantOwnerData.SignificantOwner.OwnerAddress.StreetAddress1);
xml.SubElement(xmlTrans, "SignificantOwnerCityName", significantOwnerData.SignificantOwner.OwnerAddress.City);
xml.SubElement(xmlTrans, "SignificantOwnerRegionCode", significantOwnerData.SignificantOwner.OwnerAddress.State);
xml.SubElement(xmlTrans, "SignificantOwnerPostalCode", significantOwnerData.SignificantOwner.OwnerAddress.PostalCode);
xml.SubElement(xmlTrans, "SignificantOwnerCountryCode", significantOwnerData.SignificantOwner.OwnerAddress.Country);
xml.SubElement(xmlTrans, "SignificantOwnerTitle", significantOwnerData.SignificantOwner.Title);
xml.SubElement(xmlTrans, "SignificantOwnerPercentage", significantOwnerData.SignificantOwner.Percentage);
}
internal override TerminalResponse ProcessTransaction(TerminalAuthBuilder builder)
{
ElementTree et = new ElementTree();
var transactionType = MapTransactionType(builder.TransactionType);
Element request = et.Element("SIP");
et.SubElement(request, "Version").Text("1.0");
et.SubElement(request, "ECRId").Text("1004");
et.SubElement(request, "Request").Text(transactionType);
et.SubElement(request, "RequestId", builder.ReferenceNumber);
et.SubElement(request, "CardGroup", builder.PaymentMethodType.ToString());
et.SubElement(request, "ConfirmAmount").Text("0");
et.SubElement(request, "BaseAmount").Text(builder.Amount.ToNumericCurrencyString());
if (builder.Gratuity != null)
{
et.SubElement(request, "TipAmount").Text(builder.Gratuity.ToNumericCurrencyString());
}
else
{
et.SubElement(request, "TipAmount").Text("0");
}
// EBT amount
if (builder.PaymentMethodType == PaymentMethodType.EBT)
{
et.SubElement(request, "EBTAmount").Text(builder.Amount.ToNumericCurrencyString());
}
// total
et.SubElement(request, "TotalAmount").Text(builder.Amount.ToNumericCurrencyString());
var response = SendMessage <SipDeviceResponse>(et.ToString(request), transactionType);
return(response);
}
private void HydrateBusinessData(ElementTree xml, Element xmlTrans, BusinessData businessData)
{
xml.SubElement(xmlTrans, "BusinessLegalName", businessData.BusinessLegalName);
xml.SubElement(xmlTrans, "DoingBusinessAs", businessData.DoingBusinessAs);
xml.SubElement(xmlTrans, "EIN", businessData.EmployerIdentificationNumber);
xml.SubElement(xmlTrans, "MCCCode", businessData.MerchantCategoryCode);
xml.SubElement(xmlTrans, "WebsiteURL", businessData.WebsiteURL);
xml.SubElement(xmlTrans, "BusinessDesc", businessData.BusinessDescription);
xml.SubElement(xmlTrans, "MonthlyBankCardVolume", businessData.MonthlyBankCardVolume);
xml.SubElement(xmlTrans, "AverageTicket", businessData.AverageTicket);
xml.SubElement(xmlTrans, "HighestTicket", businessData.HighestTicket);
xml.SubElement(xmlTrans, "BusinessAddress", businessData.BusinessAddress.StreetAddress1);
xml.SubElement(xmlTrans, "BusinessAddress2", businessData.BusinessAddress.StreetAddress2);
xml.SubElement(xmlTrans, "BusinessCity", businessData.BusinessAddress.City);
xml.SubElement(xmlTrans, "BusinessCountry", businessData.BusinessAddress.Country);
xml.SubElement(xmlTrans, "BusinessState", businessData.BusinessAddress.State);
xml.SubElement(xmlTrans, "BusinessZip", businessData.BusinessAddress.PostalCode);
}
private void HydrateBankDetails(ElementTree xml, Element xmlTrans, PayFacBuilder builder)
{
if (builder.CreditCardInformation != null)
{
xml.SubElement(xmlTrans, "NameOnCard", builder.CreditCardInformation.CardHolderName);
xml.SubElement(xmlTrans, "ccNum", builder.CreditCardInformation.Number);
xml.SubElement(xmlTrans, "expDate", builder.CreditCardInformation.ShortExpiry);
}
if (builder.ACHInformation != null)
{
xml.SubElement(xmlTrans, "PaymentBankAccountNumber", builder.ACHInformation.AccountNumber);
xml.SubElement(xmlTrans, "PaymentBankRoutingNumber", builder.ACHInformation.RoutingNumber);
xml.SubElement(xmlTrans, "PaymentBankAccountType", builder.ACHInformation.AccountType);
}
if (builder.BankAccountData != null)
{
xml.SubElement(xmlTrans, "AccountCountryCode", builder.BankAccountData.AccountCountryCode);
xml.SubElement(xmlTrans, "accountName", builder.BankAccountData.AccountName);
xml.SubElement(xmlTrans, "AccountNumber", builder.BankAccountData.AccountNumber);
xml.SubElement(xmlTrans, "AccountOwnershipType", builder.BankAccountData.AccountOwnershipType);
xml.SubElement(xmlTrans, "AccountType", builder.BankAccountData.AccountType);
xml.SubElement(xmlTrans, "BankName", builder.BankAccountData.BankName);
xml.SubElement(xmlTrans, "RoutingNumber", builder.BankAccountData.RoutingNumber);
}
if (builder.SecondaryBankInformation != null)
{
xml.SubElement(xmlTrans, "SecondaryAccountCountryCode", builder.SecondaryBankInformation.AccountCountryCode);
xml.SubElement(xmlTrans, "SecondaryAccountName", builder.SecondaryBankInformation.AccountName);
xml.SubElement(xmlTrans, "SecondaryAccountNumber", builder.SecondaryBankInformation.AccountNumber);
xml.SubElement(xmlTrans, "SecondaryAccountOwnershipType", builder.SecondaryBankInformation.AccountOwnershipType);
xml.SubElement(xmlTrans, "SecondaryAccountType", builder.SecondaryBankInformation.AccountType);
xml.SubElement(xmlTrans, "SecondaryBankName", builder.SecondaryBankInformation.BankName);
xml.SubElement(xmlTrans, "SecondaryRoutingNumber", builder.SecondaryBankInformation.RoutingNumber);
}
}
private void HydrateAccountPermissions(ElementTree xml, Element xmlTrans, AccountPermissions accountPermissions)
{
if (accountPermissions.ACHIn != null)
{
xml.SubElement(xmlTrans, "ACHIn", accountPermissions.ACHIn == true ? "Y" : "N");
}
if (accountPermissions.ACHOut != null)
{
xml.SubElement(xmlTrans, "ACHOut", accountPermissions.ACHOut == true ? "Y" : "N");
}
if (accountPermissions.CCProcessing != null)
{
xml.SubElement(xmlTrans, "CCProcessing", accountPermissions.CCProcessing == true ? "Y" : "N");
}
if (accountPermissions.ProPayIn != null)
{
xml.SubElement(xmlTrans, "ProPayIn", accountPermissions.ProPayIn == true ? "Y" : "N");
}
if (accountPermissions.ProPayOut != null)
{
xml.SubElement(xmlTrans, "ProPayOut", accountPermissions.ProPayOut == true ? "Y" : "N");
}
xml.SubElement(xmlTrans, "CreditCardMonthLimit", accountPermissions.CreditCardMonthLimit);
xml.SubElement(xmlTrans, "CreditCardTransactionLimit", accountPermissions.CreditCardTransactionLimit);
xml.SubElement(xmlTrans, "MerchantOverallStatus", accountPermissions.MerchantOverallStatus.ToString());
if (accountPermissions.SoftLimitEnabled != null)
{
xml.SubElement(xmlTrans, "SoftLimitEnabled", accountPermissions.SoftLimitEnabled == true ? "Y" : "N");
}
if (accountPermissions.ACHPaymentSoftLimitEnabled != null)
{
xml.SubElement(xmlTrans, "AchPaymentSoftLimitEnabled", accountPermissions.ACHPaymentSoftLimitEnabled == true ? "Y" : "N");
}
xml.SubElement(xmlTrans, "SoftLimitAchOffPercent", accountPermissions.SoftLimitACHOffPercent);
xml.SubElement(xmlTrans, "AchPaymentAchOffPercent", accountPermissions.ACHPaymentACHOffPercent);
}
private void HydrateGrossBillingData(ElementTree xml, Element xmlTrans, GrossBillingInformation grossBillingInformation)
{
xml.SubElement(xmlTrans, "GrossSettleAddress", grossBillingInformation.GrossSettleAddress.StreetAddress1);
xml.SubElement(xmlTrans, "GrossSettleCity", grossBillingInformation.GrossSettleAddress.City);
xml.SubElement(xmlTrans, "GrossSettleState", grossBillingInformation.GrossSettleAddress.State);
xml.SubElement(xmlTrans, "GrossSettleZipCode", grossBillingInformation.GrossSettleAddress.PostalCode);
xml.SubElement(xmlTrans, "GrossSettleCountry", grossBillingInformation.GrossSettleAddress.Country);
xml.SubElement(xmlTrans, "GrossSettleCreditCardNumber", grossBillingInformation.GrossSettleCreditCardData.Number);
xml.SubElement(xmlTrans, "GrossSettleNameOnCard", grossBillingInformation.GrossSettleCreditCardData.CardHolderName);
xml.SubElement(xmlTrans, "GrossSettleCreditCardExpDate", grossBillingInformation.GrossSettleCreditCardData.ShortExpiry);
xml.SubElement(xmlTrans, "GrossSettleAccountCountryCode", grossBillingInformation.GrossSettleBankData.AccountCountryCode);
xml.SubElement(xmlTrans, "GrossSettleAccountHolderName", grossBillingInformation.GrossSettleBankData.AccountHolderName);
xml.SubElement(xmlTrans, "GrossSettleAccountNumber", grossBillingInformation.GrossSettleBankData.AccountNumber);
xml.SubElement(xmlTrans, "GrossSettleAccountType", grossBillingInformation.GrossSettleBankData.AccountType);
xml.SubElement(xmlTrans, "GrossSettleRoutingNumber", grossBillingInformation.GrossSettleBankData.RoutingNumber);
}
private void HydrateBeneficialOwnerData(ElementTree xml, Element xmlTrans, BeneficialOwnerData beneficialOwnerData)
{
var ownerDetails = xml.SubElement(xmlTrans, "BeneficialOwnerData");
xml.SubElement(ownerDetails, "OwnerCount", beneficialOwnerData.OwnersCount);
if (Convert.ToInt32(beneficialOwnerData.OwnersCount) > 0)
{
var ownersList = xml.SubElement(ownerDetails, "Owners");
foreach (OwnersData ownerInfo in beneficialOwnerData.OwnersList)
{
var newOwner = xml.SubElement(ownersList, "Owner");
xml.SubElement(newOwner, "FirstName", ownerInfo.FirstName);
xml.SubElement(newOwner, "LastName", ownerInfo.LastName);
xml.SubElement(newOwner, "Email", ownerInfo.Email);
xml.SubElement(newOwner, "SSN", ownerInfo.SSN);
xml.SubElement(newOwner, "DateOfBirth", ownerInfo.DateOfBirth);
xml.SubElement(newOwner, "Address", ownerInfo.OwnerAddress.StreetAddress1);
xml.SubElement(newOwner, "City", ownerInfo.OwnerAddress.City);
xml.SubElement(newOwner, "State", ownerInfo.OwnerAddress.State);
xml.SubElement(newOwner, "Zip", ownerInfo.OwnerAddress.PostalCode);
xml.SubElement(newOwner, "Country", ownerInfo.OwnerAddress.Country);
xml.SubElement(newOwner, "Title", ownerInfo.Title);
xml.SubElement(newOwner, "Percentage", ownerInfo.Percentage);
}
}
}
private void HydrateSSORequestData(ElementTree xml, Element xmlTrans, SSORequestData ssoRequestData)
{
xml.SubElement(xmlTrans, "ReferrerUrl", ssoRequestData.ReferrerURL);
xml.SubElement(xmlTrans, "IpAddress", ssoRequestData.IPAddress);
xml.SubElement(xmlTrans, "IpSubnetMask", ssoRequestData.IPSubnetMask);
}
public Transaction ManageTransaction(ManagementBuilder builder)
{
var et = new ElementTree();
TransactionType transactionType = builder.TransactionType;
var transaction = et.Element(MapRequestType(builder))
.Set("xmlns", "http://schemas.merchantwarehouse.com/merchantware/v45/");
// Credentials
var credentials = et.SubElement(transaction, "Credentials");
et.SubElement(credentials, "MerchantName").Text(MerchantName);
et.SubElement(credentials, "MerchantSiteId").Text(MerchantSiteId);
et.SubElement(credentials, "MerchantKey").Text(MerchantKey);
// Payment Data
if (transactionType.Equals(TransactionType.Refund))
{
var paymentData = et.SubElement(transaction, "PaymentData");
et.SubElement(paymentData, "Source").Text("PreviousTransaction");
et.SubElement(paymentData, "Token", builder.TransactionId);
}
// Request
var request = et.SubElement(transaction, "Request");
if (!transactionType.Equals(TransactionType.Refund))
{
et.SubElement(request, "Token", builder.TransactionId);
}
et.SubElement(request, "Amount", builder.Amount.ToCurrencyString());
et.SubElement(request, "InvoiceNumber", builder.InvoiceNumber);
et.SubElement(request, "RegisterNumber", RegisterNumber);
et.SubElement(request, "MerchantTransactionId", builder.ClientTransactionId);
et.SubElement(request, "CardAcceptorTerminalId", TerminalId);
if (transactionType.Equals(TransactionType.TokenDelete) || transactionType.Equals(TransactionType.TokenUpdate))
{
var card = builder.PaymentMethod as CreditCardData;
et.SubElement(request, "VaultToken", card.Token);
if (transactionType.Equals(TransactionType.TokenUpdate))
{
et.SubElement(request, "ExpirationDate", card.ShortExpiry);
}
}
var response = DoTransaction(BuildEnvelope(et, transaction));
return(MapResponse(builder, response));
}
private void HydrateUserPersonalData(ElementTree xml, Element xmlTrans, UserPersonalData userPersonalData)
{
xml.SubElement(xmlTrans, "FirstName", userPersonalData.FirstName);
xml.SubElement(xmlTrans, "mInitial", userPersonalData.MiddleInitial);
xml.SubElement(xmlTrans, "LastName", userPersonalData.LastName);
xml.SubElement(xmlTrans, "dob", userPersonalData.DateOfBirth);
xml.SubElement(xmlTrans, "ssn", userPersonalData.SSN);
xml.SubElement(xmlTrans, "sourceEmail", userPersonalData.SourceEmail);
xml.SubElement(xmlTrans, "dayPhone", userPersonalData.DayPhone);
xml.SubElement(xmlTrans, "evenPhone", userPersonalData.EveningPhone);
xml.SubElement(xmlTrans, "NotificationEmail", userPersonalData.NotificationEmail);
xml.SubElement(xmlTrans, "currencyCode", userPersonalData.CurrencyCode);
xml.SubElement(xmlTrans, "tier", userPersonalData.Tier);
xml.SubElement(xmlTrans, "externalId", userPersonalData.ExternalID);
xml.SubElement(xmlTrans, "addr", userPersonalData.UserAddress.StreetAddress1);
xml.SubElement(xmlTrans, "aptNum", userPersonalData.UserAddress.StreetAddress2);
xml.SubElement(xmlTrans, "addr3", userPersonalData.UserAddress.StreetAddress3);
xml.SubElement(xmlTrans, "city", userPersonalData.UserAddress.City);
xml.SubElement(xmlTrans, "state", userPersonalData.UserAddress.State);
xml.SubElement(xmlTrans, "zip", userPersonalData.UserAddress.PostalCode);
xml.SubElement(xmlTrans, "country", userPersonalData.UserAddress.Country);
}
public Transaction ProcessAuthorization(AuthorizationBuilder builder)
{
ElementTree et = new ElementTree();
IPaymentMethod paymentMethod = builder.PaymentMethod;
var transaction = et.Element(MapRequestType(builder))
.Set("xmlns", "http://schemas.merchantwarehouse.com/merchantware/v45/");
// Credentials
var credentials = et.SubElement(transaction, "Credentials");
et.SubElement(credentials, "MerchantName").Text(MerchantName);
et.SubElement(credentials, "MerchantSiteId").Text(MerchantSiteId);
et.SubElement(credentials, "MerchantKey").Text(MerchantKey);
// Payment Data
var paymentData = et.SubElement(transaction, "PaymentData");
if (paymentMethod is CreditCardData)
{
CreditCardData card = paymentMethod as CreditCardData;
if (card.Token != null)
{
if (card.MobileType != null)
{
et.SubElement(paymentData, "Source").Text("Wallet");
et.SubElement(paymentData, "WalletId", MapWalletId(card.MobileType));
et.SubElement(paymentData, "EncryptedPaymentData", card.Token);
}
else
{
et.SubElement(paymentData, "Source").Text("Vault");
et.SubElement(paymentData, "VaultToken", card.Token);
}
}
else
{
et.SubElement(paymentData, "Source").Text("Keyed");
et.SubElement(paymentData, "CardNumber", card.Number);
et.SubElement(paymentData, "ExpirationDate", card.ShortExpiry);
et.SubElement(paymentData, "CardHolder", card.CardHolderName);
et.SubElement(paymentData, "CardVerificationValue", card.Cvn);
}
}
else if (paymentMethod is CreditTrackData)
{
et.SubElement(paymentData, "Source").Text("READER");
CreditTrackData track = paymentMethod as CreditTrackData;
et.SubElement(paymentData, "TrackData", track.Value);
}
// AVS
et.SubElement(paymentData, "AvsStreetAddress", builder.BillingAddress?.StreetAddress1);
et.SubElement(paymentData, "AvsZipCode", builder.BillingAddress?.PostalCode);
// Request
var request = et.SubElement(transaction, "Request");
et.SubElement(request, "Amount", builder.Amount.ToCurrencyString());
et.SubElement(request, "CashbackAmount", builder.CashBackAmount.ToCurrencyString());
et.SubElement(request, "SurchargeAmount", builder.ConvenienceAmount.ToCurrencyString());
//et.SubElement(request, "TaxAmount", builder..ToCurrencyString());
et.SubElement(request, "AuthorizationCode", builder.OfflineAuthCode);
if (builder.AutoSubstantiation != null)
{
var healthcare = et.SubElement(request, "HealthCareAmountDetails");
AutoSubstantiation auto = builder.AutoSubstantiation;
et.SubElement(healthcare, "CopayAmount", auto.CopaySubTotal.ToCurrencyString());
et.SubElement(healthcare, "ClinicalAmount", auto.ClinicSubTotal.ToCurrencyString());
et.SubElement(healthcare, "DentalAmount", auto.DentalSubTotal.ToCurrencyString());
et.SubElement(healthcare, "HealthCareTotalAmount", auto.TotalHealthcareAmount.ToCurrencyString());
et.SubElement(healthcare, "PrescriptionAmount", auto.PrescriptionSubTotal.ToCurrencyString());
et.SubElement(healthcare, "VisionAmount", auto.VisionSubTotal.ToCurrencyString());
}
et.SubElement(request, "InvoiceNumber", builder.InvoiceNumber);
et.SubElement(request, "RegisterNumber", RegisterNumber);
et.SubElement(request, "MerchantTransactionId", builder.ClientTransactionId);
et.SubElement(request, "CardAcceptorTerminalId", TerminalId);
et.SubElement(request, "EnablePartialAuthorization", builder.AllowPartialAuth);
et.SubElement(request, "ForceDuplicate", builder.AllowDuplicates);
// Level III
if (builder.CommercialData != null)
{
var invoice = et.SubElement(request, "Invoice");
CommercialData cd = builder.CommercialData;
et.SubElement(invoice, "TaxIndicator", MapTaxType(cd.TaxType));
et.SubElement(invoice, "ProductDescription", cd.Description);
et.SubElement(invoice, "DiscountAmount", cd.DiscountAmount);
et.SubElement(invoice, "ShippingAmount", cd.FreightAmount);
et.SubElement(invoice, "DutyAmount", cd.DutyAmount);
et.SubElement(invoice, "DestinationPostalCode", cd.DestinationPostalCode);
et.SubElement(invoice, "DestinationCountryCode", cd.DestinationCountryCode);
et.SubElement(invoice, "ShipFromPostalCode", cd.OriginPostalCode);
if (cd.LineItems.Count > 0)
{
var lineItemsElement = et.SubElement(invoice, "LineItems");
foreach (var item in cd.LineItems)
{
var lineItem = et.SubElement(lineItemsElement, "LineItem");
et.SubElement(lineItem, "CommodityCode", item.CommodityCode);
et.SubElement(lineItem, "Description", item.Description);
et.SubElement(lineItem, "Upc", item.UPC);
et.SubElement(lineItem, "Quantity", item.Quantity);
et.SubElement(lineItem, "UnitOfMeasure", item.UnitOfMeasure);
et.SubElement(lineItem, "UnitCost", item.UnitCost);
et.SubElement(lineItem, "DiscountAmount", item.DiscountAmount);
et.SubElement(lineItem, "TotalAmount", item.TotalAmount);
et.SubElement(lineItem, "TaxAmount", item.TaxAmount);
et.SubElement(lineItem, "ExtendedAmount", item.ExtendedAmount);
et.SubElement(lineItem, "DebitOrCreditIndicator", item.CreditDebitIndicator.ToString());
et.SubElement(lineItem, "NetOrGrossIndicator", item.NetGrossIndicator.ToString());
}
}
}
var response = DoTransaction(BuildEnvelope(et, transaction));
return(MapResponse(builder, response));
}
private void HydrateAccountDetails(ElementTree xml, Element xmlTrans, PayFacBuilder builder)
{
xml.SubElement(xmlTrans, "accountNum", builder.AccountNumber);
xml.SubElement(xmlTrans, "sourceEmail", builder.SourceEmail);
xml.SubElement(xmlTrans, "externalId", builder.ExternalID);
xml.SubElement(xmlTrans, "recAccntNum", builder.ReceivingAccountNumber);
xml.SubElement(xmlTrans, "amount", builder.Amount);
if (builder.AllowPending != null)
{
xml.SubElement(xmlTrans, "allowPending", builder.AllowPending == true ? "Y" : "N");
}
xml.SubElement(xmlTrans, "password", builder.Password);
if (builder.AccountPermissions != null)
{
HydrateAccountPermissions(xml, xmlTrans, builder.AccountPermissions);
}
if (builder.UserPersonalData != null)
{
HydrateUserPersonalData(xml, xmlTrans, builder.UserPersonalData);
}
if (builder.BusinessData != null)
{
HydrateBusinessData(xml, xmlTrans, builder.BusinessData);
}
HydrateBankDetails(xml, xmlTrans, builder);
if (builder.MailingAddressInformation != null)
{
HydrateMailAddress(xml, xmlTrans, builder.MailingAddressInformation);
}
if (builder.ThreatRiskData != null)
{
HydrateThreatRiskData(xml, xmlTrans, builder.ThreatRiskData);
}
if (builder.SignificantOwnerData != null)
{
HydrateSignificantOwnerData(xml, xmlTrans, builder.SignificantOwnerData);
}
if (!string.IsNullOrEmpty(builder.TimeZone))
{
var timezoneElement = xml.SubElement(xmlTrans, "TimeZone", builder.TimeZone);
}
if (builder.DeviceData != null)
{
HydrateDeviceData(xml, xmlTrans, builder.DeviceData);
}
if (builder.BeneficialOwnerData != null)
{
HydrateBeneficialOwnerData(xml, xmlTrans, builder.BeneficialOwnerData);
}
if (builder.GrossBillingInformation != null)
{
HydrateGrossBillingData(xml, xmlTrans, builder.GrossBillingInformation);
}
if (builder.RenewalAccountData != null)
{
HydrateAccountRenewDetails(xml, xmlTrans, builder.RenewalAccountData);
}
if (builder.FlashFundsPaymentCardData != null)
{
HydrateFlashFundsPaymentCardData(xml, xmlTrans, builder.FlashFundsPaymentCardData);
}
if (builder.DocumentUploadData != null)
{
HydrateDocumentUploadData(xml, xmlTrans, builder.TransactionType, builder.DocumentUploadData);
}
if (builder.SSORequestData != null)
{
HydrateSSORequestData(xml, xmlTrans, builder.SSORequestData);
}
HydrateBankAccountOwnershipData(xml, xmlTrans, builder);
xml.SubElement(xmlTrans, "ccAmount", builder.CCAmount);
if (builder.RequireCCRefund != null)
{
xml.SubElement(xmlTrans, "requireCCRefund", builder.RequireCCRefund == true ? "Y" : "N");
}
xml.SubElement(xmlTrans, "transNum", builder.TransNum);
}
private void HydrateBankAccountOwnershipData(ElementTree xml, Element xmlTrans, PayFacBuilder builder)
{
if (builder.PrimaryBankAccountOwner != null || builder.SecondaryBankAccountOwner != null)
{
var ownersDataTag = xml.SubElement(xmlTrans, "BankAccountOwnerData");
if (builder.PrimaryBankAccountOwner != null)
{
var primaryOwnerTag = xml.SubElement(ownersDataTag, "PrimaryBankAccountOwner");
xml.SubElement(primaryOwnerTag, "FirstName", builder.PrimaryBankAccountOwner.FirstName);
xml.SubElement(primaryOwnerTag, "LastName", builder.PrimaryBankAccountOwner.LastName);
xml.SubElement(primaryOwnerTag, "Address1", builder.PrimaryBankAccountOwner.OwnerAddress.StreetAddress1);
xml.SubElement(primaryOwnerTag, "Address2", builder.PrimaryBankAccountOwner.OwnerAddress.StreetAddress2);
xml.SubElement(primaryOwnerTag, "Address3", builder.PrimaryBankAccountOwner.OwnerAddress.StreetAddress3);
xml.SubElement(primaryOwnerTag, "City", builder.PrimaryBankAccountOwner.OwnerAddress.City);
xml.SubElement(primaryOwnerTag, "StateProvince", builder.PrimaryBankAccountOwner.OwnerAddress.State);
xml.SubElement(primaryOwnerTag, "PostalCode", builder.PrimaryBankAccountOwner.OwnerAddress.PostalCode);
xml.SubElement(primaryOwnerTag, "Country", builder.PrimaryBankAccountOwner.OwnerAddress.Country);
xml.SubElement(primaryOwnerTag, "Phone", builder.PrimaryBankAccountOwner.PhoneNumber);
}
if (builder.SecondaryBankAccountOwner != null)
{
var secondaryOwnerTag = xml.SubElement(ownersDataTag, "SecondaryBankAccountOwner");
xml.SubElement(secondaryOwnerTag, "FirstName", builder.SecondaryBankAccountOwner.FirstName);
xml.SubElement(secondaryOwnerTag, "LastName", builder.SecondaryBankAccountOwner.LastName);
xml.SubElement(secondaryOwnerTag, "Address1", builder.SecondaryBankAccountOwner.OwnerAddress.StreetAddress1);
xml.SubElement(secondaryOwnerTag, "Address2", builder.SecondaryBankAccountOwner.OwnerAddress.StreetAddress2);
xml.SubElement(secondaryOwnerTag, "Address3", builder.SecondaryBankAccountOwner.OwnerAddress.StreetAddress3);
xml.SubElement(secondaryOwnerTag, "City", builder.SecondaryBankAccountOwner.OwnerAddress.City);
xml.SubElement(secondaryOwnerTag, "StateProvince", builder.SecondaryBankAccountOwner.OwnerAddress.State);
xml.SubElement(secondaryOwnerTag, "PostalCode", builder.SecondaryBankAccountOwner.OwnerAddress.PostalCode);
xml.SubElement(secondaryOwnerTag, "Country", builder.SecondaryBankAccountOwner.OwnerAddress.Country);
xml.SubElement(secondaryOwnerTag, "Phone", builder.SecondaryBankAccountOwner.PhoneNumber);
}
}
}
private void HydrateThreatRiskData(ElementTree xml, Element xmlTrans, ThreatRiskData threatRiskData)
{
xml.SubElement(xmlTrans, "MerchantSourceip", threatRiskData.MerchantSourceIP);
xml.SubElement(xmlTrans, "ThreatMetrixPolicy", threatRiskData.ThreatMetrixPolicy);
xml.SubElement(xmlTrans, "ThreatMetrixSessionid", threatRiskData.ThreatMetrixSessionID);
}