public void ToXml_Includes_DeviceSessionId()
{
CreditCardRequest request = new CreditCardRequest();
request.DeviceSessionId = "my_dsid";
Assert.IsTrue(request.ToXml().Contains("my_dsid"));
}
public void ToXml_Includes_PaymentMethodNonce()
{
CreditCardRequest request = new CreditCardRequest();
request.PaymentMethodNonce = "my-payment-method-nonce";
Assert.IsTrue(request.ToXml().Contains("my-payment-method-nonce"));
}
public void ToXml_Includes_FraudMerchantId()
{
CreditCardRequest request = new CreditCardRequest();
request.FraudMerchantId = "my_fmid";
Assert.IsTrue(request.ToXml().Contains("my_fmid"));
}
public void ToXml_Includes_DeviceData()
{
CreditCardRequest request = new CreditCardRequest();
request.DeviceData = "{\"device_session_id\":\"my_dsid\", \"fraud_merchant_id\":\"my_fmid\"}";
Assert.IsTrue(request.ToXml().Contains("device-data"));
Assert.IsTrue(request.ToXml().Contains("device_session_id"));
Assert.IsTrue(request.ToXml().Contains("my_dsid"));
Assert.IsTrue(request.ToXml().Contains("fraud_merchant_id"));
Assert.IsTrue(request.ToXml().Contains("my_fmid"));
}
public void AppendWithRequest()
{
Request request = new CreditCardRequest
{
CVV = "123",
CardholderName = "Drew"
};
string actual = new QueryString().Append("[credit_card]", request).ToString();
Assert.AreEqual("%5bcredit_card%5d%5bcardholder_name%5d=Drew&%5bcredit_card%5d%5bcvv%5d=123", actual);
}
public void AppendWithNestedRequest()
{
Request request = new CreditCardRequest
{
CVV = "123",
CardholderName = "Drew",
Options = new CreditCardOptionsRequest
{
VerifyCard = true,
MakeDefault = true
}
};
string actual = new QueryString().Append("[credit_card]", request).ToString();
Assert.AreEqual("%5bcredit_card%5d%5bcardholder_name%5d=Drew&%5bcredit_card%5d%5bcvv%5d=123&%5bcredit_card%5d%5boptions%5d%5bmake_default%5d=true&%5bcredit_card%5d%5boptions%5d%5bverify_card%5d=true", actual);
}
public void Create_CreatesCreditCardForGivenCustomerId()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var creditCardRequest = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
CVV = "123",
CardholderName = "Michael Angelo",
BillingAddress = new CreditCardAddressRequest
{
FirstName = "John",
CountryName = "Chad",
CountryCodeAlpha2 = "TD",
CountryCodeAlpha3 = "TCD",
CountryCodeNumeric = "148"
}
};
CreditCard creditCard = gateway.CreditCard.Create(creditCardRequest).Target;
Assert.AreEqual("510510", creditCard.Bin);
Assert.AreEqual("5100", creditCard.LastFour);
Assert.AreEqual("510510******5100", creditCard.MaskedNumber);
Assert.AreEqual("05", creditCard.ExpirationMonth);
Assert.AreEqual("2012", creditCard.ExpirationYear);
Assert.AreEqual("Michael Angelo", creditCard.CardholderName);
Assert.IsTrue(creditCard.IsDefault.Value);
Assert.IsFalse(creditCard.IsVenmoSdk.Value);
Assert.AreEqual(DateTime.Now.Year, creditCard.CreatedAt.Value.Year);
Assert.AreEqual(DateTime.Now.Year, creditCard.UpdatedAt.Value.Year);
Assert.IsNotNull(creditCard.ImageUrl);
Address billingAddress = creditCard.BillingAddress;
Assert.AreEqual("Chad", billingAddress.CountryName);
Assert.AreEqual("TD", billingAddress.CountryCodeAlpha2);
Assert.AreEqual("TCD", billingAddress.CountryCodeAlpha3);
Assert.AreEqual("148", billingAddress.CountryCodeNumeric);
Assert.IsTrue(Regex.IsMatch(creditCard.UniqueNumberIdentifier, "\\A\\w{32}\\z"));
}
public void VerifyInvalidCreditCard()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest request = new CreditCardRequest
{
CustomerId = customer.Id,
CardholderName = "John Doe",
CVV = "123",
Number = "5105105105105100",
ExpirationDate = "05/12",
Options = new CreditCardOptionsRequest
{
VerifyCard = true
}
};
Result<CreditCard> result = gateway.CreditCard.Create(request);
Assert.IsFalse(result.IsSuccess());
CreditCardVerification verification = result.CreditCardVerification;
Assert.AreEqual(VerificationStatus.PROCESSOR_DECLINED, verification.Status);
Assert.IsNull(verification.GatewayRejectionReason);
}
public void VerifyValidCreditCardSpecifyingMerhantAccount()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest request = new CreditCardRequest
{
CustomerId = customer.Id,
CardholderName = "John Doe",
CVV = "123",
Number = "5105105105105100",
ExpirationDate = "05/12",
Options = new CreditCardOptionsRequest
{
VerifyCard = true,
VerificationMerchantAccountId = MerchantAccountIDs.NON_DEFAULT_MERCHANT_ACCOUNT_ID
}
};
Result<CreditCard> result = gateway.CreditCard.Create(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(MerchantAccountIDs.NON_DEFAULT_MERCHANT_ACCOUNT_ID, result.CreditCardVerification.MerchantAccountId);
}
public void VerifyValidCreditCardWithVerificationAmount()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest request = new CreditCardRequest
{
CustomerId = customer.Id,
CardholderName = "John Doe",
CVV = "123",
Number = "4111111111111111",
ExpirationDate = "05/12",
Options = new CreditCardOptionsRequest
{
VerifyCard = true,
VerificationAmount = "1.02"
}
};
Result<CreditCard> result = gateway.CreditCard.Create(request);
Assert.IsTrue(result.IsSuccess());
}
public virtual async Task <Result <CreditCard> > CreateAsync(CreditCardRequest request)
{
XmlNode creditCardXML = await service.PostAsync(service.MerchantPath() + "/payment_methods", request).ConfigureAwait(false);
return(new ResultImpl <CreditCard>(new NodeWrapper(creditCardXML), gateway));
}
public void ConfirmTransparentRedirectCreate_WithErrors()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest trParams = new CreditCardRequest { CustomerId = customer.Id };
CreditCardRequest request = new CreditCardRequest
{
CardholderName = "John Doe",
Number = "5105105105105100",
ExpirationDate = "05/12",
BillingAddress = new CreditCardAddressRequest
{
CountryName = "Greece",
CountryCodeAlpha2 = "MX"
}
};
string queryString = TestHelper.QueryStringForTR(trParams, request, gateway.CreditCard.TransparentRedirectURLForCreate(), service);
Result<CreditCard> result = gateway.CreditCard.ConfirmTransparentRedirect(queryString);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.ADDRESS_INCONSISTENT_COUNTRY,
result.Errors.ForObject("CreditCard").ForObject("BillingAddress").OnField("Base")[0].Code
);
}
public async Task <ActionResult> Index(CheckoutModel model)
{
//Check if the model-state is valid -- this will catch anytime someone hacks your client-side validation
if (ModelState.IsValid)
{
if (model.CustomerId == null)
{
BraintreeService service = new BraintreeService(this._braintreeGateway);
model.CustomerId = await service.GetCustomerId(model.Email, model.Phone, model.FirstName, model.LastName);
}
if ((model.CardToken == "NewCard") || (model.CardToken == null))
{
Braintree.CreditCardRequest card = new Braintree.CreditCardRequest();
card.Number = model.CreditCardNumber;
card.CVV = model.CreditCardVerificationValue;
card.ExpirationMonth = model.CreditCardExpirationMonth.ToString().PadLeft(2, '0');
card.ExpirationYear = model.CreditCardExpirationYear.ToString();
card.CardholderName = model.BillingFirstName + " " + model.BillingLastName;
card.CustomerId = model.CustomerId;
var cardResult = await _braintreeGateway.CreditCard.CreateAsync(card);
model.CardToken = cardResult.Target.Token;
}
if ((model.BillingAddressId == "NewAddress") || (model.BillingAddressId == null))
{
Braintree.AddressRequest address = new Braintree.AddressRequest();
address.StreetAddress = model.BillingAddressLine1 + " " + model.BillingAddressLine2;
address.CountryName = model.BillingCountry;
address.Locality = model.BillingCity;
address.PostalCode = model.BillingPostalCode;
address.Region = model.BillingState;
var addressResult = await _braintreeGateway.Address.CreateAsync(model.CustomerId, address);
model.BillingAddressId = addressResult.Target.Id;
}
if ((model.ShippingAddressId == "NewAddress") || (model.ShippingAddressId == null))
{
if ((model.ShippingAddressLine1 == model.BillingAddressLine1) &&
(model.ShippingAddressLine2 == model.BillingAddressLine2) &&
(model.ShippingCity == model.BillingCity) &&
(model.ShippingPostalCode == model.BillingPostalCode) &&
(model.ShippingState == model.BillingState) &&
(model.ShippingCountry == model.BillingCountry))
{
model.ShippingAddressId = model.BillingAddressId;
}
else
{
Braintree.AddressRequest address = new Braintree.AddressRequest();
address.StreetAddress = model.ShippingAddressLine1 + " " + model.ShippingAddressLine2;
address.CountryName = model.ShippingCountry;
address.Locality = model.ShippingCity;
address.PostalCode = model.ShippingPostalCode;
address.Region = model.ShippingState;
var addressResult = await _braintreeGateway.Address.CreateAsync(model.CustomerId, address);
model.ShippingAddressId = addressResult.Target.Id;
}
}
Shipment s = new Shipment
{
AddressLine1 = model.ShippingAddressLine1,
AddressLine2 = model.ShippingAddressLine2,
City = model.ShippingCity,
State = model.ShippingState,
PostalCode = model.ShippingPostalCode,
Country = model.ShippingCountry,
Modified = DateTime.UtcNow,
Created = DateTime.UtcNow
};
Purchase p = new Purchase
{
SubmittedDate = DateTime.UtcNow,
AspNetUserID = User.Identity.IsAuthenticated ? db.AspNetUsers.First(x => x.UserName == User.Identity.Name).Id : null,
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
OrderIdentifier = Guid.NewGuid().ToString().Substring(0, 8),
PurchaseProducts = this.GetBasket(db).BasketProducts.Select(x => new Models.PurchaseProduct
{
ProductID = x.ProductID,
Quantity = x.Quantity,
Created = DateTime.UtcNow,
Modified = DateTime.UtcNow,
ProductName = x.Product.Name,
ProductPrice = x.Product.Price,
Shipment = s,
}).ToArray()
};
db.Purchases.Add(p);
db.Baskets.Remove(this.GetBasket(db));
db.SaveChanges();
Braintree.TransactionRequest transaction = new Braintree.TransactionRequest();
transaction.Amount = this.GetBasket(db).BasketProducts.Sum(x => x.Quantity * (x.Product.Price ?? 0));
transaction.CustomerId = model.CustomerId;
transaction.PaymentMethodToken = model.CardToken;
transaction.OrderId = p.ID.ToString();
transaction.PurchaseOrderNumber = p.OrderIdentifier;
var transactionResult = await _braintreeGateway.Transaction.SaleAsync(transaction);
await _emailService.SendAsync(new Microsoft.AspNet.Identity.IdentityMessage
{
Subject = string.Format("Your Coding Cookware Order {0}", p.OrderIdentifier),
Destination = model.Email,
Body = CreateReceiptEmail(p)
});
if (!string.IsNullOrEmpty(model.Phone))
{
await _smsService.SendAsync(new Microsoft.AspNet.Identity.IdentityMessage
{
Subject = "",
Destination = model.Phone,
Body = "You placed order " + p.OrderIdentifier
});
}
return(RedirectToAction("Index", "Receipt", new { id = p.OrderIdentifier }));
}
;
return(View());
}
public virtual Result<CreditCard> Create(CreditCardRequest request)
{
XmlNode creditCardXML = service.Post(service.MerchantPath() + "/payment_methods", request);
return new ResultImpl<CreditCard>(new NodeWrapper(creditCardXML), gateway);
}
public void ConfirmTransparentRedirectCreate_CreatesTheCreditCard()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest trParams = new CreditCardRequest { CustomerId = customer.Id };
CreditCardRequest request = new CreditCardRequest
{
CardholderName = "John Doe",
Number = "5105105105105100",
ExpirationDate = "05/12",
BillingAddress = new CreditCardAddressRequest
{
CountryName = "Greece",
CountryCodeAlpha2 = "GR",
CountryCodeAlpha3 = "GRC",
CountryCodeNumeric = "300"
}
};
string queryString = TestHelper.QueryStringForTR(trParams, request, gateway.CreditCard.TransparentRedirectURLForCreate(), service);
Result<CreditCard> result = gateway.CreditCard.ConfirmTransparentRedirect(queryString);
Assert.IsTrue(result.IsSuccess());
CreditCard card = result.Target;
Assert.AreEqual("John Doe", card.CardholderName);
Assert.AreEqual("510510", card.Bin);
Assert.AreEqual("05", card.ExpirationMonth);
Assert.AreEqual("2012", card.ExpirationYear);
Assert.AreEqual("05/2012", card.ExpirationDate);
Assert.AreEqual("5100", card.LastFour);
Assert.IsTrue(card.Token != null);
Address billingAddress = card.BillingAddress;
Assert.AreEqual("Greece", billingAddress.CountryName);
Assert.AreEqual("GR", billingAddress.CountryCodeAlpha2);
Assert.AreEqual("GRC", billingAddress.CountryCodeAlpha3);
Assert.AreEqual("300", billingAddress.CountryCodeNumeric);
}
public void Update_UpdatesExistingBillingAddressWhenUpdateExistingIsTrue()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var request = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
BillingAddress = new CreditCardAddressRequest
{
FirstName = "John"
}
};
CreditCard creditCard = gateway.CreditCard.Create(request).Target;
var updateRequest = new CreditCardRequest
{
BillingAddress = new CreditCardAddressRequest
{
LastName = "Jones",
Options = new CreditCardAddressOptionsRequest
{
UpdateExisting = true
}
}
};
CreditCard updatedCreditCard = gateway.CreditCard.Update(creditCard.Token, updateRequest).Target;
Assert.AreEqual("John", updatedCreditCard.BillingAddress.FirstName);
Assert.AreEqual("Jones", updatedCreditCard.BillingAddress.LastName);
Assert.AreEqual(creditCard.BillingAddress.Id, updatedCreditCard.BillingAddress.Id);
}
public void Update_CreatesNewBillingAddressByDefault()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var request = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
BillingAddress = new CreditCardAddressRequest
{
FirstName = "John"
}
};
CreditCard creditCard = gateway.CreditCard.Create(request).Target;
var updateRequest = new CreditCardRequest
{
BillingAddress = new CreditCardAddressRequest
{
LastName = "Jones",
CountryName = "El Salvador",
CountryCodeAlpha2 = "SV",
CountryCodeAlpha3 = "SLV",
CountryCodeNumeric = "222"
}
};
CreditCard updatedCreditCard = gateway.CreditCard.Update(creditCard.Token, updateRequest).Target;
Assert.IsNull(updatedCreditCard.BillingAddress.FirstName);
Assert.AreEqual("Jones", updatedCreditCard.BillingAddress.LastName);
Assert.AreNotEqual(creditCard.BillingAddress.Id, updatedCreditCard.BillingAddress.Id);
Address billingAddress = updatedCreditCard.BillingAddress;
Assert.AreEqual("El Salvador", billingAddress.CountryName);
Assert.AreEqual("SV", billingAddress.CountryCodeAlpha2);
Assert.AreEqual("SLV", billingAddress.CountryCodeAlpha3);
Assert.AreEqual("222", billingAddress.CountryCodeNumeric);
}
public void Update_UpdatesDefaultIfSpecified()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var creditCardCreateRequest = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
CVV = "123",
CardholderName = "Michael Angelo"
};
CreditCard card1 = gateway.CreditCard.Create(creditCardCreateRequest).Target;
CreditCard card2 = gateway.CreditCard.Create(creditCardCreateRequest).Target;
Assert.IsTrue(card1.IsDefault.Value);
Assert.IsFalse(card2.IsDefault.Value);
var creditCardUpdateRequest = new CreditCardRequest
{
Options = new CreditCardOptionsRequest
{
MakeDefault = true
}
};
gateway.CreditCard.Update(card2.Token, creditCardUpdateRequest);
Assert.IsFalse(gateway.CreditCard.Find(card1.Token).IsDefault.Value);
Assert.IsTrue(gateway.CreditCard.Find(card2.Token).IsDefault.Value);
}
public void Update_UpdatesCreditCardByToken()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var creditCardCreateRequest = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
CVV = "123",
CardholderName = "Michael Angelo"
};
CreditCard originalCreditCard = gateway.CreditCard.Create(creditCardCreateRequest).Target;
var creditCardUpdateRequest = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "4111111111111111",
ExpirationDate = "12/05",
CVV = "321",
CardholderName = "Dave Inchy"
};
CreditCard creditCard = gateway.CreditCard.Update(originalCreditCard.Token, creditCardUpdateRequest).Target;
Assert.AreEqual("411111", creditCard.Bin);
Assert.AreEqual("1111", creditCard.LastFour);
Assert.AreEqual("12", creditCard.ExpirationMonth);
Assert.AreEqual("2005", creditCard.ExpirationYear);
Assert.AreEqual("Dave Inchy", creditCard.CardholderName);
Assert.AreEqual(DateTime.Now.Year, creditCard.CreatedAt.Value.Year);
Assert.AreEqual(DateTime.Now.Year, creditCard.UpdatedAt.Value.Year);
}
public void Find_FindsAssociatedSubscriptions()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var creditCardRequest = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
CVV = "123"
};
CreditCard originalCreditCard = gateway.CreditCard.Create(creditCardRequest).Target;
string id = Guid.NewGuid().ToString();
var subscriptionRequest = new SubscriptionRequest
{
Id = id,
PlanId = "integration_trialless_plan",
PaymentMethodToken = originalCreditCard.Token,
Price = 1.00M
};
gateway.Subscription.Create(subscriptionRequest);
CreditCard creditCard = gateway.CreditCard.Find(originalCreditCard.Token);
Subscription subscription = creditCard.Subscriptions[0];
Assert.AreEqual(id, subscription.Id);
Assert.AreEqual("integration_trialless_plan", subscription.PlanId);
Assert.AreEqual(1.00M, subscription.Price);
}
public void GatewayRejectionReason_ExposedOnVerification()
{
BraintreeGateway processingRulesGateway = new BraintreeGateway
{
Environment = Environment.DEVELOPMENT,
MerchantId = "processing_rules_merchant_id",
PublicKey = "processing_rules_public_key",
PrivateKey = "processing_rules_private_key"
};
Customer customer = processingRulesGateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest request = new CreditCardRequest
{
CustomerId = customer.Id,
CardholderName = "John Doe",
CVV = "200",
Number = "4111111111111111",
ExpirationDate = "05/12",
Options = new CreditCardOptionsRequest
{
VerifyCard = true
}
};
Result<CreditCard> result = processingRulesGateway.CreditCard.Create(request);
Assert.IsFalse(result.IsSuccess());
CreditCardVerification verification = result.CreditCardVerification;
Assert.AreEqual(TransactionGatewayRejectionReason.CVV, verification.GatewayRejectionReason);
}
public virtual Result<CreditCard> Update(string token, CreditCardRequest request)
{
XmlNode creditCardXML = service.Put(service.MerchantPath() + "/payment_methods/credit_card/" + token, request);
return new ResultImpl<CreditCard>(new NodeWrapper(creditCardXML), gateway);
}
public void Sale_WithPaymentMethodTokenAndCvv()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest creditCardRequest = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12"
};
CreditCard creditCard = gateway.CreditCard.Create(creditCardRequest).Target;
TransactionRequest request = new TransactionRequest
{
Amount = SandboxValues.TransactionAmount.AUTHORIZE,
PaymentMethodToken = creditCard.Token,
CreditCard = new TransactionCreditCardRequest
{
CVV = "301"
}
};
Result<Transaction> result = gateway.Transaction.Sale(request);
Assert.IsTrue(result.IsSuccess());
Transaction transaction = result.Target;
Assert.AreEqual("S", transaction.CvvResponseCode);
Assert.AreEqual(creditCard.Token, transaction.CreditCard.Token);
Assert.AreEqual("510510", transaction.CreditCard.Bin);
Assert.AreEqual("05/2012", transaction.CreditCard.ExpirationDate);
}
public virtual Result <CreditCard> Update(string token, CreditCardRequest request)
{
XmlNode creditCardXML = service.Put(service.MerchantPath() + "/payment_methods/credit_card/" + token, request);
return(new ResultImpl <CreditCard>(new NodeWrapper(creditCardXML), gateway));
}
public virtual Result<CreditCard> Create(CreditCardRequest request)
{
XmlNode creditCardXML = Service.Post("/payment_methods", request);
return new ResultImpl<CreditCard>(new NodeWrapper(creditCardXML), Service);
}
public void Update_UpdatesExistingBillingAddressWhenUpdateExistingIsTrueViaTransparentRedirect()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var request = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
BillingAddress = new CreditCardAddressRequest
{
FirstName = "John"
}
};
CreditCard creditCard = gateway.CreditCard.Create(request).Target;
CreditCardRequest trParams = new CreditCardRequest
{
PaymentMethodToken = creditCard.Token,
BillingAddress = new CreditCardAddressRequest
{
Options = new CreditCardAddressOptionsRequest
{
UpdateExisting = true
}
}
};
CreditCardRequest updateRequest = new CreditCardRequest
{
BillingAddress = new CreditCardAddressRequest
{
LastName = "Jones"
}
};
string queryString = TestHelper.QueryStringForTR(trParams, updateRequest, gateway.CreditCard.TransparentRedirectURLForUpdate(), service);
CreditCard updatedCreditCard = gateway.CreditCard.ConfirmTransparentRedirect(queryString).Target;
Assert.AreEqual("John", updatedCreditCard.BillingAddress.FirstName);
Assert.AreEqual("Jones", updatedCreditCard.BillingAddress.LastName);
Assert.AreEqual(creditCard.BillingAddress.Id, updatedCreditCard.BillingAddress.Id);
}
public void ConfirmTransparentRedirectCreate_CreatesTheCreditCardObservingMakeDefaultInRequest()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest request = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
Options = new CreditCardOptionsRequest
{
MakeDefault = true
}
};
CreditCard creditCard = gateway.CreditCard.Create(request).Target;
Assert.IsTrue(creditCard.IsDefault.Value);
CreditCardRequest trParams = new CreditCardRequest
{
CustomerId = customer.Id,
};
string queryString = TestHelper.QueryStringForTR(trParams, request, gateway.CreditCard.TransparentRedirectURLForCreate(), service);
CreditCard card = gateway.CreditCard.ConfirmTransparentRedirect(queryString).Target;
Assert.IsTrue(card.IsDefault.Value);
}
public void Create_CanMakeDefaultAndSetToken()
{
Result<Customer> customerResult = gateway.Customer.Create(new CustomerRequest());
Assert.IsTrue(customerResult.IsSuccess());
var creditCardRequest = new CreditCardRequest
{
CustomerId = customerResult.Target.Id,
Number = "5105105105105100",
ExpirationDate = "05/12"
};
CreditCard creditCard = gateway.CreditCard.Create(creditCardRequest).Target;
Assert.IsTrue(creditCard.IsDefault.Value);
String nonce = TestHelper.GenerateUnlockedNonce(gateway);
Random random = new Random();
int randomNumber = random.Next(0, 10000);
var token = "token_" + randomNumber;
var request = new PaymentMethodRequest
{
CustomerId = customerResult.Target.Id,
PaymentMethodNonce = nonce,
Token = token,
Options = new PaymentMethodOptionsRequest
{
MakeDefault = true
}
};
Result<PaymentMethod> paymentMethodResult = gateway.PaymentMethod.Create(request);
Assert.IsTrue(paymentMethodResult.IsSuccess());
Assert.IsTrue(paymentMethodResult.Target.IsDefault.Value);
Assert.AreEqual(token, paymentMethodResult.Target.Token);
}
public void UpdateViaTransparentRedirect()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest createRequest = new CreditCardRequest
{
CustomerId = customer.Id,
CardholderName = "John Doe",
Number = "5105105105105100",
ExpirationDate = "05/12",
BillingAddress = new CreditCardAddressRequest
{
PostalCode = "44444"
}
};
CreditCard createdCard = gateway.CreditCard.Create(createRequest).Target;
CreditCardRequest trParams = new CreditCardRequest
{
PaymentMethodToken = createdCard.Token
};
CreditCardRequest request = new CreditCardRequest
{
CardholderName = "Joe Cool"
};
string queryString = TestHelper.QueryStringForTR(trParams, request, gateway.CreditCard.TransparentRedirectURLForUpdate(), service);
Result<CreditCard> result = gateway.CreditCard.ConfirmTransparentRedirect(queryString);
Assert.IsTrue(result.IsSuccess());
CreditCard card = result.Target;
Assert.AreEqual("Joe Cool", card.CardholderName);
Assert.AreEqual("44444", card.BillingAddress.PostalCode);
}
public virtual Result<CreditCard> Update(String token, CreditCardRequest request)
{
XmlNode creditCardXML = Service.Put("/payment_methods/credit_card/" + token, request);
return new ResultImpl<CreditCard>(new NodeWrapper(creditCardXML), Service);
}
public void Delete_DeletesTheCreditCard()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
var creditCardRequest = new CreditCardRequest
{
CustomerId = customer.Id,
Number = "5105105105105100",
ExpirationDate = "05/12",
CVV = "123",
CardholderName = "Michael Angelo"
};
CreditCard creditCard = gateway.CreditCard.Create(creditCardRequest).Target;
Assert.AreEqual(creditCard.Token, gateway.CreditCard.Find(creditCard.Token).Token);
gateway.CreditCard.Delete(creditCard.Token);
try
{
gateway.CreditCard.Find(creditCard.Token);
Assert.Fail("Expected NotFoundException.");
}
catch (NotFoundException)
{
// expected
}
}
public void CheckDuplicateCreditCard()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest request = new CreditCardRequest
{
CustomerId = customer.Id,
CardholderName = "John Doe",
CVV = "123",
Number = "4111111111111111",
ExpirationDate = "05/12",
Options = new CreditCardOptionsRequest
{
FailOnDuplicatePaymentMethod = true
}
};
gateway.CreditCard.Create(request);
Result<CreditCard> result = gateway.CreditCard.Create(request);
Assert.IsFalse(result.IsSuccess());
Assert.AreEqual(
ValidationErrorCode.CREDIT_CARD_DUPLICATE_CARD_EXISTS,
result.Errors.ForObject("CreditCard").OnField("Number")[0].Code
);
}
public void VerifyValidCreditCardWithVerificationRiskData()
{
Customer customer = gateway.Customer.Create(new CustomerRequest()).Target;
CreditCardRequest request = new CreditCardRequest
{
CustomerId = customer.Id,
CardholderName = "John Doe",
CVV = "123",
Number = "4111111111111111",
ExpirationDate = "05/12",
Options = new CreditCardOptionsRequest
{
VerifyCard = true
}
};
Result<CreditCard> result = gateway.CreditCard.Create(request);
Assert.IsTrue(result.IsSuccess());
CreditCard card = result.Target;
CreditCardVerification verification = card.Verification;
Assert.IsNotNull(verification);
Assert.IsNotNull(verification.RiskData);
}
public async Task <ActionResult> Index(CheckoutModel model)
{
//Check if the model-state is valid -- this will catch anytime someone hacks your client-side validation
if (ModelState.IsValid)
{
var gateway = new BraintreeGateway
{
Environment = Braintree.Environment.SANDBOX,
MerchantId = ConfigurationManager.AppSettings["Braintree.MerchantID"],
PublicKey = ConfigurationManager.AppSettings["Braintree.PublicKey"],
PrivateKey = ConfigurationManager.AppSettings["Braintree.PrivateKey"]
};
CustomerSearchRequest searchRequest = new CustomerSearchRequest();
searchRequest.Email.Is(model.ContactEmail);
Customer c = null;
var existingCustomers = await gateway.Customer.SearchAsync(searchRequest);
if (existingCustomers.Ids.Any())
{
c = existingCustomers.FirstItem;
}
else
{
CustomerRequest newCustomer = new CustomerRequest();
newCustomer.FirstName = model.FirstName;
newCustomer.LastName = model.LastName;
newCustomer.Email = model.ContactEmail;
newCustomer.Phone = model.ContactPhone;
var customerResult = await gateway.Customer.CreateAsync(newCustomer);
if (customerResult.IsSuccess())
{
c = customerResult.Target;
}
else
{
throw new Exception(customerResult.Errors.All().First().Message);
}
}
string token;
Braintree.CreditCardRequest card = new Braintree.CreditCardRequest();
card.Number = model.CreditCardNumber;
card.CVV = model.CreditCardVerificationValue;
card.ExpirationMonth = model.CreditCardExpirationMonth.ToString().PadLeft(2, '0');
card.ExpirationYear = model.CreditCardExpirationYear.ToString();
card.CardholderName = model.FirstName + " " + model.LastName;
card.CustomerId = c.Id;
var cardResult = await gateway.CreditCard.CreateAsync(card);
if (cardResult.IsSuccess())
{
token = cardResult.Target.Token;
}
else
{
throw new Exception(cardResult.Errors.All().First().Message);
}
HttpCookie cartCookie = Request.Cookies["cart"];
var order = db.Orders.Find(int.Parse(cartCookie.Value));
Braintree.TransactionRequest transaction = new TransactionRequest();
transaction.PaymentMethodToken = token;
transaction.Amount = order.OrderedProducts.Sum(x => (x.Product.Price ?? 0) * (x.Quantity ?? 0));
transaction.CustomerId = c.Id;
var saleResult = await gateway.Transaction.SaleAsync(transaction);
if (saleResult.IsSuccess())
{
Response.SetCookie(new HttpCookie("cart")
{
Expires = DateTime.Now
});
order.OrderCompletedDate = DateTime.UtcNow;
order.CustomerEmail = model.ContactEmail;
order.BillingStreetAddress1 = model.BillingAddress.Street1;
if (model.BillingAddress.Street2 != null)
{
order.BillingStreetAddress2 = model.BillingAddress.Street2;
}
order.BillingCity = model.BillingAddress.City;
order.BillingState = model.BillingAddress.State;
order.BillingZip = model.BillingAddress.PostalCode;
order.ShippingStreetAddress1 = model.ShippingAddress.Street1;
if (model.ShippingAddress.Street2 != null)
{
order.ShippingStreetAddress2 = model.ShippingAddress.Street2;
}
order.ShippingCity = model.ShippingAddress.City;
order.ShippingState = model.ShippingAddress.State;
order.ShippingZip = model.ShippingAddress.PostalCode;
if (User.Identity.IsAuthenticated)
{
var user = db.Users.FirstOrDefault(X => X.AspNetUser.UserName == User.Identity.Name);
order.AspNetUserID = user.AspNetUserID;
}
order.LastModifiedOn = DateTime.UtcNow;
await db.SaveChangesAsync();
string apiKey = System.Configuration.ConfigurationManager.AppSettings["SendGrid.ApiKey"];
SendGrid.ISendGridClient client = new SendGridClient(apiKey);
EmailAddress from = new EmailAddress("*****@*****.**", "Paracord Store");
EmailAddress to = new EmailAddress(model.ContactEmail);
string subject = string.Format("Your Paracord Store Order {0}", order.OrderID);
string htmlContent = CreateReceiptEmail(order);
string plainTextContent = CreatePlaintextEmail(order);
SendGridMessage message = MailHelper.CreateSingleEmail(from, to, subject, plainTextContent, htmlContent);
message.SetTemplateId("a179572c-a791-467e-aebb-5ea6cca0fb2c");
Response response = await client.SendEmailAsync(message);
TempData["EmailAddress"] = model.ContactEmail;
return(RedirectToAction("Index", "Receipt", new { id = order.OrderID }));
}
}
return(View(model));
}
public virtual Result <CreditCard> Create(CreditCardRequest request)
{
XmlNode creditCardXML = service.Post(service.MerchantPath() + "/payment_methods", request);
return(new ResultImpl <CreditCard>(new NodeWrapper(creditCardXML), gateway));
}
