flowcommerce_spree 0.0.1 → 0.0.6

data/app/models/spree/address_decorator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Spree
+  Address.class_eval do
+    def prepare_from_flow_attributes(address_data)
+      self.attributes = {
+        first_name: address_data['first'],
+        last_name: address_data['last'],
+        phone: address_data['phone'],
+        address1: address_data['streets'][0],
+        address2: address_data['streets'][1],
+        zipcode: address_data['postal'],
+        city: address_data['city'],
+        state_name: address_data['province'],
+        country: Spree::Country.find_by(iso3: address_data['country'])
+      }
+    end
+  end
+end

data/app/models/spree/app_configuration_decorator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Spree
+  AppConfiguration.class_eval do
+    preference :debug_request_ip_address, :string
+  end
+end

data/app/models/spree/calculator/flow_io.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Spree
+  class Calculator
+    class FlowIo < Calculator::DefaultTax
+      def self.description
+        'FlowIO Calculator'
+      end
+
+      def compute_shipment_or_line_item(item)
+        order = item.order
+
+        if can_calculate_tax?(order)
+          flow_response = get_flow_tax_data(order)
+          tax_for_item(item, flow_response)
+        else
+          prev_tax_amount(item)
+        end
+      end
+      alias compute_shipment compute_shipment_or_line_item
+      alias compute_line_item compute_shipment_or_line_item
+
+      private
+
+      def prev_tax_amount(item)
+        if rate.included_in_price
+          item.included_tax_total
+        else
+          item.additional_tax_total
+        end
+      end
+
+      def can_calculate_tax?(order)
+        return false if order.flow_data.blank?
+        return false if %w[cart address].include?(order.state)
+
+        true
+      end
+
+      def get_flow_tax_data(order)
+        flow_io_tax_response = Rails.cache.fetch(order.flow_tax_cache_key, time_to_idle: 5.minutes) do
+          FlowcommerceSpree.client.orders.get_allocations_by_number(FlowcommerceSpree::ORGANIZATION, order.number)
+        end
+        flow_io_tax_response
+      end
+
+      def tax_for_item(item, flow_response)
+        prev_tax_amount = prev_tax_amount(item)
+        return prev_tax_amount if flow_response.nil?
+
+        item_details = flow_response.details&.find do |el|
+          item.is_a?(Spree::LineItem) ? el.number == item.variant.sku : el.key.value == 'shipping'
+        end
+        price_components = rate.included_in_price ? item_details.included : item_details.not_included
+
+        amount = price_components&.find { |el| el.key.value == 'vat_item_price' }&.total&.amount
+        amount.present? && amount > 0 ? amount : prev_tax_amount
+      end
+    end
+  end
+end

data/app/models/spree/calculator/shipping/flow_io.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Spree
+  class Calculator
+    module Shipping
+      class FlowIo < ShippingCalculator
+        preference :lower_boundary, :decimal, default: 100
+        preference :charge_default, :decimal, default: 15
+
+        def self.description
+          'FlowIO Calculator'
+        end
+
+        def compute_package(package)
+          flow_order = flow_order(package)
+          return unless flow_order
+
+          flow_order['prices'].find { |x| x['key'] == 'shipping' }['amount'] || 0
+        end
+
+        def default_charge(_country)
+          preferred_charge_default
+        end
+
+        def threshold
+          preferred_lower_boundary
+        end
+
+        private
+
+        def flow_order(package)
+          return @flow_order if defined?(@flow_order)
+
+          @flow_order = package.order.flow_data&.[]('order')
+          @flow_order
+        end
+      end
+    end
+  end
+end

data/app/models/spree/flow_io_credit_card_decorator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree
+  module FlowIoCreditCardDecorator
+    def self.prepended(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+      base.store_accessor :meta, :flow_data
+    end
+
+    def push_authorization(auth_hash)
+      self.flow_data ||= {}
+      flow_data['authorizations'] ||= []
+      card_authorizations = flow_data['authorizations']
+      card_authorizations.delete_if { |ca| ca['id'] == auth_hash['id'] }
+      card_authorizations << auth_hash
+    end
+
+    Spree::CreditCard.prepend(self) if Spree::CreditCard.included_modules.exclude?(self)
+  end
+end

data/app/models/spree/flow_io_order_decorator.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Spree
+  # Added flow specific methods to Spree::Order
+  module FlowIoOrderDecorator
+    def self.included(base)
+      base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+      base.store_accessor :meta, :flow_data
+    end
+
+    def flow_tax_cache_key
+      [number, 'flowcommerce', 'allocation', line_items.sum(:quantity)].join('-')
+    end
+
+    def display_total
+      return unless flow_data&.[]('order')
+
+      Spree::Money.new(flow_io_total_amount, currency: currency)
+    end
+
+    def flow_order
+      flow_data&.[]('order')
+    end
+
+    def flow_order_with_payments?
+      payment = payments.completed.first
+
+      payment&.payment_method&.type == 'Spree::Gateway::FlowIo'
+    end
+
+    # accepts line item, usually called from views
+    def flow_line_item_price(line_item, total = false)
+      result = if (order = flow_order)
+                 item = order['lines']&.find { |el| el['item_number'] == line_item.variant.sku }
+
+                 return 'n/a' unless item
+
+                 total ? item['total']['label'] : item['price']['label']
+               else
+                 FlowcommerceSpree::Api.format_default_price(line_item.price * (total ? line_item.quantity : 1))
+               end
+
+      # add line item promo
+      # promo_total, adjustment_total
+      result += " (#{FlowcommerceSpree::Api.format_default_price(line_item.promo_total)})" if line_item.promo_total > 0
+
+      result
+    end
+
+    # shows localized total, if possible. if not, fall back to Spree default
+    def flow_io_total_amount
+      flow_data&.dig('order', 'total', 'amount')&.to_d || 0
+    end
+
+    def flow_io_experience_key
+      flow_data&.[]('exp')
+    end
+
+    def flow_io_experience_from_zone
+      self.flow_data = (flow_data || {}).merge!('exp' => zone.flow_io_experience)
+    end
+
+    def flow_io_order_id
+      flow_data&.dig('order', 'id')
+    end
+
+    def flow_io_attributes
+      flow_data&.dig('order', 'attributes') || {}
+    end
+
+    def flow_io_attribute_add(attr_key, value)
+      self.flow_data['order'] ||= {}
+      self.flow_data['order']['attributes'] ||= {}
+      self.flow_data['order']['attributes'][attr_key] = value
+    end
+
+    def add_user_uuid_to_flow_data
+      self.flow_data['order'] ||= {}
+      self.flow_data['order']['attributes'] ||= {}
+      self.flow_data['order']['attributes']['user_uuid'] = user&.uuid || ''
+    end
+
+    def flow_io_attr_user_uuid
+      flow_data&.dig('order', 'attributes', 'user_uuid')
+    end
+
+    def flow_io_captures
+      flow_data&.[]('captures')
+    end
+
+    def flow_io_captures_sum
+      captures_sum = 0
+      flow_data&.[]('captures')&.each do |c|
+        next if c['status'] != 'succeeded'
+
+        amount = c['amount']
+        amount = amount.to_d if amount.is_a?(String)
+        captures_sum += amount
+      end
+      captures_sum.to_d
+    end
+
+    def flow_io_balance_amount
+      flow_data&.dig('order', 'balance', 'amount')&.to_d || 0
+    end
+
+    def flow_io_payments
+      flow_data.dig('order', 'payments')
+    end
+
+    def flow_customer_email
+      flow_data.dig('order', 'customer', 'email')
+    end
+
+    def flow_ship_address
+      flow_destination = flow_data.dig('order', 'destination')
+      return unless flow_destination.present?
+
+      flow_destination['first'] = flow_destination.dig('contact', 'name', 'first')
+      flow_destination['last']  = flow_destination.dig('contact', 'name', 'last')
+      flow_destination['phone'] = flow_destination.dig('contact', 'phone')
+
+      s_address = ship_address || build_ship_address
+      s_address.prepare_from_flow_attributes(flow_destination)
+      s_address
+    end
+
+    def flow_bill_address
+      flow_payment_address = flow_data.dig('order', 'payments')&.last&.[]('address')
+      return unless flow_payment_address
+
+      flow_payment_address['first'] = flow_payment_address.dig('name', 'first')
+      flow_payment_address['last']  = flow_payment_address.dig('name', 'last')
+      flow_payment_address['phone'] = ship_address['phone']
+
+      b_address = bill_address || build_bill_address
+      b_address.prepare_from_flow_attributes(flow_payment_address)
+      b_address
+    end
+
+    def prepare_flow_addresses
+      address_attributes = {}
+
+      s_address = flow_ship_address
+
+      if s_address&.changes&.any?
+        s_address.save!
+        address_attributes[:ship_address_id] = s_address.id unless ship_address_id
+      end
+
+      b_address = flow_bill_address
+      if b_address&.changes&.any?
+        b_address.save!
+        address_attributes[:bill_address_id] = b_address.id unless bill_address_id
+      end
+
+      address_attributes
+    end
+
+    Spree::Order.include(self) if Spree::Order.included_modules.exclude?(self)
+  end
+end

data/app/models/spree/flow_io_product_decorator.rb

@@ -49,7 +49,7 @@ module Spree
         rmin = min&.amount&.to_s(:rounded, precision: 0) || 0
         rmax = max&.amount&.to_s(:rounded, precision: 0) || 0
 
-        prices[currency] = rmin == rmax ? { amount: rmin } : { min: rmin, max: rmax }
+        prices[currency] = { min: rmin, max: rmax }
       end
 
       add_flow_price_range(prices, product_zone)
@@ -82,7 +82,7 @@ module Spree
       rmin = min&.amount&.to_s(:rounded, precision: 0) || 0
       rmax = max&.amount&.to_s(:rounded, precision: 0) || 0
 
-      prices[currency] = rmin == rmax ? { amount: rmin } : { min: rmin, max: rmax }
+      prices[currency] = { min: rmin, max: rmax }
       prices
     end
 

data/app/models/spree/flow_io_variant_decorator.rb

@@ -22,8 +22,8 @@ module Spree
       raise ArgumentError, 'Value should be a hash' unless value.is_a?(Hash)
 
       self.flow_data = flow_data || {}
-      self.flow_data['exp'] ||= {}
-      self.flow_data['exp'][exp] = value
+      self.flow_data['exp'] ||= {} # rubocop:disable Style/RedundantSelf
+      self.flow_data['exp'][exp] = value # rubocop:disable Style/RedundantSelf
     end
 
     # clears flow_data from the records
@@ -58,6 +58,8 @@ module Spree
 
       return { error: 'Price is 0' } if price == 0
 
+      return unless country_of_origin
+
       additional_attrs = {}
       attr_name = nil
       export_required = false

data/app/models/spree/gateway/flow_io.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Flow.io (2017)
+# adapter for Spree that talks to activemerchant_flow
+module Spree
+  class Gateway
+    class FlowIo < Gateway
+      REFUND_SUCCESS = 'succeeded'
+
+      def provider_class
+        self.class
+      end
+
+      def actions
+        %w[capture authorize purchase refund void]
+      end
+
+      # if user wants to force auto capture
+      def auto_capture?
+        false
+      end
+
+      def payment_profiles_supported?
+        true
+      end
+
+      def method_type
+        'flow_io_gateway'
+      end
+
+      def preferences
+        {}
+      end
+
+      def supports?(source)
+        # flow supports credit cards
+        source.class == Spree::CreditCard
+      end
+
+      def authorize(_amount, _payment_method, options = {})
+        order = load_order options
+        order.cc_authorization
+      end
+
+      def refund(payment, amount, _options = {})
+        request_refund_store_result(payment.order, amount)
+      rescue StandardError => e
+        ActiveMerchant::Billing::Response.new(false, e.to_s, {}, {})
+      end
+
+      def cancel(authorization)
+        original_payment = Spree::Payment.find_by(response_code: authorization)
+        request_refund_store_result(original_payment.order, original_payment.amount)
+      rescue StandardError => e
+        ActiveMerchant::Billing::Response.new(false, e.to_s, {}, {})
+      end
+
+      def void(authorization_id, _source, options = {})
+        amount = (options[:subtotal] + options[:shipping]) * 0.01
+        reversal_form = Io::Flow::V0::Models::ReversalForm.new(key: options[:order_id],
+                                                               authorization_id: authorization_id,
+                                                               amount: amount,
+                                                               currency: options[:currency])
+        FlowcommerceSpree.client.reversals.post(FlowcommerceSpree::ORGANIZATION, reversal_form)
+      end
+
+      def create_profile(payment)
+        # payment.order.state
+        @credit_card = payment.source
+
+        profile_ensure_payment_method_is_present!
+        create_flow_cc_profile!
+      end
+
+      private
+
+      def request_refund_store_result(order, amount)
+        refund_form = Io::Flow::V0::Models::RefundForm.new(order_number: order.number,
+                                                           amount: amount,
+                                                           currency: order.currency)
+        response = FlowcommerceSpree.client.refunds.post(FlowcommerceSpree::ORGANIZATION, refund_form)
+        response_status = response.status.value
+        if response_status == REFUND_SUCCESS
+          add_refund_to_order(response, order)
+          map_refund_to_payment(response, order)
+          ActiveMerchant::Billing::Response.new(true, REFUND_SUCCESS, {}, {})
+        else
+          msg = "Partial refund fail. Details: #{response_status}"
+          ActiveMerchant::Billing::Response.new(false, msg, {}, {})
+        end
+      end
+
+      def add_refund_to_order(response, order)
+        order.flow_data ||= {}
+        order.flow_data['refunds'] ||= []
+        order_refunds = order.flow_data['refunds']
+        order_refunds.delete_if { |r| r['id'] == response.id }
+        order_refunds << response.to_hash
+        order.update_column(:meta, order.meta.to_json)
+      end
+
+      def map_refund_to_payment(response, order)
+        original_payment = Spree::Payment.find_by(response_code: response.authorization.id)
+        payment = order.payments.create!(state: 'completed',
+                                         response_code: response.authorization.id,
+                                         payment_method_id: original_payment&.payment_method_id,
+                                         amount: - response.amount,
+                                         source_id: original_payment&.source_id,
+                                         source_type: original_payment&.source_type)
+
+        # For now this additional update is overwriting the generated identifier with flow.io payment identifier.
+        # TODO: Check and possibly refactor in Spree 3.0, where the `before_create :set_unique_identifier`
+        # has been removed.
+        payment.update_column(:identifier, response.id)
+      end
+
+      # hard inject Flow as payment method unless defined
+      def profile_ensure_payment_method_is_present!
+        return if @credit_card.payment_method_id
+
+        flow_payment_method = Spree::PaymentMethod.find_by(active: true, type: 'Spree::Gateway::FlowIo')
+        @credit_card.payment_method_id = flow_payment_method.id if flow_payment_method
+      end
+
+      # create payment profile with Flow and tokenize Credit Card
+      def create_flow_cc_profile!
+        return if @credit_card.gateway_customer_profile_id
+        return unless @credit_card.verification_value
+
+        # build credit card hash
+        data = {}
+        data[:number]           = @credit_card.number
+        data[:name]             = @credit_card.name
+        data[:cvv]              = @credit_card.verification_value
+        data[:expiration_year]  = @credit_card.year.to_i
+        data[:expiration_month] = @credit_card.month.to_i
+
+        # tokenize with Flow
+        # rescue Io::Flow::V0::HttpClient::ServerError
+        card_form = ::Io::Flow::V0::Models::CardForm.new(data)
+        result    = FlowcommerceSpree.client.cards.post(::FlowcommerceSpree::ORGANIZATION, card_form)
+
+        @credit_card.update_column :gateway_customer_profile_id, result.token
+      end
+
+      def load_order(options)
+        order_number = options[:order_id].split('-').first
+        spree_order  = Spree::Order.find_by number: order_number
+        ::Flow::SimpleGateway.new spree_order
+      end
+    end
+  end
+end