protected function _initialize($attributes)
{
$this->_attributes = $attributes;
if (isset($attributes['subject']['apiErrorResponse'])) {
$wrapperNode = $attributes['subject']['apiErrorResponse'];
} else {
$wrapperNode = $attributes['subject'];
}
if (isset($wrapperNode['subscription'])) {
$this->_set('subscription', Braintree_Subscription::factory($attributes['subject']['subscription']));
}
if (isset($wrapperNode['merchantAccount'])) {
$this->_set('merchantAccount', Braintree_MerchantAccount::factory($wrapperNode['merchantAccount']));
}
if (isset($wrapperNode['transaction'])) {
$this->_set('transaction', Braintree_Transaction::factory($wrapperNode['transaction']));
}
if (isset($wrapperNode['disbursement'])) {
$this->_set('disbursement', Braintree_Disbursement::factory($wrapperNode['disbursement']));
}
if (isset($wrapperNode['partnerMerchant'])) {
$this->_set('partnerMerchant', Braintree_PartnerMerchant::factory($wrapperNode['partnerMerchant']));
}
if (isset($wrapperNode['errors'])) {
$this->_set('errors', new Braintree_Error_ValidationErrorCollection($wrapperNode['errors']));
$this->_set('message', $wrapperNode['message']);
}
}
public function afterFind($results, $primary = false)
{
if ($primary) {
$results = Hash::insert($results, "{n}.BraintreeSubscription", array());
$results = Hash::insert($results, "{n}.BraintreePlan", array());
$braintreeSubscriptions = Braintree_Subscription::search([Braintree_SubscriptionSearch::ids()->in(Hash::extract($results, "{n}.BillingSubscription.remote_subscription_id"))]);
$braintreePlans = Braintree_Plan::all();
foreach ($results as $key => $result) {
foreach ($braintreeSubscriptions as $braintreeSubscription) {
if ($braintreeSubscription->id == $result['BillingSubscription']['remote_subscription_id']) {
$result['BraintreeSubscription'] = $braintreeSubscription;
break;
}
//$results = Hash::insert($results, "{n}.BillingSubscription[remote_subscription_id=".$braintreeSubscription->id."]", array('BraintreeSubscription' => $braintreeSubscription));
}
foreach ($braintreePlans as $braintreePlan) {
if ($braintreePlan->id == $result['BillingSubscription']['remote_plan_id']) {
$result['BraintreePlan'] = $braintreePlan;
break;
}
}
$results[$key] = $result;
}
}
return $results;
}
protected function _initialize($attributes)
{
$this->_attributes = $attributes;
if (isset($attributes['subject']) && isset($attributes['subject']['subscription'])) {
$this->_set('subscription', Braintree_Subscription::factory($attributes['subject']['subscription']));
}
}
/**
* updateSubscriptions
* --------------------------------------------------
* Updating the BraintreeSubscriptions.
* @return The stripe plans.
* @throws BraintreeNotConnected
* --------------------------------------------------
*/
public function updateSubscriptions()
{
// Updating plans to be up to date.
$this->updatePlans();
$subscriptions = array();
// Clollecting subscriptions.
try {
$braintreeSubscriptions = Braintree_Subscription::search(array(Braintree_SubscriptionSearch::status()->in(array(Braintree_Subscription::ACTIVE))));
} catch (Exception $e) {
// Something went wrong.
return;
}
foreach ($braintreeSubscriptions as $subscription) {
$new_subscription = new BraintreeSubscription(array('start' => $subscription->firstBillingDate, 'status' => $subscription->status));
$plan = BraintreePlan::where('plan_id', $subscription->planId)->first();
if ($plan === null) {
// Braintree integrity error, link to a non-existing plan.
return array();
}
$new_subscription->plan()->associate($plan);
array_push($subscriptions, $new_subscription);
}
// Save new.
foreach ($subscriptions as $subscription) {
$subscription->save();
}
return $subscriptions;
}
/**
* overrides default constructor
* @ignore
* @param array $response gateway response array
*/
public function __construct($response)
{
$this->_attributes = $response;
$this->_set('errors', new Braintree_Error_ErrorCollection($response['errors']));
if (isset($response['verification'])) {
$this->_set('creditCardVerification', new Braintree_Result_CreditCardVerification($response['verification']));
} else {
$this->_set('creditCardVerification', null);
}
if (isset($response['transaction'])) {
$this->_set('transaction', Braintree_Transaction::factory($response['transaction']));
} else {
$this->_set('transaction', null);
}
if (isset($response['subscription'])) {
$this->_set('subscription', Braintree_Subscription::factory($response['subscription']));
} else {
$this->_set('subscription', null);
}
if (isset($response['merchantAccount'])) {
$this->_set('merchantAccount', Braintree_MerchantAccount::factory($response['merchantAccount']));
} else {
$this->_set('merchantAccount', null);
}
}
function testContains()
{
$creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
$triallessPlan = Braintree_SubscriptionTestHelper::triallessPlan();
$trialPlan = Braintree_SubscriptionTestHelper::trialPlan();
$trialSubscription = Braintree_Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $trialPlan['id'], 'price' => '9'))->subscription;
$triallessSubscription = Braintree_Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id'], 'price' => '9'))->subscription;
$collection = Braintree_Subscription::search(array(Braintree_SubscriptionSearch::planId()->contains("ration_trial_pl"), Braintree_SubscriptionSearch::price()->is("9")));
$this->assertTrue(Braintree_TestHelper::includes($collection, $trialSubscription));
$this->assertFalse(Braintree_TestHelper::includes($collection, $triallessSubscription));
}
function testIn_multipleValues()
{
$creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
$triallessPlan = Braintree_SubscriptionTestHelper::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(Braintree_TestHelper::includes($collection, $activeSubscription));
$this->assertTrue(Braintree_TestHelper::includes($collection, $canceledSubscription));
}
/**
* sets instance properties from an array of values
*
* @access protected
* @param array $paypalAccountAttribs array of paypalAccount data
* @return none
*/
protected function _initialize($paypalAccountAttribs)
{
// set the attributes
$this->_attributes = $paypalAccountAttribs;
$subscriptionArray = array();
if (isset($paypalAccountAttribs['subscriptions'])) {
foreach ($paypalAccountAttribs['subscriptions'] as $subscription) {
$subscriptionArray[] = Braintree_Subscription::factory($subscription);
}
}
$this->_set('subscriptions', $subscriptionArray);
}
/**
* sets instance properties from an array of values
*
* @access protected
* @param array $applePayCardAttribs array of Apple Pay card properties
* @return none
*/
protected function _initialize($applePayCardAttribs)
{
// set the attributes
$this->_attributes = $applePayCardAttribs;
$subscriptionArray = array();
if (isset($applePayCardAttribs['subscriptions'])) {
foreach ($applePayCardAttribs['subscriptions'] as $subscription) {
$subscriptionArray[] = Braintree_Subscription::factory($subscription);
}
}
$this->_set('subscriptions', $subscriptionArray);
$this->_set('expirationDate', $this->expirationMonth . '/' . $this->expirationYear);
}
public function createSubscription($customer_id, $package_code, $monthly_price)
{
try {
$customer = Braintree_Customer::find($customer_id);
$payment_method_token = $customer->creditCards[0]->token;
$result = Braintree_Subscription::create(array('paymentMethodToken' => $payment_method_token, 'planId' => $package_code, 'price' => $monthly_price));
return $result;
} catch (Braintree_Exception_NotFound $e) {
$bexcption = print_r($e, true);
log_message('error', date('Y-m-d H:i:s') . ' ' . $bexcption, true);
$result = new stdClass();
$result->success = false;
return $result;
}
}
/**
* Braintree sale function
* @param bool|true $submitForSettlement
* @param bool|true $storeInVaultOnSuccess
* @return array
*/
public function sendSubscription()
{
//$customer = \Braintree_Customer::find($this->options['customerId']);
$subscriptionData = array('paymentMethodToken' => $this->options['paymentMethodToken'], 'planId' => $this->options['planId']);
$result = \Braintree_Subscription::create($subscriptionData);
if ($result->success) {
return ['status' => true, 'result' => $result];
} else {
if ($result->transaction) {
return ['status' => false, 'result' => $result];
} else {
return ['status' => false, 'result' => $result];
}
}
}
function testFind_returnsSubscriptionsAssociatedWithAPaypalAccount()
{
$customer = Braintree_Customer::createNoValidate();
$paymentMethodToken = 'paypal-account-' . strval(rand());
$nonce = Braintree_HttpClientApi::nonceForPayPalAccount(array('paypal_account' => array('consent_code' => 'consent-code', 'token' => $paymentMethodToken)));
$result = Braintree_PaymentMethod::create(array('paymentMethodNonce' => $nonce, 'customerId' => $customer->id));
$this->assertTrue($result->success);
$token = $result->paymentMethod->token;
$triallessPlan = Braintree_SubscriptionTestHelper::triallessPlan();
$subscription1 = Braintree_Subscription::create(array('paymentMethodToken' => $token, 'planId' => $triallessPlan['id']))->subscription;
$subscription2 = Braintree_Subscription::create(array('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));
}
function subscribe($nonce, $info)
{
$customerResult;
$subscriptionResult;
$customerResult = Braintree_Customer::create(['firstName' => $info['fname'], 'lastName' => $info['lname'], 'email' => $info['email'], 'paymentMethodNonce' => $nonce]);
if (!$customerResult->success) {
return $this->processErrors('subscription', $customerResult->errors->deepAll());
}
$r = $customerResult->customer;
$a = $r->addresses[0];
$sql = 'INSERT INTO users (first_name, last_name, address, city, state, zip, braintree_customer_id, created_date, email) ';
$sql .= "VALUES ('" . $r->firstName . "','" . $r->lastName . "','" . $a->streetAddress . "','" . $a->locality . "','" . $a->region . "','" . $a->postalCode . "','" . $r->id . "', now(),'" . $r->email . "');";
$info['userId'] = MysqlAccess::insert($sql);
$subscriptionResult = Braintree_Subscription::create(['paymentMethodToken' => $customerResult->customer->paymentMethods[0]->token, 'planId' => 'donation', 'price' => $info['amount']]);
if (!isset($subscriptionResult->subscription) || !$subscriptionResult->subscription) {
return $this->processErrors('subscription', $subscriptionResult->errors->deepAll());
}
return $this->retrieveSubscriptionResults($subscriptionResult->success, $subscriptionResult->subscription, $info);
}
function testRetryCharge_WithAmount()
{
$subscription = Braintree_SubscriptionTestHelper::createSubscription();
Braintree_Http::put('/subscriptions/' . $subscription->id . '/make_past_due');
$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);
}
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);
}
function cancel_subscription($sub_id)
{
$result = Braintree_Subscription::cancel($sub_id);
if ($result->success === true) {
return true;
}
$this->_parse_errors($result);
return false;
}
<?php
require_once "../library/lib/Braintree.php";
$result = Braintree_Subscription::cancel('8bpb4b');
echo "<pre>";
print_r($result);
public function checkout()
{
$this->layout = 'profile_new';
if (!$this->request->is('post')) {
throw new NotFoundException(__d('billing', 'Incorrect request type'));
}
$customer = Braintree_Customer::find('konstruktor-' . $this->currUser['User']['id']);
if (isset($this->request->data['payment_method_nonce'])) {
$nonceFromTheClient = $this->request->data['payment_method_nonce'];
$payment = Braintree_PaymentMethod::create(['customerId' => 'konstruktor-' . $this->currUser['User']['id'], 'paymentMethodNonce' => $nonceFromTheClient]);
if (!$payment->success) {
$this->Session->setFlash($payment->message);
$this->redirect(array('action' => 'payment'));
}
$payment = $payment->paymentMethod;
} elseif (isset($this->request->data['payment_method']) && !empty($this->request->data['payment_method'])) {
$payment = null;
foreach ($customer->paymentMethods as $payment) {
if ($payment->token == $this->request->data['payment_method']) {
break;
}
}
if (empty($payment)) {
throw new NotFoundException(__d('billing', 'Payment method not found'));
}
} else {
throw new NotFoundException(__d('billing', 'Unable to create subscription'));
}
$braintreePlanId = $this->Session->read('Billing.plan');
$plan = $this->BillingPlan->findByRemotePlan($braintreePlanId);
$braintreePlans = Braintree_Plan::all();
$braintreePlan = null;
foreach ($braintreePlans as $_braintreePlan) {
if ($_braintreePlan->id == $braintreePlanId) {
$braintreePlan = $_braintreePlan;
break;
}
}
if (empty($braintreePlan)) {
throw new NotFoundException(__d('billing', 'Unable to create subscription'));
}
//Important! unit setup for model must be here. Before creating Braintree subscription
$unit = Configure::read('Billing.units.' . $plan['BillingGroup']['limit_units']);
if (empty($unit['model']) || empty($unit['field'])) {
throw new NotFoundException(__d('billing', 'Invalid billing plan'));
}
$this->BillingSubscription->Behaviors->load('Billing.Limitable', array('remoteModel' => $unit['model'], 'remoteField' => $unit['field'], 'scope' => isset($unit['scope']) ? $unit['scope'] : 'user_id'));
//Precreate subscription
$braintreeData = array('paymentMethodToken' => $payment->token, 'planId' => $braintreePlanId);
$qty = $this->Session->read('Billing.qty');
if (!empty($qty)) {
if (empty($braintreePlan->addOns)) {
throw new NotFoundException(__d('billing', 'Unable to create subscription'));
}
foreach ($braintreePlan->addOns as $addOn) {
$braintreeData['addOns']['update'][] = array('existingId' => $addOn->id, 'quantity' => $qty);
}
}
$billingSubscription = $this->BillingSubscription->find('first', array('conditions' => array('BillingSubscription.group_id' => $plan['BillingGroup']['id'], 'BillingSubscription.user_id' => $this->currUser['User']['id'], 'BillingSubscription.active' => true)));
//braintree unable to update subscription to a plan with a different billing frequency So we need to cancel current
if (!empty($billingSubscription)) {
if ($braintreePlan->billingFrequency != $billingSubscription['BraintreePlan']->billingFrequency || $billingSubscription['BraintreeSubscription']->status == 'Canceled' || $billingSubscription['BraintreeSubscription']->status == 'Expired') {
if ($braintreePlan->billingFrequency != $billingSubscription['BraintreePlan']->billingFrequency || $billingSubscription['BraintreeSubscription']->status != 'Canceled') {
try {
$result = Braintree_Subscription::cancel($billingSubscription['BraintreeSubscription']->id);
if ($result->success) {
$billingSubscription['BraintreeSubscription'] = $result->subscription;
}
} catch (Exception $e) {
}
}
$status = isset($billingSubscription['BraintreeSubscription']->status) ? $billingSubscription['BraintreeSubscription']->status : 'Canceled';
$this->BillingSubscription->cancel($billingSubscription['BillingSubscription']['id'], $status);
$billingSubscription = null;
}
}
if (!isset($billingSubscription['BillingSubscription'])) {
$data = array('group_id' => $plan['BillingGroup']['id'], 'plan_id' => $plan['BillingPlan']['id'], 'user_id' => $this->currUser['User']['id'], 'limit_value' => !empty($qty) ? $qty : $plan['BillingPlan']['limit_value'], 'active' => false);
} else {
$data = $billingSubscription['BillingSubscription'];
$data['limit_value'] = !empty($qty) ? $qty : $plan['BillingPlan']['limit_value'];
}
//No Exceptions anymore!
if (!isset($data['remote_subscription_id']) || empty($data['remote_subscription_id'])) {
//Subscribe user by create
$result = Braintree_Subscription::create($braintreeData);
} else {
$data['plan_id'] = $plan['BillingPlan']['id'];
//Subscribe user by update
$result = Braintree_Subscription::update($data['remote_subscription_id'], $braintreeData);
}
if (!$result->success) {
$this->Session->setFlash(__d('billing', 'Unable to subscribe on chosen plan. Please contact with resorce administration'));
$this->redirect(array('action' => 'plans', $plan['BillingGroup']['slug']));
}
$data = Hash::merge($data, array('remote_subscription_id' => $result->subscription->id, 'remote_plan_id' => $result->subscription->planId, 'active' => $result->subscription->status === 'Active' ? true : false, 'status' => $result->subscription->status, 'expires' => $result->subscription->billingPeriodEndDate->format('Y-m-d H:i:s'), 'created' => $result->subscription->createdAt->format('Y-m-d H:i:s'), 'modified' => $result->subscription->updatedAt->format('Y-m-d H:i:s')));
if (!isset($data['id'])) {
$this->BillingSubscription->create();
}
if ($this->BillingSubscription->save($data)) {
$this->Session->write('Billing');
if (!isset($data['id']) || empty($data['id'])) {
$data['id'] = $this->BillingSubscription->getInsertID();
}
$this->redirect(array('action' => 'success', $data['id']));
} else {
$this->Session->setFlash(__d('billing', 'Unable to subscribe on chosen plan. Please contact with resorce administration'));
$this->redirect(array('action' => 'plans', $plan['BillingGroup']['slug']));
}
}
/**
* sets instance properties from an array of values
*
* @access protected
* @param array $creditCardAttribs array of creditcard data
* @return none
*/
protected function _initialize($creditCardAttribs)
{
// set the attributes
$this->_attributes = $creditCardAttribs;
// map each address into its own object
$billingAddress = isset($creditCardAttribs['billingAddress']) ? Braintree_Address::factory($creditCardAttribs['billingAddress']) : null;
$subscriptionArray = array();
if (isset($creditCardAttribs['subscriptions'])) {
foreach ($creditCardAttribs['subscriptions'] as $subscription) {
$subscriptionArray[] = Braintree_Subscription::factory($subscription);
}
}
$this->_set('subscriptions', $subscriptionArray);
$this->_set('billingAddress', $billingAddress);
$this->_set('expirationDate', $this->expirationMonth . '/' . $this->expirationYear);
$this->_set('maskedNumber', $this->bin . '******' . $this->last4);
}
/**
* @ignore
*/
private function _verifyGatewayResponse($response)
{
if (isset($response['subscription'])) {
return new Braintree_Result_Successful(Braintree_Subscription::factory($response['subscription']));
} else {
if (isset($response['transaction'])) {
// return a populated instance of Braintree_Transaction, for subscription retryCharge
return new Braintree_Result_Successful(Braintree_Transaction::factory($response['transaction']));
} else {
if (isset($response['apiErrorResponse'])) {
return new Braintree_Result_Error($response['apiErrorResponse']);
} else {
throw new Braintree_Exception_Unexpected("Expected subscription, transaction, or apiErrorResponse");
}
}
}
}
function cancel(&$order)
{
//require a subscription id
if (empty($order->subscription_transaction_id)) {
return false;
}
//find the customer
if (!empty($order->subscription_transaction_id)) {
//cancel
try {
$result = Braintree_Subscription::cancel($order->subscription_transaction_id);
} catch (Exception $e) {
$order->updateStatus("cancelled");
//assume it's been cancelled already
$order->error = __("Could not find the subscription.", "pmpro") . " " . $e->getMessage();
$order->shorterror = $order->error;
return false;
//no subscription found
}
if ($result->success) {
$order->updateStatus("cancelled");
return true;
} else {
$order->updateStatus("cancelled");
//assume it's been cancelled already
$order->error = __("Could not find the subscription.", "pmpro") . " " . $result->message;
$order->shorterror = $order->error;
return false;
//no subscription found
}
} else {
$order->error = __("Could not find the subscription.", "pmpro");
$order->shorterror = $order->error;
return false;
//no customer found
}
}
<?php
require_once 'environment.php';
$customerID = $_POST['customerID'];
try {
$customer_id = $customerID;
$customer = Braintree_Customer::find($customer_id);
$payment_method_token = $customer->creditCards[0]->token;
$result = Braintree_Subscription::create(array('paymentMethodToken' => $payment_method_token, 'planId' => 'test_plan_1'));
if ($result->success) {
echo "Success! Subscription " . $result->subscription->id . " is " . $result->subscription->status;
} else {
echo "Validation errors:<br/>";
foreach ($result->errors->deepAll() as $error) {
echo "- " . $error->message . "<br/>";
}
}
} catch (Braintree_Exception_NotFound $e) {
echo "Failure: no customer found with ID " . $_GET["customer_id"];
}
function testSearch_price()
{
$creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
$triallessPlan = Braintree_SubscriptionTestHelper::triallessPlan();
$subscription_850 = Braintree_Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id'], 'price' => '8.50'))->subscription;
$subscription_851 = Braintree_Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id'], 'price' => '8.51'))->subscription;
$subscription_852 = Braintree_Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $triallessPlan['id'], 'price' => '8.52'))->subscription;
$collection = Braintree_Subscription::search(array(Braintree_SubscriptionSearch::price()->between('8.51', '8.52')));
$this->assertTrue(Braintree_TestHelper::includes($collection, $subscription_851));
$this->assertTrue(Braintree_TestHelper::includes($collection, $subscription_852));
$this->assertFalse(Braintree_TestHelper::includes($collection, $subscription_850));
}
function testRetryCharge_WithAmount()
{
$subscription = Braintree_SubscriptionTestHelper::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);
}
$plan = "fitness";
} else {
if ($role[0] == "t") {
$plan = "training";
} else {
if ($role[0] == "r") {
$plan = "rep";
} else {
if ($role[0] == "l") {
$plan = "licensee";
}
}
}
}
$plan .= "_plan_basic";
$result = Braintree_Subscription::create(array('paymentMethodToken' => $payToken, 'planId' => $plan));
if (!$result->success) {
$error_msg = '<p class="error">Subscription Not Started:</p>';
foreach ($result->errors->deepAll() as $error) {
$error_msg .= '<p class="error">' . $error->code . ": " . $error->message . '</p>';
}
echo $error_msg;
} else {
// Set Account Status to Active
if ($stmt = $mysqli->prepare("UPDATE members SET account_status='" . ACCOUNT_STATUS_ACTIVE . "', askee='' " . "WHERE id = ?")) {
// Bind "$si" to parameter.
$stmt->bind_param('i', $si);
$stmt->execute();
// Execute the prepared query.
global $subdomain;
if ($role[0] == "f") {
static function createSubscription()
{
$plan = Braintree_SubscriptionTestHelper::triallessPlan();
$result = Braintree_Subscription::create(array('paymentMethodToken' => Braintree_SubscriptionTestHelper::createCreditCard()->token, 'price' => '54.99', 'planId' => $plan['id']));
return $result->subscription;
}
function testSnapshotPlanIdAddOnsAndDiscountsFromSubscription()
{
$creditCard = Braintree_SubscriptionTestHelper::createCreditCard();
$plan = Braintree_SubscriptionTestHelper::triallessPlan();
$result = Braintree_Subscription::create(array('paymentMethodToken' => $creditCard->token, 'planId' => $plan['id'], 'addOns' => array('add' => array(array('amount' => '11.00', 'inheritedFromId' => 'increase_10', 'quantity' => 2, 'numberOfBillingCycles' => 5), array('amount' => '21.00', 'inheritedFromId' => 'increase_20', 'quantity' => 3, 'numberOfBillingCycles' => 6))), 'discounts' => array('add' => array(array('amount' => '7.50', 'inheritedFromId' => 'discount_7', 'quantity' => 2, 'neverExpires' => true)))));
$transaction = $result->subscription->transactions[0];
$this->assertEquals($transaction->planId, $plan['id']);
$addOns = $transaction->addOns;
Braintree_SubscriptionTestHelper::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 doCancelSubscription()
{
$user = Auth::user();
if ($user->subscriptionId) {
try {
$result = Braintree_Subscription::cancel($user->subscriptionId);
} catch (Exception $e) {
return Redirect::back()->with('error', "Couldn't process subscription, try again later.");
}
$user->subscriptionId = '';
$user->plan = 'cancelled';
$user->save();
IntercomHelper::cancelled($user);
return Redirect::route('auth.plan')->with('success', 'Unsubscribed successfully');
} else {
Redirect::back()->with('error', 'No valid subscription');
}
}
function testFind_returnsCreditCardsWithSubscriptions()
{
$customer = Braintree_Customer::createNoValidate();
$creditCardResult = Braintree_CreditCard::create(array('customerId' => $customer->id, 'number' => '5105105105105100', 'expirationDate' => '05/2011'));
$this->assertTrue($creditCardResult->success);
$subscriptionId = strval(rand());
Braintree_Subscription::create(array('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);
}
/**
* cancelBraintreeSubscription
* --------------------------------------------------
* @return Cancels the current Braintree Subscription.
* --------------------------------------------------
*/
private function cancelBraintreeSubscription()
{
/* Initialize variables */
$result = ['errors' => FALSE, 'messages' => ''];
error_log('recece');
/* Cancel braintree subscription */
$cancellationResult = Braintree_Subscription::cancel($this->braintree_subscription_id);
/* Error */
if (!$cancellationResult->success) {
error_log('not success');
/* Get and store errors */
foreach ($cancellationResult->errors->deepAll() as $error) {
/* SKIP | Subscription has already been canceled. */
if ($error->code == SiteConstants::getBraintreeErrorCodes()['Subscription has already been canceled']) {
continue;
} else {
$result['errors'] |= TRUE;
$result['messages'] .= $error->code . ": " . $error->message . ' ';
}
}
}
/* Return result */
return $result;
}
