flowcommerce_spree 0.0.3 → 0.0.4

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/serializers/api/v2/order_serializer_decorator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Api::V2::OrderSerializer.class_eval do
+  attribute :duty_included, if: proc { object.flow_io_attributes.present? }
+  attribute :vat_included, if: proc { object.flow_io_attributes.present? }
+
+  def duty_included
+    flow_io_order_attributes&.[]('duty') == 'included'
+  end
+
+  def vat_included
+    flow_io_order_attributes&.[]('vat') == 'included'
+  end
+
+  private
+
+  def flow_io_order_attributes
+    @flow_io_order_attributes ||= Oj.load(object.flow_io_attributes['pricing_key'])
+  end
+end

data/app/services/flowcommerce_spree/import_experience_items.rb

@@ -13,7 +13,7 @@ module FlowcommerceSpree
       items      = []
       total = 0
 
-      while offset == 0 || items.length == 100
+      while offset == 0 || items.length != 0
         # show current list size
         @logger.info "\nGetting items: #{@experience_key.green}, rows #{offset} - #{offset + page_size}"
 

data/app/services/flowcommerce_spree/order_sync.rb

@@ -16,41 +16,30 @@ module FlowcommerceSpree
   #  flow_order.synchronize!                 # sends order to flow
   class OrderSync # rubocop:disable Metrics/ClassLength
     FLOW_CENTER = 'default'
-    SESSION_EXPIRATION_THRESHOLD = 10 # Refresh session if less than 10 seconds to session expiration remains
 
-    attr_reader :digest, :order, :response
+    attr_reader :order, :response
 
     delegate :url_helpers, to: 'Rails.application.routes'
 
-    class << self
-      def clear_cache(order)
-        return unless order.flow_data['order']
-
-        order.flow_data.delete('order')
-        order.update_column :meta, order.meta.to_json
-      end
-    end
-
-    def initialize(order:)
+    def initialize(order:, flow_session_id:)
       raise(ArgumentError, 'Experience not defined or not active') unless order.zone&.flow_io_active_experience?
 
       @experience = order.flow_io_experience_key
+      @flow_session_id = flow_session_id
       @order = order
-      @client = FlowcommerceSpree.client(session_id: fetch_session_id)
+      @client = FlowcommerceSpree.client(session_id: flow_session_id)
     end
 
     # helper method to send complete order from Spree to flow.io
     def synchronize!
+      return unless @order.zone&.flow_io_active_experience? && @order.state == 'cart' && @order.line_items.size > 0
+
       sync_body!
-      check_state!
       write_response_in_cache
 
-      # This is for 1st order syncing, when no checkout_token has been fetched yet. In all the subsequent syncs,
-      # the checkout_token is fetched in the `fetch_session_id` method, calling the refresh_checkout_token method when
-      # necessary.
-      refresh_checkout_token if @order.flow_io_checkout_token.blank?
-      @order.update_column(:meta, @order.meta.to_json)
-      @response
+      @order.update_columns(total: @order.total, meta: @order.meta.to_json)
+      refresh_checkout_token
+      @checkout_token
     end
 
     def error
@@ -65,46 +54,6 @@ module FlowcommerceSpree
       @response&.[]('code') && @response&.[]('messages') ? true : false
     end
 
-    def delivery
-      deliveries.select { |el| el[:active] }.first
-    end
-
-    # delivery methods are defined in flow console
-    def deliveries
-      # if we have error with an order, but still using this method
-      return [] unless @order.flow_order
-
-      @order.flow_data ||= {}
-
-      delivery_list = @order.flow_order['deliveries'][0]['options'].map do |opts|
-        name = opts['tier']['name']
-
-        # add original Flow ID
-        # name        += ' (%s)' % opts['tier']['strategy'] if opts['tier']['strategy']
-
-        selection_id = opts['id']
-
-        { id: selection_id,
-          price: { label: opts['price']['label'] },
-          active: @order.flow_order['selections'].include?(selection_id),
-          name: name }
-      end.to_a
-
-      # make first one active unless we have active element
-      delivery_list.first[:active] = true unless delivery_list.select { |el| el[:active] }.first
-
-      delivery_list
-    end
-
-    def total_price
-      @order.flow_total
-    end
-
-    def delivered_duty
-      # paid is default
-      @order.flow_data['delivered_duty'] || ::Io::Flow::V0::Models::DeliveredDuty.paid.value
-    end
-
     # builds object that can be sent to api.flow.io to sync order data
     def build_flow_request
       @opts = { experience: @experience, expand: ['experience'] }
@@ -112,94 +61,31 @@ module FlowcommerceSpree
 
       try_to_add_customer
 
-      if (flow_data = @order.flow_data['order'])
-        @body[:selections] = flow_data['selections'].presence
-        @body[:delivered_duty] = flow_data['delivered_duty'].presence
-        @body[:attributes] = flow_data['attributes'].presence
+      return unless (flow_data = @order.flow_data['order'])
 
-        if @order.adjustment_total != 0
-          # discount on full order is applied
-          @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency }
-        end
-      end
+      @body[:selections] = flow_data['selections'].presence
+      @body[:delivered_duty] = flow_data['delivered_duty'].presence
+      @body[:attributes] = flow_data['attributes'].presence
 
-      # calculate digest body and cache it
-      @digest = Digest::SHA1.hexdigest(@opts.to_json + @body.to_json)
+      # discount on full order is applied
+      @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency } if @order.adjustment_total != 0
     end
 
     private
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    def fetch_session_id
-      session = RequestStore.store[:session]
-      current_session_id = session&.[]('_f60_session')
-      session_expire_at = session&.[]('_f60_expires_at')&.to_datetime
-      session_expired = flow_io_session_expired?(session_expire_at.to_i)
-      order_flow_session_id = @order.flow_data['session_id']
-      order_session_expire_at = @order.flow_io_session_expires_at
-      order_session_expired = flow_io_session_expired?(order_session_expire_at.to_i)
-
-      if order_flow_session_id == current_session_id && session_expire_at == order_session_expire_at &&
-         @order.flow_io_checkout_token.present? && session_expired == false
-        return current_session_id
-      elsif current_session_id && session_expire_at && session_expired == false
-        # If request flow_session is not expired, don't refresh the flow_session (i.e., don't mark the refresh_session
-        # lvar as true), just store the flow_session data into the order, if it is new, and refresh the checkout_token
-        refresh_session = nil
-      elsif order_flow_session_id && order_session_expire_at && order_session_expired == false && session_expired.nil?
-        refresh_checkout_token if @order.flow_io_order_id && @order.flow_io_checkout_token.blank?
-        return order_flow_session_id
-      else
-        refresh_session = true
-      end
-
-      if refresh_session
-        flow_io_session = Session.new(
-          ip: '127.0.0.1',
-          visitor: "session-#{Digest::SHA1.hexdigest(@order.guest_token)}",
-          experience: @experience
-        )
-        flow_io_session.create
-        current_session_id = flow_io_session.id
-        session_expire_at = flow_io_session.expires_at.to_s
-      end
-
-      @order.flow_data['session_id'] = current_session_id
-      @order.flow_data['session_expires_at'] = session_expire_at
-
-      if session.respond_to?(:[])
-        session['_f60_session'] = current_session_id
-        session['_f60_expires_at'] = session_expire_at
-      end
-
-      # On the 1st OrderSync at this moment the order is not yet created at flow.io, so we couldn't yet retrieve the
-      # checkout_token. This is done after the order will be synced, in the `synchronize!` method.
-      refresh_checkout_token if @order.flow_io_order_id
-
-      current_session_id
-    end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    def flow_io_session_expired?(expiration_time)
-      return nil if expiration_time == 0
-
-      expiration_time - Time.zone.now.utc.to_i < SESSION_EXPIRATION_THRESHOLD
-    end
-
     def refresh_checkout_token
       root_url = url_helpers.root_url
       order_number = @order.number
-      confirmation_url = "#{root_url}thankyou?order=#{order_number}&t=#{@order.guest_token}"
-      checkout_token = FlowcommerceSpree.client.checkout_tokens.post_checkout_and_tokens_by_organization(
+      confirmation_url = "#{root_url}flow/order-completed?order=#{order_number}&t=#{@order.guest_token}"
+      @checkout_token = FlowcommerceSpree.client.checkout_tokens.post_checkout_and_tokens_by_organization(
         FlowcommerceSpree::ORGANIZATION,
         discriminator: 'checkout_token_reference_form',
         order_number: order_number,
-        session_id: @order.flow_data['session_id'],
+        session_id: @flow_session_id,
         urls: { continue_shopping: root_url,
                 confirmation: confirmation_url,
                 invalid_checkout: root_url }
-      )
-      @order.add_flow_checkout_token(checkout_token.id)
+      )&.id
 
       @order.flow_io_attribute_add('flow_return_url', confirmation_url)
       @order.flow_io_attribute_add('checkout_continue_shopping_url', root_url)
@@ -244,16 +130,13 @@ module FlowcommerceSpree
     end
 
     def sync_body!
-      build_flow_request if @body.blank?
+      build_flow_request
 
       @use_get = false
 
       # use get if order is completed and closed
       @use_get = true if @order.flow_data.dig('order', 'submitted_at').present? || @order.state == 'complete'
 
-      # use get if local digest hash check said there is no change
-      @use_get ||= true if @order.flow_data['digest'] == @digest
-
       # do not use get if there is no local order cache
       @use_get = false unless @order.flow_data['order']
 
@@ -265,19 +148,6 @@ module FlowcommerceSpree
       end
     end
 
-    def check_state!
-      # authorize if not authorized
-      # if !@order.flow_order_authorized?
-
-      # authorize payment on complete, unless authorized
-      if @order.state == 'complete' && !@order.flow_order_authorized?
-        simple_gateway = Flow::SimpleGateway.new(@order)
-        simple_gateway.cc_authorization
-      end
-
-      @order.flow_finalize! if @order.flow_order_authorized? && @order.state != 'complete'
-    end
-
     def add_item(line_item)
       variant    = line_item.variant
       price_root = variant.flow_data&.dig('exp', @experience, 'prices')&.[](0) || {}
@@ -294,17 +164,18 @@ module FlowcommerceSpree
     # written in flow_data field inside spree_orders table
     def write_response_in_cache
       if !@response || error?
-        @order.flow_data.delete('digest')
         @order.flow_data.delete('order')
       else
-        response_total = @response.dig('total', 'label')
-        cache_total    = @order.flow_data.dig('order', 'total', 'label')
+        response_total = @response[:total]
+        response_total_label = response_total&.[](:label)
+        cache_total = @order.flow_data.dig('order', 'total', 'label')
 
         # return if total is not changed, no products removed or added
-        return if @use_get && response_total == cache_total
+        return if @use_get && response_total_label == cache_total
 
         # update local order
-        @order.flow_data.merge!('digest' => @digest, 'order' => @response)
+        @order.total = response_total&.[](:amount)
+        @order.flow_data.merge!('order' => @response)
       end
     end
   end

data/app/services/flowcommerce_spree/order_updater.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  class OrderUpdater
+    def initialize(order:)
+      raise(ArgumentError, 'Experience not defined or not active') unless order&.zone&.flow_io_active_experience?
+
+      @experience = order.flow_io_experience_key
+      @order = order
+      @client = FlowcommerceSpree.client
+    end
+
+    def upsert_data(flow_io_order = nil)
+      return if @order.state == 'complete'
+
+      flow_io_order ||= @client.orders.get_by_number(FlowcommerceSpree::ORGANIZATION, @order.number).to_hash
+
+      @order.flow_data['order'] = flow_io_order
+      return if @order.flow_data.dig('order', 'submitted_at').blank?
+
+      attrs_to_update = { meta: @order.meta.to_json, email: @order.flow_customer_email, payment_state: 'pending' }
+      attrs_to_update.merge!(@order.prepare_flow_addresses)
+      @order.update_columns(attrs_to_update)
+      @order.state = 'delivery'
+      @order.save!
+      @order.create_proposed_shipments
+      @order.shipment.update_amounts
+      @order.line_items.each(&:store_ets)
+      @order.charge_taxes
+
+      @order.state = 'payment'
+      @order.save!
+    end
+
+    def finalize_order
+      @order.reload
+      @order.finalize!
+      @order.update_totals
+      @order.save
+      @order.after_completed_order
+    end
+
+    def complete_checkout
+      upsert_data
+      map_payments_to_spree
+      finalize_order if @order.state == 'complete'
+    end
+
+    def map_payments_to_spree
+      @order.flow_io_payments&.each do |p|
+        payment =
+          @order.payments.find_or_initialize_by(response_code: p['reference'], payment_method_id: payment_method_id)
+        next unless payment.new_record?
+
+        payment.amount = p.dig('total', 'amount')
+        payment.pend
+
+        # 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, p['id'])
+      end
+
+      return if @order.payments.sum(:amount) < @order.amount || @order.state == 'complete'
+
+      @order.state = 'confirm'
+      @order.save!
+      @order.state = 'complete'
+      @order.save!
+    end
+
+    def payment_method_id
+      @payment_method_id ||= Spree::PaymentMethod.find_by(active: true, type: 'Spree::Gateway::FlowIo').id
+    end
+  end
+end

data/app/views/spree/admin/payments/source_views/_flow_io_gateway.html.erb

@@ -0,0 +1,21 @@
+<fieldset data-hook="credit_card">
+  <legend align="center"><%= Spree.t(:credit_card) %></legend>
+
+  <div class="row">
+    <div class="alpha six columns">
+      <dl>
+        <dt><%= Spree.t(:name_on_card) %>:</dt>
+        <dd><%= payment.source&.name %></dd>
+
+        <dt><%= Spree.t(:card_type) %>:</dt>
+        <dd><%= payment.source&.cc_type %></dd>
+
+        <dt><%= Spree.t(:card_number) %>:</dt>
+        <dd><%= payment.source&.display_number %></dd>
+
+        <dt><%= Spree.t(:expiration) %>:</dt>
+        <dd><%= payment.source&.month %>/<%= payment.source&.year %></dd>
+      </dl>
+    </div>
+  </div>
+</fieldset>

data/config/routes.rb

@@ -2,4 +2,6 @@
 
 FlowcommerceSpree::Engine.routes.draw do
   post '/event-target', to: 'webhooks#handle_flow_web_hook_event'
+  get '/order-completed', to: 'orders#order_completed'
+  post '/online-stock-availability', to: 'inventory#online_stock_availability'
 end

data/db/migrate/20201021755957_add_meta_to_spree_tables.rb

@@ -5,13 +5,15 @@ class AddMetaToSpreeTables < ActiveRecord::Migration
     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)
+    add_column :spree_payment_capture_events, :meta, :jsonb, default: '{}' unless column_exists?(:spree_payment_capture_events, :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_payment_capture_events, :meta if column_exists?(:spree_payment_capture_events, :meta)
     remove_column :spree_credit_cards, :meta if column_exists?(:spree_credit_cards, :meta)
+    remove_column :spree_promotions, :meta if column_exists?(:spree_promotions, :meta)
+    remove_column :spree_orders, :meta if column_exists?(:spree_orders, :meta)
+    remove_column :spree_variants, :meta if column_exists?(:spree_variants, :meta)
+    remove_column :spree_products, :meta if column_exists?(:spree_products, :meta)
   end
 end

data/lib/flow/simple_gateway.rb

@@ -34,42 +34,6 @@ module Flow
       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