== More information == For more detailed information on Customers, see {@link http://www.braintreepayments.com/gateway/customer-api http://www.braintreepaymentsolutions.com/gateway/customer-api}
Inheritance: extends braintree\Base
 /**
  * @param string $customer_id
  * @param string $plan_id
  * @param array $addOns
  * @param array $discounts
  * @param array $removeAddOns
  * @param array $removeDiscounts
  * @return bool | int
  * @throws Exception
  */
 public function createSubscription($customer_id, $plan_id, $addOns = [], $discounts = [], $removeAddOns = [], $removeDiscounts = [])
 {
     $customer = Braintree_Customer::find($customer_id);
     $the_token = null;
     if (!empty($customer)) {
         $the_token = $customer->paymentMethods[0]->token;
     } else {
         throw new Exception("Customer not found \n");
     }
     $formattedAddOns = [];
     foreach ($addOns as $addOn) {
         $formattedAddOns[] = ['inheritedFromId' => $addOn];
     }
     $formattedDiscounts = [];
     foreach ($discounts as $discount) {
         $formattedDiscounts[] = ['inheritedFromId' => $discount];
     }
     $result = Braintree_Subscription::create(['paymentMethodToken' => $the_token, 'planId' => $plan_id, 'addOns' => ['add' => $formattedAddOns, 'remove' => $removeAddOns], 'discounts' => ['add' => $formattedDiscounts, 'remove' => $removeDiscounts]]);
     if ($result->success) {
         return $result->subscription->id;
     } else {
         foreach ($result->errors->deepAll() as $error) {
             throw new Exception($error->code . ": " . $error->message . "\n");
         }
     }
     return false;
 }
 /**
  * Handle the event.
  *
  * @param  \Laravel\Spark\Events\Profile\ContactInformationUpdated  $event
  */
 public function handle($event)
 {
     if (!$event->user->hasBillingProvider()) {
         return;
     }
     BraintreeCustomer::update($event->user->braintree_id, ['email' => $event->user->email]);
 }
 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);
 }
 /**
  * @depends testCustomerCreate
  */
 public function testTokenPayment()
 {
     $customer = Customer::find(self::$customer->id);
     $this->assertInstanceOf('\\Braintree\\Customer', $customer);
     $this->assertArrayHasKey(0, $customer->paymentMethods());
     $model = new BraintreeForm();
     $model->setScenario('saleFromVault');
     $this->assertTrue($model->load(['amount' => rand(1, 200), 'paymentMethodToken' => $customer->paymentMethods()[0]->token], ''));
     $this->assertNotFalse($model->send());
 }
 public function test_deepAll_givesAllErrorsDeeply()
 {
     $result = Braintree\Customer::create(['email' => 'invalid', 'creditCard' => ['number' => '1234123412341234', 'expirationDate' => 'invalid', 'billingAddress' => ['countryName' => 'invalid']]]);
     $expectedErrors = [Braintree\Error\Codes::CUSTOMER_EMAIL_IS_INVALID, Braintree\Error\Codes::CREDIT_CARD_EXPIRATION_DATE_IS_INVALID, Braintree\Error\Codes::CREDIT_CARD_NUMBER_IS_INVALID, Braintree\Error\Codes::ADDRESS_COUNTRY_NAME_IS_NOT_ACCEPTED];
     $actualErrors = $result->errors->deepAll();
     $this->assertEquals($expectedErrors, self::mapValidationErrorsToCodes($actualErrors));
     $expectedErrors = [Braintree\Error\Codes::CREDIT_CARD_EXPIRATION_DATE_IS_INVALID, Braintree\Error\Codes::CREDIT_CARD_NUMBER_IS_INVALID, Braintree\Error\Codes::ADDRESS_COUNTRY_NAME_IS_NOT_ACCEPTED];
     $actualErrors = $result->errors->forKey('customer')->forKey('creditCard')->deepAll();
     $this->assertEquals($expectedErrors, self::mapValidationErrorsToCodes($actualErrors));
 }
 public function testValueForHtmlField()
 {
     $result = Braintree\Customer::create(['email' => 'invalid-email', 'creditCard' => ['number' => 'invalid-number', 'expirationDate' => 'invalid-exp', 'billingAddress' => ['countryName' => 'invalid-country']], 'customFields' => ['store_me' => 'some custom value']]);
     $this->assertEquals(false, $result->success);
     $this->assertEquals('invalid-email', $result->valueForHtmlField('customer[email]'));
     $this->assertEquals('', $result->valueForHtmlField('customer[credit_card][number]'));
     $this->assertEquals('invalid-exp', $result->valueForHtmlField('customer[credit_card][expiration_date]'));
     $this->assertEquals('invalid-country', $result->valueForHtmlField('customer[credit_card][billing_address][country_name]'));
     $this->assertEquals('some custom value', $result->valueForHtmlField('customer[custom_fields][store_me]'));
 }
 public function testSale_createsASaleUsingGivenToken()
 {
     $customer = Braintree\Customer::createNoValidate();
     $http = new HttpClientApi(Braintree\Configuration::$global);
     $nonce = Test\Helper::generateValidUsBankAccountNonce();
     $result = Braintree\PaymentMethod::create(['customerId' => $customer->id, 'paymentMethodNonce' => $nonce]);
     $result = Braintree\UsBankAccount::sale($result->paymentMethod->token, ['merchantAccountId' => 'us_bank_merchant_account', 'amount' => '100.00']);
     $this->assertTrue($result->success);
     $transaction = $result->transaction;
     $this->assertEquals(Braintree\Transaction::SETTLEMENT_PENDING, $transaction->status);
     $this->assertEquals(Braintree\Transaction::SALE, $transaction->type);
     $this->assertEquals('100.00', $transaction->amount);
     $this->assertEquals('021000021', $transaction->usBankAccount->routingNumber);
     $this->assertEquals('1234', $transaction->usBankAccount->last4);
     $this->assertEquals('checking', $transaction->usBankAccount->accountType);
     $this->assertEquals('PayPal Checking - 1234', $transaction->usBankAccount->accountDescription);
     $this->assertEquals('Dan Schulman', $transaction->usBankAccount->accountHolderName);
     $this->assertRegExp('/CHASE/', $transaction->usBankAccount->bankName);
 }
 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 testFindErrorsOnWhitespaceId()
 {
     $this->setExpectedException('InvalidArgumentException');
     Braintree\Customer::find('\\t');
 }
 public function testGrant_returnsANonceThatIsVaultable()
 {
     $partnerMerchantGateway = new Braintree\Gateway(['environment' => 'development', 'merchantId' => 'integration_merchant_public_id', 'publicKey' => 'oauth_app_partner_user_public_key', 'privateKey' => 'oauth_app_partner_user_private_key']);
     $customer = $partnerMerchantGateway->customer()->create(['firstName' => 'Joe', 'lastName' => 'Brown'])->customer;
     $creditCard = $partnerMerchantGateway->creditCard()->create(['customerId' => $customer->id, 'cardholderName' => 'Adam Davis', 'number' => '4111111111111111', 'expirationDate' => '05/2009'])->creditCard;
     $oauthAppGateway = new Braintree\Gateway(['clientId' => 'client_id$development$integration_client_id', 'clientSecret' => 'client_secret$development$integration_client_secret']);
     $code = Test\Braintree\OAuthTestHelper::createGrant($oauthAppGateway, ['merchant_public_id' => 'integration_merchant_id', 'scope' => 'grant_payment_method']);
     $credentials = $oauthAppGateway->oauth()->createTokenFromCode(['code' => $code]);
     $grantingGateway = new Braintree\Gateway(['accessToken' => $credentials->accessToken]);
     $grantResult = $grantingGateway->paymentMethod()->grant($creditCard->token, true);
     $customer = Braintree\Customer::create(['firstName' => 'Bob', 'lastName' => 'Rob'])->customer;
     $result = Braintree\PaymentMethod::create(['customerId' => $customer->id, 'paymentMethodNonce' => $grantResult->nonce]);
     $this->assertTrue($result->success);
 }
 public function test_throwsIfNoOperatorNodeGiven()
 {
     $this->setExpectedException('InvalidArgumentException', 'Operator must be provided');
     Braintree\Customer::search(array(Braintree\CustomerSearch::creditCardExpirationDate()));
 }
 public function testDelete_worksWithPayPalAccounts()
 {
     $paymentMethodToken = 'PAYPAL_TOKEN-' . strval(rand());
     $customer = Braintree\Customer::createNoValidate();
     $http = new HttpClientApi(Braintree\Configuration::$global);
     $nonce = $http->nonceForPayPalAccount(array('paypal_account' => array('consent_code' => 'PAYPAL_CONSENT_CODE', 'token' => $paymentMethodToken)));
     $paypalAccountResult = Braintree\PaymentMethod::create(array('customerId' => $customer->id, 'paymentMethodNonce' => $nonce));
     $this->assertTrue($paypalAccountResult->success);
     Braintree\PaymentMethod::delete($paymentMethodToken);
     $this->setExpectedException('Braintree\\Exception\\NotFound');
     Braintree\PaymentMethod::find($paymentMethodToken);
 }
 public function updateCustomerViaTr($regularParams, $trParams)
 {
     Test\Helper::suppressDeprecationWarnings();
     $trData = Braintree\TransparentRedirect::updateCustomerData(array_merge($trParams, ["redirectUrl" => "http://www.example.com"]));
     return Test\Helper::submitTrRequest(Braintree\Customer::updateCustomerUrl(), $regularParams, $trData);
 }
 /**
  * generic method for validating incoming gateway responses
  *
  * creates a new Customer 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['customer'])) {
         // return a populated instance of Customer
         return new Result\Successful(Customer::factory($response['customer']));
     } else {
         if (isset($response['apiErrorResponse'])) {
             return new Result\Error($response['apiErrorResponse']);
         } else {
             throw new Exception\Unexpected("Expected customer or apiErrorResponse");
         }
     }
 }
 public static function createCreditCard()
 {
     $customer = Braintree\Customer::createNoValidate(['creditCard' => ['number' => '5105105105105100', 'expirationDate' => '05/2010']]);
     return $customer->creditCards[0];
 }
 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);
 }
 public function testCount_returnsTheNumberOfErrors()
 {
     $result = Braintree\Customer::create(['email' => 'invalid', 'creditCard' => ['number' => 'invalid', 'expirationDate' => 'invalid', 'billingAddress' => ['countryName' => 'invaild']]]);
     $this->assertEquals(false, $result->success);
     $this->assertEquals(4, count($result->errors));
 }
 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 test_multipleValueNode_status()
 {
     $result = Braintree\Customer::create(array('creditCard' => array('cardholderName' => 'Joe Smith', 'number' => '4000111111111115', 'expirationDate' => '12/2016', 'options' => array('verifyCard' => true))));
     $creditCardVerification = $result->creditCardVerification;
     $collection = Braintree\CreditCardVerification::search(array(Braintree\CreditCardVerificationSearch::id()->is($creditCardVerification->id), Braintree\CreditCardVerificationSearch::status()->is($creditCardVerification->status)));
     $this->assertEquals(1, $collection->maximumCount());
     $this->assertEquals($creditCardVerification->id, $collection->firstItem()->id);
     $collection = Braintree\CreditCardVerification::search(array(Braintree\CreditCardVerificationSearch::id()->is($creditCardVerification->id), Braintree\CreditCardVerificationSearch::status()->in(array($creditCardVerification->status, Braintree\Result\CreditCardVerification::VERIFIED))));
     $this->assertEquals(1, $collection->maximumCount());
     $this->assertEquals($creditCardVerification->id, $collection->firstItem()->id);
     $collection = Braintree\CreditCardVerification::search(array(Braintree\CreditCardVerificationSearch::id()->is($creditCardVerification->id), Braintree\CreditCardVerificationSearch::status()->is(Braintree\Result\CreditCardVerification::VERIFIED)));
     $this->assertEquals(0, $collection->maximumCount());
 }
 public function testUpdateNoValidate()
 {
     $customer = Braintree\Customer::createNoValidate();
     $createdAddress = Braintree\Address::createNoValidate(['customerId' => $customer->id, 'firstName' => 'Old First', 'lastName' => 'Old Last', 'company' => 'Old Company', 'streetAddress' => '1 E Old St', 'extendedAddress' => 'Apt Old', 'locality' => 'Old Chicago', 'region' => 'Old Region', 'postalCode' => 'Old Postal', 'countryName' => 'United States of America']);
     $address = Braintree\Address::updateNoValidate($customer->id, $createdAddress->id, ['firstName' => 'New First', 'lastName' => 'New Last', 'company' => 'New Company', 'streetAddress' => '1 E New St', 'extendedAddress' => 'Apt New', 'locality' => 'New Chicago', 'region' => 'New Region', 'postalCode' => 'New Postal', 'countryName' => 'Mexico']);
     $this->assertEquals('New First', $address->firstName);
     $this->assertEquals('New Last', $address->lastName);
     $this->assertEquals('New Company', $address->company);
     $this->assertEquals('1 E New St', $address->streetAddress);
     $this->assertEquals('Apt New', $address->extendedAddress);
     $this->assertEquals('New Chicago', $address->locality);
     $this->assertEquals('New Region', $address->region);
     $this->assertEquals('New Postal', $address->postalCode);
     $this->assertEquals('Mexico', $address->countryName);
 }
Exemple #22
0
 /**
  * @param string $idCustomer
  * @return Customer
  */
 public function findCustomer($idCustomer)
 {
     return Customer::find($idCustomer);
 }
 /**
  * Get the Braintree customer for the user.
  *
  * @return \Braintree\Customer
  */
 public function asBraintreeCustomer()
 {
     return BraintreeCustomer::find($this->braintree_id);
 }
 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);
 }
 public function testOnHtmlField_returnsEmptyForCustomFieldsIfNoErrors()
 {
     $result = Braintree\Customer::create(array('email' => 'invalid', 'creditCard' => array('number' => '5105105105105100', 'expirationDate' => '05/12'), 'customFields' => array('storeMe' => 'value')));
     $this->assertEquals(false, $result->success);
     $this->assertEquals(array(), $result->errors->onHtmlField('customer[custom_fields][store_me]'));
 }
 /**
  * @param \AppBundle\Entity\User $user
  * @param float $amount
  * @return boolean
  */
 public function chargeUser(User $user, float $amount, $description)
 {
     //get braintree customer
     $customer = BraintreeCustomer::find($this->getCustomerId($user));
     $result = BraintreeTransaction::sale(['paymentMethodToken' => $customer->creditCards[0]->token, 'amount' => round($amount)]);
     $payment = new Payment();
     $payment->setUser($user);
     $payment->setSuccess(true);
     $payment->setDate(new \DateTime());
     $payment->setIntegration('braintree');
     $payment->setAmount($amount * 100);
     $payment->setReference($result->transaction->id);
     $this->persist($payment);
     $this->flush();
     return $result;
 }
 public function testSale_createsASaleUsingGivenToken()
 {
     $nonce = Braintree\Test\Nonces::$paypalFuturePayment;
     $customer = Braintree\Customer::createNoValidate(['paymentMethodNonce' => $nonce]);
     $paypalAccount = $customer->paypalAccounts[0];
     $result = Braintree\PayPalAccount::sale($paypalAccount->token, ['amount' => '100.00']);
     $this->assertTrue($result->success);
     $this->assertEquals('100.00', $result->transaction->amount);
     $this->assertEquals($customer->id, $result->transaction->customerDetails->id);
     $this->assertEquals($paypalAccount->token, $result->transaction->paypalDetails->token);
 }
 public function testCreate_withVaultedPayPal()
 {
     $paymentMethodToken = 'PAYPAL_TOKEN-' . strval(rand());
     $customer = Braintree\Customer::createNoValidate();
     $http = new HttpClientApi(Braintree\Configuration::$global);
     $nonce = $http->nonceForPayPalAccount(['paypal_account' => ['consent_code' => 'PAYPAL_CONSENT_CODE', 'token' => $paymentMethodToken]]);
     Braintree\PaymentMethod::create(['customerId' => $customer->id, 'paymentMethodNonce' => $nonce]);
     $result = Braintree\Transaction::sale(['amount' => Braintree\Test\TransactionAmounts::$authorize, 'paymentMethodToken' => $paymentMethodToken]);
     $this->assertTrue($result->success);
     $transaction = $result->transaction;
     $this->assertEquals('*****@*****.**', $transaction->paypalDetails->payerEmail);
     $this->assertNotNull($transaction->paypalDetails->imageUrl);
     $this->assertNotNull($transaction->paypalDetails->debugId);
 }