spree_paypal_checkout 0.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2e2d9fa4598b56c85022a9703e132d1addabaa9318fc41199c1ed8eb590dfe2a
+  data.tar.gz: f8e04b13cd445993ad93f30cbea36dbe5a1bfedc1bace9e0e8d0598736ecf89a
+SHA512:
+  metadata.gz: '079a5d90edfc6816fe8100caf2286c1b9d39151b1ac28a6c8985915b93bdd7630f60eaf0fbb897f4af6b4ec4cea92a6f5a84ded4723c35d726ada1c97257f966'
+  data.tar.gz: '09a9f5f86659326ed5b1461d5cec9e1c4cea0ebe8c2f44b025b323556f3da97d0e04aa7a4cf18d1354dd8da09700c8150eb45287b0fe4c8d46cc366bf4a9c0ff'

data/LICENSE.md

@@ -0,0 +1,12 @@
+Copyright (c) 2025 Vendo Connect Inc.
+All rights reserved.
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see [https://www.gnu.org/licenses/](https://www.gnu.org/licenses/).

data/README.md

@@ -0,0 +1,69 @@
+# Spree PayPal Checkout
+
+This is the official PayPal Checkout extension for [Spree Commerce](https://spreecommerce.org).
+
+This PayPal Checkout integration is bundled in the [Spree Starter](https://github.com/spree/spree_starter/) for your development convenience.
+
+Or you could follow the [installation instructions](https://spreecommerce.org/docs/integrations/payments/paypal).
+
+If you like what you see, consider giving this repo a GitHub star :star:
+
+Thank you for supporting Spree open-source :heart:
+
+## Installation
+
+1. Add this extension to your Gemfile with this line:
+
+    ```ruby
+    bundle add spree_paypal_checkout
+    ```
+
+2. Run the install generator
+
+    ```ruby
+    bundle exec rails g spree_paypal_checkout:install
+    ```
+
+3. Restart your server
+
+  If your server was running, restart it so that it can find the assets properly.
+
+## Developing
+
+1. Create a dummy app
+
+    ```bash
+    bundle update
+    bundle exec rake test_app
+    ```
+
+2. Add your new code
+3. Run tests
+
+    ```bash
+    bundle exec rspec
+    ```
+
+When testing your applications integration with this extension you may use it's factories.
+Simply add this require statement to your spec_helper:
+
+```ruby
+require 'spree_paypal_checkout/factories'
+```
+
+## Releasing a new version
+
+```shell
+bundle exec gem bump -p -t
+bundle exec gem release
+```
+
+For more options please see [gem-release README](https://github.com/svenfuchs/gem-release)
+
+## Contributing
+
+If you'd like to contribute, please take a look at the
+[instructions](CONTRIBUTING.md) for installing dependencies and crafting a good
+pull request.
+
+Copyright (c) 2025 Vendo Connect Inc, released under the AGPL-3.0 license

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir['spec/dummy'].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir('../../')
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_paypal_checkout'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/assets/config/spree_paypal_checkout_manifest.js

@@ -0,0 +1,2 @@
+//= link spree_paypal_checkout/application.js
+//= link_tree ../../javascript/spree_paypal_checkout/controllers .js

data/app/controllers/spree/api/v2/storefront/paypal_orders_controller.rb

@@ -0,0 +1,55 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class PaypalOrdersController < ::Spree::Api::V2::BaseController
+          include Spree::Api::V2::Storefront::OrderConcern
+
+          before_action :require_paypal_checkout_gateway
+
+          # POST /api/v2/storefront/paypal_orders
+          def create
+            order_presenter = SpreePaypalCheckout::OrderPresenter.new(spree_current_order)
+
+            paypal_response = paypal_client.orders.create_order(order_presenter.to_json)
+
+            paypal_order = spree_current_order.paypal_checkout_orders.create!(
+              paypal_id: paypal_response.data.id,
+              data: paypal_response.data.as_json,
+              amount: spree_current_order.total,
+              payment_method: current_store.paypal_checkout_gateway
+            )
+
+            render_serialized_payload { serialize_resource(paypal_order) }
+          rescue PaypalServerSdk::ErrorException => e
+            render_error_payload(e.message)
+          end
+
+          # PUT /api/v2/storefront/paypal_orders/:id/capture
+          def capture
+            paypal_order = spree_current_order.paypal_checkout_orders.find_by!(paypal_id: params[:id])
+            paypal_order.capture!
+
+            render_serialized_payload { serialize_resource(paypal_order) }
+          end
+
+          private
+
+          def resource_serializer
+            Spree::Api::V2::Storefront::PaypalOrderSerializer
+          end
+
+          def paypal_client
+            @paypal_client ||= current_store.paypal_checkout_gateway.client
+          end
+
+          def require_paypal_checkout_gateway
+            return if current_store.paypal_checkout_gateway.present?
+
+            render_error_payload('Paypal checkout gateway not found', :not_found) && return
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree_paypal_checkout/store_controller_decorator.rb

@@ -0,0 +1,9 @@
+module SpreePaypalCheckout
+  module StoreControllerDecorator
+    def self.prepended(base)
+      base.helper SpreePaypalCheckout::BaseHelper
+    end
+  end
+end
+
+Spree::StoreController.prepend(SpreePaypalCheckout::StoreControllerDecorator) if defined?(Spree::StoreController)

data/app/helpers/spree_paypal_checkout/base_helper.rb

@@ -0,0 +1,11 @@
+module SpreePaypalCheckout
+  module BaseHelper
+    def current_paypal_checkout_gateway
+      @current_paypal_checkout_gateway ||= current_store.paypal_checkout_gateway
+    end
+
+    def paypal_checkout_enabled?
+      current_paypal_checkout_gateway.present?
+    end
+  end
+end

data/app/javascript/spree_paypal_checkout/application.js

@@ -0,0 +1,16 @@
+import '@hotwired/turbo-rails'
+import { Application } from '@hotwired/stimulus'
+
+let application
+
+if (typeof window.Stimulus === "undefined") {
+  application = Application.start()
+  application.debug = false
+  window.Stimulus = application
+} else {
+  application = window.Stimulus
+}
+
+import CheckoutPaypalController from 'spree_paypal_checkout/controllers/checkout_paypal_controller'
+
+application.register('checkout-paypal', CheckoutPaypalController)

data/app/javascript/spree_paypal_checkout/controllers/checkout_paypal_controller.js

@@ -0,0 +1,99 @@
+import { Controller } from '@hotwired/stimulus'
+import showFlashMessage from 'spree/storefront/helpers/show_flash_message'
+import { post, put } from '@rails/request.js'
+
+export default class extends Controller {
+  static values = {
+    clientKey: String,
+    orderNumber: String,
+    orderToken: String,
+    currency: String,
+    amount: Number,
+    apiCreateOrderPath: String,
+    apiCaptureOrderPath: String,
+    apiCheckoutUpdatePath: String,
+    returnUrl: String,
+  }
+
+  connect() {
+    this.initPayPal();
+
+    this.submitTarget = document.querySelector('#checkout-payment-submit')
+    this.billingAddressCheckbox = document.querySelector('#order_use_shipping')
+    this.billingAddressForm = document.querySelector('form.edit_order')
+
+    // hide submit button
+    this.submitTarget.style.display = 'none'
+  }
+
+  disconnect() {
+    this.submitTarget.style.display = 'block'
+  }
+
+  initPayPal() {
+    const paypalButtons = window.paypal.Buttons({
+      style: {
+        shape: "rect",
+        layout: "vertical",
+        color: "gold",
+        label: "paypal",
+      },
+      message: {
+        amount: this.amountValue,
+      },
+      createOrder: async () => {
+        const response = await post(this.apiCreateOrderPathValue, {
+          headers: {
+            "X-Spree-Order-Token": this.orderTokenValue,
+          }
+        });
+
+        if (response.ok) {
+          const paypalOrder = await response.json;
+
+          if (!paypalOrder.data) {
+            console.error('No data in PayPal order response:', paypalOrder);
+            throw new Error(paypalOrder.error || 'Failed to create PayPal order');
+          }
+
+          const orderId = paypalOrder.data.attributes.paypal_id;
+          console.log('PayPal order ID to return:', orderId);
+
+          if (!orderId) {
+            console.error('No paypal_id found in response data:', paypalOrder.data);
+            throw new Error('No PayPal order ID found in response');
+          }
+
+          // Make sure we're returning a string
+          return String(orderId);
+        } else {
+          console.error('Failed to create PayPal order:', response.error);
+          showFlashMessage('error', `Sorry, your transaction could not be processed...<br><br>${response.error}`);
+          throw new Error(response.error || 'Failed to create PayPal order');
+        }
+      },
+      onApprove: async (data, actions) => {
+        const response = await put(
+          this.apiCaptureOrderPathValue.replace(this.orderNumberValue, data.orderID),
+          {
+            headers: {
+              "X-Spree-Order-Token": this.orderTokenValue,
+            },
+          }
+        );
+
+        if (response.ok) {
+          window.location.href = this.returnUrlValue; 
+        } else {
+          console.error('Failed to capture PayPal order:', response.error);
+          showFlashMessage('error', `Sorry, your transaction could not be processed...<br><br>${response.error}`);
+        }
+      },
+      onError: (err) => {
+        showFlashMessage('error', `Your transaction was cancelled...<br><br>${err}`);
+      }
+    });
+
+    paypalButtons.render(this.element);
+  }
+}

data/app/models/spree_paypal_checkout/base.rb

@@ -0,0 +1,6 @@
+module SpreePaypalCheckout
+  class Base < ::Spree.base_class
+    self.abstract_class = true
+    self.table_name_prefix = 'spree_paypal_checkout_'
+  end
+end

data/app/models/spree_paypal_checkout/gateway.rb

@@ -0,0 +1,185 @@
+module SpreePaypalCheckout
+  class Gateway < ::Spree::Gateway
+    include PaypalServerSdk
+
+    #
+    # Preferences
+    #
+    preference :client_id, :password
+    preference :client_secret, :password
+    preference :test_mode, :boolean, default: true
+
+    #
+    # Validations
+    #
+    validates :preferred_client_id, :preferred_client_secret, presence: true
+
+    def provider_class
+      self.class
+    end
+
+    def payment_source_class
+      SpreePaypalCheckout::PaymentSources::Paypal
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def default_name
+      'PayPal'
+    end
+
+    def method_type
+      'spree_paypal_checkout'
+    end
+
+    def payment_icon_name
+      'paypal'
+    end
+
+    def description_partial_name
+      'spree_paypal_checkout'
+    end
+
+    def configuration_guide_partial_name
+      'spree_paypal_checkout'
+    end
+
+    def source_partial_name
+      'paypal_checkout'
+    end
+
+    def create_profile(payment)
+      user = payment.order.user
+      return if user.blank?
+
+      return if payment.source.blank?
+      return unless payment.source.is_a?(SpreePaypalCheckout::PaymentSources::Paypal)
+
+      paypal_account_id = payment.source.account_id
+
+      return if paypal_account_id.blank?
+
+      payment.payment_method.gateway_customers.find_or_create_by(user: user, profile_id: paypal_account_id)
+    end
+
+    def client
+      @client ||= Client.new(
+        client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
+          o_auth_client_id: preferred_client_id,
+          o_auth_client_secret: preferred_client_secret
+        ),
+        environment: preferred_test_mode ? Environment::SANDBOX : Environment::PRODUCTION,
+        logging_configuration: LoggingConfiguration.new(
+          log_level: Logger::INFO,
+          request_logging_config: RequestLoggingConfiguration.new(
+            log_body: true
+          ),
+          response_logging_config: ResponseLoggingConfiguration.new(
+            log_headers: true
+          )
+        )
+      )
+    end
+
+    def authorize(amount_in_cents, payment_source, gateway_options = {})
+      raise 'Not implemented'
+    end
+
+    # Purchase is the same as authorize + capture in one step
+    def purchase(amount_in_cents, payment_source, gateway_options = {})
+      capture(amount_in_cents, payment_source.paypal_id, gateway_options)
+    end
+
+    # Capture a previously authorized payment
+    # @param amount_in_cents [Integer] the amount in cents to capture
+    # @param paypal_id [String] the PayPal Order ID
+    # @param gateway_options [Hash] this is an instance of Spree::Payment::GatewayOptions.to_hash
+    def capture(amount_in_cents, paypal_id, gateway_options = {})
+      protect_from_error do
+        order = find_order(gateway_options[:order_id])
+        return failure('Order not found') unless order
+
+        response = client.orders.capture_order({
+          'id' => paypal_id,
+          'prefer' => 'return=representation'
+        })
+
+        if response.data.status == 'COMPLETED'
+          success(response.data.id, response.data.as_json)
+        else
+          failure('Failed to capture PayPal payment', response.data)
+        end
+      end
+    end
+
+    def void(authorization, source, gateway_options = {})
+      raise 'Not implemented'
+    end
+
+    def credit(amount_in_cents, _payment_source, paypal_payment_id, gateway_options = {})
+      refund_originator = gateway_options[:originator]
+      order = refund_originator.respond_to?(:order) ? refund_originator.order : refund_originator
+
+      return failure('Order not found') unless order
+
+      protect_from_error do
+        payload = {
+          capture_id: paypal_payment_id,
+          amount: {
+            value: (amount_in_cents / 100.0).to_s,
+            currency_code: order.currency.upcase
+          }
+        }.deep_stringify_keys
+
+        response = client.payments.refund_captured_payment(payload)
+
+        success(response.data.id, response.data.as_json)
+      end
+    end
+
+    def cancel(authorization, payment = nil)
+      raise 'Not implemented'
+    end
+
+    private
+
+    def find_order(order_id)
+      return nil unless order_id
+
+      order_number, _payment_number = order_id.split('-')
+      Spree::Order.find_by(number: order_number)
+    end
+
+    def find_capture_id(order_data)
+      return nil unless order_data
+
+      # Navigate through the order data to find the capture ID
+      order_data.dig('purchase_units', 0, 'payments', 'captures', 0, 'id')
+    end
+
+    def protect_from_error
+      yield
+    rescue PaypalServerSdk::APIException => e
+      raise Spree::Core::GatewayError, "PayPal API error: #{e.message}"
+    end
+
+    def success(authorization, response)
+      ActiveMerchant::Billing::Response.new(
+        true,
+        'Transaction successful',
+        response,
+        authorization: authorization
+      )
+    end
+
+    def failure(message, response = {})
+      ActiveMerchant::Billing::Response.new(
+        false,
+        message,
+        response
+      )
+    end
+  end
+end

data/app/models/spree_paypal_checkout/order.rb

@@ -0,0 +1,71 @@
+module SpreePaypalCheckout
+  class Order < Base
+    class NotCapturedError < StandardError; end
+    class AlreadyCapturedError < StandardError; end
+
+    #
+    # Associations
+    #
+    belongs_to :order, class_name: 'Spree::Order'
+    belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+    alias gateway payment_method
+
+    #
+    # Callbacks
+    #
+    before_validation :set_amount_from_order, on: :create
+
+    #
+    # Validations
+    #
+    validates :paypal_id, presence: true, uniqueness: true
+    validates :order, :payment_method, :data, presence: true
+    validates :amount, numericality: { greater_than: 0 }, presence: true
+
+    store_accessor :data, :payer, :purchase_units, :payment_source, :status
+
+    # Create a Spree::Payment record for this PayPal order
+    # @return [Spree::Payment]
+    def create_payment!
+      raise NotCapturedError unless completed?
+
+      SpreePaypalCheckout::CreatePayment.new(
+        order: order,
+        paypal_order: self,
+        gateway: payment_method,
+        amount: amount
+      ).call
+    end
+
+    # Capture the PayPal order in PayPal API
+    # @return [SpreePaypalCheckout::Order]
+    def capture!
+      raise AlreadyCapturedError if completed?
+
+      CaptureOrder.new(paypal_order: self).call
+    end
+
+    # gets the PayPal payment ID from the PayPal order
+    # only available for authorized or captured orders
+    # @return [String]
+    def paypal_payment_id
+      @paypal_payment_id ||= data.dig('purchase_units', 0, 'payments', 'captures', 0, 'id')
+    end
+
+    # gets the PayPal order from PayPal API
+    # @return [PaypalServerSdk::ApiResponse]
+    def paypal_order
+      @paypal_order ||= gateway.client.orders.get_order({ 'id' => paypal_id })
+    end
+
+    def completed?
+      status == 'COMPLETED'
+    end
+
+    private
+
+    def set_amount_from_order
+      self.amount ||= order&.total
+    end
+  end
+end

data/app/models/spree_paypal_checkout/order_decorator.rb

@@ -0,0 +1,11 @@
+module SpreePaypalCheckout
+  module OrderDecorator
+    def self.prepended(base)
+      base.store_accessor :private_metadata, :paypal_id
+
+      base.has_many :paypal_checkout_orders, class_name: 'SpreePaypalCheckout::Order', dependent: :destroy, foreign_key: :order_id
+    end
+  end
+end
+
+Spree::Order.prepend(SpreePaypalCheckout::OrderDecorator)

data/app/models/spree_paypal_checkout/payment_method_decorator.rb

@@ -0,0 +1,15 @@
+module SpreePaypalCheckout
+  module PaymentMethodDecorator
+    PAYPAL_CHECKOUT_TYPE = 'SpreePaypalCheckout::Gateway'.freeze
+
+    def self.prepended(base)
+      base.scope :paypal_checkout, -> { where(type: PAYPAL_CHECKOUT_TYPE) }
+    end
+
+    def paypal_checkout?
+      type == PAYPAL_CHECKOUT_TYPE
+    end
+  end
+end
+
+Spree::PaymentMethod.prepend(SpreePaypalCheckout::PaymentMethodDecorator)

data/app/models/spree_paypal_checkout/payment_sources/paypal.rb

@@ -0,0 +1,15 @@
+module SpreePaypalCheckout
+  module PaymentSources
+    class Paypal < ::Spree::PaymentSource
+      store_accessor :public_metadata, :email, :name, :account_status, :account_id
+
+      def actions
+        %w[credit void]
+      end
+
+      def self.display_name
+        'PayPal'
+      end
+    end
+  end
+end

data/app/models/spree_paypal_checkout/store_decorator.rb

@@ -0,0 +1,9 @@
+module SpreePaypalCheckout
+  module StoreDecorator
+    def paypal_checkout_gateway
+      @paypal_checkout_gateway ||= payment_methods.paypal_checkout.active.last
+    end
+  end
+end
+
+Spree::Store.prepend(SpreePaypalCheckout::StoreDecorator)

data/app/presenters/spree_paypal_checkout/order_presenter.rb

@@ -0,0 +1,59 @@
+require 'paypal_server_sdk'
+
+module SpreePaypalCheckout
+  class OrderPresenter
+    include PaypalServerSdk
+
+    def initialize(order)
+      @order = order
+    end
+
+    attr_reader :order
+
+    def to_json
+      {
+        'body' => OrderRequest.new(
+          intent: CheckoutPaymentIntent::CAPTURE,
+          purchase_units: [
+            PurchaseUnitRequest.new(
+              amount: AmountWithBreakdown.new(
+                currency_code: order.currency.upcase,
+                value: order.total.to_s,
+                breakdown: AmountBreakdown.new(
+                  item_total: Money.new(
+                    currency_code: order.currency.upcase,
+                    value: order.item_total.to_s
+                  ),
+                  shipping: Money.new(
+                    currency_code: order.currency.upcase,
+                    value: order.ship_total.to_s
+                  ),
+                  tax_total: Money.new(
+                    currency_code: order.currency.upcase,
+                    value: order.tax_total.to_s
+                  ),
+                  discount: Money.new(
+                    currency_code: order.currency.upcase,
+                    value: order.promo_total.to_s
+                  )
+                )
+              ),
+              items: order.line_items.map do |line_item|
+                Item.new(
+                  name: line_item.name,
+                  unit_amount: Money.new(
+                    currency_code: order.currency.upcase,
+                    value: line_item.price.to_s
+                  ),
+                  quantity: line_item.quantity.to_s,
+                  sku: line_item.sku,
+                  category: line_item.variant.digital? ? ItemCategory::DIGITAL_GOODS : ItemCategory::PHYSICAL_GOODS
+                )
+              end
+            )
+          ]
+        )
+      }
+    end
+  end
+end