Server : Apache System : Linux server2.corals.io 4.18.0-348.2.1.el8_5.x86_64 #1 SMP Mon Nov 15 09:17:08 EST 2021 x86_64 User : corals ( 1002) PHP Version : 7.4.33 Disable Function : exec,passthru,shell_exec,system Directory : /home/corals/job-board.corals.io/Corals/modules/Payment/PayPal/ |
<?php
/**
* PayPal Pro Class using REST API
*/
namespace Corals\Modules\Payment\PayPal;
use Corals\Modules\Ecommerce\Models\Order;
use Corals\Modules\Payment\Common\AbstractGateway;
use Corals\Modules\Payment\Common\Models\WebhookCall;
use Corals\Modules\Subscriptions\Models\Subscription;
use Corals\Modules\Subscriptions\Models\Plan;
use Corals\User\Models\User;
use Illuminate\Http\Request;
/**
* PayPal Pro Class using REST API
*
* This class forms the gateway class for PayPal REST requests via the PayPal REST APIs.
*
* The PayPal API uses HTTP verbs and a RESTful endpoint structure. OAuth 2.0 is used
* as the API Authorization framework. Request and response payloads are formatted as JSON.
*
* The PayPal REST APIs are supported in two environments. Use the Sandbox environment
* for testing purposes, then move to the live environment for production processing.
* When testing, generate an access token with your test credentials to make calls to
* the Sandbox URIs. When you’re set to go live, use the live credentials assigned to
* your app to generate a new access token to be used with the live URIs.
*
* ### Test Mode
*
* In order to use this for testing in sandbox mode you will need at least two sandbox
* test accounts. One will need to be a business account, and one will need to be a
* personal account with credit card details. To create these you will need to go to
* the sandbox accounts section of the PayPal developer dashboard, here:
* https://developer.paypal.com/webapps/developer/applications/accounts
* On that page click "Create Account" and follow the prompts. When you are creating the
* Personal account, ensure that it is created with a credit card -- either Visa or
* MasterCard or one of the other types. When you are testing in the sandbox, use the
* credit card details you will receive for this Personal account rather than any other
* commonly used test credit card numbers (e.g. visa card 4111111111111111 or 4444333322221111
* both of which will result in Error 500 / INTERNAL_SERVICE_ERROR type errors from the
* PayPal gateway).
*
* With each API call, you’ll need to set request headers, including an OAuth 2.0
* access token. Get an access token by using the OAuth 2.0 client_credentials token
* grant type with your clientId:secret as your Basic Auth credentials. For more
* information, see Make your first call (link). This class sets all of the headers
* associated with the API call for you, including making preliminary calls to create
* or update the OAuth 2.0 access token before each call you make, if required. All
* you need to do is provide the clientId and secret when you initialize the gateway,
* or use the set*() calls to set them after creating the gateway object.
*
* ### Credentials
*
* To create production and sandbox credentials for your PayPal account:
*
* * Log into your PayPal account.
* * Navigate to your Sandbox accounts at https://developer.paypal.com/webapps/developer/applications/accounts
* to ensure that you have a valid sandbox account to use for testing. If you don't already have a sandbox
* account, one can be created on this page. You will actually need 2 accounts, a personal account and a
* business account, the business account is the one you need to use for creating API applications.
* * Check your account status on https://developer.paypal.com/webapps/developer/account/status to ensure
* that it is valid for live transactions.
* * Navigate to the My REST apps page: https://developer.paypal.com/webapps/developer/applications/myapps
* * Click *Create App*
* * On the next page, enter an App name and select the sandbox account to use, then click *Create app*.
* * On the next page the sandbox account, endpoint, Client ID and Secret should be displayed.
* Record these. The Sandbox account should match the one that you selected on the previous
* page, and the sandbox endpoint should be ai.sandbox.paypal.com
* * Adjacent to *Live credentials* click *Show* to display your live credentials. The endpoint
* for these should be api.paypal.com, there should also be a Client ID and Secret.
*
* You can create additional REST APIs apps for other websites -- because the webhooks are
* stored per app then it pays to have one API app per website that you are using (and an
* additional one for things like command line testing, etc).
*
* ### Example
*
* #### Initialize Gateway
*
* <code>
* // Create a gateway for the PayPal RestGateway
* // (routes to GatewayFactory::create)
* $gateway = Payment::create('PayPal_Rest');
*
* // Initialise the gateway
* $gateway->initialize(array(
* 'clientId' => 'MyPayPalClientId',
* 'secret' => 'MyPayPalSecret',
* 'testMode' => true, // Or false when you are ready for live transactions
* ));
* </code>
*
* #### Direct Credit Card Payment
*
* <code>
* // Create a credit card object
* // DO NOT USE THESE CARD VALUES -- substitute your own
* // see the documentation in the class header.
* $card = new CreditCard(array(
* 'firstName' => 'Example',
* 'lastName' => 'User',
* 'number' => '4111111111111111',
* 'expiryMonth' => '01',
* 'expiryYear' => '2020',
* 'cvv' => '123',
* 'billingAddress1' => '1 Scrubby Creek Road',
* 'billingCountry' => 'AU',
* 'billingCity' => 'Scrubby Creek',
* 'billingPostcode' => '4999',
* 'billingState' => 'QLD',
* ));
*
* // Do a purchase transaction on the gateway
* try {
* $transaction = $gateway->purchase(array(
* 'amount' => '10.00',
* 'currency' => 'AUD',
* 'description' => 'This is a test purchase transaction.',
* 'card' => $card,
* ));
* $response = $transaction->send();
* $data = $response->getData();
* echo "Gateway purchase response data == " . print_r($data, true) . "\n";
*
* if ($response->isSuccessful()) {
* echo "Purchase transaction was successful!\n";
* }
* } catch (\Exception $e) {
* echo "Exception caught while attempting authorize.\n";
* echo "Exception type == " . get_class($e) . "\n";
* echo "Message == " . $e->getMessage() . "\n";
* }
* </code>
*
* ### Dashboard
*
* Once you have processed some payments you can go to the PayPal sandbox site,
* at https://www.sandbox.paypal.com/ and log in with the email address and password
* of your PayPal sandbox business test account. You will then see the result
* of those transactions on the "My recent activity" list under the My Account
* tab.
*
* @link https://developer.paypal.com/docs/api/
* @link https://devtools-paypal.com/integrationwizard/
* @link http://paypal.github.io/sdk/
* @link https://developer.paypal.com/docs/integration/direct/rest_api_payment_country_currency_support/
* @link https://developer.paypal.com/docs/faq/
* @link https://developer.paypal.com/docs/integration/direct/make-your-first-call/
* @link https://developer.paypal.com/docs/integration/web/accept-paypal-payment/
* @link https://developer.paypal.com/docs/api/#authentication--headers
* @see \Corals\Modules\Payment\PayPal\Message\AbstractRestRequest
*/
class RestGateway extends AbstractGateway
{
// Constants used in plan creation
const BILLING_PLAN_TYPE_FIXED = 'FIXED';
const BILLING_PLAN_TYPE_INFINITE = 'INFINITE';
const BILLING_PLAN_FREQUENCY_DAY = 'DAY';
const BILLING_PLAN_FREQUENCY_WEEK = 'WEEK';
const BILLING_PLAN_FREQUENCY_MONTH = 'MONTH';
const BILLING_PLAN_FREQUENCY_YEAR = 'YEAR';
const BILLING_PLAN_STATE_CREATED = 'CREATED';
const BILLING_PLAN_STATE_ACTIVE = 'ACTIVE';
const BILLING_PLAN_STATE_INACTIVE = 'INACTIVE';
const BILLING_PLAN_STATE_DELETED = 'DELETED';
const PAYMENT_TRIAL = 'TRIAL';
const PAYMENT_REGULAR = 'REGULAR';
public function getName()
{
return 'PayPal_Rest';
}
public function getDefaultParameters()
{
return array(
'clientId' => '',
'secret' => '',
'token' => '',
'testMode' => false,
);
}
//
// Tokens -- methods to set up, store and retrieve the OAuth 2.0 access token.
//
// @link https://developer.paypal.com/docs/api/#authentication--headers
//
/**
* Get OAuth 2.0 client ID for the access token.
*
* Get an access token by using the OAuth 2.0 client_credentials
* token grant type with your clientId:secret as your Basic Auth
* credentials.
*
* @return string
*/
public function getClientId()
{
return $this->getParameter('clientId');
}
/**
* Set OAuth 2.0 client ID for the access token.
*
* Get an access token by using the OAuth 2.0 client_credentials
* token grant type with your clientId:secret as your Basic Auth
* credentials.
*
* @param string $value
* @return RestGateway provides a fluent interface
*/
public function setClientId($value)
{
return $this->setParameter('clientId', $value);
}
/**
* Get OAuth 2.0 secret for the access token.
*
* Get an access token by using the OAuth 2.0 client_credentials
* token grant type with your clientId:secret as your Basic Auth
* credentials.
*
* @return string
*/
public function getSecret()
{
return $this->getParameter('secret');
}
/**
* Set OAuth 2.0 secret for the access token.
*
* Get an access token by using the OAuth 2.0 client_credentials
* token grant type with your clientId:secret as your Basic Auth
* credentials.
*
* @param string $value
* @return RestGateway provides a fluent interface
*/
public function setSecret($value)
{
return $this->setParameter('secret', $value);
}
/**
* Get OAuth 2.0 access token.
*
* @param bool $createIfNeeded [optional] - If there is not an active token present, should we create one?
* @return string
*/
public function getToken($createIfNeeded = true)
{
if ($createIfNeeded && !$this->hasToken()) {
$response = $this->createToken()->send();
if ($response->isSuccessful()) {
$data = $response->getData();
if (isset($data['access_token'])) {
$this->setToken($data['access_token']);
$this->setTokenExpires(time() + $data['expires_in']);
if ($this->getTestMode()) {
\Settings::set('payment_paypal_rest_sandbox_access_token', $data['access_token'], 'Payment');
\Settings::set('payment_paypal_rest_sandbox_access_token_expiry', time() + $data['expires_in'], 'Payment');
} else {
\Settings::set('payment_paypal_rest_live_access_token', $data['access_token'], 'Payment');
\Settings::set('payment_paypal_rest_live_access_token_expiry', time() + $data['expires_in'], 'Payment');
}
}
}
}
return $this->getParameter('token');
}
/**
* Create OAuth 2.0 access token request.
*
* @return \Corals\Modules\Payment\PayPal\Message\RestTokenRequest
*/
public function createToken()
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestTokenRequest', array());
}
/**
* Set OAuth 2.0 access token.
*
* @param string $value
* @return RestGateway provides a fluent interface
*/
public function setToken($value)
{
return $this->setParameter('token', $value);
}
/**
* Get OAuth 2.0 access token expiry time.
*
* @return integer
*/
public function getTokenExpires()
{
return $this->getParameter('tokenExpires');
}
/**
* Set OAuth 2.0 access token expiry time.
*
* @param integer $value
* @return RestGateway provides a fluent interface
*/
public function setTokenExpires($value)
{
return $this->setParameter('tokenExpires', $value);
}
/**
* Is there a bearer token and is it still valid?
*
* @return bool
*/
public function hasToken()
{
$token = $this->getParameter('token');
$expires = $this->getTokenExpires();
if (!empty($expires) && !is_numeric($expires)) {
$expires = strtotime($expires);
}
return !empty($token) && time() < $expires;
}
/**
* Create Request
*
* This overrides the parent createRequest function ensuring that the OAuth
* 2.0 access token is passed along with the request data -- unless the
* request is a RestTokenRequest in which case no token is needed. If no
* token is available then a new one is created (e.g. if there has been no
* token request or the current token has expired).
*
* @param string $class
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\AbstractRestRequest
*/
public function createRequest($class, array $parameters = array())
{
if (!$this->hasToken() && $class != '\Corals\Modules\Payment\PayPal\Message\RestTokenRequest') {
// This will set the internal token parameter which the parent
// createRequest will find when it calls getParameters().
$this->getToken(true);
}
return parent::createRequest($class, $parameters);
}
//
// Payments -- Create payments or get details of one or more payments.
//
// @link https://developer.paypal.com/docs/api/#payments
//
/**
* Create a purchase request.
*
* PayPal provides various payment related operations using the /payment
* resource and related sub-resources. Use payment for direct credit card
* payments and PayPal account payments. You can also use sub-resources
* to get payment related details.
*
* @link https://developer.paypal.com/docs/api/#create-a-payment
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestPurchaseRequest
*/
public function purchase(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestPurchaseRequest', $parameters);
}
/**
* Fetch a purchase request.
*
* Use this call to get details about payments that have not completed,
* such as payments that are created and approved, or if a payment has failed.
*
* @link https://developer.paypal.com/docs/api/#look-up-a-payment-resource
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestFetchPurchaseRequest
*/
public function fetchPurchase(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestFetchPurchaseRequest', $parameters);
}
/**
* List purchase requests.
*
* Use this call to get a list of payments in any state (created, approved,
* failed, etc.). The payments returned are the payments made to the merchant
* making the call.
*
* @link https://developer.paypal.com/docs/api/#list-payment-resources
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestListPurchaseRequest
*/
public function listPurchase(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestListPurchaseRequest', $parameters);
}
/**
* Completes a purchase request.
*
* @link https://developer.paypal.com/docs/api/#execute-an-approved-paypal-payment
* @param array $parameters
* @return Message\AbstractRestRequest
*/
public function completePurchase(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCompletePurchaseRequest', $parameters);
}
/**
* Completes a purchase request.
*
* @link https://developer.paypal.com/docs/api/#execute-an-approved-paypal-payment
* @param array $parameters
* @return Message\AbstractRestRequest
*/
public function createCharge(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCompletePurchaseRequest', $parameters);
}
// TODO: Update a payment resource https://developer.paypal.com/docs/api/#update-a-payment-resource
//
// Authorizations -- Capture, reauthorize, void and look up authorizations.
//
// @link https://developer.paypal.com/docs/api/#authorizations
// @link https://developer.paypal.com/docs/integration/direct/capture-payment/
//
/**
* Create an authorization request.
*
* To collect payment at a later time, first authorize a payment using the /payment resource.
* You can then capture the payment to complete the sale and collect payment.
*
* @link https://developer.paypal.com/docs/integration/direct/capture-payment/#authorize-the-payment
* @link https://developer.paypal.com/docs/api/#authorizations
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestAuthorizeRequest
*/
public function authorize(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestAuthorizeRequest', $parameters);
}
/**
* Void an authorization.
*
* To to void a previously authorized payment.
*
* @link https://developer.paypal.com/docs/api/#void-an-authorization
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestVoidRequest
*/
public function void(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestVoidRequest', $parameters);
}
/**
* Capture an authorization.
*
* Use this resource to capture and process a previously created authorization.
* To use this resource, the original payment call must have the intent set to
* authorize.
*
* @link https://developer.paypal.com/docs/api/#capture-an-authorization
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestCaptureRequest
*/
public function capture(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCaptureRequest', $parameters);
}
// TODO: Authorizations with payment_method == paypal.
/**
* Refund a Captured Payment
*
* To refund captured payments (authorization transaction) created by a authorize request.
*
* @link https://developer.paypal.com/docs/api/#refund-a-captured-payment
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestRefundCaptureRequest
*/
public function refundCapture(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestRefundCaptureRequest', $parameters);
}
//
// Sale Transactions -- Get and refund completed payments (sale transactions).
// @link https://developer.paypal.com/docs/api/#sale-transactions
//
/**
* Fetch a Sale Transaction
*
* To get details about completed payments (sale transaction) created by a payment request
* or to refund a direct sale transaction, PayPal provides the /sale resource and related
* sub-resources.
*
* @link https://developer.paypal.com/docs/api/#sale-transactions
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestFetchTransactionRequest
*/
public function fetchTransaction(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestFetchTransactionRequest', $parameters);
}
/**
* Refund a Sale Transaction
*
* To get details about completed payments (sale transaction) created by a payment request
* or to refund a direct sale transaction, PayPal provides the /sale resource and related
* sub-resources.
*
* @link https://developer.paypal.com/docs/api/#sale-transactions
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestRefundRequest
*/
public function refund(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestRefundRequest', $parameters);
}
//
// Vault: Store customer credit cards securely.
//
// @link https://developer.paypal.com/docs/api/#vault
//
/**
* Store a credit card in the vault
*
* You can currently use the /vault API to store credit card details
* with PayPal instead of storing them on your own server. After storing
* a credit card, you can then pass the credit card id instead of the
* related credit card details to complete a payment.
*
* @link https://developer.paypal.com/docs/api/#store-a-credit-card
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestCreateCardRequest
*/
public function createCard(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCreateCardRequest', $parameters);
}
/**
* Delete a credit card from the vault.
*
* Updating a card in the vault is no longer supported -- see
* http://stackoverflow.com/questions/20858910/paypal-rest-api-update-a-stored-credit-card
* Therefore the only way to update a card is to remove it using deleteCard and
* then re-add it using createCard.
*
* @link https://developer.paypal.com/docs/api/#delete-a-stored-credit-card
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestDeleteCardRequest
*/
public function deleteCard(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestDeleteCardRequest', $parameters);
}
//
// Billing Plans and Agreements -- Set up recurring payments.
// @link https://developer.paypal.com/docs/api/#billing-plans-and-agreements
//
/**
* Create a billing plan.
*
* You can create an empty billing plan and add a trial period and/or regular
* billing. Alternatively, you can create a fully loaded plan that includes
* both a trial period and regular billing. Note: By default, a created billing
* plan is in a CREATED state. A user cannot subscribe to the billing plan
* unless it has been set to the ACTIVE state.
*
* @link https://developer.paypal.com/docs/api/#create-a-plan
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestCreatePlanRequest
*/
public function createPlan(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCreatePlanRequest', $parameters);
}
/**
* Update a billing plan.
*
* You can update the information for an existing billing plan. The state of a plan
* must be active before a billing agreement is created.
*
* @link https://developer.paypal.com/docs/api/#update-a-plan
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestUpdatePlanRequest
*/
public function updatePlan(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestUpdatePlanRequest', $parameters);
}
/**
* DELETE a billing plan.
*
* You can Deactivate the information for an existing billing plan. The state of a plan will be changed to INACTIVE
*
* @link https://developer.paypal.com/docs/api/#update-a-plan
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestUpdatePlanRequest
*/
public function deletePlan(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestUpdatePlanRequest', $parameters);
}
/**
* Activate a billing plan.
*
* You can Activate the information for an existing billing plan. The state of a plan
* must be active before a billing agreement is created.
*
* @link https://developer.paypal.com/docs/api/#update-a-plan
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestUpdatePlanRequest
*/
public function activatePlan(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestUpdatePlanRequest', $parameters);
}
/**
* List billing plans.
*
* Use this call to get a list of plans in any state (CREATED, ACTIVE, etc.).
* The plans returned are the plans made by the merchant making the call.
*
* @link https://developer.paypal.com/docs/api/payments.billing-plans#plan_list
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestListPlanRequest
*/
public function listPlan(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestListPlanRequest', $parameters);
}
/**
* Fetch billing plan details.
*
* Use this call to get a fetch a plan by ID
* Return Plan Object
*
* @link https://developer.paypal.com/docs/api/payments.billing-plans#billing-plans_get
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestListPlanRequest
*/
public function fetchPlan(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestFetchPlanRequest', $parameters);
}
/**
* Create a subscription.
*
* Use this call to create a billing agreement for the buyer.
*
* @link https://developer.paypal.com/docs/api/#create-an-agreement
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestCreateSubscriptionRequest
*/
public function prepareSubscription(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCreateSubscriptionRequest', $parameters);
}
/**
* Complete (execute) a subscription.
*
* Use this call to execute an agreement after the buyer approves it.
*
* @link https://developer.paypal.com/docs/api/#execute-an-agreement
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestCompleteSubscriptionRequest
*/
public function createSubscription(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCompleteSubscriptionRequest', $parameters);
}
/**
* Cancel a subscription.
*
* Use this call to cancel an agreement.
*
* @link https://developer.paypal.com/docs/api/#cancel-an-agreement
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestCancelSubscriptionRequest
*/
public function cancelSubscription(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestCancelSubscriptionRequest', $parameters);
}
/**
* Suspend a subscription.
*
* Use this call to suspend an agreement.
*
* @link https://developer.paypal.com/docs/api/#suspend-an-agreement
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestSuspendSubscriptionRequest
*/
public function suspendSubscription(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestSuspendSubscriptionRequest', $parameters);
}
/**
* Reactivate a suspended subscription.
*
* Use this call to reactivate or un-suspend an agreement.
*
* @link https://developer.paypal.com/docs/api/#reactivate-an-agreement
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestReactivateSubscriptionRequest
*/
public function reactivateSubscription(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestReactivateSubscriptionRequest', $parameters);
}
/**
* Search for transactions.
*
* Use this call to search for the transactions within a billing agreement.
* Note that this is not a generic transaction search function -- for that
* see RestListPurchaseRequest. It only searches for transactions within
* a billing agreement.
*
* This should be used on a regular basis to determine the success / failure
* state of transactions on active billing agreements.
*
* @link https://developer.paypal.com/docs/api/#search-for-transactions
* @param array $parameters
* @return \Corals\Modules\Payment\PayPal\Message\RestCompleteSubscriptionRequest
*/
public function searchTransaction(array $parameters = array())
{
return $this->createRequest('\Corals\Modules\Payment\PayPal\Message\RestSearchTransactionRequest', $parameters);
}
public function setAuthentication()
{
$client_id = '';
$client_secret = '';
$sandbox = \Settings::get('payment_paypal_rest_sandbox_mode', 'true');
if ($sandbox == 'true') {
$sandbox_mode = true;
$client_id = \Settings::get('payment_paypal_rest_sandbox_client_id');
$client_secret = \Settings::get('payment_paypal_rest_sandbox_client_secret');
$access_token = \Settings::get('payment_paypal_rest_sandbox_access_token');
$access_token_expiry = \Settings::get('payment_paypal_rest_sandbox_access_token_expiry');
} else {
$sandbox_mode = false;
$client_id = \Settings::get('payment_paypal_rest_live_client_id');
$client_secret = \Settings::get('payment_paypal_rest_live_client_secret');
$access_token = \Settings::get('payment_paypal_rest_live_access_token');
$access_token_expiry = \Settings::get('payment_paypal_rest_live_access_token_expiry');
}
$this->setClientId($client_id);
$this->setSecret($client_secret);
$this->setTestMode($sandbox_mode);
$this->setToken($access_token);
$this->setTokenExpires($access_token_expiry);
}
public function getApiPublicKey()
{
return $this->getClientId();;
}
public function getPaymentViewName($type = null)
{
return "PayPal::{$type}-checkout";
}
public function preparePlanActivationParameters(Plan $plan)
{
$plan_code = $this->getPlanIntegrationId($plan);
$parameter = [
'state' => 'ACTIVE',
'transactionReference' => $plan_code
];
return $parameter;
}
public function preparePlanParameters(Plan $plan)
{
$paymentDefinitions[] =
[
'name' => $plan->name,
'amount' => ['value' => $plan->price, 'currency' => strtoupper($plan->currency)],
'type' => $this::PAYMENT_REGULAR,
'frequency' => strtoupper($plan->bill_cycle),
'frequency_interval' => $plan->bill_frequency
];
if ($plan->trial_period > 0) {
$paymentDefinitions[] =
[
'name' => $plan->name . " Trial",
'amount' => ['value' => $plan->price, 'currency' => strtoupper($plan->currency)],
'type' => $this::PAYMENT_TRIAL,
'frequency_interval' => $plan->trial_period,
'frequency' => $this::BILLING_PLAN_FREQUENCY_DAY,
'cycles' => '1'
];
}
if ($plan->status == "active") {
$state = "ACTIVE";
} else {
$state = "INACTIVE";
}
$parameter = [
'name' => $plan->name,
'state' => $state,
'description' => $plan->description,
'type' => $this::BILLING_PLAN_TYPE_INFINITE,
'paymentDefinitions' => $paymentDefinitions,
'merchant_preferences' => [
'setup_fee' => [
'value' => 0,
'currency' => strtoupper($plan->currency)
],
'return_url' => 'http://www.return.com',
'cancel_url' => 'http://www.cancel.com',
'auto_bill_amount' => 'YES',
'initial_fail_amount_action' => 'CONTINUE',
'max_fail_attempts' => '3'
]
];
$plan_code = $this->getPlanIntegrationId($plan);
if ($plan_code) {
$parameter['transactionReference'] = $plan_code;
}
return $parameter;
}
public function prepareSubscriptionTokenParameters(Plan $plan)
{
$parameters = [
'name' => $plan->name,
'description' => $plan->description,
'startDate' => new \DateTime('tomorrow'),
'planId' => $this->getPlanIntegrationId($plan),
'payerDetails' => ['payment_method' => 'paypal'],
];
return $parameters;
}
public function preparePaymentTokenParameters($amount, $currency, $description, $params = [])
{
$parameters = [
'amount' => $amount,
'currency' => $currency,
'description' => $description,
'returnUrl' => url('/payment/paypal/return/?txn_id='),
'cancelUrl' => url('/payment/paypal/return/?txn_id='),
];
return $parameters;
}
public function getPlanIntegrationId($plan)
{
$plan_reference = $plan->gatewayStatus()->where('gateway', $this->getName())->first();
if ($plan_reference) {
return $plan_reference->object_reference;
}
return false;
}
public function prepareSubscriptionParameters(Plan $plan, User $user, Subscription $subscription = null, $subscription_data = null)
{
$parameters = ['transactionReference' => session()->get('checkoutToken')];
session()->forget('checkoutToken');
return $parameters;
}
public function prepareSubscriptionCancellationParameters(User $user, Subscription $current_subscription)
{
$parameters = [
'description' => 'Plan Cancellation',
'transactionReference' => $current_subscription->subscription_reference,
];
return $parameters;
}
public static function webhookHandler(Request $request)
{
try {
$webhookCall = null;
$eventPayload = $request->input();
$data = [
'event_name' => 'paypal_rest.' . $eventPayload['event_type'],
'payload' => $eventPayload,
'gateway' => 'PayPal_Rest'
];
$webhookCall = WebhookCall::create($data);
$webhookCall->process();
die();
} catch (\Exception $exception) {
if ($webhookCall) {
$webhookCall->saveException($exception);
}
log_exception($exception, 'Webhooks', 'paypal_rest');
}
}
public function prepareCreateChargeParameters($order, User $user, $checkoutDetails)
{
return [
'transactionReference' => $checkoutDetails['token']['paymentID'],
'payerID' => $checkoutDetails['token']['payerID'],
];
}
public function prepareCreateMultiOrderChargeParameters($orders, User $user, $checkoutDetails)
{
return [
'transactionReference' => $checkoutDetails['token']['paymentID'],
'payerID' => $checkoutDetails['token']['payerID'],
];
}
public function prepareCreateRefundParameters($order, $amount)
{
return [
'amount' => $amount,
'currency' => $order->currency,
'transactionReference' => $order->billing['payment_reference'],
];
}
}