private Transaction GetTokenInformation(AuthorizationBuilder builder)
{
string request;
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "GetTokenInformation");
if (builder.PaymentMethod is ITokenizable tokenizablePayment)
{
if (string.IsNullOrEmpty(tokenizablePayment.Token))
{
throw new BuilderException("Payment method has not been tokenized");
}
request = new GetTokenInformationRequest(et)
.Build(envelope, builder, Credentials);
}
else
{
throw new BuilderException("Token Information is currently only retrievable for Credit and eCheck payment methods.");
}
var response = DoTransaction(request, publicEndpoint);
var result = new TokenInformationRequestResponse()
.WithResponseTagName("GetTokenInformationResponse")
.WithResponse(response)
.Map();
if (result.ResponseCode == "0")
{
return(result);
}
throw new GatewayException(message: "An error occurred attempting to retrieve token information", responseCode: result.ResponseCode, responseMessage: result.ResponseMessage);
}
public SipBaseResponse(byte[] buffer, params string[] messageIds)
{
_response = string.Empty;
foreach (byte b in buffer)
{
_response += (char)b;
}
var messages = _response.Split('\r');
foreach (var message in messages)
{
if (string.IsNullOrEmpty(message))
{
continue;
}
var root = ElementTree.Parse(message).Get("SIP");
Command = root.GetValue <string>("Response");
if (Command != null && !messageIds.ToList().Contains(Command))
{
throw new MessageException("Excpected {0} but recieved {1}".FormatWith(string.Join(", ", messageIds), Command));
}
Version = root.GetValue <string>("Version");
EcrId = root.GetValue <string>("ECRId");
SipId = root.GetValue <string>("SIPId");
Status = root.GetValue <string>("MultipleMessage");
DeviceResponseCode = NormalizeResponse(root.GetValue <string>("Result"));
DeviceResponseText = root.GetValue <string>("ResultText");
MapResponse(root);
}
FinalizeResponse();
}
private TResult MapRecurringResponse <TResult>(string rawResponse, RecurringBuilder <TResult> builder) where TResult : class
{
var root = new ElementTree(rawResponse).Get("response");
// check response
CheckResponse(root);
return(builder.Entity as TResult);
}
public Transaction ManageTransaction(ManagementBuilder builder)
{
var et = new ElementTree();
string timestamp = GenerationUtils.GenerateTimestamp();
string orderId = builder.OrderId ?? GenerationUtils.GenerateOrderId();
string transactionType = MapManageRequestType(builder.TransactionType);
// 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)
{
et.SubElement(request, "amount", builder.Amount.ToNumericCurrencyString()).Set("currency", builder.Currency);
}
else if (builder.TransactionType == TransactionType.Capture)
{
throw new BuilderException("Amount cannot be null for capture.");
}
// payer authentication response
if (builder.TransactionType == TransactionType.VerifySignature)
{
et.SubElement(request, "pares", builder.PayerAuthenticationResponse);
}
// rebate hash
if (builder.TransactionType == TransactionType.Refund)
{
et.SubElement(request, "authcode").Text(builder.AuthorizationCode);
et.SubElement(request, "refundhash", GenerationUtils.GenerateHash(RebatePassword ?? string.Empty));
}
// 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, ""));
var response = DoTransaction(et.ToString(request));
return(MapResponse(response, MapAcceptedCodes(transactionType)));
}
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 Transaction MapResponse(string rawResponse, List <string> acceptedCodes = null)
{
var root = new ElementTree(rawResponse).Get("response");
CheckResponse(root, acceptedCodes);
var result = new Transaction {
ResponseCode = root.GetValue <string>("result"),
ResponseMessage = root.GetValue <string>("message"),
CvnResponseCode = root.GetValue <string>("cvnresult"),
AvsResponseCode = root.GetValue <string>("avspostcoderesponse"),
Timestamp = root.GetAttribute <string>("timestamp"),
TransactionReference = new TransactionReference {
AuthCode = root.GetValue <string>("authcode"),
OrderId = root.GetValue <string>("orderid"),
PaymentMethodType = PaymentMethodType.Credit,
TransactionId = root.GetValue <string>("pasref"),
AlternativePaymentType = root.GetValue <string>("paymentmethod"),
BatchNumber = root.GetValue <string>("batchid")
}
};
// 3d secure enrolled
if (root.Has("enrolled"))
{
result.ThreeDSecure = new ThreeDSecure();
result.ThreeDSecure.Enrolled = root.GetValue <string>("enrolled");
result.ThreeDSecure.PayerAuthenticationRequest = root.GetValue <string>("pareq");
result.ThreeDSecure.Xid = root.GetValue <string>("xid");
result.ThreeDSecure.IssuerAcsUrl = root.GetValue <string>("url");
}
// threedsecure
if (root.Has("threedsecure"))
{
result.ThreeDSecure = new ThreeDSecure();
result.ThreeDSecure.Status = root.GetValue <string>("status");
result.ThreeDSecure.Xid = root.GetValue <string>("xid");
result.ThreeDSecure.Cavv = root.GetValue <string>("cavv");
var eci = root.GetValue <string>("eci");
if (!string.IsNullOrEmpty(eci))
{
result.ThreeDSecure.Eci = int.Parse(eci);
}
var algorithm = root.GetValue <string>("algorithm");
if (!string.IsNullOrEmpty(algorithm))
{
result.ThreeDSecure.Algorithm = int.Parse(algorithm);
}
}
// stored credential
result.SchemeId = root.GetValue <string>("srd");
return(result);
}
/// <summary>
/// Adds the XML Namespaces neccessary to make BillPay SOAP requests
/// </summary>
/// <param name="et">The element tree for the SOAP request</param>
private void AddXMLNS(ElementTree et)
{
et.AddNamespace("soapenv", @"http://schemas.xmlsoap.org/soap/envelope/");
et.AddNamespace("bil", @"https://test.heartlandpaymentservices.net/BillingDataManagement/v3/BillingDataManagementService");
et.AddNamespace("bdms", @"http://schemas.datacontract.org/2004/07/BDMS.NewModel");
et.AddNamespace("hps", @"http://schemas.datacontract.org/2004/07/HPS.BillerDirect.ACHCard.Wrapper");
et.AddNamespace("pos", @"http://schemas.datacontract.org/2004/07/POSGateway.Wrapper");
et.AddNamespace("bdm", @"https://test.heartlandpaymentservices.net/BillingDataManagement/v3/BDMServiceAdmin");
}
/// <summary>
/// Creates a SOAP envelope with the necessary namespaces
/// </summary>
/// <param name="soapAction">The method name that is the target of the invocation</param>
/// <returns>The Element that represents the envelope node</returns>
protected Element CreateSOAPEnvelope(ElementTree et, string soapAction)
{
SetSOAPAction(soapAction);
AddXMLNS(et);
var envelope = et.Element("soapenv:Envelope");
return(envelope);
}
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);
}
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 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 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);
}
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 Transaction MapResponse <T>(T builder, string rawResponse) where T : TransactionBuilder <Transaction>
{
var root = ElementTree.Parse(rawResponse).Get(MapRequestType(builder) + "Response");
// check response
string errorCode = root.GetValue <string>("ErrorCode");
string errorMessage = root.GetValue <string>("ErrorMessage");
if (!string.IsNullOrEmpty(errorMessage))
{
throw new GatewayException(
string.Format("Unexpected Gateway Response: {0} - {1}", errorCode, errorMessage),
errorCode,
errorMessage
);
}
var response = new Transaction {
ResponseCode = "00",
ResponseMessage = root.GetValue <string>("ApprovalStatus"),
TransactionId = root.GetValue <string>("Token"),
AuthorizationCode = root.GetValue <string>("AuthorizationCode"),
HostResponseDate = root.GetValue <DateTime>("TransactionDate"),
AuthorizedAmount = root.GetValue <string>("Amount").ToAmount(),
AvailableBalance = root.GetValue <string>("RemainingCardBalance")?.ToAmount(),
//MaskedCardNumber = root.GetValue<string>("CardNumber"),
//CardHolder
CardType = root.GetValue <string>("CardType"),
//FsaCard
//ReaderEntryMode
AvsResponseCode = root.GetValue <string>("AvsResponse"),
CvnResponseCode = root.GetValue <string>("CvResponse"),
//ExtraData
//FraudScoring
//DebitTraceNumber
//Rfmiq
//Invoice
Token = root.GetValue <string>("VaultToken")
};
if (root.Has("BatchStatus"))
{
var summary = new BatchSummary {
Status = root.GetValue <string>("BatchStatus"),
TotalAmount = root.GetValue <decimal>("BatchAmount"),
TransactionCount = root.GetValue <int>("TransactionCount")
};
response.BatchSummary = summary;
}
return(response);
}
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));
}
private BillingResponse ClearLoadedBills()
{
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "ClearLoadedBills");
var request = new ClearLoadedBillsRequest(et)
.Build(envelope, Credentials);
var response = DoTransaction(request, publicEndpoint);
return(new BillingRequestResponse()
.WithResponseTagName("ClearLoadedBillsResponse")
.WithResponse(response)
.Map());
}
/// <summary>
/// Calculates the structure of the document model.
/// </summary>
/// <param name="documentModel">Document model to recalculate</param>
public void Restructure(IDocumentModelTree documentModel)
{
var context = new DocumentModelProcessContext()
{
DocumentModel = (DocumentModelTree)documentModel,
ElementPointers = new Dictionary <IElement, IDocumentObject>()
};
foreach (var element in ElementTree.NavigateAllElementsRecursively(context.DocumentModel.OwnerComponent))
{
}
ProcessElementRecuresively(context, context.DocumentModel.OwnerComponent, null);
context.DocumentModel.RootDocumentObject = context.ElementPointers[context.DocumentModel.OwnerComponent];
}
internal T Execute(ReportBuilder <T> builder)
{
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "GetTransactionByOrderID");
var request = new GetTransactionByOrderIDRequest(et)
.Build(envelope, builder, Credentials);
var response = DoTransaction(request, publicEndpoint);
var result = new TransactionByOrderIDRequestResponse()
.WithResponseTagName("GetTransactionByOrderIDResponse")
.WithResponse(response)
.Map();
return(result as T);
}
public void DisplayTree(ElementTree elementTree)
{
if (!elementTrees.Contains(elementTree))
{
return;
}
for (int i = 0; i < spellSlots.GetLength(0); i++)
{
for (int j = 0; j < spellSlots.GetLength(1); j++)
{
spellSlots[i, j].Initialise(elementTree.TreeSpells[i, j]);
}
}
}
public void TestLayoutCalculation_Basic()
{
var layoutEngine = new LayoutEngine();
var componentTree = new ElementTree(null);
var testData = new BasicTestData(componentTree);
var result = layoutEngine.ProcessLayout(new AbsoluteSize(800, 600), componentTree);
Assert.Equal(0, result.GetLayoutBoxInformation(testData.ComponentTop).AbsoluteBox.Top);
Assert.Equal(800, result.GetLayoutBoxInformation(testData.ComponentTop).AbsoluteBox.Right);
Assert.Equal(50, result.GetLayoutBoxInformation(testData.ComponentTop).AbsoluteBox.Bottom);
Assert.Equal(0, result.GetLayoutBoxInformation(testData.ComponentTop).AbsoluteBox.Left);
Assert.Equal(50, result.GetLayoutBoxInformation(testData.ComponentBottom).AbsoluteBox.Top);
Assert.Equal(800, result.GetLayoutBoxInformation(testData.ComponentBottom).AbsoluteBox.Right);
Assert.Equal(600, result.GetLayoutBoxInformation(testData.ComponentBottom).AbsoluteBox.Bottom);
Assert.Equal(0, result.GetLayoutBoxInformation(testData.ComponentBottom).AbsoluteBox.Left);
Assert.Equal(50, result.GetLayoutBoxInformation(testData.ComponentLeft).AbsoluteBox.Top);
Assert.Equal(200, result.GetLayoutBoxInformation(testData.ComponentLeft).AbsoluteBox.Right);
Assert.Equal(130, result.GetLayoutBoxInformation(testData.ComponentLeft).AbsoluteBox.Bottom);
Assert.Equal(0, result.GetLayoutBoxInformation(testData.ComponentLeft).AbsoluteBox.Left);
Assert.Equal(50, result.GetLayoutBoxInformation(testData.ComponentLeft1).AbsoluteBox.Top);
Assert.Equal(200, result.GetLayoutBoxInformation(testData.ComponentLeft1).AbsoluteBox.Right);
Assert.Equal(90, result.GetLayoutBoxInformation(testData.ComponentLeft1).AbsoluteBox.Bottom);
Assert.Equal(0, result.GetLayoutBoxInformation(testData.ComponentLeft1).AbsoluteBox.Left);
Assert.Equal(90, result.GetLayoutBoxInformation(testData.ComponentLeft2).AbsoluteBox.Top);
Assert.Equal(200, result.GetLayoutBoxInformation(testData.ComponentLeft2).AbsoluteBox.Right);
Assert.Equal(130, result.GetLayoutBoxInformation(testData.ComponentLeft2).AbsoluteBox.Bottom);
Assert.Equal(0, result.GetLayoutBoxInformation(testData.ComponentLeft2).AbsoluteBox.Left);
Assert.Equal(50, result.GetLayoutBoxInformation(testData.ComponentRight).AbsoluteBox.Top);
Assert.Equal(800, result.GetLayoutBoxInformation(testData.ComponentRight).AbsoluteBox.Right);
Assert.Equal(600, result.GetLayoutBoxInformation(testData.ComponentRight).AbsoluteBox.Bottom);
Assert.Equal(200, result.GetLayoutBoxInformation(testData.ComponentRight).AbsoluteBox.Left);
Assert.Equal(50, result.GetLayoutBoxInformation(testData.ComponentRight1).AbsoluteBox.Top);
Assert.Equal(800, result.GetLayoutBoxInformation(testData.ComponentRight1).AbsoluteBox.Right);
Assert.Equal(90, result.GetLayoutBoxInformation(testData.ComponentRight1).AbsoluteBox.Bottom);
Assert.Equal(200, result.GetLayoutBoxInformation(testData.ComponentRight1).AbsoluteBox.Left);
Assert.Equal(90, result.GetLayoutBoxInformation(testData.ComponentRight2).AbsoluteBox.Top);
Assert.Equal(800, result.GetLayoutBoxInformation(testData.ComponentRight2).AbsoluteBox.Right);
Assert.Equal(170, result.GetLayoutBoxInformation(testData.ComponentRight2).AbsoluteBox.Bottom);
Assert.Equal(200, result.GetLayoutBoxInformation(testData.ComponentRight2).AbsoluteBox.Left);
}
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 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);
}
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);
}
public SipBaseResponse(byte[] buffer, params string[] messageIds)
{
StringBuilder sb = new StringBuilder();
response = string.Empty;
foreach (byte b in buffer)
{
response += (char)b;
}
var messages = response.Split('\r');
foreach (var message in messages)
{
if (string.IsNullOrEmpty(message))
{
continue;
}
currentMessage = message;
var root = ElementTree.Parse(message).Get("SIP");
Command = root.GetValue <string>("Response");
if (Command != null && !messageIds.ToList().Contains(Command))
{
throw new MessageException("Excpected {0} but recieved {1}".FormatWith(string.Join(", ", messageIds), Command));
}
Version = root.GetValue <string>("Version");
EcrId = root.GetValue <string>("ECRId");
SipId = root.GetValue <string>("SIPId");
RequestId = root.GetValue <string>("RequestId");
ResponseId = root.GetValue <string>("ResponseId");
Status = root.GetValue <string>("MultipleMessage");
DeviceResponseCode = NormalizeResponse(root.GetValue <string>("Result"));
DeviceResponseText = root.GetValue <string>("ResultText");
if ((DeviceResponseCode.Equals("00", StringComparison.OrdinalIgnoreCase)) || (DeviceResponseCode.Equals("2501", StringComparison.OrdinalIgnoreCase)))
{
MapResponse(root);
}
}
FinalizeResponse();
}
private Transaction MakeBlindPaymentReturnToken(AuthorizationBuilder builder)
{
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "MakeBlindPaymentReturnToken");
var request = new MakeBlindPaymentReturnTokenRequest(et)
.Build(envelope, builder, Credentials);
var response = DoTransaction(request, publicEndpoint);
var result = new TransactionResponse()
.WithResponseTagName("MakeBlindPaymentReturnTokenResponse")
.WithResponse(response)
.Map();
if (result.ResponseCode == "0")
{
return(result);
}
throw new GatewayException(message: "An error occurred attempting to make the payment", responseCode: result.ResponseCode, responseMessage: result.ResponseMessage);
}
internal override TerminalResponse ProcessTransaction(TerminalAuthBuilder 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(transactionType);
et.SubElement(request, "RequestId", requestId);
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 BillingResponse PreloadBills(BillingBuilder builder)
{
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "PreloadBills");
var request = new PreloadBillsRequest(et)
.Build(envelope, builder, Credentials);
var response = DoTransaction(request, publicEndpoint);
var result = new PreloadBillsResponse()
.WithResponseTagName("PreloadBillsResponse")
.WithResponse(response)
.Map();
if (result.IsSuccessful)
{
return(result);
}
throw new GatewayException(message: "An error occurred attempting to load the hosted bills", responseCode: result.ResponseCode, responseMessage: result.ResponseMessage);
}
private ConvenienceFeeResponse GetConvenienceFee(BillingBuilder builder)
{
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "GetConvenienceFee");
var request = new GetConvenienceFeeRequest(et)
.Build(envelope, builder, Credentials);
var response = DoTransaction(request, publicEndpoint);
var result = new ConvenienceFeeRequestResponse()
.WithResponseTagName("GetConvenienceFeeResponse")
.WithResponse(response)
.Map();
if (result.IsSuccessful)
{
return(result);
}
throw new GatewayException(message: "An error occurred attempting to retrieve the payment fee", responseCode: result.ResponseCode, responseMessage: result.ResponseMessage);
}
private Transaction UpdateToken(CreditCardData card)
{
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "UpdateTokenExpirationDate");
var request = new UpdateTokenRequest(et)
.Build(envelope, card, Credentials);
var response = DoTransaction(request, publicEndpoint);
var result = new UpdateTokenResponse()
.WithResponseTagName("UpdateTokenExpirationDateResponse")
.WithResponse(response)
.Map();
if (result.ResponseCode == "0")
{
return(result);
}
throw new GatewayException(message: "There was an error attempting to the token expiry information", responseCode: result.ResponseCode, responseMessage: result.ResponseMessage);
}
private Transaction ReversePayment(ManagementBuilder builder)
{
var et = new ElementTree();
var envelope = CreateSOAPEnvelope(et, "ReversePayment");
var request = new ReversePaymentRequest(et)
.Build(envelope, builder, Credentials);
var response = DoTransaction(request, publicEndpoint);
var result = new ReversalResponse()
.WithResponseTagName("ReversePaymentResponse")
.WithResponse(response)
.Map();
if (result.ResponseCode == "0")
{
return(result);
}
throw new GatewayException(message: "There was an error attempting to reverse the payment", responseCode: result.ResponseCode, responseMessage: result.ResponseMessage);
}
