/** * overrides default constructor * @ignore * @param array $response gateway response array */ public function __construct($response) { $this->_attributes = $response; $this->_set('errors', new ErrorCollection($response['errors'])); if (isset($response['verification'])) { $this->_set('creditCardVerification', new CreditCardVerification($response['verification'])); } else { $this->_set('creditCardVerification', null); } if (isset($response['transaction'])) { $this->_set('transaction', Transaction::factory($response['transaction'])); } else { $this->_set('transaction', null); } if (isset($response['subscription'])) { $this->_set('subscription', Subscription::factory($response['subscription'])); } else { $this->_set('subscription', null); } if (isset($response['merchantAccount'])) { $this->_set('merchantAccount', MerchantAccount::factory($response['merchantAccount'])); } else { $this->_set('merchantAccount', null); } }
/** * Handle the event. * * @param mixed $event * @return void */ public function handle($event) { $subscription = $event->billable->subscription(); if (!$subscription || !$subscription->valid()) { return; } $plan = BraintreeService::findPlan($subscription->braintree_plan); BraintreeSubscription::update($subscription->braintree_id, ['price' => $plan->price * (1 + $event->billable->taxPercentage() / 100), 'options' => ['prorateCharges' => false]]); }
public function testIn_multipleValues() { $creditCard = SubscriptionHelper::createCreditCard(); $triallessPlan = SubscriptionHelper::triallessPlan(); $activeSubscription = Braintree\Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id'], 'price' => '4'))->subscription; $canceledSubscription = Braintree\Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id'], 'price' => '4'))->subscription; Braintree\Subscription::cancel($canceledSubscription->id); $collection = Braintree\Subscription::search(array(Braintree\SubscriptionSearch::status()->in(array(Braintree\Subscription::ACTIVE, Braintree\Subscription::CANCELED)), Braintree\SubscriptionSearch::price()->is('4'))); $this->assertTrue(Test\Helper::includes($collection, $activeSubscription)); $this->assertTrue(Test\Helper::includes($collection, $canceledSubscription)); }
public function testFind_returnsSubscriptionsAssociatedWithAPaypalAccount() { $customer = Braintree\Customer::createNoValidate(); $paymentMethodToken = 'paypal-account-' . strval(rand()); $http = new HttpClientApi(Braintree\Configuration::$global); $nonce = $http->nonceForPayPalAccount(['paypal_account' => ['consent_code' => 'consent-code', 'token' => $paymentMethodToken]]); $result = Braintree\PaymentMethod::create(['paymentMethodNonce' => $nonce, 'customerId' => $customer->id]); $this->assertTrue($result->success); $token = $result->paymentMethod->token; $triallessPlan = SubscriptionHelper::triallessPlan(); $subscription1 = Braintree\Subscription::create(['paymentMethodToken' => $token, 'planId' => $triallessPlan['id']])->subscription; $subscription2 = Braintree\Subscription::create(['paymentMethodToken' => $token, 'planId' => $triallessPlan['id']])->subscription; $paypalAccount = Braintree\PayPalAccount::find($token); $getIds = function ($sub) { return $sub->id; }; $subIds = array_map($getIds, $paypalAccount->subscriptions); $this->assertTrue(in_array($subscription1->id, $subIds)); $this->assertTrue(in_array($subscription2->id, $subIds)); }
/** * Get the subscription as a Braintree subscription object. * * @return \Braintree\Subscription */ public function asBraintreeSubscription() { return BraintreeSubscription::find($this->braintree_id); }
public function testSearch_transactionId() { $creditCard = SubscriptionHelper::createCreditCard(); $triallessPlan = SubscriptionHelper::triallessPlan(); $matchingSubscription = Braintree\Subscription::create(['paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id']])->subscription; $nonMatchingSubscription = Braintree\Subscription::create(['paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id']])->subscription; $collection = Braintree\Subscription::search([Braintree\SubscriptionSearch::transactionId()->is($matchingSubscription->transactions[0]->id)]); $this->assertTrue(Test\Helper::includes($collection, $matchingSubscription)); $this->assertFalse(Test\Helper::includes($collection, $nonMatchingSubscription)); }
public function testFindReturnsAssociatedSubscriptions() { $customer = Braintree\Customer::createNoValidate(); $result = Braintree\CreditCard::create(array('customerId' => $customer->id, 'cardholderName' => 'Cardholder', 'number' => '5105105105105100', 'expirationDate' => '05/12', 'billingAddress' => array('firstName' => 'Drew', 'lastName' => 'Smith', 'company' => 'Smith Co.', 'streetAddress' => '1 E Main St', 'extendedAddress' => 'Suite 101', 'locality' => 'Chicago', 'region' => 'IL', 'postalCode' => '60622', 'countryName' => 'United States of America'))); $id = strval(rand()); Braintree\Subscription::create(array('id' => $id, 'paymentMethodToken' => $result->creditCard->token, 'planId' => 'integration_trialless_plan', 'price' => '1.00')); $creditCard = Braintree\CreditCard::find($result->creditCard->token); $this->assertEquals($id, $creditCard->subscriptions[0]->id); $this->assertEquals('integration_trialless_plan', $creditCard->subscriptions[0]->planId); $this->assertEquals('1.00', $creditCard->subscriptions[0]->price); }
public function testFind_returnsCreditCardsWithSubscriptions() { $customer = Braintree\Customer::createNoValidate(); $creditCardResult = Braintree\CreditCard::create(['customerId' => $customer->id, 'number' => '5105105105105100', 'expirationDate' => '05/2011']); $this->assertTrue($creditCardResult->success); $subscriptionId = strval(rand()); Braintree\Subscription::create(['id' => $subscriptionId, 'paymentMethodToken' => $creditCardResult->creditCard->token, 'planId' => 'integration_trialless_plan', 'price' => '1.00']); $foundCreditCard = Braintree\PaymentMethod::find($creditCardResult->creditCard->token); $this->assertEquals($subscriptionId, $foundCreditCard->subscriptions[0]->id); $this->assertEquals('integration_trialless_plan', $foundCreditCard->subscriptions[0]->planId); $this->assertEquals('1.00', $foundCreditCard->subscriptions[0]->price); }
/** * Update current subscription plan to another with the same billing cycle. * * @param \Braintree\Plan $newPlan * @return $this * @throws \Exception */ protected function updatePlan(Plan $newPlan) { $changes = ['price' => $this->planPriceWithTax($newPlan, $this->user->taxPercentage()), 'planId' => $newPlan->id, 'options' => ['prorateCharges' => true]]; $result = BraintreeSubscription::update($this->braintree_id, $changes); if (!$result->success) { throw new Exception('Plan was not swapped.'); } $this->update(['braintree_plan' => $newPlan->id]); return $this; }
/** * Create a new Braintree subscription. * * @param string|null $nonce * @param array $customerOptions * @param array $subscriptionOptions * * @return \LimeDeck\CashierBraintree\Subscription * @throws \Exception */ public function create($nonce = null, array $customerOptions = [], array $subscriptionOptions = []) { $customer = $this->getBraintreeCustomer($nonce, $customerOptions); $plan = $this->findPlanById($this->plan); $planPriceWithTax = $this->planPriceWithTax($plan, $this->getTaxPercentageForPayload()); $subscriptionOptions = array_merge($subscriptionOptions, ['price' => $planPriceWithTax, 'paymentMethodToken' => $customer->paymentMethods[0]->token, 'planId' => $this->plan, 'trialDuration' => $this->trialDays ?: 0, 'trialDurationUnit' => 'day', 'trialPeriod' => $this->trialDays ? true : false]); if ($this->coupon) { $coupon = $this->findCouponById($this->coupon); $amount = $this->couponPercentage ? $coupon->amount / 100 * $planPriceWithTax : $coupon->amount; $subscriptionOptions['discounts'] = ['add' => [['inheritedFromId' => $this->coupon, 'amount' => $this->formatAmount($amount)]]]; } $result = BraintreeSubscription::create($subscriptionOptions); if (!$result->success) { throw new Exception('Subscription was not created'); } return $this->user->subscriptions()->create(['name' => $this->name, 'braintree_id' => $result->subscription->id, 'braintree_plan' => $this->plan, 'quantity' => 1, 'trial_ends_at' => $this->trialDays ? Carbon::now()->addDays($this->trialDays) : null, 'ends_at' => null]); }
/** * @ignore */ private function _verifyGatewayResponse($response) { if (isset($response['subscription'])) { return new Result\Successful(Subscription::factory($response['subscription'])); } else { if (isset($response['transaction'])) { // return a populated instance of Transaction, for subscription retryCharge return new Result\Successful(Transaction::factory($response['transaction'])); } else { if (isset($response['apiErrorResponse'])) { return new Result\Error($response['apiErrorResponse']); } else { throw new Exception\Unexpected("Expected subscription, transaction, or apiErrorResponse"); } } } }
public function retryChargeSubscription($subscriptionId, $amount) { $retryResult = Subscription::retryCharge($subscriptionId, $amount); if ($retryResult->success) { $result = Transaction::submitForSettlement($retryResult->transaction->id); return $result; } return $retryResult; }
/** * Create a new Braintree subscription. * * @param string|null $token * @param array $customerOptions * @param array $subscriptionOptions * * @return SubscriptionModel * * @throws Exception */ public function create($token = null, array $customerOptions = [], array $subscriptionOptions = []) { $payload = $this->getSubscriptionPayload($this->getBraintreeCustomer($token, $customerOptions), $subscriptionOptions); if ($this->coupon) { $payload = $this->addCouponToPayload($payload); } $response = BraintreeSubscription::create($payload); if (!$response->success) { throw new Exception('Braintree failed to create subscription: ' . $response->message); } if ($this->skipTrial) { $trialEndsAt = null; } else { $trialEndsAt = $this->trialDays ? Carbon::now()->addDays($this->trialDays) : null; } $subscriptionModel = Yii::createObject(['class' => SubscriptionModel::className(), 'userId' => $this->user->id, 'name' => $this->name, 'braintreeId' => $response->subscription->id, 'braintreePlan' => $this->plan, 'trialEndAt' => $trialEndsAt, 'endAt' => null]); if ($subscriptionModel->save()) { return $subscriptionModel; } else { throw new Exception('Subscription was not saved.'); } }
public function testErrorsOnFindWithWhitespaceArgument() { $this->setExpectedException('InvalidArgumentException'); Braintree\Subscription::find('\\t'); }
/** * Create a new Braintree subscription. * * @param string|null $token * @param array $customerOptions * @param array $subscriptionOptions * @return \Laravel\Cashier\Subscription */ public function create($token = null, array $customerOptions = [], array $subscriptionOptions = []) { $payload = $this->getSubscriptionPayload($this->getBraintreeCustomer($token, $customerOptions), $subscriptionOptions); if ($this->coupon) { $payload = $this->addCouponToPayload($payload); } $response = BraintreeSubscription::create($payload); if (!$response->success) { throw new Exception('Braintree failed to create subscription: ' . $response->message); } if ($this->skipTrial) { $trialEndsAt = null; } else { $trialEndsAt = $this->trialDays ? Carbon::now()->addDays($this->trialDays) : null; } return $this->user->subscriptions()->create(['name' => $this->name, 'braintree_id' => $response->subscription->id, 'braintree_plan' => $this->plan, 'quantity' => 1, 'trial_ends_at' => $trialEndsAt, 'ends_at' => null]); }
/** * Update the payment method token for all of the user's subscriptions. * * @param string $token * @return void */ protected function updateSubscriptionsToPaymentMethod($token) { foreach ($this->subscriptions as $subscription) { if ($subscription->active()) { BraintreeSubscription::update($subscription->braintree_id, ['paymentMethodToken' => $token]); } } }
public static function createSubscription() { $plan = self::triallessPlan(); $result = Braintree\Subscription::create(['paymentMethodToken' => self::createCreditCard()->token, 'price' => '54.99', 'planId' => $plan['id']]); return $result->subscription; }
/** * Get a collection of the entity's invoices. * * @param bool $includePending * @param array $parameters * * @return \Illuminate\Support\Collection */ public function invoices($includePending = false, $parameters = []) { $invoices = new Collection(); $customer = $this->asBraintreeCustomer(); $parameters = array_merge([TransactionSearch::customerId()->is($customer->id)], $parameters); $braintreeTransactions = Transaction::search($parameters); $subscriptionIds = []; foreach ($braintreeTransactions as $braintreeTransaction) { $subscriptionIds[] = $braintreeTransaction->subscriptionId; } $braintreeSubscriptions = BraintreeSubscription::fetch([], array_unique($subscriptionIds)); // Here we will loop through the Braintree invoices and create our own custom Invoice // instances that have more helper methods and are generally more convenient to // work with than the plain Braintree objects are. Then, we'll return the array. if (!is_null($braintreeSubscriptions)) { foreach ($braintreeSubscriptions as $subscription) { if ($subscription->status == BraintreeSubscription::ACTIVE || $includePending) { foreach ($subscription->transactions as $transaction) { $invoices->push(new Invoice($this, $subscription, $transaction)); } } } } return $invoices->sortByDesc(function ($invoice) { return $invoice->date(); }); }
public function testRetryCharge_WithAmount() { $subscription = SubscriptionHelper::createSubscription(); $http = new Braintree\Http(Braintree\Configuration::$global); $path = Braintree\Configuration::$global->merchantPath() . '/subscriptions/' . $subscription->id . '/make_past_due'; $http->put($path); $result = Braintree\Subscription::retryCharge($subscription->id, 1000); $this->assertTrue($result->success); $transaction = $result->transaction; $this->assertEquals(1000, $transaction->amount); $this->assertNotNull($transaction->processorAuthorizationCode); $this->assertEquals(Braintree\Transaction::SALE, $transaction->type); $this->assertEquals(Braintree\Transaction::AUTHORIZED, $transaction->status); }
/** * @param string $subscription_id * @param bool $get_payment_method_info * @param int $numberOfTransactions * @return bool|\stdClass | {status, createdAt, updatedAt, cancelledAt, pastDue, daysPastDue, transactions} */ public function getSubscriptionInfo($subscription_id, $get_payment_method_info = true, $numberOfTransactions = 5) { $subscription = Braintree_Subscription::find($subscription_id); if (!empty($subscription)) { $data = new \stdClass(); $statuses = [Braintree_Subscription::ACTIVE => 'Active', Braintree_Subscription::CANCELED => 'Canceled', Braintree_Subscription::EXPIRED => 'Expired', Braintree_Subscription::PAST_DUE => 'Past due', Braintree_Subscription::PENDING => 'Pending']; $data->status = $statuses[$subscription->status]; $data->createdAt = Carbon::instance($subscription->createdAt); $data->updatedAt = Carbon::instance($subscription->updatedAt); //The date/time the object was last updated. If a subscription has been cancelled, this value will represent the date/time of cancellation. if ($subscription->status == Braintree_Subscription::CANCELED) { $data->cancelledAt = Carbon::instance($data->updatedAt); } else { $data->cancelledAt = null; } $data->gracePeriod = $this->getGracePeriodFromSubscriptionInstance($subscription); $data->currentBillingCycle = $subscription->currentBillingCycle; $data->successfullyBilled = $data->currentBillingCycle > 0; $data->nextBill = new \stdClass(); $data->nextBill->date = $subscription->nextBillingDate; $data->nextBill->amount = $subscription->nextBillingPeriodAmount; //String, The total subscription amount for the next billing period. This amount includes add-ons and discounts but does not include the current balance. if ($subscription->status == Braintree_Subscription::PAST_DUE) { $data->pastDue = true; $data->daysPastDue = $subscription->daysPastDue; //int, The number of days that the subscription is past due. } else { $data->pastDue = false; $data->daysPastDue = 0; } $data->transactions = []; $i = 0; $transactionStatuses = [Braintree_Transaction::AUTHORIZATION_EXPIRED => 'Authorization expired', Braintree_Transaction::AUTHORIZED => 'Authorized', Braintree_Transaction::AUTHORIZING => 'Authorizing', Braintree_Transaction::GATEWAY_REJECTED => 'Gateway rejected', Braintree_Transaction::FAILED => 'Failed', Braintree_Transaction::PROCESSOR_DECLINED => 'Processor declined', Braintree_Transaction::SETTLED => 'Settled', Braintree_Transaction::SETTLING => 'Settling', Braintree_Transaction::SUBMITTED_FOR_SETTLEMENT => 'Submitted for settlement', Braintree_Transaction::VOIDED => 'Voided', Braintree_Transaction::UNRECOGNIZED => 'Unrecognized', Braintree_Transaction::SETTLEMENT_DECLINED => 'Settlement declined', Braintree_Transaction::SETTLEMENT_PENDING => 'Settlement pending', Braintree_Transaction::SETTLEMENT_CONFIRMED => 'Settlement confirmed']; foreach ($subscription->transactions as $transaction) { $data->transactions[] = (object) ['status' => $transactionStatuses[$transaction->status], 'amount' => $transaction->amount, 'date' => Carbon::instance($transaction->createdAt), 'credit_card' => (object) ['type' => $transaction->creditCardDetails->cardType, 'last4' => $transaction->creditCardDetails->last4]]; $i++; if ($i >= $numberOfTransactions) { break; } } $subscription->transactions; // Array of Braintree_Transaction objects, Transactions associated with the subscription, sorted by creation date with the most recent first. if ($get_payment_method_info) { $paymentMethod = Braintree_PaymentMethod::find($subscription->paymentMethodToken); $data->payment_method = new \stdClass(); $data->payment_method->credit_card = (object) ['type' => $paymentMethod->cardType, 'last4' => $paymentMethod->last4, 'expiration_month' => $paymentMethod->expirationMonth, 'expiration_year' => $paymentMethod->expirationYear]; $data->payment_method->billing_address = (object) ['first_name' => $paymentMethod->billingAddress->firstName, 'last_name' => $paymentMethod->billingAddress->lastName, 'address' => $paymentMethod->billingAddress->streetAddress, 'city' => $paymentMethod->billingAddress->locality, 'state' => $paymentMethod->billingAddress->region, 'zip' => $paymentMethod->billingAddress->postalCode]; } return $data; } return false; }
public function testSnapshotPlanIdAddOnsAndDiscountsFromSubscription() { $creditCard = SubscriptionHelper::createCreditCard(); $plan = SubscriptionHelper::triallessPlan(); $result = Braintree\Subscription::create(['paymentMethodToken' => $creditCard->token, 'planId' => $plan['id'], 'addOns' => ['add' => [['amount' => '11.00', 'inheritedFromId' => 'increase_10', 'quantity' => 2, 'numberOfBillingCycles' => 5], ['amount' => '21.00', 'inheritedFromId' => 'increase_20', 'quantity' => 3, 'numberOfBillingCycles' => 6]]], 'discounts' => ['add' => [['amount' => '7.50', 'inheritedFromId' => 'discount_7', 'quantity' => 2, 'neverExpires' => true]]]]); $transaction = $result->subscription->transactions[0]; $this->assertEquals($transaction->planId, $plan['id']); $addOns = $transaction->addOns; SubscriptionHelper::sortModificationsById($addOns); $this->assertEquals($addOns[0]->amount, "11.00"); $this->assertEquals($addOns[0]->id, "increase_10"); $this->assertEquals($addOns[0]->quantity, 2); $this->assertEquals($addOns[0]->numberOfBillingCycles, 5); $this->assertFalse($addOns[0]->neverExpires); $this->assertEquals($addOns[1]->amount, "21.00"); $this->assertEquals($addOns[1]->id, "increase_20"); $this->assertEquals($addOns[1]->quantity, 3); $this->assertEquals($addOns[1]->numberOfBillingCycles, 6); $this->assertFalse($addOns[1]->neverExpires); $discounts = $transaction->discounts; $this->assertEquals($discounts[0]->amount, "7.50"); $this->assertEquals($discounts[0]->id, "discount_7"); $this->assertEquals($discounts[0]->quantity, 2); $this->assertEquals($discounts[0]->numberOfBillingCycles, null); $this->assertTrue($discounts[0]->neverExpires); }
public function testContains() { $creditCard = SubscriptionHelper::createCreditCard(); $triallessPlan = SubscriptionHelper::triallessPlan(); $trialPlan = SubscriptionHelper::trialPlan(); $trialSubscription = Braintree\Subscription::create(['paymentMethodToken' => $creditCard->token, 'planId' => $trialPlan['id'], 'price' => '9'])->subscription; $triallessSubscription = Braintree\Subscription::create(['paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id'], 'price' => '9'])->subscription; $collection = Braintree\Subscription::search([Braintree\SubscriptionSearch::planId()->contains("ration_trial_pl"), Braintree\SubscriptionSearch::price()->is("9")]); $this->assertTrue(Test\Helper::includes($collection, $trialSubscription)); $this->assertFalse(Test\Helper::includes($collection, $triallessSubscription)); }