== More information ==
For more detailed information on CreditCards, see {@link http://www.braintreepayments.com/gateway/credit-card-api http://www.braintreepaymentsolutions.com/gateway/credit-card-api}
For more detailed information on CreditCard verifications, see {@link http://www.braintreepayments.com/gateway/credit-card-verification-api http://www.braintreepaymentsolutions.com/gateway/credit-card-verification-api}
For more detailed information on CreditCard verifications, see {@link http://www.braintreepayments.com/gateway/credit-card-verification-api http://www.braintreepaymentsolutions.com/gateway/credit-card-verification-api}
public function testCreate_fromPaymentMethodToken()
{
$customer = Braintree\Customer::createNoValidate();
$card = Braintree\CreditCard::create(['customerId' => $customer->id, 'cardholderName' => 'Cardholder', 'number' => '5105105105105100', 'expirationDate' => '05/12'])->creditCard;
$result = Braintree\PaymentMethodNonce::create($card->token);
$this->assertTrue($result->success);
$this->assertNotNull($result->paymentMethodNonce);
$this->assertNotNull($result->paymentMethodNonce->nonce);
}
public function test_GatewayRespectsMakeDefault()
{
$result = Braintree\Customer::create();
$this->assertTrue($result->success);
$customerId = $result->customer->id;
$result = Braintree\CreditCard::create(array('customerId' => $customerId, 'number' => '4111111111111111', 'expirationDate' => '11/2099'));
$this->assertTrue($result->success);
$clientToken = Test\Helper::decodedClientToken(array("customerId" => $customerId, "options" => array("makeDefault" => true)));
$authorizationFingerprint = json_decode($clientToken)->authorizationFingerprint;
$http = new HttpClientApi(Braintree\Configuration::$global);
$response = $http->post('/client_api/v1/payment_methods/credit_cards.json', json_encode(array("credit_card" => array("number" => "4242424242424242", "expirationDate" => "11/2099"), "authorization_fingerprint" => $authorizationFingerprint, "shared_customer_identifier" => "fake_identifier", "shared_customer_identifier_type" => "testing")));
$this->assertEquals(201, $response["status"]);
$customer = Braintree\Customer::find($customerId);
$this->assertEquals(2, count($customer->creditCards));
foreach ($customer->creditCards as $creditCard) {
if ($creditCard->last4 == "4242") {
$this->assertTrue($creditCard->default);
}
}
}
public function testUpdateAndMakeDefault()
{
$customer = Braintree\Customer::createNoValidate();
$creditCardResult = Braintree\CreditCard::create(['customerId' => $customer->id, 'number' => '5105105105105100', 'expirationDate' => '05/12']);
$this->assertTrue($creditCardResult->success);
$http = new HttpClientApi(Braintree\Configuration::$global);
$nonce = $http->nonceForPayPalAccount(['paypal_account' => ['consent_code' => 'PAYPAL_CONSENT_CODE']]);
$createResult = Braintree\PaymentMethod::create(['customerId' => $customer->id, 'paymentMethodNonce' => $nonce]);
$this->assertTrue($createResult->success);
$updateResult = Braintree\PayPalAccount::update($createResult->paymentMethod->token, ['options' => ['makeDefault' => true]]);
$this->assertTrue($updateResult->success);
$this->assertTrue($updateResult->paypalAccount->isDefault());
}
public function testVerificationIsLatestVerification()
{
$creditCard = Braintree\CreditCard::factory(['verifications' => [['id' => '123', 'createdAt' => DateTime::createFromFormat('Ymd', '20121212')], ['id' => '932', 'createdAt' => DateTime::createFromFormat('Ymd', '20121215')], ['id' => '456', 'createdAt' => DateTime::createFromFormat('Ymd', '20121213')]]]);
$this->assertEquals('932', $creditCard->verification->id);
}
public function testUnknownCardTypeIndicators()
{
$customer = Braintree\Customer::createNoValidate();
$result = Braintree\CreditCard::create(array('customerId' => $customer->id, 'cardholderName' => 'Cardholder', 'number' => CardTypeIndicators::UNKNOWN, 'expirationDate' => '05/12', 'options' => array('verifyCard' => true)));
$this->assertEquals(Braintree\CreditCard::PREPAID_UNKNOWN, $result->creditCard->prepaid);
$this->assertEquals(Braintree\CreditCard::DURBIN_REGULATED_UNKNOWN, $result->creditCard->durbinRegulated);
$this->assertEquals(Braintree\CreditCard::PAYROLL_UNKNOWN, $result->creditCard->payroll);
$this->assertEquals(Braintree\CreditCard::DEBIT_UNKNOWN, $result->creditCard->debit);
$this->assertEquals(Braintree\CreditCard::HEALTHCARE_UNKNOWN, $result->creditCard->healthcare);
$this->assertEquals(Braintree\CreditCard::COMMERCIAL_UNKNOWN, $result->creditCard->commercial);
$this->assertEquals(Braintree\CreditCard::COUNTRY_OF_ISSUANCE_UNKNOWN, $result->creditCard->countryOfIssuance);
$this->assertEquals(Braintree\CreditCard::ISSUING_BANK_UNKNOWN, $result->creditCard->issuingBank);
}
public function testDelete_worksWithCreditCards()
{
$paymentMethodToken = 'CREDIT_CARD_TOKEN-' . strval(rand());
$customer = Braintree\Customer::createNoValidate();
$creditCardResult = Braintree\CreditCard::create(['customerId' => $customer->id, 'number' => '5105105105105100', 'expirationDate' => '05/2011', 'token' => $paymentMethodToken]);
$this->assertTrue($creditCardResult->success);
Braintree\PaymentMethod::delete($paymentMethodToken);
$this->setExpectedException('Braintree\\Exception\\NotFound');
Braintree\PaymentMethod::find($paymentMethodToken);
self::integrationMerchantConfig();
}
public function testUpdate_canUpdatePaymentMethodWithPaymentMethodNonce()
{
$oldCreditCard = SubscriptionHelper::createCreditCard();
$plan = SubscriptionHelper::triallessPlan();
$subscription = Braintree\Subscription::create(['paymentMethodToken' => $oldCreditCard->token, 'price' => '54.99', 'planId' => $plan['id']])->subscription;
$customerId = Braintree\Customer::create()->customer->id;
$http = new HttpClientApi(Braintree\Configuration::$global);
$nonce = $http->nonce_for_new_card(["creditCard" => ["number" => "4111111111111111", "expirationMonth" => "11", "expirationYear" => "2099"], "customerId" => $oldCreditCard->customerId, "share" => true]);
$result = Braintree\Subscription::update($subscription->id, ['paymentMethodNonce' => $nonce]);
$this->assertTrue($result->success);
$newCreditCard = Braintree\CreditCard::find($result->subscription->paymentMethodToken);
$this->assertEquals("1111", $newCreditCard->last4);
$this->assertNotEquals($oldCreditCard->last4, $newCreditCard->last4);
}
/**
* @param User $user
* @param $request
* @return boolean
*/
public function addCard(User $user, $request)
{
$result = BraintreeCreditCard::create(["customerId" => $this->getCustomerId($user), "number" => $request->request->get("number"), "cvv" => $request->request->get("cvv"), "expirationMonth" => $request->request->get("month"), "expirationYear" => $request->request->get("year")]);
return $result->success;
}
/**
* generic method for validating incoming gateway responses
*
* creates a new CreditCard or PayPalAccount object
* and encapsulates it inside a Result\Successful object, or
* encapsulates a Errors object inside a Result\Error
* alternatively, throws an Unexpected exception if the response is invalid.
*
* @ignore
* @param array $response gateway response values
* @return Result\Successful|Result\Error
* @throws Exception\Unexpected
*/
private function _verifyGatewayResponse($response)
{
if (isset($response['creditCard'])) {
return new Result\Successful(CreditCard::factory($response['creditCard']), 'paymentMethod');
} else {
if (isset($response['paypalAccount'])) {
return new Result\Successful(PayPalAccount::factory($response['paypalAccount']), "paymentMethod");
} else {
if (isset($response['coinbaseAccount'])) {
return new Result\Successful(CoinbaseAccount::factory($response['coinbaseAccount']), "paymentMethod");
} else {
if (isset($response['applePayCard'])) {
return new Result\Successful(ApplePayCard::factory($response['applePayCard']), "paymentMethod");
} else {
if (isset($response['androidPayCard'])) {
return new Result\Successful(AndroidPayCard::factory($response['androidPayCard']), "paymentMethod");
} else {
if (isset($response['amexExpressCheckoutCard'])) {
return new Result\Successful(AmexExpressCheckoutCard::factory($response['amexExpressCheckoutCard']), "paymentMethod");
} else {
if (isset($response['europeBankAccount'])) {
return new Result\Successful(EuropeBankAccount::factory($response['europeBankAccount']), "paymentMethod");
} else {
if (isset($response['venmoAccount'])) {
return new Result\Successful(VenmoAccount::factory($response['venmoAccount']), "paymentMethod");
} else {
if (isset($response['apiErrorResponse'])) {
return new Result\Error($response['apiErrorResponse']);
} else {
if (is_array($response)) {
return new Result\Successful(UnknownPaymentMethod::factory($response), "paymentMethod");
} else {
throw new Exception\Unexpected('Expected payment method or apiErrorResponse');
}
}
}
}
}
}
}
}
}
}
}
/**
* generic method for validating incoming gateway responses
*
* creates a new CreditCard object and encapsulates
* it inside a Result\Successful object, or
* encapsulates a Errors object inside a Result\Error
* alternatively, throws an Unexpected exception if the response is invalid
*
* @ignore
* @param array $response gateway response values
* @return Result\Successful|Result\Error
* @throws Exception\Unexpected
*/
private function _verifyGatewayResponse($response)
{
if (isset($response['creditCard'])) {
// return a populated instance of Address
return new Result\Successful(CreditCard::factory($response['creditCard']));
} elseif (isset($response['apiErrorResponse'])) {
return new Result\Error($response['apiErrorResponse']);
} else {
throw new Exception\Unexpected("Expected address or apiErrorResponse");
}
}
public function test_rangeNode_amount()
{
$customer = Braintree\Customer::createNoValidate();
$creditCard = Braintree\CreditCard::create(['customerId' => $customer->id, 'cardholderName' => 'Jane Everywoman' . rand(), 'number' => '5105105105105100', 'expirationDate' => '05/12'])->creditCard;
$t_1000 = Braintree\Transaction::saleNoValidate(['amount' => '1000.00', 'paymentMethodToken' => $creditCard->token]);
$t_1500 = Braintree\Transaction::saleNoValidate(['amount' => '1500.00', 'paymentMethodToken' => $creditCard->token]);
$t_1800 = Braintree\Transaction::saleNoValidate(['amount' => '1800.00', 'paymentMethodToken' => $creditCard->token]);
$collection = Braintree\Transaction::search([Braintree\TransactionSearch::creditCardCardholderName()->is($creditCard->cardholderName), Braintree\TransactionSearch::amount()->greaterThanOrEqualTo('1700')]);
$this->assertEquals(1, $collection->maximumCount());
$this->assertEquals($t_1800->id, $collection->firstItem()->id);
$collection = Braintree\Transaction::search([Braintree\TransactionSearch::creditCardCardholderName()->is($creditCard->cardholderName), Braintree\TransactionSearch::amount()->lessThanOrEqualTo('1250')]);
$this->assertEquals(1, $collection->maximumCount());
$this->assertEquals($t_1000->id, $collection->firstItem()->id);
$collection = Braintree\Transaction::search([Braintree\TransactionSearch::creditCardCardholderName()->is($creditCard->cardholderName), Braintree\TransactionSearch::amount()->between('1100', '1600')]);
$this->assertEquals(1, $collection->maximumCount());
$this->assertEquals($t_1500->id, $collection->firstItem()->id);
}
public function testUpdateCreditCardFromTransparentRedirect()
{
$customer = Braintree\Customer::create(array('firstName' => 'Mike', 'lastName' => 'Jonez'))->customer;
$creditCard = Braintree\CreditCard::create(array('customerId' => $customer->id, 'number' => Braintree\Test\CreditCardNumbers::$masterCard, 'expirationMonth' => '10', 'expirationYear' => '10'))->creditCard;
$params = array('credit_card' => array('number' => Braintree\Test\CreditCardNumbers::$visa));
$trParams = array('paymentMethodToken' => $creditCard->token, 'creditCard' => array('expirationMonth' => '11', 'expirationYear' => '11'));
$trData = Braintree\TransparentRedirect::updateCreditCardData(array_merge($trParams, array("redirectUrl" => "http://www.example.com")));
$queryString = Test\Helper::submitTrRequest(Braintree\TransparentRedirect::url(), $params, $trData);
Braintree\TransparentRedirect::confirm($queryString);
$creditCard = Braintree\CreditCard::find($creditCard->token);
$this->assertequals('401288', $creditCard->bin);
$this->assertequals('1881', $creditCard->last4);
$this->assertequals('11/2011', $creditCard->expirationDate);
}
/**
* sets instance properties from an array of values
*
* @ignore
* @access protected
* @param array $customerAttribs array of customer data
* @return void
*/
protected function _initialize($customerAttribs)
{
// set the attributes
$this->_attributes = $customerAttribs;
// map each address into its own object
$addressArray = [];
if (isset($customerAttribs['addresses'])) {
foreach ($customerAttribs['addresses'] as $address) {
$addressArray[] = Address::factory($address);
}
}
$this->_set('addresses', $addressArray);
// map each creditCard into its own object
$creditCardArray = [];
if (isset($customerAttribs['creditCards'])) {
foreach ($customerAttribs['creditCards'] as $creditCard) {
$creditCardArray[] = CreditCard::factory($creditCard);
}
}
$this->_set('creditCards', $creditCardArray);
// map each coinbaseAccount into its own object
$coinbaseAccountArray = [];
if (isset($customerAttribs['coinbaseAccounts'])) {
foreach ($customerAttribs['coinbaseAccounts'] as $coinbaseAccount) {
$coinbaseAccountArray[] = CoinbaseAccount::factory($coinbaseAccount);
}
}
$this->_set('coinbaseAccounts', $coinbaseAccountArray);
// map each paypalAccount into its own object
$paypalAccountArray = [];
if (isset($customerAttribs['paypalAccounts'])) {
foreach ($customerAttribs['paypalAccounts'] as $paypalAccount) {
$paypalAccountArray[] = PayPalAccount::factory($paypalAccount);
}
}
$this->_set('paypalAccounts', $paypalAccountArray);
// map each applePayCard into its own object
$applePayCardArray = [];
if (isset($customerAttribs['applePayCards'])) {
foreach ($customerAttribs['applePayCards'] as $applePayCard) {
$applePayCardArray[] = ApplePayCard::factory($applePayCard);
}
}
$this->_set('applePayCards', $applePayCardArray);
// map each androidPayCard into its own object
$androidPayCardArray = [];
if (isset($customerAttribs['androidPayCards'])) {
foreach ($customerAttribs['androidPayCards'] as $androidPayCard) {
$androidPayCardArray[] = AndroidPayCard::factory($androidPayCard);
}
}
$this->_set('androidPayCards', $androidPayCardArray);
$this->_set('paymentMethods', array_merge($this->creditCards, $this->paypalAccounts, $this->applePayCards, $this->coinbaseAccounts, $this->androidPayCards));
}
/**
* This save credit cart to braintree.
* @return array
*/
public function saveCreditCard()
{
$sendArray = $this->options['creditCard'];
if (isset($this->options['billing'])) {
$sendArray['billingAddress'] = $this->options['billing'];
}
if (isset($this->options['customerId'])) {
$sendArray['customerId'] = $this->options['customerId'];
}
$result = CreditCard::create($sendArray);
if ($result->success) {
return ['status' => true, 'result' => $result];
} else {
return ['status' => false, 'result' => $result];
}
}
/**
* @param string $token
* @return \Braintree\CreditCard|null
*/
public function find($token)
{
try {
return CreditCard::find($token);
} catch (\Exception $e) {
return null;
}
}