solidus_bolt 0.0.1

data/app/controllers/spree/admin/bolts_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Spree
+  module Admin
+    class BoltsController < Spree::Admin::BaseController
+      before_action :bolt_configuration
+
+      def show; end
+
+      def edit; end
+
+      def update
+        if @bolt_configuration.update(bolt_configuration_params)
+          flash[:success] = t('spree.admin.bolt.updated_successfully')
+          redirect_to admin_bolt_path
+        else
+          flash[:error] = @bolt_configuration.errors.full_messages.to_sentence
+          render :edit
+        end
+      end
+
+      private
+
+      def bolt_configuration
+        @bolt_configuration = SolidusBolt::BoltConfiguration.fetch
+      end
+
+      def bolt_configuration_params
+        params
+          .require(:solidus_bolt_bolt_configuration)
+          .permit(
+            :bearer_token,
+            :environment,
+            :merchant_public_id,
+            :division_public_id,
+            :api_key,
+            :signing_secret,
+            :publishable_key
+          )
+      end
+    end
+  end
+end

data/app/decorators/controllers/solidus_bolt/spree_checkout_controller/add_addresses_to_bolt.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module SpreeCheckoutController
+    module AddAddressesToBolt
+      def finalize_order
+        if session[:bolt_access_token] && current_order.payments.last&.source_type == "SolidusBolt::PaymentSource"
+          spree_current_user.addresses.each do |address|
+            SolidusBolt::AddAddressJob.perform_later(
+              order: current_order,
+              access_token: SolidusBolt::Users::RefreshAccessTokenService.call(session: session),
+              address: address
+            )
+          end
+        end
+
+        super
+      end
+
+      Spree::CheckoutController.prepend self
+    end
+  end
+end

data/app/decorators/controllers/solidus_bolt/spree_checkout_controller/refresh_bolt_addresses.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module SpreeCheckoutController
+    module RefreshBoltAddresses
+      def before_address
+        SolidusBolt::Users::SyncAddressesService.call(
+          user: spree_current_user, access_token: SolidusBolt::Users::RefreshAccessTokenService.call(session: session)
+        )
+
+        super
+      end
+
+      Spree::CheckoutController.prepend self
+    end
+  end
+end

data/app/decorators/controllers/solidus_bolt/spree_checkout_controller/refresh_bolt_payment_source.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module SpreeCheckoutController
+    module RefreshBoltPaymentSource
+      def before_payment
+        SolidusBolt::Users::SyncPaymentSourcesService.call(
+          user: spree_current_user, access_token: SolidusBolt::Users::RefreshAccessTokenService.call(session: session)
+        )
+
+        super
+      end
+
+      Spree::CheckoutController.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_bolt/address_decorator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module AddressDecorator
+    def bolt_address(email)
+      {
+        street_address1: address1,
+        street_address2: address2,
+        locality: city,
+        region: state.abbr,
+        postal_code: zipcode,
+        country_code: country.iso,
+        first_name: Spree::Address::Name.new(name).first_name,
+        last_name: Spree::Address::Name.new(name).last_name,
+        phone: phone,
+        email: email
+      }
+    end
+
+    Spree::Address.prepend(self)
+  end
+end

data/app/decorators/models/solidus_bolt/log_entry_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module LogEntryDecorator
+    def parsed_details
+      @parsed_details ||= YAML.load(details) # rubocop:disable Security/YAMLLoad
+    end
+
+    Spree::LogEntry.prepend self
+  end
+end

data/app/decorators/models/solidus_bolt/order_decorator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module OrderDecorator
+    def bolt_cart
+      {
+        total_amount: display_total.cents,
+        order_reference: number,
+        currency: currency,
+        items: line_items.map do |line_item|
+          {
+            sku: line_item.sku,
+            name: line_item.name,
+            unit_price: cents(line_item.price),
+            quantity: line_item.quantity
+          }
+        end
+      }
+    end
+
+    def bolt_user_identifier
+      {
+        email: email,
+        phone: bill_address.phone
+      }
+    end
+
+    def bolt_user_identity
+      name = bill_address.name.split(' ')
+      {
+        first_name: name.first,
+        last_name: name.last
+      }
+    end
+
+    private
+
+    def cents(float)
+      (float * 100).to_i
+    end
+
+    Spree::Order.prepend(self)
+  end
+end

data/app/decorators/models/solidus_bolt/payment_decorator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module PaymentDecorator
+    def can_void?
+      super && state == 'pending'
+    end
+
+    Spree::Payment.prepend(self)
+  end
+end

data/app/decorators/omniauth/strategies/bolt_decorator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module OmniAuth::Strategies::BoltDecorator # rubocop:disable Style/ClassAndModuleChildren
+    def callback_phase
+      super.tap do
+        session[:bolt_access_token] = @access_token
+        session[:bolt_expiration_time] = @expiration_time
+        session[:bolt_refresh_token] = @refresh_token
+        session[:bolt_refresh_token_scope] = @refresh_token_scope
+      end
+    end
+
+    ::OmniAuth::Strategies::Bolt.prepend self
+  end
+end

data/app/jobs/solidus_bolt/add_address_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  class AddAddressJob < ApplicationJob
+    def perform(order:, access_token:, address:)
+      SolidusBolt::Accounts::AddAddressService.call(
+        order: order, access_token: access_token, address: address
+      )
+    end
+  end
+end

data/app/models/solidus_bolt/bolt_configuration.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_dependency 'solidus_bolt'
+
+module SolidusBolt
+  class BoltConfiguration < ApplicationRecord
+    after_commit :update_bolt_config_credentials
+
+    REGISTER_URL = 'https://merchant.bolt.com/register'
+    EVENTS = %w[all payment credit capture void auth pending rejected_irreversible rejected_reversible no_op
+                failed_payment newsletter_subscription risk_insights credit_card_deleted].freeze
+
+    enum environment: { production: 0, sandbox: 1, staging: 2 }
+
+    validate :config_can_be_created, on: :create
+
+    def self.fetch
+      first_or_create
+    end
+
+    def self.can_create?
+      count.zero?
+    end
+
+    def self.config_empty?
+      whitelist = %w[id created_at updated_at environment]
+
+      fetch.attributes.all? do |attr, val|
+        whitelist.include?(attr) || val.blank?
+      end
+    end
+
+    def environment_url
+      case BoltConfiguration.environments[environment]
+      when 0 then 'https://api.bolt.com'
+      when 1 then 'https://api-sandbox.bolt.com'
+      when 2 then 'https://api-staging.bolt.com'
+      end
+    end
+
+    def embed_js
+      case BoltConfiguration.environments[environment]
+      when 0 then 'https://connect.bolt.com/embed.js'
+      else 'https://connect-sandbox.bolt.com/embed.js'
+      end
+    end
+
+    def account_js
+      case BoltConfiguration.environments[environment]
+      when 0 then 'https://connect.bolt.com/account.js'
+      else
+        'https://connect-sandbox.bolt.com/account.js'
+      end
+    end
+
+    private
+
+    def update_bolt_config_credentials
+      bolt_config_credentials = Spree::Config
+                                .static_model_preferences
+                                .for_class(SolidusBolt::PaymentMethod)['bolt_config_credentials']
+                                &.preferences
+      return unless bolt_config_credentials
+
+      bolt_config_credentials[:bolt_api_key] = api_key
+      bolt_config_credentials[:bolt_signing_secret] = signing_secret
+      bolt_config_credentials[:bolt_publishable_key] = publishable_key
+    end
+
+    def config_can_be_created
+      errors.add(:base, 'Can create only one record for this Model') unless SolidusBolt::BoltConfiguration.can_create?
+    end
+  end
+end

data/app/models/solidus_bolt/gateway.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  class Gateway
+    def initialize(options = {}); end
+
+    def authorize(_amount, payment_source, gateway_options)
+      order_number = gateway_options[:order_id].split('-').first
+      order = fetch_spree_order(order_number)
+
+      authorization_response = ::SolidusBolt::Transactions::AuthorizeService.call(
+        order: order,
+        create_bolt_account: payment_source.create_bolt_account,
+        credit_card: credit_card_params(payment_source),
+        payment_method: payment_source.payment_method,
+        repeat: payment_source.card_id.present?
+      )
+
+      unless payment_source.card_id
+        payment_source.update(card_id: authorization_response['transaction']['from_credit_card']['id'])
+      end
+
+      ActiveMerchant::Billing::Response.new(true, 'Transaction approved', payment_source.attributes,
+        authorization: authorization_response['transaction']['reference'])
+    rescue ServerError => e
+      ActiveMerchant::Billing::Response.new(false, e, {})
+    end
+
+    def capture(float_amount, response_code, gateway_options)
+      payment = gateway_options[:originator]
+      payment_source = payment.source
+      payment_method = payment.payment_method
+      currency = gateway_options[:currency]
+
+      capture_response = SolidusBolt::Transactions::CaptureService.call(
+        transaction_reference: response_code,
+        amount: float_amount,
+        currency: currency,
+        payment_method: payment_method
+      )
+
+      ActiveMerchant::Billing::Response.new(
+        true,
+        'Transaction Captured', payment_source.attributes,
+        authorization: capture_response['reference']
+      )
+    rescue ServerError => e
+      ActiveMerchant::Billing::Response.new(false, e, {})
+    end
+
+    def void(response_code, gateway_options)
+      payment = gateway_options[:originator]
+      payment_source = payment.source
+      payment_method = payment.payment_method
+
+      void_response = SolidusBolt::Transactions::VoidService.call(
+        transaction_reference: response_code,
+        payment_method: payment_method
+      )
+
+      ActiveMerchant::Billing::Response.new(
+        true,
+        'Transaction Void', payment_source.attributes,
+        authorization: void_response['reference']
+      )
+    rescue ServerError => e
+      ActiveMerchant::Billing::Response.new(false, e, {})
+    end
+
+    def credit(amount, response_code, _gateway_options)
+      payment = Spree::Payment.find_by(response_code: response_code)
+      payment_source = payment.source
+      payment_method = payment.payment_method
+      currency = payment.currency
+
+      credit_response = SolidusBolt::Transactions::RefundService.call(
+        transaction_reference: response_code,
+        amount: amount,
+        currency: currency,
+        payment_method: payment_method
+      )
+
+      ActiveMerchant::Billing::Response.new(
+        true,
+        'Transaction Refunded', payment_source.attributes,
+        authorization: credit_response['reference']
+      )
+    rescue ServerError => e
+      ActiveMerchant::Billing::Response.new(false, e, {})
+    end
+
+    def purchase(_float_amount, payment_source, gateway_options)
+      order_number = gateway_options[:order_id].split('-').first
+      order = fetch_spree_order(order_number)
+
+      authorization_response = ::SolidusBolt::Transactions::AuthorizeService.call(
+        order: order,
+        create_bolt_account: payment_source.create_bolt_account,
+        credit_card: credit_card_params(payment_source),
+        payment_method: payment_source.payment_method,
+        auto_capture: true,
+        repeat: payment_source.card_id.present?
+      )
+
+      unless payment_source.card_id
+        payment_source.update(card_id: authorization_response['transaction']['from_credit_card']['id'])
+      end
+
+      ActiveMerchant::Billing::Response.new(true, 'Transaction approved and captured', payment_source.attributes,
+        authorization: authorization_response['transaction']['reference'])
+    rescue ServerError => e
+      ActiveMerchant::Billing::Response.new(false, e, {})
+    end
+
+    private
+
+    def fetch_spree_order(order_number)
+      Spree::Order.find_by(number: order_number)
+    end
+
+    def credit_card_params(payment_source)
+      card_params = { token_type: 'bolt' }
+
+      payment_source.attributes.each do |k, v|
+        next unless k.include?('card_')
+
+        card_params[k.gsub('card_', '').to_sym] = v unless v.nil?
+      end
+
+      card_params
+    end
+  end
+end

data/app/models/solidus_bolt/payment_method.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  class PaymentMethod < SolidusSupport.payment_method_parent_class
+    preference :bolt_api_key, :string
+    preference :bolt_signing_secret, :string
+    preference :bolt_publishable_key, :string
+
+    def gateway_class
+      ::SolidusBolt::Gateway
+    end
+
+    def payment_source_class
+      ::SolidusBolt::PaymentSource
+    end
+
+    def partial_name
+      'bolt'
+    end
+
+    def preferred_bolt_base_url
+      bolt_config.embed_js
+    end
+
+    def preferred_bolt_api_url
+      bolt_config.environment_url
+    end
+
+    private
+
+    def bolt_config
+      @bolt_config = SolidusBolt::BoltConfiguration.fetch
+    end
+  end
+end

data/app/models/solidus_bolt/payment_source.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_dependency 'solidus_bolt'
+
+module SolidusBolt
+  class PaymentSource < SolidusSupport.payment_source_parent_class
+    validates :payment_method_id, presence: true
+
+    def reusable?
+      card_id.present?
+    end
+  end
+end

data/app/models/solidus_bolt.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  def self.table_name_prefix
+    'solidus_bolt_'
+  end
+end

data/app/overrides/spree/shared/_head/add_bolt_embed_script.html.erb.deface

@@ -0,0 +1,6 @@
+<!-- insert_after 'meta[name="viewport"]' -->
+
+<meta name="bolt-publishable-key" content="<%= SolidusBolt::BoltConfiguration.fetch.publishable_key %>" />
+<meta name="bolt-domain" content="<%= SolidusBolt::BoltConfiguration.fetch.environment_url%>" />
+<script id="bolt-embedded" type="text/javascript" src="<%= SolidusBolt::BoltConfiguration.fetch.embed_js %>"></script>
+<script id="bolt-account" type="text/javascript" async="" src="<%= SolidusBolt::BoltConfiguration.fetch.account_js %>" data-publishable-key="<%= SolidusBolt::BoltConfiguration.fetch.publishable_key %>"></script>

data/app/services/solidus_bolt/accounts/add_address_service.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Accounts
+    class AddAddressService < SolidusBolt::BaseService
+      attr_reader :order, :address, :access_token
+
+      def initialize(order:, address:, access_token:)
+        @order = order
+        @address = address
+        @access_token = access_token
+        super
+      end
+
+      def call
+        return if address_already_uploaded?
+
+        add_address
+      end
+
+      private
+
+      def bolt_addresses
+        @bolt_addresses ||= SolidusBolt::Accounts::DetailService.call(access_token: access_token)['addresses']
+      end
+
+      def address_already_uploaded?
+        bolt_addresses.any? do |bolt_address|
+          bolt_address['street_address1'] == address.address1 &&
+          bolt_address['locality'] == address.city &&
+          bolt_address['region'] == address.state&.abbr &&
+          bolt_address['postal_code'] == address.zipcode
+        end
+      end
+
+      def add_address
+        handle_result(HTTParty.post("#{api_base_url}/#{api_version}/account/addresses", build_options))
+      end
+
+      def address_body
+        address.bolt_address(order.email).to_json
+      end
+
+      def build_options
+        {
+          body: address_body,
+          headers: {
+            'Authorization' => "Bearer #{access_token}",
+            'Content-Type' => 'application/json'
+          }.merge(authentication_header)
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/accounts/add_payment_method_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Accounts
+    class AddPaymentMethodService < SolidusBolt::BaseService
+      attr_reader :access_token, :credit_card, :address, :email
+
+      def initialize(access_token:, credit_card:, address:, email:)
+        @access_token = access_token
+        @credit_card = credit_card
+        @address = address
+        @email = email
+        super
+      end
+
+      def call
+        add_payment_method
+      end
+
+      private
+
+      def add_payment_method
+        handle_result(HTTParty.post("#{api_base_url}/#{api_version}/account/payment_methods", build_options))
+      end
+
+      def body
+        credit_card.merge(billing_address: address_body).to_json
+      end
+
+      def address_body
+        address.bolt_address(email)
+      end
+
+      def build_options
+        {
+          headers: {
+            'Authorization' => "Bearer #{access_token}",
+            'Content-Type' => 'application/json'
+          }.merge(authentication_header),
+          body: body
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/accounts/detail_service.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Accounts
+    class DetailService < SolidusBolt::BaseService
+      attr_reader :access_token
+
+      def initialize(access_token:)
+        @access_token = access_token
+        super
+      end
+
+      def call
+        detail
+      end
+
+      private
+
+      def detail
+        options = build_options
+        handle_result(
+          HTTParty.get(
+            "#{api_base_url}/#{api_version}/account",
+            options
+          )
+        )
+      end
+
+      def build_options
+        {
+          headers: {
+            'Authorization' => "Bearer #{access_token}",
+          }.merge(authentication_header)
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/accounts/detect_account_service.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Accounts
+    class DetectAccountService < SolidusBolt::BaseService
+      attr_reader :email
+
+      def initialize(email:)
+        @email = email
+        super
+      end
+
+      def call
+        detect_account
+      end
+
+      private
+
+      def detect_account
+        options = build_options
+        handle_result(
+          HTTParty.get(
+            "#{api_base_url}/#{api_version}/account/exists",
+            options
+          )
+        )
+      end
+
+      def build_options
+        { query: { email: email } }
+      end
+    end
+  end
+end