flowcommerce_spree 0.0.1

data/app/views/spree/order_mailer/confirm_email.text.erb

@@ -0,0 +1,38 @@
+<%= Spree.t('order_mailer.confirm_email.dear_customer') %>
+
+<%= Spree.t('order_mailer.confirm_email.instructions') %>
+
+============================================================
+<%= Spree.t('order_mailer.confirm_email.order_summary') %>
+============================================================
+<% @order.line_items.each do |item| %>
+  <%= item.variant.sku %> <%= raw(item.variant.product.name) %> <%= raw(item.variant.options_text) -%> (<%=item.quantity%>) @ <%= item.single_money %> = <%= @order.flow_line_item_price(line_item, :with_quantity) %>
+<% end %>
+============================================================
+<%= Spree.t('order_mailer.confirm_email.subtotal', :subtotal => @order.display_item_total) %>
+<% if @order.line_item_adjustments.exists? %>
+  <% if @order.all_adjustments.promotion.eligible.exists? %>
+    <% @order.all_adjustments.promotion.eligible.group_by(&:label).each do |label, adjustments| %>
+      <%= Spree.t(:promotion) %>: <%= label %> <%= Spree::Money.new(adjustments.sum(&:amount), currency: @order.currency) %>
+    <% end %>
+  <% end %>
+<% end %>
+
+<% @order.shipments.group_by { |s| s.selected_shipping_rate.try(:name) }.each do |name, shipments| %>
+  <%= Spree.t(:shipping) %>: <%= name %> <%= Spree::Money.new(shipments.sum(&:discounted_cost), currency: @order.currency) %>
+<% end %>
+
+<% if @order.all_adjustments.eligible.tax.exists? %>
+  <% @order.all_adjustments.eligible.tax.group_by(&:label).each do |label, adjustments| %>
+    <%= Spree.t(:tax) %>: <%= label %> <%= Spree::Money.new(adjustments.sum(&:amount), currency: @order.currency) %>
+  <% end %>
+<% end %>
+
+<% @order.adjustments.eligible.each do |adjustment| %>
+  <% next if (adjustment.source_type == 'Spree::TaxRate') and (adjustment.amount == 0) %>
+  <%= adjustment.label %> <%= adjustment.display_amount %>
+<% end %>
+============================================================
+<%= Spree.t('order_mailer.confirm_email.total', :total => @order.display_total) %>
+
+<%= Spree.t('order_mailer.confirm_email.thanks') %>

data/config/initializers/flowcommerce_spree.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  ORGANIZATION = ENV.fetch('FLOW_ORGANIZATION', 'flow.io')
+  BASE_COUNTRY = ENV.fetch('FLOW_BASE_COUNTRY', 'USA')
+  API_KEY = ENV.fetch('FLOW_TOKEN', 'test_key')
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+FlowcommerceSpree::Engine.routes.draw do
+  post '/event-target', to: 'webhooks#handle_flow_web_hook_event'
+end

data/db/migrate/20201021160159_add_type_and_meta_to_spree_zone.rb

@@ -0,0 +1,23 @@
+class AddTypeAndMetaToSpreeZone < ActiveRecord::Migration
+  def up
+    add_column :spree_zones, :klass, :text unless column_exists?(:spree_zones, :klass)
+    add_column :spree_zones, :status, :text unless column_exists?(:spree_zones, :status)
+    add_column :spree_zones, :meta, :jsonb, default: '{}' unless column_exists?(:spree_zones, :meta)
+
+    add_index :spree_zones, :meta, using: :gin unless index_exists?(:spree_zones, :meta)
+    add_index :spree_zones, %i[id klass] unless index_exists?(:spree_zones, %i[id klass])
+    add_index :spree_zones, %i[klass name], unique: true unless index_exists?(:spree_zones, %i[klass name])
+    add_index :spree_zones, :status unless index_exists?(:spree_zones, :status)
+  end
+
+  def down
+    remove_index :spree_zones, :status if index_exists?(:spree_zones, :status)
+    remove_index :spree_zones, %i[klass name] if index_exists?(:spree_zones, %i[klass name])
+    remove_index :spree_zones, %i[id klass] if index_exists?(:spree_zones, %i[id klass])
+    remove_index :spree_zones, :meta if index_exists?(:spree_zones, :meta)
+
+    remove_column :spree_zones, :meta if column_exists?(:spree_zones, :meta)
+    remove_column :spree_zones, :status if column_exists?(:spree_zones, :status)
+    remove_column :spree_zones, :klass if column_exists?(:spree_zones, :klass)
+  end
+end

data/db/migrate/20201021755957_add_meta_to_spree_tables.rb

@@ -0,0 +1,17 @@
+class AddMetaToSpreeTables < ActiveRecord::Migration
+  def up
+    add_column :spree_products, :meta, :jsonb, default: '{}' unless column_exists?(:spree_products, :meta)
+    add_column :spree_variants, :meta, :jsonb, default: '{}' unless column_exists?(:spree_variants, :meta)
+    add_column :spree_orders, :meta, :jsonb, default: '{}' unless column_exists?(:spree_orders, :meta)
+    add_column :spree_promotions, :meta, :jsonb, default: '{}' unless column_exists?(:spree_promotions, :meta)
+    add_column :spree_credit_cards, :meta, :jsonb, default: '{}' unless column_exists?(:spree_credit_cards, :meta)
+  end
+
+  def down
+    remove_column :spree_products, :meta if column_exists?(:spree_products, :meta)
+    remove_column :spree_variants, :meta if column_exists?(:spree_variants, :meta)
+    remove_column :spree_orders, :meta if column_exists?(:spree_orders, :meta)
+    remove_column :spree_promotions, :meta if column_exists?(:spree_promotions, :meta)
+    remove_column :spree_credit_cards, :meta if column_exists?(:spree_credit_cards, :meta)
+  end
+end

data/db/migrate/20201022173210_add_zone_type_to_spree_zone_members.rb

@@ -0,0 +1,24 @@
+class AddZoneTypeToSpreeZoneMembers < ActiveRecord::Migration
+  def up
+    add_column :spree_zone_members, :zone_type, :text unless column_exists?(:spree_zone_members, :zone_type)
+
+    unless index_exists?(:spree_zone_members, %i[zone_id zone_type])
+      add_index :spree_zone_members, %i[zone_id zone_type],
+                name: "index_spree_zone_members_on_zone_id_and_zone_type", using: :btree
+    end
+
+    if index_exists?(:spree_zone_members, name: "index_spree_zone_members_on_zone_id")
+      remove_index :spree_zone_members, name: "index_spree_zone_members_on_zone_id"
+    end
+  end
+
+  def down
+    add_index :spree_zone_members, :zone_id unless index_exists?(:spree_zone_members, :zone_id)
+
+    if index_exists?(:spree_zone_members, %i[zone_id zone_type])
+      remove_index :spree_zone_members, name: "index_spree_zone_members_on_zone_id_and_zone_type"
+    end
+
+    remove_column :spree_zone_members, :zone_type if column_exists?(:spree_zone_members, :zone_type)
+  end
+end

data/db/migrate/20201022174252_add_kind_to_zone.rb

@@ -0,0 +1,22 @@
+# This is from Spree 3.0
+# https://github.com/spree/spree/commit/f9509a511def39de9d98199ddbf35f35c8580ca4#diff-984b308f2dc59ffb6e47183ac28b9895cfaa58bb26fb6f6e56a6afbe888fdece
+class AddKindToZone < ActiveRecord::Migration
+  def up
+    unless column_exists?(:spree_zones, :kind)
+      add_column :spree_zones, :kind, :string
+      add_index :spree_zones, :kind
+
+      Spree::Zone.find_each do |zone|
+        last_type = zone.members.where.not(zoneable_type: nil).pluck(:zoneable_type).last
+        zone.update_column :kind, last_type.demodulize.underscore if last_type
+      end
+    end
+
+    add_index :spree_zones, :kind unless index_exists?(:spree_zones, :kind)
+  end
+
+  def down
+    remove_index :spree_zones, :kind if index_exists?(:spree_zones, :kind)
+    remove_column :spree_zones, :kind if column_exists?(:spree_zones, :kind)
+  end
+end

data/lib/flow/error.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Flow (2017)
+# api error logger and formater
+
+require 'digest/sha1'
+
+class Flow::Error < StandardError
+  # logs error to file for easy discovery and fix
+  def self.log(exception, request)
+    history = exception.backtrace.reject { |el| el.index('/gems/') }.map { |el| el.sub(Rails.root.to_s, '') }.join($/)
+
+    msg  = "#{exception.class} in #{request.url}"
+    data = [msg, exception.message, history].join("\n\n")
+    key  = Digest::SHA1.hexdigest(exception.backtrace.first.split(' ').first)
+
+    folder = Rails.root.join('log/exceptions').to_s
+    Dir.mkdir(folder) unless Dir.exist?(folder)
+
+    folder += "/#{exception.class.to_s.tableize.gsub('/', '-')}"
+    Dir.mkdir(folder) unless Dir.exist?(folder)
+
+    "#{folder}/#{key}.txt".tap do |path|
+      File.write(path, data)
+    end
+  end
+
+  def self.format_message(exception)
+    # format Flow errors in a special way
+    # Io::Flow::V0::HttpClient::ServerError - 422 Unprocessable Entity:
+    # {"code":"invalid_number","messages":["Card number is not valid"]}
+    # hash['code']    = 'invalid_number'
+    # hash['message'] = 'Card number is not valid'
+    # hash['title']   = '422 Unprocessable Entity'
+    # hash['klass']   = 'Io::Flow::V0::HttpClient::ServerError'
+    if exception.class == Io::Flow::V0::HttpClient::ServerError
+      parts = exception.message.split(': ', 2)
+      hash  = Oj.load(parts[1])
+
+      hash[:message] = hash['messages'].join(', ')
+      hash[:title]   = parts[0]
+      hash[:klass]   = exception.class
+      hash[:code]    = hash['code']
+    else
+      msg = exception.message.is_a?(Array) ? exception.message.join(' - ') : exception.message
+
+      hash = {}
+      hash[:message] = msg
+      hash[:title]   = '-'
+      hash[:klass]   = exception.class
+      hash[:code]    = '-'
+    end
+
+    hash
+  end
+
+  def self.format_order_message(order)
+    message = if order['messages']
+                msg = order['messages'].join(', ')
+                msg += " (#{Spree::Variant.where(id: order['numbers']).map(&:name).join(', ')})" if order['numbers']
+                msg
+              else
+                'Order not properly localized (sync issue)'
+              end
+
+    # sub_info = 'Flow.io'
+    # sub_info += ' - %s' % flow_experience.key[0, 15] if flow_experience
+
+    # '%s (%s)' % [message, sub_info]
+
+    message
+  end
+end

data/lib/flow/pay_pal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Flow.io (2017)
+# communicates with flow api to synchronize Spree order with PayPal
+
+module Flow::PayPal
+  extend self
+
+  def get_id(order)
+    raise 'PayPal only supported while using flow' unless order.flow_order
+
+    # get PayPal ID using Flow api
+    body = {
+      # discriminator: 'merchant_of_record_payment_form',
+      method: 'paypal',
+      order_number: order.number,
+      amount: order.flow_order.total.amount,
+      currency: order.flow_order.total.currency
+    }
+
+    # FlowcommerceSpree::Api.run :post, '/:organization/payments', {}, body
+    form = ::Io::Flow::V0::Models::MerchantOfRecordPaymentForm.new body
+    FlowcommerceSpree.client.payments.post FlowcommerceSpree::ORGANIZATION, form
+  end
+end

data/lib/flow/simple_gateway.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+# Flow.io (2017)
+# communicates with Flow payments API, easy access to session
+# to basic shop frontend and backend needs
+module Flow
+  class SimpleGateway
+    cattr_accessor :clear_zero_amount_payments
+
+    def initialize(order)
+      @order = order
+    end
+
+    # authorises credit card and prepares for capture
+    def cc_authorization
+      response = FlowcommerceSpree.client.authorizations.post(FlowcommerceSpree::ORGANIZATION, build_authorization_form)
+      status_message = response.result.status.value
+      status = status_message == ::Io::Flow::V0::Models::AuthorizationStatus.authorized.value
+
+      store = { key: response.key,
+                amount: response.amount,
+                currency: response.currency,
+                authorization_id: response.id }
+
+      @order.flow_data['authorization'] = store
+      @order.update_column(:meta, @order.meta.to_json)
+
+      if self.class.clear_zero_amount_payments
+        @order.payments.where(amount: 0, state: %w[invalid processing pending]).map(&:destroy)
+      end
+
+      ActiveMerchant::Billing::Response.new(status, status_message, { response: response }, authorization: store)
+    rescue Io::Flow::V0::HttpClient::ServerError => e
+      error_response(e)
+    end
+
+    # capture authorised funds
+    def cc_capture
+      # GET /:organization/authorizations, order_number: abc
+      data = @order.flow_data['authorization']
+
+      raise ArgumentError, 'No Authorization data, please authorize first' unless data
+
+      capture_form = ::Io::Flow::V0::Models::CaptureForm.new(data)
+      response = FlowcommerceSpree.client.captures.post(FlowcommerceSpree::ORGANIZATION, capture_form)
+
+      return ActiveMerchant::Billing::Response.new false, 'error', response: response unless response.id
+
+      @order.update_column :flow_data, @order.flow_data.merge('capture': response.to_hash)
+      @order.flow_finalize!
+
+      ActiveMerchant::Billing::Response.new true, 'success', response: response
+    rescue StandardError => e
+      error_response(e)
+    end
+
+    def cc_refund
+      raise ArgumentError, 'capture info is not available' unless @order.flow_data['capture']
+
+      # we allways have capture ID, so we use it
+      refund_data = { capture_id: @order.flow_data['capture']['id'] }
+      refund_form = ::Io::Flow::V0::Models::RefundForm.new(refund_data)
+      response    = FlowcommerceSpree.client.refunds.post(FlowcommerceSpree::ORGANIZATION, refund_form)
+
+      return ActiveMerchant::Billing::Response.new false, 'error', response: response unless response.id
+
+      @order.update_column :flow_data, @order.flow_data.merge('refund': response.to_hash)
+      ActiveMerchant::Billing::Response.new true, 'success', response: response
+    rescue StandardError => e
+      error_response(e)
+    end
+
+    private
+
+    # if order is not in flow, we use local Spree settings
+    def in_flow?
+      @order.flow_order ? true : false
+    end
+
+    def build_authorization_form
+      if in_flow?
+        # we have order id so we allways use MerchantOfRecordAuthorizationForm
+        ::Io::Flow::V0::Models::MerchantOfRecordAuthorizationForm.new('order_number': @order.flow_number,
+                                                                      'currency': @order.flow_order.total.currency,
+                                                                      'amount': @order.flow_order.total.amount,
+                                                                      'token': cc_get_token)
+      else
+        # when not using Flow, we fall back to Spree default
+        ::Io::Flow::V0::Models::DirectAuthorizationForm.new('currency': @order.currency,
+                                                            'amount': @order.total,
+                                                            'token': cc_get_token)
+      end
+    end
+
+    # gets credit card token
+    def cc_get_token
+      cards = @order.credit_cards.select(&:gateway_customer_profile_id)
+      raise StandardError, 'Credit card with token not found' unless cards.first
+
+      cards.first.gateway_customer_profile_id
+    end
+
+    # we want to return errors in standardized format
+    def error_response(exception_object)
+      message = if exception_object.respond_to?(:body) && exception_object.body.length > 0
+                  description = Oj.load(exception_object.body)['messages'].to_sentence
+                  "#{exception_object.details}: #{description} (#{exception_object.code})"
+                else
+                  exception_object.message
+                end
+
+      ActiveMerchant::Billing::Response.new(false, message, exception: exception_object)
+    end
+  end
+end

data/lib/flowcommerce_spree.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'flowcommerce'
+require 'flowcommerce_spree/api'
+require 'flowcommerce_spree/refresher'
+require 'flowcommerce_spree/engine'
+require 'flowcommerce_spree/logging_http_client'
+require 'flowcommerce_spree/logging_http_handler'
+require 'flowcommerce_spree/webhook_service'
+require 'flowcommerce_spree/session'
+require 'flow/simple_gateway'
+
+module FlowcommerceSpree
+  def self.client(logger: FlowcommerceSpree.logger, **opts)
+    FlowCommerce.instance(http_handler: LoggingHttpHandler.new(logger: logger), **opts)
+  end
+
+  def self.configure
+    yield self if block_given?
+  end
+
+  def self.logger
+    logger = ActiveSupport::Logger.new(STDOUT, 3, 10_485_760)
+
+    # Broadcast the log into the file besides STDOUT, if `log` folder exists
+    if Dir.exist?('log')
+      logger.extend(ActiveSupport::Logger.broadcast(ActiveSupport::Logger.new('log/flowcommerce_spree.log')))
+    end
+    logger
+  end
+end

data/lib/flowcommerce_spree/api.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# module for communication and customization based on Flow API
+# for now all in same class
+module FlowcommerceSpree
+  module Api
+    extend self
+
+    # builds curl command and gets remote data
+    def run(action, path, params = {}, body = nil)
+      body ||= params.delete(:BODY)
+
+      remote_params = URI.encode_www_form params
+      remote_path   = debug_path = path.sub('%o', ORGANIZATION).sub(':organization', ORGANIZATION)
+      remote_path  += "?#{remote_params}" unless remote_params.blank?
+
+      curl = ['curl -s']
+      curl.push "-X #{action.to_s.upcase}"
+      curl.push "-u #{API_KEY}:"
+
+      if body
+        body = body.to_json unless body.is_a?(Array)
+        curl.push '-H "Content-Type: application/json"'
+        curl.push "-d '#{body.gsub(%['], %['"'"'])}'" if body
+      end
+
+      curl.push "\"https://api.flow.io#{remote_path}\""
+      command = curl.join(' ')
+
+      puts command if defined?(Rails::Console)
+
+      dir = Rails.root.join('log/api')
+      Dir.mkdir(dir) unless Dir.exist?(dir)
+      debug_file = "#{dir}/#{debug_path.gsub(/[^\w]+/, '_')}.bash"
+      File.write debug_file, command + "\n"
+
+      JSON.load `#{command}`
+    end
+
+    def logger
+      @logger ||= Logger.new('./log/flow.log') # or nil for no logging
+    end
+
+    def format_default_price(amount)
+      format('$%<price>.2f', amount)
+    end
+  end
+end