solidus_bolt 0.0.1

data/app/services/solidus_bolt/base_service.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  class BaseService
+    def initialize(*)
+      @config = SolidusBolt::BoltConfiguration.fetch
+    end
+
+    def call
+      raise NotImplementedError
+    end
+
+    def self.call(*args)
+      new(*args).call
+    end
+
+    private
+
+    def handle_result(result)
+      return result.parsed_response if result.success?
+
+      raise ServerError, error_message(result)
+    end
+
+    def error_message(result)
+      return result['errors'].map { |e| e['message'] }.join(', ') if result['errors']
+
+      "#{result['error']}: #{result['error_description']}"
+    end
+
+    def api_base_url
+      @config.environment_url
+    end
+
+    def api_version
+      'v1'
+    end
+
+    def generate_nonce
+      SecureRandom.hex
+    end
+
+    def authentication_header
+      { 'X-API-KEY' => @config.api_key }
+    end
+
+    def publishable_key
+      @config.publishable_key
+    end
+
+    def api_key
+      @config.api_key
+    end
+  end
+end

data/app/services/solidus_bolt/oauth/token_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Oauth
+    class TokenService < SolidusBolt::BaseService
+      attr_reader :authorization_code, :scope
+
+      def initialize(authorization_code:, scope:)
+        @authorization_code = authorization_code
+        @scope = scope
+        super
+      end
+
+      def call
+        token
+      end
+
+      private
+
+      def token
+        options = build_options
+        handle_result(
+          HTTParty.post(
+            "#{api_base_url}/#{api_version}/oauth/token",
+            options
+          )
+        )
+      end
+
+      def build_options
+        {
+          body: {
+            grant_type: 'authorization_code',
+            code: authorization_code,
+            scope: scope,
+            client_id: publishable_key,
+            client_secret: api_key
+          }
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/payments/capture_sync_service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Payments
+    class CaptureSyncService < SolidusBolt::BaseService
+      attr_reader :payment, :capture_amount
+
+      def initialize(payment:, capture_amount:)
+        @payment = payment
+        @capture_amount = capture_amount
+        super
+      end
+
+      def call
+        return if payment.completed?
+
+        amount = Money.new(capture_amount).to_d
+
+        payment.capture_events.create!(amount: amount)
+        payment.update!(amount: amount, state: 'completed')
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/payments/credit_sync_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Payments
+    class CreditSyncService < BaseService
+      attr_reader :payment, :amount, :transaction_id, :refund_reason, :order
+
+      def initialize(payment:, amount:, transaction_id:)
+        @payment = payment
+        @amount = amount
+        @transaction_id = transaction_id
+        @refund_reason = Spree::RefundReason.return_processing_reason&.id
+        @order = payment.order
+        super
+      end
+
+      def call
+        return if Spree::Refund.find_by(transaction_id: transaction_id)
+
+        create_refund
+        order.recalculate
+      end
+
+      private
+
+      def create_refund
+        payload = {
+          payment_id: payment.id,
+          amount: amount.to_f / 100,
+          transaction_id: transaction_id,
+          refund_reason_id: refund_reason
+        }
+
+        if Spree.solidus_gem_version >= Gem::Version.create('3.0')
+          Spree::Refund.create!(payload)
+        else
+          # Skip after_save callbacks that call the Gateway. Callbacks removed from solidus 3.0 up
+          # https://github.com/solidusio/solidus/blob/v2.11/core/app/models/spree/refund.rb#L20-L22
+          Spree::Refund.insert!(payload) # rubocop:disable Rails/SkipsModelValidations
+        end
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/payments/void_sync_service.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Payments
+    class VoidSyncService < BaseService
+      attr_reader :payment
+
+      def initialize(payment:)
+        @payment = payment
+        super
+      end
+
+      def call
+        payment.void! unless payment.void?
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/server_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  class ServerError < StandardError
+  end
+end

data/app/services/solidus_bolt/transactions/authorize_service.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Transactions
+    class AuthorizeService < SolidusBolt::Transactions::BaseService
+      attr_reader :order, :create_bolt_account, :credit_card, :auto_capture, :repeat
+
+      def initialize(order:, create_bolt_account:, credit_card:, payment_method:, auto_capture: false, repeat: false)
+        @order = order
+        @create_bolt_account = create_bolt_account
+        @credit_card = credit_card
+        @auto_capture = auto_capture
+        @repeat = repeat
+        super
+      end
+
+      def call
+        authorize
+      end
+
+      private
+
+      def authorize
+        url = "#{api_base_url}/#{api_version}/merchant/transactions/authorize"
+        handle_result(
+          HTTParty.post(
+            url, headers: headers, body: (repeat ? repeat_authorization_body : new_authorization_body).to_json
+          )
+        )
+      end
+
+      def new_authorization_body
+        body.merge(
+          credit_card: credit_card,
+          division_id: '', # used to be defined, now needs to stay empty for call to work
+          shipping_address: shipping_address,
+          create_bolt_account: create_bolt_account
+        )
+      end
+
+      def repeat_authorization_body
+        body.merge(
+          credit_card_id: credit_card[:id]
+        )
+      end
+
+      def body
+        {
+          auto_capture: auto_capture,
+          cart: order.bolt_cart,
+          source: 'direct_payments',
+          user_identifier: order.bolt_user_identifier,
+          user_identity: order.bolt_user_identity
+        }
+      end
+
+      def shipping_address
+        order.shipping_address.yield_self do |address|
+          address.bolt_address(order.email)
+        end
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json',
+          'X-Nonce' => generate_nonce,
+          'X-Publishable-Key' => publishable_key
+        }.merge(authentication_header)
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/transactions/base_service.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Transactions
+    class BaseService < SolidusBolt::BaseService
+      attr_reader :payment_method
+
+      def initialize(payment_method:, **args)
+        @payment_method = payment_method
+        super
+      end
+
+      private
+
+      def api_base_url
+        payment_method.preferred_bolt_api_url
+      end
+
+      def authentication_header
+        { 'X-API-KEY' => payment_method.preferred_bolt_api_key }
+      end
+
+      def publishable_key
+        payment_method.preferred_bolt_publishable_key
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/transactions/capture_service.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Transactions
+    class CaptureService < SolidusBolt::Transactions::BaseService
+      attr_reader :transaction_reference, :amount, :currency
+
+      def initialize(transaction_reference:, amount:, currency:, payment_method:)
+        @transaction_reference = transaction_reference
+        @amount = amount
+        @currency = currency
+        super
+      end
+
+      def call
+        capture
+      end
+
+      private
+
+      def capture
+        options = build_options
+        handle_result(
+          HTTParty.post(
+            "#{api_base_url}/#{api_version}/merchant/transactions/capture",
+            options
+          )
+        )
+      end
+
+      def build_options
+        {
+          body: {
+            transaction_reference: transaction_reference,
+            amount: amount,
+            currency: currency
+          }.to_json,
+          headers: {
+            'X-Nonce' => generate_nonce,
+            'Content-Type' => 'application/json'
+          }.merge(authentication_header)
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Transactions
+    class DetailService < SolidusBolt::Transactions::BaseService
+      attr_reader :transaction_reference
+
+      def initialize(transaction_reference:, payment_method:)
+        @transaction_reference = transaction_reference
+        super
+      end
+
+      def call
+        detail
+      end
+
+      private
+
+      def detail
+        options = build_options
+        handle_result(
+          HTTParty.get(
+            "#{api_base_url}/#{api_version}/merchant/transactions/#{transaction_reference}",
+            options
+          )
+        )
+      end
+
+      def build_options
+        {
+          headers: {
+            'X-Nonce' => generate_nonce
+          }.merge(authentication_header)
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/transactions/refund_service.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Transactions
+    class RefundService < SolidusBolt::Transactions::BaseService
+      attr_reader :transaction_reference, :amount, :currency
+
+      def initialize(transaction_reference:, amount:, currency:, payment_method:)
+        @transaction_reference = transaction_reference
+        @amount = amount
+        @currency = currency
+        super
+      end
+
+      def call
+        refund
+      end
+
+      private
+
+      def refund
+        options = build_options
+        handle_result(
+          HTTParty.post(
+            "#{api_base_url}/#{api_version}/merchant/transactions/credit",
+            options
+          )
+        )
+      end
+
+      def build_options
+        {
+          body: {
+            transaction_reference: transaction_reference,
+            amount: amount,
+            currency: currency
+          }.to_json,
+          headers: {
+            'X-Nonce' => generate_nonce,
+            'Content-Type' => 'application/json'
+          }.merge(authentication_header)
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/transactions/void_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Transactions
+    class VoidService < SolidusBolt::Transactions::BaseService
+      attr_reader :transaction_reference, :transaction_id
+
+      def initialize(payment_method:, transaction_reference: nil, transaction_id: nil)
+        @transaction_reference = transaction_reference
+        @transaction_id = transaction_id
+        super
+      end
+
+      def call
+        void
+      end
+
+      private
+
+      def void
+        options = build_options
+        handle_result(
+          HTTParty.post(
+            "#{api_base_url}/#{api_version}/merchant/transactions/void",
+            options
+          )
+        )
+      end
+
+      def build_options
+        {
+          body: {
+            transaction_reference: transaction_reference,
+            transaction_id: transaction_id,
+          }.to_json,
+          headers: {
+            'X-Nonce' => generate_nonce,
+            'Content-Type' => 'application/json'
+          }.merge(authentication_header)
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/users/refresh_access_token_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Users
+    class RefreshAccessTokenService < SolidusBolt::BaseService
+      attr_reader :session
+
+      def initialize(session:)
+        @session = session
+        super
+      end
+
+      def call
+        return if session[:bolt_access_token].nil?
+        return session[:bolt_access_token] if session[:bolt_expiration_time] >= Time.now.utc
+
+        refresh_access_token
+      end
+
+      private
+
+      def refresh_access_token
+        response = handle_result(HTTParty.post("#{api_base_url}/#{api_version}/oauth/token", build_options))
+
+        session[:bolt_expiration_time] = Time.now.utc + response['expires_in']
+        session[:bolt_refresh_token] = response['refresh_token']
+        session[:bolt_refresh_token_scope] = response['refresh_token_scope']
+        session[:bolt_access_token] = response['access_token']
+      end
+
+      def build_options
+        {
+          body: {
+            grant_type: 'refresh_token',
+            refresh_token: session[:bolt_refresh_token],
+            client_id: publishable_key,
+            scope: session[:bolt_refresh_token_scope],
+            client_secret: api_key
+          }
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/users/sync_addresses_service.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Users
+    class SyncAddressesService < SolidusBolt::BaseService
+      attr_reader :user, :access_token
+
+      def initialize(user:, access_token:)
+        @access_token = access_token
+        @user = user
+        super
+      end
+
+      def call
+        return if user.nil? || access_token.nil?
+
+        bolt_addresses.each do |bolt_address|
+          default = bolt_address['default']
+          address = convert_to_solidus(bolt_address)
+          user.save_in_address_book(address, default, :shipping)
+          user.save_in_address_book(address, default, :billing)
+        end
+      end
+
+      private
+
+      def user_info
+        @user_info ||= Accounts::DetailService.call(access_token: access_token)
+      end
+
+      def bolt_addresses
+        user_info['addresses']
+      end
+
+      def convert_to_solidus(bolt_address)
+        country = Spree::Country.find_by(iso: bolt_address['country_code'])
+        {
+          address1: bolt_address['street_address1'],
+          city: bolt_address['locality'],
+          state: country.states.find_by(abbr: bolt_address['region_code']),
+          zipcode: bolt_address['postal_code'],
+          name: bolt_address['name'],
+          country: country,
+          phone: bolt_address['phone_number'] || user_info['profile']['phone']
+        }
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/users/sync_payment_sources_service.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Users
+    class SyncPaymentSourcesService < SolidusBolt::BaseService
+      attr_reader :user, :access_token, :bolt_payment_method
+
+      def initialize(user:, access_token:)
+        @user = user
+        @access_token = access_token
+        @bolt_payment_method = SolidusBolt::PaymentMethod.last
+        super
+      end
+
+      def call
+        return if user.nil? || access_token.nil? || bolt_payment_method.nil?
+
+        payment_methods.each do |payment_method|
+          add_payment_source(payment_method)
+        end
+      end
+
+      private
+
+      def user_info
+        @user_info ||= Accounts::DetailService.call(access_token: access_token)
+      end
+
+      def payment_methods
+        user_info['payment_methods']
+      end
+
+      def spree_wallet
+        @spree_wallet ||= Spree::Wallet.new(user)
+      end
+
+      def add_payment_source(payment_method)
+        # format of card_expiration: '2022-04'
+        card_expiration = "#{payment_method['exp_year']}-#{payment_method['exp_month'].to_s.rjust(2, '0')}"
+        payment_source = SolidusBolt::PaymentSource.find_or_create_by!(
+          payment_method_id: bolt_payment_method.id,
+          card_last4: payment_method['last4'],
+          card_expiration: card_expiration,
+          card_id: payment_method['id']
+        )
+        spree_wallet.add(payment_source)
+      end
+    end
+  end
+end

data/app/services/solidus_bolt/webhooks/create_service.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidusBolt
+  module Webhooks
+    class CreateService < SolidusBolt::BaseService
+      attr_reader :division_public_id, :event, :url
+
+      def initialize(event:, url:)
+        @event = event
+        @url = url
+        @division_public_id = SolidusBolt::BoltConfiguration.fetch.division_public_id
+        super
+      end
+
+      def call
+        create
+      end
+
+      private
+
+      def create
+        options = build_options
+        handle_result(
+          HTTParty.post(
+            "#{api_base_url}/#{api_version}/webhooks",
+            options
+          )
+        )
+      end
+
+      def build_options
+        {
+          body: {
+            division_id: division_public_id,
+            url: url
+          }.merge(event_fields).to_json,
+          headers: {
+            'Content-Type' => 'application/json'
+          }.merge(authentication_header)
+        }
+      end
+
+      def event_fields
+        if event == 'all'
+          { event_group: event }
+        else
+          { events: [event] }
+        end
+      end
+    end
+  end
+end

data/app/views/spree/admin/bolt_webhooks/new.html.erb

@@ -0,0 +1,22 @@
+<% admin_breadcrumb(plural_resource_name(SolidusBolt::BoltConfiguration)) %>
+
+<%= form_for :bolt_webhook, url: admin_bolt_webhook_path do |f| %>
+  <fieldset class="form-group no-border-bottom no-border-top">
+    <div class="row">
+      <div id="general_fields" class="col-9">
+        <div class="row">
+          <div class="col-12">
+            <%= f.label :event %>
+            <%= f.select :event, SolidusBolt::BoltConfiguration::EVENTS %><br />
+            <%= f.label :webhook_url %>
+            <%= f.text_field :webhook_url, class: 'fullwidth', value: 'https://domain.com/webhooks/bolt' %>
+          </div>
+        </div>
+        <div class="row p-2 justify-content-center">
+          <%= f.submit 'Create', class: 'btn btn-primary', data: { disable_with: 'Creating..' } %>
+          <%= link_to 'Cancel', admin_bolt_path, class: 'button' %>
+        </div>
+      </div>
+    </div>
+  </fieldset>
+<% end %>