mirror of
https://github.com/invoiceninja/invoiceninja.git
synced 2024-11-10 21:22:58 +01:00
494 lines
15 KiB
PHP
494 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* Invoice Ninja (https://invoiceninja.com)
|
|
*
|
|
* @link https://github.com/invoiceninja/invoiceninja source repository
|
|
*
|
|
* @copyright Copyright (c) 2020. Invoice Ninja LLC (https://invoiceninja.com)
|
|
*
|
|
* @license https://opensource.org/licenses/AAL
|
|
*/
|
|
|
|
namespace App\PaymentDrivers;
|
|
|
|
use App\Events\Payment\PaymentWasCreated;
|
|
use App\Factory\PaymentFactory;
|
|
use App\Jobs\Mail\PaymentFailureMailer;
|
|
use App\Jobs\Util\SystemLogger;
|
|
use App\Models\ClientGatewayToken;
|
|
use App\Models\GatewayType;
|
|
use App\Models\Invoice;
|
|
use App\Models\Payment;
|
|
use App\Models\PaymentType;
|
|
use App\Models\SystemLog;
|
|
use App\Utils\Traits\MakesHash;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Carbon;
|
|
use Stripe\PaymentIntent;
|
|
use Stripe\SetupIntent;
|
|
use Stripe\Stripe;
|
|
|
|
class StripePaymentDriver extends BasePaymentDriver
|
|
{
|
|
use MakesHash;
|
|
|
|
protected $refundable = true;
|
|
|
|
protected $token_billing = true;
|
|
|
|
protected $can_authorise_credit_card = true;
|
|
|
|
protected $customer_reference = 'customerReferenceParam';
|
|
|
|
protected $payment_method;
|
|
|
|
/**
|
|
* Methods in this class are divided into
|
|
* two separate streams
|
|
*
|
|
* 1. Omnipay Specific
|
|
* 2. Stripe Specific
|
|
*
|
|
* Our Stripe integration is deeper than
|
|
* other gateways and therefore
|
|
* relies on direct calls to the API
|
|
*/
|
|
/************************************** Stripe API methods **********************************************************/
|
|
|
|
/**
|
|
* Initializes the Stripe API
|
|
* @return void
|
|
*/
|
|
public function init() :void
|
|
{
|
|
Stripe::setApiKey($this->company_gateway->getConfigField('apiKey'));
|
|
}
|
|
|
|
/**
|
|
* Return payment method type.
|
|
*
|
|
* @param string $method
|
|
* @return $this
|
|
*/
|
|
public function setPaymentMethod(string $method)
|
|
{
|
|
// Example: setPaymentMethod('App\\PaymentDrivers\\Stripe\\CreditCard');
|
|
|
|
$this->payment_method = new $method($this);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns the gateway types
|
|
*/
|
|
public function gatewayTypes() :array
|
|
{
|
|
$types = [
|
|
GatewayType::CREDIT_CARD,
|
|
//GatewayType::TOKEN,
|
|
];
|
|
|
|
if ($this->company_gateway->getSofortEnabled() && $this->invitation && $this->client() && isset($this->client()->country) && in_array($this->client()->country, ['AUT', 'BEL', 'DEU', 'ITA', 'NLD', 'ESP'])) {
|
|
$types[] = GatewayType::SOFORT;
|
|
}
|
|
|
|
if ($this->company_gateway->getAchEnabled()) {
|
|
$types[] = GatewayType::BANK_TRANSFER;
|
|
}
|
|
|
|
if ($this->company_gateway->getSepaEnabled()) {
|
|
$types[] = GatewayType::SEPA;
|
|
}
|
|
|
|
if ($this->company_gateway->getBitcoinEnabled()) {
|
|
$types[] = GatewayType::CRYPTO;
|
|
}
|
|
|
|
if ($this->company_gateway->getAlipayEnabled()) {
|
|
$types[] = GatewayType::ALIPAY;
|
|
}
|
|
|
|
if ($this->company_gateway->getApplePayEnabled()) {
|
|
$types[] = GatewayType::APPLE_PAY;
|
|
}
|
|
|
|
|
|
return $types;
|
|
}
|
|
|
|
public function viewForType($gateway_type_id)
|
|
{
|
|
switch ($gateway_type_id) {
|
|
case GatewayType::CREDIT_CARD:
|
|
case GatewayType::TOKEN:
|
|
return 'gateways.stripe.credit_card';
|
|
break;
|
|
case GatewayType::SOFORT:
|
|
return 'gateways.stripe.sofort';
|
|
break;
|
|
case GatewayType::BANK_TRANSFER:
|
|
return 'gateways.stripe.ach';
|
|
break;
|
|
case GatewayType::SEPA:
|
|
return 'gateways.stripe.sepa';
|
|
break;
|
|
case GatewayType::CRYPTO:
|
|
case GatewayType::ALIPAY:
|
|
case GatewayType::APPLE_PAY:
|
|
return 'gateways.stripe.other';
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Proxy method to pass the data into payment method authorizeView().
|
|
*
|
|
* @param array $data
|
|
*
|
|
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
|
|
*/
|
|
public function authorizeView(array $data)
|
|
{
|
|
return $this->payment_method->authorizeView($data);
|
|
}
|
|
|
|
/**
|
|
* Processes the gateway response for credit card authorization.
|
|
*
|
|
* @param Request $request The returning request object
|
|
* @return view Returns the user to payment methods screen.
|
|
* @throws \Stripe\Exception\ApiErrorException
|
|
*/
|
|
public function authorizeCreditCardResponse($request)
|
|
{
|
|
return $this->payment_method->authorizeResponse($request);
|
|
}
|
|
|
|
/**
|
|
* Process the payment with gateway.
|
|
*
|
|
* @param array $data
|
|
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View|void
|
|
* @throws \Exception
|
|
*/
|
|
public function processPaymentView(array $data)
|
|
{
|
|
$payment_intent_data = [
|
|
'amount' => $this->convertToStripeAmount($data['amount_with_fee'], $this->client->currency()->precision),
|
|
'currency' => $this->client->getCurrencyCode(),
|
|
'customer' => $this->findOrCreateCustomer(),
|
|
'description' => $data['invoices']->pluck('id'), //todo more meaningful description here:
|
|
];
|
|
|
|
if ($data['token']) {
|
|
$payment_intent_data['payment_method'] = $data['token']->token;
|
|
} else {
|
|
$payment_intent_data['setup_future_usage'] = 'off_session';
|
|
// $payment_intent_data['save_payment_method'] = true;
|
|
// $payment_intent_data['confirm'] = true;
|
|
}
|
|
|
|
|
|
$data['intent'] = $this->createPaymentIntent($payment_intent_data);
|
|
|
|
$data['gateway'] = $this;
|
|
|
|
return render($this->viewForType($data['payment_method_id']), $data);
|
|
}
|
|
|
|
/**
|
|
* Payment Intent Reponse looks like this
|
|
+"id": "pi_1FMR7JKmol8YQE9DuC4zMeN3"
|
|
+"object": "payment_intent"
|
|
+"allowed_source_types": array:1 [▼
|
|
0 => "card"
|
|
]
|
|
+"amount": 2372484
|
|
+"canceled_at": null
|
|
+"cancellation_reason": null
|
|
+"capture_method": "automatic"
|
|
+"client_secret": "pi_1FMR7JKmol8YQE9DuC4zMeN3_secret_J3yseWJG6uV0MmsrAT1FlUklV"
|
|
+"confirmation_method": "automatic"
|
|
+"created": 1569381877
|
|
+"->currency()": "usd"
|
|
+"description": "[3]"
|
|
+"last_payment_error": null
|
|
+"livemode": false
|
|
+"next_action": null
|
|
+"next_source_action": null
|
|
+"payment_method": "pm_1FMR7ZKmol8YQE9DQWqPuyke"
|
|
+"payment_method_types": array:1 [▶]
|
|
+"receipt_email": null
|
|
+"setup_future_usage": "off_session"
|
|
+"shipping": null
|
|
+"source": null
|
|
+"status": "succeeded"
|
|
*/
|
|
public function processPaymentResponse($request) //We never have to worry about unsuccessful payments as failures are handled at the front end for this driver.
|
|
{
|
|
$server_response = json_decode($request->input('gateway_response'));
|
|
|
|
$payment_method = $server_response->payment_method;
|
|
$payment_status = $server_response->status;
|
|
$save_card = $request->input('store_card');
|
|
|
|
$gateway_type_id = $request->input('payment_method_id');
|
|
$hashed_ids = $request->input('hashed_ids');
|
|
$invoices = Invoice::whereIn('id', $this->transformKeys($hashed_ids))
|
|
->whereClientId($this->client->id)
|
|
->get();
|
|
/**
|
|
* Potential statuses that can be returned
|
|
*
|
|
* requires_action
|
|
* processing
|
|
* canceled
|
|
* requires_action
|
|
* requires_confirmation
|
|
* requires_payment_method
|
|
*
|
|
*/
|
|
|
|
if ($this->getContact()) {
|
|
$client_contact = $this->getContact();
|
|
} else {
|
|
$client_contact = $invoices->first()->invitations->first()->contact;
|
|
}
|
|
|
|
$this->init();
|
|
$payment_intent = \Stripe\PaymentIntent::retrieve($server_response->id);
|
|
$customer = $payment_intent->customer;
|
|
|
|
if ($payment_status == 'succeeded') {
|
|
|
|
$charge_id = $payment_intent->charges->data[0]->id;
|
|
|
|
$this->init();
|
|
$stripe_payment_method = \Stripe\PaymentMethod::retrieve($payment_method);
|
|
$stripe_payment_method_obj = $stripe_payment_method->jsonSerialize();
|
|
|
|
$payment_meta = new \stdClass;
|
|
|
|
if ($stripe_payment_method_obj['type'] == 'card') {
|
|
$payment_meta->exp_month = $stripe_payment_method_obj['card']['exp_month'];
|
|
$payment_meta->exp_year = $stripe_payment_method_obj['card']['exp_year'];
|
|
$payment_meta->brand = $stripe_payment_method_obj['card']['brand'];
|
|
$payment_meta->last4 = $stripe_payment_method_obj['card']['last4'];
|
|
$payment_meta->type = $stripe_payment_method_obj['type'];
|
|
|
|
$payment_type = PaymentType::parseCardType($stripe_payment_method_obj['card']['brand']);
|
|
}
|
|
|
|
if ($save_card == 'true') {
|
|
$stripe_payment_method->attach(['customer' => $customer]);
|
|
|
|
$cgt = new ClientGatewayToken;
|
|
$cgt->company_id = $this->client->company->id;
|
|
$cgt->client_id = $this->client->id;
|
|
$cgt->token = $payment_method;
|
|
$cgt->company_gateway_id = $this->company_gateway->id;
|
|
$cgt->gateway_type_id = $gateway_type_id;
|
|
$cgt->gateway_customer_reference = $customer;
|
|
$cgt->meta = $payment_meta;
|
|
$cgt->save();
|
|
|
|
if ($this->client->gateway_tokens->count() == 1) {
|
|
$this->client->gateway_tokens()->update(['is_default'=>0]);
|
|
|
|
$cgt->is_default = 1;
|
|
$cgt->save();
|
|
}
|
|
}
|
|
|
|
//todo need to fix this to support payment types other than credit card.... sepa etc etc
|
|
if (!$payment_type) {
|
|
$payment_type = PaymentType::CREDIT_CARD_OTHER;
|
|
}
|
|
|
|
|
|
$data = [
|
|
'payment_method' => $charge_id,
|
|
'payment_type' => $payment_type,
|
|
'amount' => $server_response->amount,
|
|
];
|
|
|
|
/* Create payment*/
|
|
$payment = $this->createPayment($data);
|
|
|
|
/* Link invoices to payment*/
|
|
$this->attachInvoices($payment, $hashed_ids);
|
|
|
|
$payment->service()->UpdateInvoicePayment();
|
|
|
|
event(new PaymentWasCreated($payment, $payment->company));
|
|
|
|
SystemLogger::dispatch(
|
|
[
|
|
'server_response' => $payment_intent,
|
|
'data' => $data
|
|
],
|
|
SystemLog::CATEGORY_GATEWAY_RESPONSE,
|
|
SystemLog::EVENT_GATEWAY_SUCCESS,
|
|
SystemLog::TYPE_STRIPE,
|
|
$this->client
|
|
);
|
|
|
|
return redirect()->route('client.payments.show', ['payment' => $this->encodePrimaryKey($payment->id)]);
|
|
} else {
|
|
|
|
PaymentFailureMailer::dispatch($this->client, $server_response->cancellation_reason, $this->client->company, $server_response->amount);
|
|
|
|
/*Fail and log*/
|
|
SystemLogger::dispatch(
|
|
[
|
|
'server_response' => $server_response,
|
|
'data' => $data
|
|
],
|
|
SystemLog::CATEGORY_GATEWAY_RESPONSE,
|
|
SystemLog::EVENT_GATEWAY_FAILURE,
|
|
SystemLog::TYPE_STRIPE,
|
|
$this->client
|
|
);
|
|
|
|
throw new \Exception("Failed to process payment", 1);
|
|
}
|
|
}
|
|
|
|
public function createPayment($data) :Payment
|
|
{
|
|
$payment = parent::createPayment($data);
|
|
|
|
$client_contact = $this->getContact();
|
|
$client_contact_id = $client_contact ? $client_contact->id : null;
|
|
|
|
$payment->amount = $this->convertFromStripeAmount($data['amount'], $this->client->currency()->precision);
|
|
$payment->type_id = $data['payment_type'];
|
|
$payment->transaction_reference = $data['payment_method'];
|
|
$payment->client_contact_id = $client_contact_id;
|
|
$payment->save();
|
|
|
|
return $payment;
|
|
}
|
|
|
|
public function convertFromStripeAmount($amount, $precision)
|
|
{
|
|
return $amount / pow(10, $precision);
|
|
}
|
|
|
|
public function convertToStripeAmount($amount, $precision)
|
|
{
|
|
return $amount * pow(10, $precision);
|
|
}
|
|
/**
|
|
* Creates a new String Payment Intent
|
|
*
|
|
* @param array $data The data array to be passed to Stripe
|
|
* @return PaymentIntent The Stripe payment intent object
|
|
*/
|
|
public function createPaymentIntent($data) :?\Stripe\PaymentIntent
|
|
{
|
|
$this->init();
|
|
|
|
return PaymentIntent::create($data);
|
|
}
|
|
|
|
/**
|
|
* Returns a setup intent that allows the user
|
|
* to enter card details without initiating a transaction.
|
|
*
|
|
* @return \Stripe\SetupIntent
|
|
*/
|
|
public function getSetupIntent() :\Stripe\SetupIntent
|
|
{
|
|
$this->init();
|
|
|
|
return SetupIntent::create();
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the Stripe publishable key
|
|
* @return NULL|string The stripe publishable key
|
|
*/
|
|
public function getPublishableKey() :?string
|
|
{
|
|
return $this->company_gateway->getPublishableKey();
|
|
}
|
|
|
|
/**
|
|
* Finds or creates a Stripe Customer object
|
|
*
|
|
* @return NULL|\Stripe\Customer A Stripe customer object
|
|
*/
|
|
public function findOrCreateCustomer() :?\Stripe\Customer
|
|
{
|
|
$customer = null;
|
|
|
|
$this->init();
|
|
|
|
$client_gateway_token = ClientGatewayToken::whereClientId($this->client->id)->whereCompanyGatewayId($this->company_gateway->id)->first();
|
|
|
|
if ($client_gateway_token && $client_gateway_token->gateway_customer_reference) {
|
|
$customer = \Stripe\Customer::retrieve($client_gateway_token->gateway_customer_reference);
|
|
} else {
|
|
$data['name'] = $this->client->present()->name();
|
|
$data['phone'] = $this->client->present()->phone();
|
|
|
|
if (filter_var($this->client->present()->email(), FILTER_VALIDATE_EMAIL)) {
|
|
$data['email'] = $this->client->present()->email();
|
|
}
|
|
|
|
$customer = \Stripe\Customer::create($data);
|
|
}
|
|
|
|
if (!$customer) {
|
|
throw new \Exception('Unable to create gateway customer');
|
|
}
|
|
|
|
return $customer;
|
|
}
|
|
|
|
public function refund(Payment $payment, $amount)
|
|
{
|
|
$this->gateway();
|
|
|
|
$response = $this->gateway
|
|
->refund(['transactionReference'=>$payment->transaction_reference, 'amount' => $amount, 'currency' => $payment->client->getCurrencyCode()])
|
|
->send();
|
|
|
|
if ($response->isSuccessful()) {
|
|
SystemLogger::dispatch(
|
|
[
|
|
'server_response' => $response->getMessage(),
|
|
'data' => request()->all(),
|
|
],
|
|
SystemLog::CATEGORY_GATEWAY_RESPONSE,
|
|
SystemLog::EVENT_GATEWAY_SUCCESS,
|
|
SystemLog::TYPE_PAYPAL,
|
|
$this->client
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
SystemLogger::dispatch(
|
|
[
|
|
'server_response' => $response->getMessage(),
|
|
'data' => request()->all(),
|
|
],
|
|
SystemLog::CATEGORY_GATEWAY_RESPONSE,
|
|
SystemLog::EVENT_GATEWAY_FAILURE,
|
|
SystemLog::TYPE_PAYPAL,
|
|
$this->client
|
|
);
|
|
|
|
return false;
|
|
}
|
|
|
|
/************************************** Omnipay API methods **********************************************************/
|
|
}
|