/**
* 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));
}
