private function _braintreeConfigure()
{
Braintree_Configuration::environment(Config::get('app.braintree_environment'));
Braintree_Configuration::merchantId(Config::get('app.braintree_merchant_id'));
Braintree_Configuration::publicKey(Config::get('app.braintree_public_key'));
Braintree_Configuration::privateKey(Config::get('app.braintree_private_key'));
}
public function generateToken()
{
require "lib/braintree-php-3.5.0/lib/Braintree.php";
Braintree_Configuration::environment('sandbox');
Braintree_Configuration::merchantId('w7gz99fhtbrhj6y6');
Braintree_Configuration::publicKey('p5hhp9ctz3znhsq3');
Braintree_Configuration::privateKey('2baa5dd4adcb171001ce768fc2edf041');
$clientToken = Braintree_ClientToken::generate();
return $clientToken;
}
function testAuthorizationWithConfig()
{
$config = new Braintree_Configuration(array('environment' => 'development', 'merchant_id' => 'integration_merchant_id', 'publicKey' => 'badPublicKey', 'privateKey' => 'badPrivateKey'));
$http = new Braintree_Http($config);
$result = $http->_doUrlRequest('GET', $config->baseUrl() . '/merchants/integration_merchant_id/customers');
$this->assertEquals(401, $result['status']);
}
/**
*
* @return Braintree_AddOn[]
*/
public function all()
{
$path = $this->_config->merchantPath() . '/add_ons';
$response = $this->_http->get($path);
$addOns = array("addOn" => $response['addOns']);
return Braintree_Util::extractAttributeAsArray($addOns, 'addOn');
}
public function __construct($config)
{
if (is_array($config)) {
$config = new Braintree_Configuration($config);
}
$config->assertValid();
$this->config = $config;
}
/**
*
* @param string $settlement_date
* @param string $groupByCustomField
* @return Braintree_SettlementBatchSummary|Braintree_Result_Error
*/
public function generate($settlement_date, $groupByCustomField = NULL)
{
$criteria = array('settlement_date' => $settlement_date);
if (isset($groupByCustomField)) {
$criteria['group_by_custom_field'] = $groupByCustomField;
}
$params = array('settlement_batch_summary' => $criteria);
$path = $this->_config->merchantPath() . '/settlement_batch_summary';
$response = $this->_http->post($path, $params);
if (isset($groupByCustomField)) {
$response['settlementBatchSummary']['records'] = $this->_underscoreCustomField($groupByCustomField, $response['settlementBatchSummary']['records']);
}
return $this->_verifyGatewayResponse($response);
}
public function __construct()
{
\Braintree_Configuration::environment(Config::BRAINTREE_MODE);
\Braintree_Configuration::merchantId(Config::BRAINTREE_MERCHANT_ID);
\Braintree_Configuration::publicKey(Config::BRAINTREE_PUBLIC_KEY);
\Braintree_Configuration::privateKey(Config::BRAINTREE_PRIVATE_KEY);
}
/**
*v setup a config
*/
public function setupConfig()
{
\Braintree_Configuration::environment($this->environment);
\Braintree_Configuration::merchantId($this->merchantId);
\Braintree_Configuration::publicKey($this->publicKey);
\Braintree_Configuration::privateKey($this->privateKey);
}
public function send()
{
$this->load->model('checkout/order');
$order_info = $this->model_checkout_order->getOrder($this->session->data['order_id']);
$amount = $this->currency->format($order_info['total'], $order_info['currency_code'], 1.0, false);
//Load Braintree Library
require_once './vendor/braintree/braintree_php/lib/Braintree.php';
Braintree_Configuration::environment($this->config->get('simple_braintree_payments_mode'));
Braintree_Configuration::merchantId($this->config->get('simple_braintree_payments_merchant'));
Braintree_Configuration::publicKey($this->config->get('simple_braintree_payments_public_key'));
Braintree_Configuration::privateKey($this->config->get('simple_braintree_payments_private_key'));
// Payment nonce received from the client js side
$nonce = $_POST["payment_method_nonce"];
//create object to use as json
$json = array();
$result = null;
try {
// Perform the transaction
$result = Braintree_Transaction::sale(array('amount' => $amount, 'paymentMethodNonce' => $nonce, 'orderId' => $this->session->data['order_id']));
} catch (Exception $e) {
$json['phperror'] = $e->getMessage();
}
$json['details'] = $result;
if ($result->success) {
$this->model_checkout_order->confirm($this->session->data['order_id'], $this->config->get('simple_braintree_payments_order_status_id'));
$json['success'] = $this->url->link('checkout/success', '', 'SSL');
} else {
$json['error'] = $result->_attributes['message'];
}
$this->response->setOutput(json_encode($json));
}
public static function _doUrlRequest($httpVerb, $url, $requestBody = null)
{
$curl = curl_init();
curl_setopt($curl, CURLOPT_TIMEOUT, 60);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $httpVerb);
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_ENCODING, 'gzip');
curl_setopt($curl, CURLOPT_HTTPHEADER, array('Accept: application/xml', 'Content-Type: application/xml', 'User-Agent: Braintree PHP Library ' . Braintree_Version::get(), 'X-ApiVersion: ' . Braintree_Configuration::API_VERSION));
curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
curl_setopt($curl, CURLOPT_USERPWD, Braintree_Configuration::publicKey() . ':' . Braintree_Configuration::privateKey());
// curl_setopt($curl, CURLOPT_VERBOSE, true);
if (Braintree_Configuration::sslOn()) {
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, true);
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 2);
curl_setopt($curl, CURLOPT_CAINFO, Braintree_Configuration::caFile());
}
if (!empty($requestBody)) {
curl_setopt($curl, CURLOPT_POSTFIELDS, $requestBody);
}
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($curl);
$httpStatus = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);
if (Braintree_Configuration::sslOn()) {
if ($httpStatus == 0) {
throw new Braintree_Exception_SSLCertificate();
}
}
return array('status' => $httpStatus, 'body' => $response);
}
function testHmacSha1_again()
{
Braintree_Configuration::privateKey(str_repeat(chr(0xaa), 80));
$message = 'Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data';
$d = Braintree_Digest::_hmacSha1($message, Braintree_Configuration::privateKey());
$this->assertEquals('e8e99d0f45237d786d6bbaa7965c7808bbff1a91', $d);
}
function testMerchantConfig()
{
Braintree_Configuration::environment('development');
Braintree_Configuration::merchantId('test_merchant_id');
Braintree_Configuration::publicKey('test_public_key');
Braintree_Configuration::privateKey('test_private_key');
}
public function init()
{
require_once 'braintree-php-2.26.0/lib/Braintree.php';
Braintree_Configuration::environment($this->ENV);
Braintree_Configuration::merchantId($this->MERCHANT_ID);
Braintree_Configuration::publicKey($this->PUBLIC_KEY);
Braintree_Configuration::privateKey($this->PRIVATE_KEY);
}
function __construct()
{
$braintree = (include 'config/braintree.php');
Braintree_Configuration::environment($braintree['environment']);
Braintree_Configuration::merchantId($braintree['merchantId']);
Braintree_Configuration::publicKey($braintree['publicKey']);
Braintree_Configuration::privateKey($braintree['privateKey']);
}
/**
* @expectedException Braintree_Exception_Configuration
* @expectedExceptionMessage merchantId needs to be set.
*/
function testConfigGetsAssertedValid()
{
Braintree_Configuration::environment('development');
//Braintree_Configuration::merchantId('integration_merchant_id');
Braintree_Configuration::publicKey('integration_public_key');
Braintree_Configuration::privateKey('integration_private_key');
new Braintree_Gateway(Braintree_Configuration::$global);
}
/**
* Create a new Stripe gateway instance.
*
* @param \Laravel\Cashier\Contracts\Billable $billable
* @param string|null $plan
* @return void
*/
public function __construct(BillableContract $billable, $plan = null)
{
$this->plan = $plan;
$this->billable = $billable;
Braintree::environment($this->getBraintreeEnvironment());
Braintree::merchantId($this->getBraintreeMerchantId());
Braintree::publicKey($this->getBraintreePublicKey());
Braintree::privateKey($this->getBraintreePrivateKey());
}
/**
* Constructor method to call the main braintree php api
* & set the configuration there
*
* included since v1.0
*
* @param $config
*/
public function __construct($config)
{
//Including main braintree library for connection
//braintree configuration
Braintree_Configuration::environment($config['environment']);
Braintree_Configuration::merchantId($config['merchantId']);
Braintree_Configuration::publicKey($config['publicKey']);
Braintree_Configuration::privateKey($config['privateKey']);
}
public function __construct()
{
$this->ci =& get_instance();
$this->input = $this->ci->input;
Braintree_Configuration::environment("sandbox");
Braintree_Configuration::merchantId("yv7v3d5f833vjkp2");
Braintree_Configuration::publicKey("chg92p6xsjrx4nhj");
Braintree_Configuration::privateKey("da8986a0ea0ffa58ef149c5f101faee5");
}
private static function _matchingSignature($signaturePairs)
{
foreach ($signaturePairs as $pair) {
$components = preg_split("/\\|/", $pair);
if ($components[0] == Braintree_Configuration::publicKey()) {
return $components[1];
}
}
return null;
}
public function __construct()
{
$this->ci =& get_instance();
$this->config = $this->ci->config->item('payment');
$btCfg = $this->ci->config->item('braintree');
Braintree_Configuration::environment($btCfg['enviroment']);
Braintree_Configuration::merchantId($btCfg['merchantID']);
Braintree_Configuration::publicKey($btCfg['publicKey']);
Braintree_Configuration::privateKey($btCfg['privateKey']);
}
public function createBraintreeDriver()
{
$config = $this->_cfg('provider_config')['braintree'];
$test = $this->_cfg('test');
\Braintree_Configuration::environment($test ? 'sandbox' : 'production');
\Braintree_Configuration::merchantId($config['merchant_id']);
\Braintree_Configuration::publicKey($config['public_key']);
\Braintree_Configuration::privateKey($config['private_key']);
return new BraintreePaymentProvider($config, $test, $this->app['log']->getMonolog(), $this->auditLogger);
}
function testParsingWebhookWithWrongKeysRaisesError()
{
$sampleNotification = Braintree_WebhookTesting::sampleNotification(Braintree_WebhookNotification::SUBSCRIPTION_WENT_PAST_DUE, 'my_id');
Braintree_Configuration::environment('development');
Braintree_Configuration::merchantId('integration_merchant_id');
Braintree_Configuration::publicKey('wrong_public_key');
Braintree_Configuration::privateKey('wrong_private_key');
$this->setExpectedException('Braintree_Exception_InvalidSignature', 'no matching public key');
$webhookNotification = Braintree_WebhookNotification::parse($sampleNotification['bt_signature'], "bad" . $sampleNotification['bt_payload']);
}
function setUp()
{
echo __METHOD__ . '()' . PHP_EOL;
$config = (include getenv("CONFIG_path") . "payment.php");
$braintreeConfig = $config['provider_config']['braintree'];
\Braintree_Configuration::environment('sandbox');
\Braintree_Configuration::merchantId($braintreeConfig['merchant_id']);
\Braintree_Configuration::publicKey($braintreeConfig['public_key']);
\Braintree_Configuration::privateKey($braintreeConfig['private_key']);
$this->provider = new BraintreePaymentProvider($braintreeConfig, true, $this);
}
/**
* @param $config
* @param $isTest
*
* @return mixed|void
*/
public function setConfig($config, $isTest)
{
if ($isTest == true) {
\Braintree_Configuration::environment('sandbox');
} else {
\Braintree_Configuration::environment('production');
}
\Braintree_Configuration::merchantId($config['merchantId']);
\Braintree_Configuration::publicKey($config['publicKey']);
\Braintree_Configuration::privateKey($config['privateKey']);
}
/**
* The Constructor Function
*/
public function __construct($config)
{
Payment_Utility::load('file', 'vendor/braintree/lib/Braintree');
$bt_mode = $config['mode'] == 'test' ? 'sandbox' : 'production';
Braintree_Configuration::environment($bt_mode);
unset($config['mode']);
foreach ($config as $k => $v) {
//merchantId, publicKey, privateKey need to be set
Braintree_Configuration::$k($v);
}
}
function __construct()
{
include 'addons/braintree/Braintree.php';
$this->CI =& get_instance();
$this->CI->load->model('transaction');
// Braintree settings
Braintree_Configuration::environment('sandbox');
Braintree_Configuration::merchantId('YOUR_MERCHANT_ID');
Braintree_Configuration::publicKey('YOUR_PUBLIC_KEY');
Braintree_Configuration::privateKey('YOUR_PRIVATE_KEY');
}
/**
* Constructor
*
* @param string $mode the mode of operation: live or test
*
* @return void
*/
function __construct($mode, &$paymentProcessor)
{
$this->_mode = $mode;
$this->_paymentProcessor = $paymentProcessor;
$this->_processorName = ts('Braintree');
$environment = $mode == "test" ? 'sandbox' : 'sandbox';
Braintree_Configuration::environment($environment);
Braintree_Configuration::merchantId($paymentProcessor["user_name"]);
Braintree_Configuration::publicKey($paymentProcessor["password"]);
Braintree_Configuration::privateKey($paymentProcessor["signature"]);
}
function __construct()
{
include 'lib/Braintree.php';
$this->CI =& get_instance();
$this->transaction_cost = 10.0;
//$this->CI->load->model('transaction');
// Braintree settings
Braintree_Configuration::environment('sandbox');
Braintree_Configuration::merchantId('y7drg3qfz5csnm6p');
Braintree_Configuration::publicKey('f5ng46jp79rt95mg');
Braintree_Configuration::privateKey('a0bc06bf7aa3dd851764b95c218ef929');
}
function testSandboxSSL()
{
try {
Braintree_Configuration::environment('sandbox');
$this->setExpectedException('Braintree_Exception_Authentication');
Braintree_Http::get('/');
} catch (Exception $e) {
Braintree_Configuration::environment('development');
throw $e;
}
Braintree_Configuration::environment('development');
}
/**
* connect.
* --------------------------------------------------
* Connecting the user with our stored credentials.
* @throws BraintreeNotConnected
* --------------------------------------------------
*/
public function connect()
{
/* Check valid connection */
if (!$this->user->isBraintreeConnected()) {
throw new BraintreeNotConnected();
}
$credentials = json_decode($this->user->connections()->where('service', 'braintree')->first()->access_token);
Braintree_Configuration::environment($credentials['environment']);
Braintree_Configuration::merchantId($credentials['merchantID']);
Braintree_Configuration::publicKey($credentials['publicKey']);
Braintree_Configuration::privateKey($credentials['privateKey']);
}
