solidus_afterpay 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff5d1583df1845d1d0f620355fe613076850dd3f8d7a534a9311b2c91aadf01f
-  data.tar.gz: f657c4a2d45062e63333bb8ec8932fb1e6d45785df730e93a242ef95334778bc
+  metadata.gz: 8765915b73f132484c9c0a37e556f00be9d4ddebc9a366f58ad65ac735104851
+  data.tar.gz: cc860fb8245b3b727084ce0566bfb845b3f2addee262bd61d0978852ecc6f880
 SHA512:
-  metadata.gz: 59b6adb36612219fdafa8b03fbce5b5315b8c14ca700af128075fb87979968c909f402e967beba8b494d3e03d091172b2c05fb2671b56d3332d0accb2dd6b770
-  data.tar.gz: 02feaeda3db7d7403e0b67289b57c3b88ed945911da446de1fc546f48ba0a0cff08152f2aed37167dd22cf1d42faf99ce8863ec5050dd9840b04d566c2684bb1
+  metadata.gz: be2b0dce8edf3f39a249a986b406817de704080b8010788a87ab95b0ee6522fb6fbe7af47ca7c47fb7bf0cd7db69ea57120ae38dcd30ac4bfe18b7e12244876d
+  data.tar.gz: 645f595276aeb50bcdaae034a352aae98eea1e112b98315eb8d4a74da968ba23b2500be2588d0a4bd9f942715182089c90a071301a726ebe2ad3afd2e03debed

data/README.md

@@ -1,8 +1,7 @@
+[![CircleCI](https://circleci.com/gh/nebulab/solidus_afterpay.svg?style=shield)](https://circleci.com/gh/nebulab/solidus_afterpay)
+[![codecov](https://codecov.io/gh/nebulab/solidus_afterpay/branch/main/graph/badge.svg)](https://codecov.io/gh/solidusio/solidus_afterpay)
 # Solidus Afterpay
 
-[![CircleCI](https://circleci.com/gh/solidusio-contrib/solidus_afterpay.svg?style=shield)](https://circleci.com/gh/solidusio-contrib/solidus_afterpay)
-[![codecov](https://codecov.io/gh/solidusio-contrib/solidus_afterpay/branch/master/graph/badge.svg)](https://codecov.io/gh/solidusio-contrib/solidus_afterpay)
-
 <!-- Explain what your extension does. -->
 
 ## Installation
@@ -18,68 +17,97 @@ Bundle your dependencies and run the installation generator:
 ```shell
 bin/rails generate solidus_afterpay:install
 ```
+
 ## Basic Setup
 
 ### Retrieve Afterpay account details
+
 You'll need the following account details:
+
 - `Merchant ID`
 - `Secret key`
 
 These values can be obtained by calling the `Merchant Support` [here](https://developers.afterpay.com/afterpay-online/docs/merchant-support).
 
 ### Create a new payment method
+
 Payment methods can accept preferences either directly entered in admin, or from a static source in code. For most projects we recommend using a static source, so that sensitive account credentials are not stored in the database.
 
 1. Set static preferences in an initializer
-  ```ruby
-  # config/initializers/spree.rb
-  Spree::Config.configure do |config|
-    config.static_model_preferences.add(
-      SolidusAfterpay::PaymentMethod,
-      'afterpay_credentials', {
-        merchant_id: ENV['AFTERPAY_MERCHANT_ID'],
-        secret_key: ENV['AFTERPAY_SECRET_KEY'],
-      }
-    )
-  end
-  ```
 
-2. Visit `/admin/payment_methods/new`
+```ruby
+# config/initializers/spree.rb
+Spree::Config.configure do |config|
+  config.static_model_preferences.add(
+    SolidusAfterpay::PaymentMethod,
+    'afterpay_credentials', {
+      merchant_id: ENV['AFTERPAY_MERCHANT_ID'],
+      secret_key: ENV['AFTERPAY_SECRET_KEY'],
+    }
+  )
+end
+```
 
+2. Visit `/admin/payment_methods/new`
 3. Set `provider` to SolidusAfterpay::PaymentMethod
-
 4. Click "Save"
-
 5. Choose `afterpay_credentials` from the `Preference Source` select
-
 6. Click `Update` to save
 
 Alternatively, create a payment method from the Rails console with:
+
 ```ruby
 SolidusAfterpay::PaymentMethod.new(
   name: "Afterpay",
   preference_source: "afterpay_credentials"
 ).save
 ```
+
 ## Deferred Payment Flow
 
 This flow completes the payment approval and starts the consumer's payment plan, but does not initiate the settlement process. This flow allows settlement of merchant funds to be deferred until order fulfilment can be confirmed.
 
-Simply check the deferred checkbox when creating the Afterpay payment_method to activate the deferred payment flow instead of the immediate payment flow.
+Simply set the auto_capture to false when creating the Afterpay payment_method to activate the deferred payment flow instead of the immediate payment flow.
 
 For more info about the deferred payment flow click [here](https://developers.afterpay.com/afterpay-online/reference#deferred-payment-flow).
 
 ## Usage
 
+### Customizing shipping rate builder
+
+By default, the extension will build the shipping rates based on the default Solidus shipments building the Afterpay array.
+
+If you want to override this logic, you can provide your own `shipping_rate_calculator_class`.
+
+### Customizing update order attributes service
+
+By default, the extension will update the order payment_attributes, order email attribute and shipments attributes based on the Afterpay returned data.
+
+If you want to override this logic, adding/removing attributes, you can provide your own `update_order_attributes_service_class`.
+
+### Express checkout from the cart
+
+An Afterpay button can also be included on the cart view to enable express checkouts:
+
+```ruby
+<%= render "solidus_afterpay/afterpay_checkout_button" %>
+```
+
 ### Afterpay Messaging
 
 Afterpay offers an on-site messaging component to notify the customer that there are financing options available.
 
 To add the `Afterpay messaging` simply add the `Afterpay messaging partial` into your `html.erb` file, like this.
 
+You need to provide the products as well, so you can exclude products from `Afterpay messaging`. It is required to
+add the product in an array for example: `products: [<product>]`, or for multiple products: `products: [<product1>, <product2>]`.
+
+If you only have the order you can do it like this `products: order.line_items.map { |item| item.variant.product }`.
+
 ```erb
-<%= render "spree/shared/afterpay_messaging", min: nil, max: nil, data: { amount: <Product price>, locale: "en_US", currency: "USD" } %>
+<%= render "spree/shared/afterpay_messaging", min: nil, max: nil, products: [<Product>], data: { amount: <Product price>, locale: "en_US", currency: "USD" } %>
 ```
+
 The amount, locale and currency are required in order to work properly.
 
 This will automatically render an Afterpay messaging icon.
@@ -91,8 +119,9 @@ The min attribute is to configure from which amount Afterpay should be available
 For example if you would write...
 
 ```erb
-<%= render "spree/shared/afterpay_messaging", min: nil, max: 25, data: { amount: <Product price>, locale: "en_US", currency: "USD" } %>
+<%= render "spree/shared/afterpay_messaging", min: nil, max: 25, products: [<Product>], data: { amount: <Product price>, locale: "en_US", currency: "USD" } %>
 ```
+
 And a product price is `28.99`, Afterpay will display on that product that Afterpay is only available for orders between 1$ and 25$.
 
 The default value for min is 1$.
@@ -104,7 +133,7 @@ Click [here](https://developers.afterpay.com/afterpay-online/docs/advanced-usage
 If you would like to change the size of the Afterpay messaging you simply add size to the `data` hash. For example...
 
 ```erb
-<%= render "spree/shared/afterpay_messaging", min: nil, max: nil, data: { amount: <Product price>, locale: "en_US", currency: "USD", size: "sm" } %>
+<%= render "spree/shared/afterpay_messaging", min: nil, max: nil, product: [<Product>], data: { amount: <Product price>, locale: "en_US", currency: "USD", size: "sm" } %>
 ```
 
 ## Development

data/app/assets/javascripts/solidus_afterpay/afterpay_checkout.js

@@ -1,4 +1,4 @@
-$(function () {
+$(document).bind("afterpay.loaded", function () {
   function enableSubmit() {
     /* If we're using jquery-ujs on the frontend, it will automatically disable
      * the submit button, but do so in a setTimeout here:
@@ -58,13 +58,13 @@ $(function () {
             order_number: orderNumber,
             payment_method_id: paymentMethodId,
           },
-        })
-          .success(function (response) {
+          success: function (response) {
             onSuccess(response);
-          })
-          .error(function (response) {
+          },
+          error: function (response) {
             onError(response);
-          });
+          }
+        })
       }
     });
   }
@@ -103,13 +103,13 @@ $(function () {
         payment_method_id: paymentMethodId,
         order_token: event.data.orderToken,
       },
-    })
-      .success(function (response) {
+      success: function (response) {
         window.location.href = response.redirect_url;
-      })
-      .error(function (response) {
+      },
+      error: function (response) {
         enableSubmit();
-      });
+      }
+    })
   }
 
   function onAfterpayCancel(event) {

data/app/assets/javascripts/solidus_afterpay/afterpay_checkout_button.js

@@ -0,0 +1,85 @@
+$(document).bind("afterpay.loaded", function () {
+  function initializeExpressCheckout(selector) {
+    AfterPay.initializeForPopup({
+      countryCode: "US",
+      onCommenceCheckout: function (actions) {
+        Spree.ajax({
+          method: "POST",
+          url: "/solidus_afterpay/checkouts.json",
+          data: { order_number: orderNumber, mode: "express" },
+          success: function (response) {
+            actions.resolve(response.token);
+          },
+          error: function () {
+            actions.reject(AfterPay.CONSTANTS.SERVICE_UNAVAILABLE);
+          }
+        })
+      },
+      onShippingAddressChange: function (data, actions) {
+        Spree.ajax({
+          method: "PATCH",
+          url: `/solidus_afterpay/express_callbacks/${orderNumber}.json`,
+          data: { address: data },
+          success: function (response) {
+            let results = response.data.map((shipping) =>
+              shippingMethod(shipping)
+            );
+
+            if (results.length > 0) {
+              actions.resolve(results);
+            } else {
+              actions.reject(AfterPay.CONSTANTS.SHIPPING_ADDRESS_UNSUPPORTED);
+            }
+          },
+          error: function (error) {
+            actions.reject(AfterPay.CONSTANTS.BAD_RESPONSE);
+            console.error(error);
+          }
+        })
+      },
+      onComplete: function (data) {
+        if (data.data.status == "SUCCESS") {
+          Spree.ajax({
+            method: "POST",
+            url: `/solidus_afterpay/express_callbacks/${orderNumber}.json`,
+            data: {
+              token: data.data.orderToken,
+              payment_method_id: paymentMethodId,
+            },
+            success: function (response) {
+              window.location.href = response.redirect_url;
+            },
+            error: function (error) {
+              const errorBody = JSON.parse(error.responseText);
+              showError(errorBody.error);
+            }
+          })
+        }
+      },
+      target: selector,
+      buyNow: false,
+      pickup: false,
+      shippingOptionRequired: true,
+    });
+  }
+
+  if ($("#afterpay-button").length > 0) {
+    var orderNumber = $("#afterpay-button").data("order-number");
+    var paymentMethodId = $("#afterpay-button").data("payment-method-id");
+
+    initializeExpressCheckout("#afterpay-button");
+  }
+});
+
+function shippingMethod(shipping) {
+  return {
+    id: shipping.id,
+    name: shipping.name,
+    description: shipping.description,
+    shippingAmount: {
+      amount: shipping.shipping_amount,
+      currency: shipping.currency,
+    },
+    orderAmount: { amount: shipping.order_amount, currency: shipping.currency },
+  };
+}

data/app/assets/javascripts/solidus_afterpay/afterpay_init.js

@@ -0,0 +1,12 @@
+function initAfterpay() {
+  $(function() {
+    $(document).trigger('afterpay.loaded');
+  });
+}
+
+function showError(errorMessage) {
+  if (!$("#content").is("*")) return;
+
+  $(".flash").remove();
+  $("#content").prepend(`<div class="flash error">${errorMessage}</div>`);
+}

data/app/assets/javascripts/solidus_afterpay/backend/afterpay_autocomplete.js

@@ -0,0 +1,9 @@
+Spree.ready(function () {
+  if (
+    $(
+      'form#edit_payment_method option[value="SolidusAfterpay::PaymentMethod"]:selected'
+    ).length > 0
+  ) {
+    $("#payment_method_preferred_excluded_products").productAutocomplete();
+  }
+});

data/app/assets/javascripts/spree/backend/solidus_afterpay.js

@@ -1,2 +1,4 @@
 // Placeholder manifest file.
-// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/backend/all.js'
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/backend/all.js'
+
+//= require solidus_afterpay/backend/afterpay_autocomplete

data/app/assets/javascripts/spree/frontend/solidus_afterpay.js

@@ -1,4 +1,6 @@
 // Placeholder manifest file.
 // the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/frontend/all.js'
 
+//= require solidus_afterpay/afterpay_init
 //= require solidus_afterpay/afterpay_checkout
+//= require solidus_afterpay/afterpay_checkout_button

data/app/controllers/solidus_afterpay/checkouts_controller.rb

@@ -8,7 +8,9 @@ module SolidusAfterpay
       response = payment_method.gateway.create_checkout(
         order,
         redirect_confirm_url: redirect_confirm_url,
-        redirect_cancel_url: redirect_cancel_url
+        redirect_cancel_url: redirect_cancel_url,
+        mode: params[:mode],
+        popup_origin_url: request.referer
       )
 
       if response.success?
@@ -29,7 +31,11 @@ module SolidusAfterpay
     end
 
     def payment_method
-      @payment_method ||= SolidusAfterpay::PaymentMethod.active.find(params[:payment_method_id])
+      @payment_method ||= if params[:payment_method_id]
+                            SolidusAfterpay::PaymentMethod.active.find(params[:payment_method_id])
+                          else
+                            SolidusAfterpay::PaymentMethod.active.first
+                          end
     end
 
     def redirect_confirm_url

data/app/controllers/solidus_afterpay/express_callbacks_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  class ExpressCallbacksController < SolidusAfterpay::BaseController
+    def create
+      authorize! :update, order, order_token
+
+      unless SolidusAfterpay.update_order_attributes_service_class.call(
+        order: order,
+        afterpay_order_token: params[:token],
+        payment_method: payment_method,
+        request_env: request.headers.env
+      )
+        render(
+          json: {
+            error: I18n.t('solidus_afterpay.express_checkout.errors.unable_place_order'),
+            errorCode: :internal_server_error
+          },
+          status: :internal_server_error
+        )
+        return
+      end
+
+      order.next!
+      order.next!
+
+      render json: { redirect_url: checkout_state_url(order.state) }, status: :ok
+    end
+
+    def update
+      authorize! :update, order, order_token
+
+      unless SolidusAfterpay::UpdateOrderAddressesService.call(order: order, address_params: params[:address])
+        render json: { errorCode: :internal_server_error }, status: :internal_server_error
+        return
+      end
+
+      order.next!
+      # rubocop:disable Rails/SkipsModelValidations
+      order.update_columns(email: nil) if order.email == SolidusAfterpay.configuration.dummy_email
+      # rubocop:enable Rails/SkipsModelValidations
+
+      render(
+        json: {
+          data: ::SolidusAfterpay.shipping_rate_builder_service_class.call(order: order)
+        },
+        status: :ok
+      )
+    end
+
+    private
+
+    def order
+      @order ||= ::Spree::Order.find_by!(number: params[:order_number])
+    end
+
+    def payment_method
+      @payment_method ||= SolidusAfterpay::PaymentMethod.active.find(params[:payment_method_id])
+    end
+  end
+end

data/app/decorators/controllers/solidus_afterpay/spree/orders_controller_decorator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  module Spree
+    module OrdersControllerDecorator
+      def self.prepended(base)
+        base.helper ::SolidusAfterpay::AfterpayHelper
+      end
+
+      ::Spree::OrdersController.prepend(self) if SolidusSupport.frontend_available?
+    end
+  end
+end

data/app/helpers/solidus_afterpay/afterpay_helper.rb

@@ -2,14 +2,15 @@
 
 module SolidusAfterpay
   module AfterpayHelper
-    def include_afterpay_js(test_mode: false)
+    def include_afterpay_js(test_mode: false, merchant_key: nil)
+      js_name = merchant_key ? "afterpay.js?merchant_key=#{merchant_key}" : 'afterpay-async.js'
       afterpay_js_url = if test_mode
-                          'https://portal.sandbox.afterpay.com/afterpay.js'
+                          "https://portal.sandbox.afterpay.com/#{js_name}"
                         else
-                          'https://portal.afterpay.com/afterpay.js'
+                          "https://portal.afterpay.com/#{js_name}"
                         end
 
-      javascript_include_tag afterpay_js_url
+      javascript_include_tag afterpay_js_url, async: true, defer: true, onload: 'initAfterpay()'
     end
   end
 end

data/app/models/solidus_afterpay/gateway.rb

@@ -15,18 +15,26 @@ module SolidusAfterpay
       end
     end
 
-    def authorize(_amount, payment_source, _gateway_options)
+    def authorize(amount, payment_source, gateway_options)
       result = {}
 
-      if payment_source.payment_method.preferred_deferred
+      unless payment_source.payment_method.auto_capture
         response = ::Afterpay::API::Payment::Auth.call(
-          payment: ::Afterpay::Components::Payment.new(token: payment_source.token)
+          payment: ::Afterpay::Components::Payment.new(
+            token: payment_source.token,
+            amount: ::Afterpay::Components::Money.new(
+              amount: Money.from_cents(amount).amount.to_s,
+              currency: gateway_options[:currency]
+            )
+          )
         )
         result = response.body
       end
 
       ActiveMerchant::Billing::Response.new(true, 'Transaction approved', result, authorization: result[:id])
     rescue ::Afterpay::BaseError => e
+      ::Afterpay::API::Payment::Reversal.call(token: payment_source.token) if e.is_a?(::Afterpay::RequestTimeoutError)
+
       message = e.message
       error_code = e.error_code
       if message == 'Afterpay::PaymentRequiredError'
@@ -39,10 +47,10 @@ module SolidusAfterpay
     def capture(amount, response_code, gateway_options)
       payment_method = gateway_options[:originator].payment_method
 
-      response = if payment_method.preferred_deferred
-                   deferred_capture(amount, response_code, gateway_options)
-                 else
+      response = if payment_method.auto_capture
                    immediate_capture(amount, response_code, gateway_options)
+                 else
+                   deferred_capture(amount, response_code, gateway_options)
                  end
       result = response.body
 
@@ -52,6 +60,11 @@ module SolidusAfterpay
 
       ActiveMerchant::Billing::Response.new(true, 'Transaction captured', result, authorization: result.id)
     rescue ::Afterpay::BaseError => e
+      if e.is_a?(::Afterpay::RequestTimeoutError)
+        payment_source = gateway_options[:originator].payment_source
+        ::Afterpay::API::Payment::Reversal.call(token: payment_source.token)
+      end
+
       ActiveMerchant::Billing::Response.new(false, e.message, {}, error_code: e.error_code)
     end
 
@@ -84,7 +97,7 @@ module SolidusAfterpay
     def void(response_code, gateway_options)
       payment_method = gateway_options[:originator].payment_method
 
-      unless payment_method.preferred_deferred
+      if payment_method.auto_capture
         return ActiveMerchant::Billing::Response.new(false, "Transaction can't be voided", {},
           error_code: 'void_not_allowed')
       end
@@ -109,8 +122,10 @@ module SolidusAfterpay
       response = ::Afterpay::API::Order::Create.call(
         order: SolidusAfterpay::OrderComponentBuilder.new(
           order: order,
+          mode: gateway_options[:mode],
           redirect_confirm_url: gateway_options[:redirect_confirm_url],
-          redirect_cancel_url: gateway_options[:redirect_cancel_url]
+          redirect_cancel_url: gateway_options[:redirect_cancel_url],
+          popup_origin_url: gateway_options[:popup_origin_url]
         ).call
       )
       result = response.body
@@ -126,6 +141,12 @@ module SolidusAfterpay
       nil
     end
 
+    def find_order(token:)
+      ::Afterpay::API::Order::Find.call(token: token).body
+    rescue ::Afterpay::BaseError
+      nil
+    end
+
     def retrieve_configuration
       ::Afterpay::API::Configuration::Retrieve.call.body
     rescue ::Afterpay::BaseError
@@ -134,11 +155,17 @@ module SolidusAfterpay
 
     private
 
-    def immediate_capture(_amount, _response_code, gateway_options)
+    def immediate_capture(amount, _response_code, gateway_options)
       payment_source = gateway_options[:originator].payment_source
 
       ::Afterpay::API::Payment::Capture.call(
-        payment: ::Afterpay::Components::Payment.new(token: payment_source.token)
+        payment: ::Afterpay::Components::Payment.new(
+          token: payment_source.token,
+          amount: ::Afterpay::Components::Money.new(
+            amount: Money.from_cents(amount).amount.to_s,
+            currency: gateway_options[:currency]
+          )
+        )
       )
     end
 

data/app/models/solidus_afterpay/order_component_builder.rb

@@ -4,17 +4,20 @@ require 'afterpay'
 
 module SolidusAfterpay
   class OrderComponentBuilder
-    attr_reader :order, :redirect_confirm_url, :redirect_cancel_url
+    attr_reader :order, :mode, :redirect_confirm_url, :redirect_cancel_url, :popup_origin_url
 
-    def initialize(order:, redirect_confirm_url:, redirect_cancel_url:)
+    def initialize(order:, mode: nil, redirect_confirm_url: nil, redirect_cancel_url: nil, popup_origin_url: nil)
       @order = order
+      @mode = mode
       @redirect_confirm_url = redirect_confirm_url
       @redirect_cancel_url = redirect_cancel_url
+      @popup_origin_url = popup_origin_url
     end
 
     def call
       ::Afterpay::Components::Order.new(
         amount: amount,
+        mode: mode,
         consumer: consumer,
         billing: address(order.billing_address),
         shipping: address(order.shipping_address),
@@ -27,6 +30,8 @@ module SolidusAfterpay
     private
 
     def address(address)
+      return unless address
+
       name = if SolidusSupport.combined_first_and_last_name_in_address?
                address.name
              else
@@ -45,6 +50,8 @@ module SolidusAfterpay
     end
 
     def consumer
+      return unless order.billing_address
+
       if SolidusSupport.combined_first_and_last_name_in_address?
         name_components = ::Spree::Address::Name.new(order.billing_address.name)
         first_name = name_components.first_name
@@ -55,7 +62,7 @@ module SolidusAfterpay
       end
 
       ::Afterpay::Components::Consumer.new(
-        email: order.user&.email || order.email,
+        email: order.user&.email || order.email || 'afterpay@guest.com',
         given_names: first_name,
         surname: last_name,
         phone: order.billing_address.phone
@@ -72,7 +79,8 @@ module SolidusAfterpay
     def merchant
       ::Afterpay::Components::Merchant.new(
         redirect_confirm_url: redirect_confirm_url,
-        redirect_cancel_url: redirect_cancel_url
+        redirect_cancel_url: redirect_cancel_url,
+        popup_origin_url: popup_origin_url
       )
     end
 
@@ -90,8 +98,29 @@ module SolidusAfterpay
         price: ::Afterpay::Components::Money.new(
           amount: line_item.price.to_s,
           currency: line_item.currency
-        )
+        ),
+        preorder: pre_order?(line_item),
+        estimated_shipment_date: estimated_shipment_date(line_item)
       )
     end
+
+    def estimated_shipment_date_product(line_item)
+      line_item.product.property("estimatedShipmentDate")
+    end
+
+    def estimated_shipment_date_variant(line_item)
+      line_item.variant.variant_properties.find{ |prop| prop.property.name == "estimatedShipmentDate" }&.value
+    end
+
+    def estimated_shipment_date(line_item)
+      @estimated_shipment_date ||=
+        (estimated_shipment_date_variant(line_item) || estimated_shipment_date_product(line_item))
+    end
+
+    def pre_order?(line_item)
+      return false if estimated_shipment_date(line_item).nil?
+
+      Time.zone.local(*estimated_shipment_date(line_item).split("-")) > Time.zone.now
+    end
   end
 end