public static DeviceMessage BuildUpaAdminRequest(int requestId, string ecrId, string txnType, string lineItemLeft = null, string lineItemRight = null, int?displayOption = null)
{
var doc = new JsonDoc();
doc.Set("message", UpaMessageType.Msg);
var data = doc.SubElement("data");
data.Set("command", txnType);
data.Set("EcrId", ecrId);
data.Set("requestId", requestId);
if ((!string.IsNullOrEmpty(lineItemLeft) || !string.IsNullOrEmpty(lineItemRight)) || displayOption.HasValue)
{
var request = data.SubElement("data");
var requestParams = request.SubElement("params");
requestParams.Set("lineItemLeft", lineItemLeft);
requestParams.Set("lineItemRight", lineItemRight);
if (displayOption.HasValue)
{
requestParams.Set("displayOption", displayOption);
}
}
return(BuildUpaRequest(doc.ToString()));
}
internal IDeviceMessage BuildReportTransaction(TerminalReportBuilder builder)
{
var requestId = builder.SearchBuilder.ReferenceNumber;
if (requestId == default(string) && RequestIdProvider != null)
{
requestId = RequestIdProvider.GetRequestId().ToString();
}
var doc = new JsonDoc();
doc.Set("message", "MSG");
var baseRequest = doc.SubElement("data");
baseRequest.Set("command", MapReportType(builder.ReportType));
if (!(builder.SearchBuilder.EcrId == null))
{
baseRequest.Set("EcrId", builder.SearchBuilder.EcrId);
}
baseRequest.Set("requestId", requestId.ToString());
if (builder.ReportType == TerminalReportType.GetOpenTabDetails)
{
return(TerminalUtilities.BuildUpaRequest(doc.ToString()));
}
var txnData = baseRequest.SubElement("data");
var txnParams = txnData.SubElement("params");
txnParams.Set("reportOutput", builder.SearchBuilder.ReportOutput);
txnParams.Set("batch", builder.SearchBuilder.Batch);
return(TerminalUtilities.BuildUpaRequest(doc.ToString()));
}
private JsonDoc BuildAmount(JsonDoc request, string name, decimal?amount, string currency, TransactionType type)
{
if (amount.HasValue)
{
var node = request.SubElement(name);
node.Set("value", amount.ToNumericCurrencyString());
if (type == TransactionType.Create)
{
node.Set("currency", currency);
}
}
return(request);
}
internal IDeviceMessage BuildManageTransaction(TerminalManageBuilder builder)
{
var transType = builder.TransactionType;
var transModifier = builder.TransactionModifier;
int requestId = builder.ReferenceNumber;
if (requestId == default(int) && RequestIdProvider != null)
{
requestId = RequestIdProvider.GetRequestId();
}
var doc = new JsonDoc();
doc.Set("message", "MSG");
var baseRequest = doc.SubElement("data");
// Possibly update the requestToken parameter in the future if necessary
baseRequest.Set("command", MapTransactionType(transType, transModifier, false, builder.Gratuity));
baseRequest.Set("EcrId", builder.EcrId.ToString());
baseRequest.Set("requestId", requestId.ToString());
var txnData = baseRequest.SubElement("data");
var transaction = txnData.SubElement("transaction");
transaction.Set("referenceNumber", builder.TransactionId ?? StringUtils.PadLeft(builder.TerminalRefNumber, 4, '0'));
transaction.Set("amount", ToCurrencyString(builder.Amount));
transaction.Set("taxAmount", ToCurrencyString(builder.TaxAmount));
transaction.Set("tipAmount", ToCurrencyString(builder.Gratuity));
transaction.Set("taxIndicator", builder.TaxExempt);
transaction.Set("invoiceNbr", builder.InvoiceNumber);
transaction.Set("processCPC", builder.ProcessCPC);
return(TerminalUtilities.BuildUpaRequest(doc.ToString()));
}
private JsonDoc BuildPaymentMethod(JsonDoc request, RecurringPaymentMethod payment, TransactionType type)
{
if (payment != null)
{
request.Set("preferredPayment", payment.PreferredPayment);
request.Set("paymentMethodIdentifier", payment.Id);
request.Set("customerKey", payment.CustomerKey);
request.Set("nameOnAccount", payment.NameOnAccount);
BuildAddress(request, payment.Address);
if (type == TransactionType.Create)
{
string tokenValue = null;
var hasToken = HasToken(payment.PaymentMethod, out tokenValue);
JsonDoc paymentInfo = null;
if (payment.PaymentMethod is ICardData)
{
var method = payment.PaymentMethod as ICardData;
paymentInfo = request.SubElement(hasToken ? "alternateIdentity" : "card")
.Set("type", hasToken ? "SINGLEUSETOKEN" : null)
.Set(hasToken ? "token" : "number", hasToken ? tokenValue : method.Number)
.Set("expMon", method.ExpMonth)
.Set("expYear", method.ExpYear);
request.Set("cardVerificationValue", method.Cvn);
}
else if (payment.PaymentMethod is ITrackData)
{
var method = payment.PaymentMethod as ITrackData;
paymentInfo = request.SubElement("track")
.Set("data", method.Value)
.Set("dataEntryMode", method.EntryMethod.ToString().ToUpper());
}
else if (payment.PaymentMethod is eCheck)
{
var check = payment.PaymentMethod as eCheck;
request.Set("achType", check.AccountType.ToInitialCase())
.Set("accountType", check.CheckType.ToInitialCase())
.Set("telephoneIndicator", (check.SecCode == SecCode.CCD || check.SecCode == SecCode.PPD) ? false : true)
.Set("routingNumber", check.RoutingNumber)
.Set("accountNumber", check.AccountNumber)
.Set("accountHolderYob", check.BirthYear.ToString())
.Set("driversLicenseState", check.DriversLicenseState)
.Set("driversLicenseNumber", check.DriversLicenseNumber)
.Set("socialSecurityNumberLast4", check.SsnLast4);
request.Remove("country");
}
if (payment.PaymentMethod is IEncryptable)
{
var enc = (payment.PaymentMethod as IEncryptable).EncryptionData;
if (enc != null)
{
paymentInfo.Set("trackNumber", enc.TrackNumber);
paymentInfo.Set("key", enc.KTB);
paymentInfo.Set("encryptionType", "E3");
}
}
}
else // EDIT FIELDS
{
request.Remove("customerKey");
request.Set("paymentStatus", payment.Status);
request.Set("cpcTaxType", payment.TaxType);
request.Set("expirationDate", payment.ExpirationDate);
}
}
return(request);
}
public Transaction ProcessSecure3d(Secure3dBuilder builder)
{
TransactionType transType = builder.TransactionType;
IPaymentMethod paymentMethod = builder.PaymentMethod;
ISecure3d secure3d = (ISecure3d)paymentMethod;
string timestamp = DateTime.Now.ToString("yyyy-MM-dd'T'hh:mm:ss.ffffff");
JsonDoc request = new JsonDoc();
if (transType.Equals(TransactionType.VerifyEnrolled))
{
request.Set("request_timestamp", timestamp);
request.Set("merchant_id", MerchantId);
request.Set("account_id", AccountId);
request.Set("method_notification_url", MethodNotificationUrl);
string hashValue = string.Empty;
if (paymentMethod is CreditCardData cardData)
{
request.Set("number", cardData.Number);
request.Set("scheme", MapCardScheme(cardData.CardType.ToUpper()));
hashValue = cardData.Number;
}
else if (paymentMethod is RecurringPaymentMethod storedCard)
{
request.Set("payer_reference", storedCard.CustomerKey);
request.Set("payment_method_reference", storedCard.Key);
hashValue = storedCard.CustomerKey;
}
string hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, hashValue);
SetAuthHeader(hash);
string rawResponse = DoTransaction(HttpMethod.Post, "protocol-versions", request.ToString());
return(MapResponse(rawResponse));
}
else if (transType.Equals(TransactionType.VerifySignature))
{
string hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, builder.ServerTransactionId);
SetAuthHeader(hash);
var queryValues = new Dictionary <string, string>();
queryValues.Add("merchant_id", MerchantId);
queryValues.Add("request_timestamp", timestamp);
string rawResponse = DoTransaction(HttpMethod.Get, string.Format("authentications/{0}", builder.ServerTransactionId), null, queryValues);
return(MapResponse(rawResponse));
}
else if (transType.Equals(TransactionType.InitiateAuthentication))
{
string orderId = builder.OrderId;
if (string.IsNullOrEmpty(orderId))
{
orderId = GenerationUtils.GenerateOrderId();
}
ThreeDSecure secureEcom = secure3d.ThreeDSecure;
request.Set("request_timestamp", timestamp);
request.Set("authentication_source", builder.AuthenticationSource.ToString());
request.Set("authentication_request_type", builder.AuthenticationRequestType.ToString());
request.Set("message_category", builder.MessageCategory.ToString());
request.Set("message_version", "2.1.0");
request.Set("server_trans_id", secureEcom.ServerTransactionId);
request.Set("merchant_id", MerchantId);
request.Set("account_id", AccountId);
request.Set("challenge_notification_url", ChallengeNotificationUrl);
request.Set("method_url_completion", builder.MethodUrlCompletion.ToString());
request.Set("merchant_contact_url", MerchantContactUrl);
request.Set("merchant_initiated_request_type", builder.MerchantInitiatedRequestType?.ToString());
request.Set("whitelist_status", builder.WhitelistStatus);
request.Set("decoupled_flow_request", builder.DecoupledFlowRequest);
request.Set("decoupled_flow_timeout", builder.DecoupledFlowTimeout);
request.Set("decoupled_notification_url", builder.DecoupledNotificationUrl);
request.Set("enable_exemption_optimization", builder.EnableExemptionOptimization);
// card details
string hashValue = string.Empty;
JsonDoc cardDetail = request.SubElement("card_detail");
if (paymentMethod is CreditCardData cardData)
{
hashValue = cardData.Number;
cardDetail.Set("number", cardData.Number);
cardDetail.Set("scheme", cardData.CardType.ToUpper());
cardDetail.Set("expiry_month", cardData.ExpMonth.ToString());
cardDetail.Set("expiry_year", cardData.ExpYear.ToString().Substring(2));
cardDetail.Set("full_name", cardData.CardHolderName);
if (!string.IsNullOrEmpty(cardData.CardHolderName))
{
string[] names = cardData.CardHolderName.Split(' ');
if (names.Length >= 1)
{
cardDetail.Set("first_name", names[0]);
}
if (names.Length >= 2)
{
cardDetail.Set("last_name", string.Join(" ", names.Skip(1)));
}
}
}
else if (paymentMethod is RecurringPaymentMethod storedCard)
{
hashValue = storedCard.CustomerKey;
cardDetail.Set("payer_reference", storedCard.CustomerKey);
cardDetail.Set("payment_method_reference", storedCard.Key);
}
// order details
JsonDoc order = request.SubElement("order");
order.Set("amount", builder.Amount.ToNumericCurrencyString());
order.Set("currency", builder.Currency);
order.Set("id", orderId);
order.Set("address_match_indicator", builder.AddressMatchIndicator ? "true" : "false");
order.Set("date_time_created", builder.OrderCreateDate?.ToString("yyyy-MM-dd'T'hh:mm'Z'"));
order.Set("gift_card_count", builder.GiftCardCount);
order.Set("gift_card_currency", builder.GiftCardCurrency);
order.Set("gift_card_amount", builder.GiftCardAmount.ToNumericCurrencyString());
order.Set("delivery_email", builder.DeliveryEmail);
order.Set("delivery_timeframe", builder.DeliveryTimeframe?.ToString());
order.Set("shipping_method", builder.ShippingMethod?.ToString());
order.Set("shipping_name_matches_cardholder_name", builder.ShippingNameMatchesCardHolderName);
order.Set("preorder_indicator", builder.PreOrderIndicator?.ToString());
order.Set("reorder_indicator", builder.ReorderIndicator?.ToString());
order.Set("transaction_type", builder.OrderTransactionType?.ToString());
order.Set("preorder_availability_date", builder.PreOrderAvailabilityDate?.ToString("yyyy-MM-dd"));
// shipping address
Address shippingAddress = builder.ShippingAddress;
if (shippingAddress != null)
{
JsonDoc shippingAddressElement = order.SubElement("shipping_address");
shippingAddressElement.Set("line1", shippingAddress.StreetAddress1);
shippingAddressElement.Set("line2", shippingAddress.StreetAddress2);
shippingAddressElement.Set("line3", shippingAddress.StreetAddress3);
shippingAddressElement.Set("city", shippingAddress.City);
shippingAddressElement.Set("postal_code", shippingAddress.PostalCode);
shippingAddressElement.Set("state", shippingAddress.State);
shippingAddressElement.Set("country", shippingAddress.CountryCode);
}
// payer
JsonDoc payer = request.SubElement("payer");
payer.Set("email", builder.CustomerEmail);
payer.Set("id", builder.CustomerAccountId);
payer.Set("account_age", builder.AccountAgeIndicator?.ToString());
payer.Set("account_creation_date", builder.AccountCreateDate?.ToString("yyyy-MM-dd"));
payer.Set("account_change_indicator", builder.AccountChangeIndicator?.ToString());
payer.Set("account_change_date", builder.AccountChangeDate?.ToString("yyyy-MM-dd"));
payer.Set("account_password_change_indicator", builder.PasswordChangeIndicator?.ToString());
payer.Set("account_password_change_date", builder.PasswordChangeDate?.ToString("yyyy-MM-dd"));
payer.Set("payment_account_age_indicator", builder.PaymentAgeIndicator?.ToString());
payer.Set("payment_account_creation_date", builder.PaymentAccountCreateDate?.ToString("yyyy-MM-dd"));
payer.Set("purchase_count_last_6months", builder.NumberOfPurchasesInLastSixMonths);
payer.Set("transaction_count_last_24hours", builder.NumberOfTransactionsInLast24Hours);
payer.Set("transaction_count_last_year", builder.NumberOfTransactionsInLastYear);
payer.Set("provision_attempt_count_last_24hours", builder.NumberOfAddCardAttemptsInLast24Hours);
payer.Set("shipping_address_creation_indicator", builder.ShippingAddressUsageIndicator?.ToString());
payer.Set("shipping_address_creation_date", builder.ShippingAddressCreateDate?.ToString("yyyy-MM-dd"));
// suspicious activity
if (builder.PreviousSuspiciousActivity != null)
{
payer.Set("suspicious_account_activity", builder.PreviousSuspiciousActivity.Value ? "SUSPICIOUS_ACTIVITY" : "NO_SUSPICIOUS_ACTIVITY");
}
// home phone
if (!string.IsNullOrEmpty(builder.HomeNumber))
{
payer.SubElement("home_phone")
.Set("country_code", builder.HomeCountryCode)
.Set("subscriber_number", builder.HomeNumber);
}
// work phone
if (!string.IsNullOrEmpty(builder.WorkNumber))
{
payer.SubElement("work_phone")
.Set("country_code", builder.WorkCountryCode)
.Set("subscriber_number", builder.WorkNumber);
}
// payer login data
if (builder.HasPayerLoginData)
{
request.SubElement("payer_login_data")
.Set("authentication_data", builder.CustomerAuthenticationData)
.Set("authentication_timestamp", builder.CustomerAuthenticationTimestamp?.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'"))
.Set("authentication_type", builder.CustomerAuthenticationMethod?.ToString());
}
// prior authentication data
if (builder.HasPriorAuthenticationData)
{
request.SubElement("payer_prior_three_ds_authentication_data")
.Set("authentication_method", builder.PriorAuthenticationMethod?.ToString())
.Set("acs_transaction_id", builder.PriorAuthenticationTransactionId)
.Set("authentication_timestamp", builder.PriorAuthenticationTimestamp?.ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'"))
.Set("authentication_data", builder.PriorAuthenticationData);
}
// recurring authorization data
if (builder.HasRecurringAuthData)
{
request.SubElement("recurring_authorization_data")
.Set("max_number_of_instalments", builder.MaxNumberOfInstallments)
.Set("frequency", builder.RecurringAuthorizationFrequency)
.Set("expiry_date", builder.RecurringAuthorizationExpiryDate?.ToString("yyyy-MM-dd"));
}
// billing details
Address billingAddress = builder.BillingAddress;
if (billingAddress != null)
{
JsonDoc billingAddressElement = payer.SubElement("billing_address");
billingAddressElement.Set("line1", billingAddress.StreetAddress1);
billingAddressElement.Set("line2", billingAddress.StreetAddress2);
billingAddressElement.Set("line3", billingAddress.StreetAddress3);
billingAddressElement.Set("city", billingAddress.City);
billingAddressElement.Set("postal_code", billingAddress.PostalCode);
billingAddressElement.Set("state", billingAddress.State);
billingAddressElement.Set("country", billingAddress.CountryCode);
}
// mobile phone
if (!string.IsNullOrEmpty(builder.MobileNumber))
{
JsonDoc mobilePhone = payer.SubElement("mobile_phone");
mobilePhone.Set("country_code", builder.MobileCountryCode);
mobilePhone.Set("subscriber_number", builder.MobileNumber);
}
// browser_data
BrowserData broswerData = builder.BrowserData;
if (broswerData != null)
{
JsonDoc browserDataElement = request.SubElement("browser_data");
browserDataElement.Set("accept_header", broswerData.AcceptHeader);
browserDataElement.Set("color_depth", broswerData.ColorDepth.ToString());
browserDataElement.Set("ip", broswerData.IpAddress);
browserDataElement.Set("java_enabled", broswerData.JavaEnabled);
browserDataElement.Set("javascript_enabled", broswerData.JavaScriptEnabled);
browserDataElement.Set("language", broswerData.Language);
browserDataElement.Set("screen_height", broswerData.ScreenHeight);
browserDataElement.Set("screen_width", broswerData.ScreenWidth);
browserDataElement.Set("challenge_window_size", broswerData.ChallengeWindowSize.ToString());
browserDataElement.Set("timezone", broswerData.Timezone);
browserDataElement.Set("user_agent", broswerData.UserAgent);
}
// mobile fields
if (builder.HasMobileFields)
{
JsonDoc sdkInformationElement = request.SubElement("sdk_information")
.Set("application_id", builder.ApplicationId)
.Set("ephemeral_public_key", builder.EphemeralPublicKey)
.Set("maximum_timeout", builder.MaximumTimeout)
.Set("reference_number", builder.ReferenceNumber)
.Set("sdk_trans_id", builder.SdkTransactionId)
.Set("encoded_data", builder.EncodedData)
;
// device render options
if (builder.SdkInterface != null || builder.SdkUiTypes != null)
{
var dro = sdkInformationElement.SubElement("device_render_options");
dro.Set("sdk_interface", builder.SdkInterface?.ToString());
if (builder.SdkUiTypes != null)
{
var uiTypes = new List <string>();
foreach (var sdkuiType in builder.SdkUiTypes)
{
uiTypes.Add(sdkuiType.ToString());
}
dro.Set("sdk_ui_type", uiTypes.ToArray());
}
}
}
string hash = GenerationUtils.GenerateHash(SharedSecret, timestamp, MerchantId, hashValue, secureEcom.ServerTransactionId);
SetAuthHeader(hash);
string rawResponse = DoTransaction(HttpMethod.Post, "authentications", request.ToString());
return(MapResponse(rawResponse));
}
throw new ApiException(string.Format("Unknown transaction type {0}.", transType));
}
internal IDeviceMessage BuildProcessTransaction(TerminalAuthBuilder builder)
{
var pmt = builder.PaymentMethodType;
var transType = builder.TransactionType;
var transModifier = builder.TransactionModifier;
bool isTipAdjust = IsTipAdjust(transType, builder.Gratuity);
bool isCardHSAFSA = IsCardHSAFSA(builder.AutoSubstantiation);
if (pmt != PaymentMethodType.Credit && pmt != PaymentMethodType.Debit && pmt != PaymentMethodType.EBT)
{
throw new UnsupportedTransactionException("The supplied payment method type is not supported");
}
int requestId = builder.ReferenceNumber;
if (requestId == default(int) && RequestIdProvider != null)
{
requestId = RequestIdProvider.GetRequestId();
}
var doc = new JsonDoc();
doc.Set("message", "MSG");
var baseRequest = doc.SubElement("data");
baseRequest.Set("command", MapTransactionType(transType, transModifier, builder.RequestMultiUseToken, builder.Gratuity));
baseRequest.Set("EcrId", builder.EcrId.ToString());
baseRequest.Set("requestId", requestId.ToString());
if (transType != TransactionType.Balance)
{
var txnData = baseRequest.SubElement("data");
var txnParams = txnData.SubElement("params");
txnParams.Set("clerkId", builder.ClerkId);
if (transType == TransactionType.Tokenize || transType == TransactionType.Verify)
{
txnParams.Set("cardIsHSAFSA", isCardHSAFSA ? "1" : "0");
}
if (!IsTokenRequestApplicable(isTipAdjust, transType))
{
txnParams.Set("tokenRequest", builder.RequestMultiUseToken ? "1" : "0");
}
if (builder.PaymentMethod is CreditCardData)
{
txnParams.Set("tokenValue", ((CreditCardData)builder.PaymentMethod).Token);
}
if (builder.RequestMultiUseToken && (transType == TransactionType.Sale || transType == TransactionType.Refund || transType == TransactionType.Verify ||
transType == TransactionType.Auth))
{
if (builder.CardOnFileIndicator != null)
{
txnParams.Set("cardOnFileIndicator", EnumConverter.GetMapping(Target.UPA, builder.CardOnFileIndicator));
}
txnParams.Set("cardBrandTransId", builder.CardBrandTransId);
}
txnParams.Set("lineItemLeft", builder.LineItemLeft);
txnParams.Set("lineItemRight", builder.LineItemRight);
txnParams.Set("directMktInvoiceNbr", builder.InvoiceNumber);
if (builder.ShippingDate != DateTime.MinValue)
{
txnParams.Set("directMktShipMonth", builder.ShippingDate.Month.ToString("00"));
txnParams.Set("directMktShipDay", builder.ShippingDate.Day.ToString("00"));
}
if (transType != TransactionType.Verify && transType != TransactionType.Refund && !isTipAdjust && transType != TransactionType.Tokenize)
{
var transaction = txnData.SubElement("transaction");
if (transType == TransactionType.Auth)
{
transaction.Set("amount", ToCurrencyString(builder.Amount));
}
else
{
transaction.Set("baseAmount", ToCurrencyString(builder.Amount));
transaction.Set("cashBackAmount", ToCurrencyString(builder.CashBackAmount));
transaction.Set("tipAmount", ToCurrencyString(builder.Gratuity));
transaction.Set("taxIndicator", builder.TaxExempt);
transaction.Set("invoiceNbr", builder.InvoiceNumber);
transaction.Set("processCPC", builder.ProcessCPC);
transaction.Set("taxAmount", ToCurrencyString(builder.TaxAmount));
}
transaction.Set("referenceNumber", builder.TerminalRefNumber);
transaction.Set("cardIsHSAFSA", isCardHSAFSA ? "1" : "0");
transaction.Set("prescriptionAmount", ToCurrencyString(builder.PrescriptionAmount));
transaction.Set("clinicAmount", ToCurrencyString(builder.ClinicAmount));
transaction.Set("dentalAmount", ToCurrencyString(builder.DentalAmount));
transaction.Set("visionOpticalAmount", ToCurrencyString(builder.VisionOpticalAmount));
}
if (transType == TransactionType.Refund)
{
var transaction = txnData.SubElement("transaction");
transaction.Set("totalAmount", ToCurrencyString(builder.Amount));
}
if (isTipAdjust)
{
var transaction = txnData.SubElement("transaction");
transaction.Set("tranNo", builder.TerminalRefNumber);
transaction.Set("tipAmount", ToCurrencyString(builder.Gratuity));
}
}
return(TerminalUtilities.BuildUpaRequest(doc.ToString()));
}
