flowcommerce_spree 0.0.2 → 0.0.7

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_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

data/app/models/spree/{credit_card_decorator.rb → payment_capture_event_decorator.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Spree
-  CreditCard.class_eval do
+  PaymentCaptureEvent.class_eval do
     serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
 
     store_accessor :meta, :flow_data

data/app/models/spree/promotion_handler/coupon_decorator.rb

@@ -5,7 +5,7 @@ module Spree
     Coupon.class_eval do
       def apply
         if order.coupon_code.present?
-          if promotion&.actions.exists?
+          if promotion&.actions&.exists?
             experience_key  = order.flow_order&.dig('experience', 'key')
             forbiden_keys   = promotion.flow_data&.dig('filter', 'experience') || []
 

data/app/models/spree/zones/flow_io_product_zone_decorator.rb

@@ -16,6 +16,10 @@ module Spree
         flow_data&.[]('key')
       end
 
+      def flow_io_experience_country
+        flow_data&.[]('country')
+      end
+
       def flow_io_experience_currency
         flow_data&.[]('currency')
       end
@@ -24,6 +28,10 @@ module Spree
         flow_data&.[]('key').present? && flow_data['status'] == 'active'
       end
 
+      def flow_io_active_or_archiving_experience?
+        flow_data&.[]('key').present? && %w[active archiving].include?(flow_data['status'])
+      end
+
       def update_on_flow; end
 
       def remove_on_flow_io

data/app/models/tracking/setup_decorator.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Tracking
+  Setup.module_eval do
+    private
+
+    def setup_tracking
+      return if request.path.start_with?(ADMIN_PATH)
+
+      user_consents = UserConsent.new(cookies)
+      setup_visitor_cookie(user_consents)
+      store_order_flow_io_attributes(user_consents) if current_order&.zone&.flow_io_active_experience?
+    end
+
+    def store_order_flow_io_attributes(user_consents)
+      # Using `save!` and not `update_column` for callbacks to work and sync the order to flow.io
+      current_order.save!(validate: false) if order_user_consents_updated?(user_consents) || user_uuid_updated?
+    end
+
+    def order_user_consents_updated?(user_consents)
+      consents_changed = nil
+      user_consents.active_groups.each do |consent_group|
+        group_value = consent_group[1][:value]
+        gdpr_group_name = "gdpr_#{consent_group[1][:name]}"
+        next if current_order.flow_io_attributes[gdpr_group_name] == group_value
+
+        consents_changed ||= true
+        current_order.flow_io_attribute_add(gdpr_group_name, group_value)
+      end
+
+      consents_changed
+    end
+
+    def user_uuid_updated?
+      return if current_order.flow_io_attr_user_uuid.present?
+
+      current_order.add_user_uuid_to_flow_data
+    end
+  end
+end