solidus_afterpay 0.1.0 → 0.3.0

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

data/app/models/solidus_afterpay/payment_method.rb

@@ -4,11 +4,9 @@ module SolidusAfterpay
   class PaymentMethod < SolidusSupport.payment_method_parent_class
     preference :merchant_id, :string
     preference :secret_key, :string
-    preference :deferred, :boolean
     preference :popup_window, :boolean
-    preference :minimum_amount, :decimal
-    preference :maximum_amount, :decimal
-    preference :currency, :string
+    preference :merchant_key, :string
+    preference :excluded_products, :string
 
     def gateway_class
       SolidusAfterpay::Gateway
@@ -33,24 +31,59 @@ module SolidusAfterpay
     end
 
     def available_for_order?(order)
+      return false if order.line_items.any?{ |item| excluded_product_ids.include? item.variant.product_id }
+
       available_payment_currency == order.currency && available_payment_range.include?(order.total)
     end
 
+    def excluded_product?(product)
+      excluded_product_ids.include? product.id
+    end
+
     private
 
-    def available_payment_range
-      min = preferred_minimum_amount || configuration&.minimumAmount&.amount.to_f
-      max = preferred_maximum_amount || configuration&.maximumAmount&.amount.to_f
+    def excluded_product_ids
+      return [] if preferred_excluded_products.nil?
 
-      min..max
+      preferred_excluded_products.split(",").map(&:to_i)
     end
 
-    def available_payment_currency
-      preferred_currency || configuration&.maximumAmount&.currency
+    def available_payment_range
+      minimum_amount..maximum_amount
     end
 
     def configuration
       @configuration ||= gateway.retrieve_configuration
     end
+
+    def minimum_amount
+      @minimum_amount ||= fetch_configuration(:minimumAmount, :amount).to_f
+    end
+
+    def maximum_amount
+      @maximum_amount ||= fetch_configuration(:maximumAmount, :amount).to_f
+    end
+
+    def available_payment_currency
+      @available_payment_currency = fetch_configuration(:maximumAmount, :currency)
+    end
+
+    def fetch_configuration(*keys)
+      cache_key = "solidus_afterpay_configuration_#{keys.join('_')}"
+
+      return Rails.cache.read(cache_key) if Rails.cache.exist?(cache_key)
+
+      value = configuration&.dig(*keys)
+
+      unless configuration.nil?
+        Rails.cache.write(
+          cache_key,
+          value,
+          expires_in: SolidusAfterpay.config.cache_expiry
+        )
+      end
+
+      value
+    end
   end
 end

data/app/models/solidus_afterpay/payment_source.rb

@@ -13,7 +13,7 @@ module SolidusAfterpay
     def can_void?(payment)
       payment_method = payment.payment_method
 
-      return false unless payment_method.preferred_deferred
+      return false if payment_method.auto_capture
 
       payment_state = payment_method.gateway.find_payment(order_id: payment.response_code).try(:[], :paymentState)
 

data/app/presentes/solidus_afterpay/order_presenter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  class OrderPresenter
+    def initialize(order:)
+      @order = order
+    end
+
+    def line_items_tax_amount
+      order.line_item_adjustments.tax.eligible.sum(&:amount)
+    end
+
+    private
+
+    attr_reader :order
+  end
+end

data/app/presentes/solidus_afterpay/shipping_rate_presenter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  class ShippingRatePresenter
+    def initialize(shipping_rate:)
+      @shipping_rate = shipping_rate
+    end
+
+    def order_amount
+      shipping_rate.order.item_total.to_f +
+        shipping_rate.cost +
+        shipping_rate.taxes.sum(&:amount) +
+        order_presenter.line_items_tax_amount
+    end
+
+    def amount_with_taxes
+      shipping_rate.cost.to_f + shipping_rate.taxes.sum(&:amount)
+    end
+
+    private
+
+    def order_presenter
+      @order_presenter ||= SolidusAfterpay::OrderPresenter.new(order: shipping_rate.order)
+    end
+
+    attr_reader :shipping_rate
+  end
+end

data/app/services/solidus_afterpay/base_service.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  class BaseService
+    def self.call(*args, **kws, &block)
+      new(*args, **kws, &block).call
+    end
+
+    def call
+      raise NotImplementedError
+    end
+  end
+end

data/app/services/solidus_afterpay/shipping_rate_builder_service.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  class ShippingRateBuilderService < BaseService
+    def initialize(order:)
+      @order = order
+
+      super()
+    end
+
+    def call
+      order.shipments.map do |shipment|
+        shipment.shipping_rates.map do |rate|
+          shipping_rate_presenter = SolidusAfterpay::ShippingRatePresenter.new(shipping_rate: rate)
+
+          {
+            id: rate.id.to_s,
+            name: rate.name,
+            description: rate.display_price,
+            shipping_amount: shipping_rate_presenter.amount_with_taxes.round(4).to_s,
+            currency: rate.currency,
+            order_amount: shipping_rate_presenter.order_amount.round(4).to_s
+          }
+        end
+      end.flatten
+    end
+
+    private
+
+    attr_reader :order
+  end
+end

data/app/services/solidus_afterpay/update_order_addresses_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  class UpdateOrderAddressesService < BaseService
+    def initialize(order:, address_params:)
+      @order = order
+      @address_params = address_params
+
+      super()
+    end
+
+    def call
+      order.state = 'address'
+      order.email = SolidusAfterpay.configuration.dummy_email if order.email.blank?
+      order.ship_address_attributes = address_object
+      order.bill_address_attributes = address_object
+      order.save
+    end
+
+    private
+
+    def address_object
+      {
+        address1: address_params[:address1],
+        address2: address_params[:address2],
+        name: address_params[:name],
+        city: address_params[:suburb],
+        zipcode: address_params[:postcode],
+        phone: address_params[:phoneNumber],
+        country: country,
+        state: state
+      }
+    end
+
+    def country
+      @country ||= ::Spree::Country.find_by(iso: address_params[:countryCode])
+    end
+
+    def state
+      @state ||= ::Spree::State.find_by(country_id: country.id, abbr: address_params[:state])
+    end
+
+    attr_reader :order, :address_params
+  end
+end

data/app/services/solidus_afterpay/update_order_attributes_service.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidusAfterpay
+  class UpdateOrderAttributesService < BaseService
+    def initialize(order:, afterpay_order_token:, payment_method:, request_env:)
+      @order = order
+      @afterpay_order_token = afterpay_order_token
+      @payment_method = payment_method
+      @request_env = request_env
+
+      super()
+    end
+
+    def call
+      return false if afterpay_order.nil?
+
+      ::Spree::OrderUpdateAttributes.new(order, update_params, request_env: request_env).apply
+    end
+
+    private
+
+    def afterpay_order
+      @afterpay_order ||= payment_method.gateway.find_order(token: afterpay_order_token)
+    end
+
+    def shipping_rate
+      @shipping_rate ||= ::Spree::ShippingRate.find(afterpay_order.shippingOptionIdentifier.to_i)
+    end
+
+    def update_params
+      {
+        email: afterpay_order.consumer.email,
+        shipments_attributes: [{
+          selected_shipping_rate_id: shipping_rate.id,
+          id: shipping_rate.shipment.id
+        }],
+        payments_attributes: [{
+          payment_method_id: payment_method.id,
+          amount: afterpay_order.amount.amount,
+          source_attributes: {
+            token: afterpay_order_token
+          }
+        }]
+      }
+    end
+
+    attr_reader :order, :afterpay_order_token, :payment_method, :request_env
+  end
+end

data/app/views/solidus_afterpay/_afterpay_checkout_button.html.erb

@@ -0,0 +1,9 @@
+<% payment_method = SolidusAfterpay::PaymentMethod.active.first unless local_assigns[:payment_method] %>
+
+<%= render partial: 'solidus_afterpay/afterpay_javascript', locals: { payment_method: payment_method } if Rails.env != "test" %>
+
+<% if payment_method.present? && payment_method.available_for_order?(@order)  %>
+  <button type="button" id="afterpay-button" data-afterpay-entry-point="cart" data-order-number="<%= @order.number %>" data-payment-method-id="<%= payment_method.id %>">
+    <%= I18n.t('solidus_afterpay.express_checkout.button') %>
+  </button>
+<% end %>

data/app/views/solidus_afterpay/_afterpay_javascript.html.erb

@@ -1,5 +1,8 @@
+<% payment_method = SolidusAfterpay::PaymentMethod.active.first unless local_assigns[:payment_method] %>
 <% if payment_method.present? %>
   <% content_for :head do %>
-    <%= include_afterpay_js(test_mode: payment_method.preferred_test_mode) %>
+    <%= include_afterpay_js(
+      test_mode: payment_method.preferred_test_mode,
+      merchant_key: payment_method.preferred_merchant_key) %>
   <% end %>
 <% end %>

data/app/views/spree/api/payments/source_views/_afterpay.json.jbuilder

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-json.nil!
+json.call(payment_source, :id, :token, :created_at)

data/app/views/spree/shared/_afterpay_messaging.html.erb

@@ -1,13 +1,15 @@
-<% content_for :head do %>
-  <script
-    src="https://js.afterpay.com/afterpay-1.x.js"
-    data-analytics-enabled
-    async
-    <% if max %>
-    data-min="<%= min %>"
-    data-max="<%= max %>"
-    <% end %>
-  ></script>
-<% end %>
+<% if products.none? { |product| ::SolidusAfterpay::PaymentMethod.active.first.excluded_product?(product) } %>
+  <% content_for :head do %>
+    <script
+      src="https://js.afterpay.com/afterpay-1.x.js"
+      data-analytics-enabled
+      async
+      <% if max %>
+      data-min="<%= min %>"
+      data-max="<%= max %>"
+      <% end %>
+    ></script>
+  <% end %>
 
-<%= content_tag("afterpay-placement", nil, data: data) %>
+  <%= content_tag("afterpay-placement", nil, data: data) %>
+<% end %>

data/bin/sandbox

@@ -22,7 +22,7 @@ if [ ! -z $SOLIDUS_BRANCH ]
 then
   BRANCH=$SOLIDUS_BRANCH
 else
-  BRANCH="master"
+  BRANCH="main"
 fi
 
 extension_name="solidus_afterpay"

data/config/locales/en.yml

@@ -10,3 +10,7 @@ en:
     resource_not_found: The resource you were looking for could not be found.
     order_token_not_found: Invalid order confirmation data passed in.
     unauthorized: You are not authorized to perform that action.
+    express_checkout:
+      errors:
+        unable_place_order: 'Unable to place the order!'
+      button: Checkout with Afterpay

data/config/routes.rb

@@ -4,4 +4,6 @@ SolidusAfterpay::Engine.routes.draw do
   match '/callbacks/confirm', to: '/solidus_afterpay/callbacks#confirm', via: %i[get post]
   get '/callbacks/cancel', to: '/solidus_afterpay/callbacks#cancel'
   post '/checkouts', to: '/solidus_afterpay/checkouts#create'
+  patch '/express_callbacks/:order_number', to: '/solidus_afterpay/express_callbacks#update'
+  post '/express_callbacks/:order_number', to: '/solidus_afterpay/express_callbacks#create'
 end

data/lib/generators/solidus_afterpay/install/templates/initializer.rb

@@ -2,4 +2,16 @@
 
 SolidusAfterpay.configure do |config|
   config.use_solidus_api = false
+  # A class that extend SolidusAfterpay::BaseService, respond to .call, accepting a Spree::Order
+  # and return an Afterpay shipping rate object (check the Afterpay documentation)
+  # config.shipping_rate_builder_service_class = 'SolidusAfterpay::ShippingRateBuilderService'
+
+  # A class that extend SolidusAfterpay::BaseService, respond to .call, accepting a Spree::Order
+  # and return true or false
+  # config.update_order_attributes_service_class = 'SolidusAfterpay::UpdateOrderAttributesService'
+
+  # There is a cache for retrieving the minimum amount, maximum amount and the currency from Afterpay
+  # the default value us set to 1.day, this is also recommended by Afterpay itself. If you prefer a shorter
+  # or longer time simply uncomment config.cache_expiry and add the preferred value.
+  # config.cache_expiry = 1.day
 end

data/lib/solidus_afterpay/configuration.rb

@@ -3,6 +3,25 @@
 module SolidusAfterpay
   class Configuration
     attr_accessor :use_solidus_api
+    attr_writer :shipping_rate_builder_service_class, :cache_expiry
+
+    def dummy_email
+      'afterpay@dummy.com'
+    end
+
+    def shipping_rate_builder_service_class
+      @shipping_rate_builder_service_class ||= 'SolidusAfterpay::ShippingRateBuilderService'
+      @shipping_rate_builder_service_class.constantize
+    end
+
+    def update_order_attributes_service_class
+      @update_order_attributes_service_class ||= 'SolidusAfterpay::UpdateOrderAttributesService'
+      @update_order_attributes_service_class.constantize
+    end
+
+    def cache_expiry
+      @cache_expiry ||= 1.day
+    end
   end
 
   class << self
@@ -21,5 +40,15 @@ module SolidusAfterpay
 
       SolidusAfterpay::BaseController
     end
+
+    # rubocop:disable Rails/Delegate
+    def shipping_rate_builder_service_class
+      configuration.shipping_rate_builder_service_class
+    end
+
+    def update_order_attributes_service_class
+      configuration.update_order_attributes_service_class
+    end
+    # rubocop:enable Rails/Delegate
   end
 end

data/lib/solidus_afterpay/engine.rb

@@ -19,7 +19,7 @@ module SolidusAfterpay
     initializer "spree.payment_methods.register_afterpay_payment_method",
       after: "spree.register.payment_methods" do |app|
       app.config.spree.payment_methods << "SolidusAfterpay::PaymentMethod"
-      Spree::PermittedAttributes.source_attributes.concat [:token]
+      Spree::PermittedAttributes.source_attributes.push :token
     end
   end
 end

data/lib/solidus_afterpay/testing_support/factories.rb

@@ -18,3 +18,23 @@ FactoryBot.define do
     token { "12345678910" }
   end
 end
+
+FactoryBot.define do
+  factory :order_with_variant_property, class: "Spree::Order", parent: :order_with_line_items do
+    after(:build) do |order|
+      variant_property_rule_value = create(:variant_property_rule_value, value: "2021-09-19",
+        property: create(:property, name: "estimatedShipmentDate"))
+      order.line_items.first.variant.product.variant_property_rules << variant_property_rule_value.variant_property_rule
+      order.line_items.first.variant.option_values << variant_property_rule_value.variant_property_rule
+                                                                                 .option_values.first
+    end
+  end
+end
+
+FactoryBot.define do
+  factory :order_with_product_property, class: "Spree::Order", parent: :order_with_line_items do
+    after(:build) do |order|
+      order.line_items.first.product.set_property("estimatedShipmentDate", "2025-10-25")
+    end
+  end
+end

data/lib/solidus_afterpay/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidusAfterpay
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

data/solidus_afterpay.gemspec

@@ -16,23 +16,23 @@ Gem::Specification.new do |spec|
   spec.metadata['source_code_uri'] = 'https://github.com/solidusio-contrib/solidus_afterpay'
   spec.metadata['changelog_uri'] = 'https://github.com/solidusio-contrib/solidus_afterpay/blob/master/CHANGELOG.md'
 
-  spec.required_ruby_version = Gem::Requirement.new('~> 2.5')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5', '< 4')
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
 
   spec.files = files.grep_v(%r{^(test|spec|features)/})
-  spec.test_files = files.grep(%r{^(test|spec|features)/})
   spec.bindir = "exe"
   spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'afterpay', '~> 0.2.0'
-  spec.add_dependency 'solidus_core', ['>= 2.0.0', '< 4']
+  spec.add_dependency 'afterpay', '~> 0.6.0'
+  spec.add_dependency 'solidus_core', ['>= 2.0.0']
   spec.add_dependency 'solidus_support', '~> 0.5'
 
   spec.add_development_dependency 'solidus_dev_support', '~> 2.5'
   spec.add_development_dependency 'vcr', '~> 6.0'
   spec.add_development_dependency 'webmock', '~> 3.14'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end