flowcommerce_spree 0.0.3 → 0.0.8

data/app/models/spree/flow_io_product_decorator.rb

@@ -7,6 +7,7 @@ module Spree
       base.serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
 
       base.store_accessor :meta, :flow_data, :zone_ids
+      base.after_save :sync_variants_with_flow
     end
 
     def price_in_zone(currency, product_zone)
@@ -86,6 +87,10 @@ module Spree
       prices
     end
 
+    def sync_variants_with_flow
+      variants_including_master.each(&:sync_product_to_flow)
+    end
+
     Spree::Product.prepend(self) if Spree::Product.included_modules.exclude?(self)
   end
 end

data/app/models/spree/flow_io_variant_decorator.rb

@@ -49,15 +49,23 @@ module Spree
       product.update_columns(meta: product.meta.to_json)
     end
 
+    def sync_flow_info?
+      if FlowcommerceSpree::API_KEY.blank? || FlowcommerceSpree::API_KEY == 'test_key'
+        return { error: 'Api Keys not configured' }
+      end
+      return { error: 'Price is 0' } if price == 0
+      return { error: 'Country of Origin is empty.' } unless country_of_origin
+    end
+
     # upload product variant to Flow's Product Catalog
     def sync_product_to_flow
-      # initial Spree seed will fail, so skip unless we have Flow data field
-      return unless respond_to?(:flow_data)
+      error = sync_flow_info?
+      return error if error.present?
 
-      return if FlowcommerceSpree::API_KEY.blank? || FlowcommerceSpree::API_KEY == 'test_key'
-
-      return { error: 'Price is 0' } if price == 0
+      update_flow_data
+    end
 
+    def update_flow_data
       additional_attrs = {}
       attr_name = nil
       export_required = false
@@ -82,7 +90,7 @@ module Spree
       flow_item_sh1 = Digest::SHA1.hexdigest(flow_item.to_json)
 
       # skip if sync not needed
-      return nil if flow_data&.[](:last_sync_sh1) == flow_item_sh1
+      return { error: 'Synchronization not needed' } if flow_data&.[](:last_sync_sh1) == flow_item_sh1
 
       response = FlowcommerceSpree.client.items.put_by_number(FlowcommerceSpree::ORGANIZATION, sku, flow_item)
       self.flow_data ||= {}
@@ -91,6 +99,8 @@ module Spree
       # after successful put, write cache
       update_column(:meta, meta.to_json)
 
+      FlowcommerceSpree::ImportItemWorker.perform_async(sku)
+
       response
     rescue Net::OpenTimeout => e
       { error: e.message }

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

@@ -5,6 +5,8 @@
 module Spree
   class Gateway
     class FlowIo < Gateway
+      REFUND_SUCCESS = 'succeeded'
+
       def provider_class
         self.class
       end
@@ -23,7 +25,7 @@ module Spree
       end
 
       def method_type
-        'gateway'
+        'flow_io_gateway'
       end
 
       def preferences
@@ -40,34 +42,29 @@ module Spree
         order.cc_authorization
       end
 
-      def capture(_amount, _payment_method, options = {})
-        order = load_order options
-        order.cc_capture
-      end
-
-      def purchase(_amount, _payment_method, options = {})
-        order = load_order options
-        flow_auth = order.cc_authorization
-
-        if flow_auth.success?
-          order.cc_capture
-        else
-          flow_auth
-        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 refund(_money, _authorization_key, options = {})
-        order = load_order options
-        order.cc_refund
+      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(money, authorization_key, options = {})
-        # binding.pry
+      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)
-        # binding.pry
-
         # payment.order.state
         @credit_card = payment.source
 
@@ -77,12 +74,52 @@ module Spree
 
       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 = Spree::PaymentMethod.where(active: true, type: 'Spree::Gateway::FlowIo').first
-        @credit_card.payment_method_id = flow_payment.id if flow_payment
+        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

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/zones/flow_io_product_zone_decorator.rb

@@ -28,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/overrides/spree/admin/order_sidebar_summary_flow_link.rb

@@ -0,0 +1,13 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/shared/_order_tabs',
+  name: 'spree_admin_order_additional_information_flow_message',
+  insert_top: '.additional-info',
+  text: '
+    <% if FlowcommerceSpree::ORGANIZATION.present? && @order.flow_order.present? %>
+      <div style="text-align: center">
+        <%= link_to "See Flow Order",
+                    "https://console.flow.io/#{FlowcommerceSpree::ORGANIZATION}/orders/#{@order.number}",
+                    target: "_blank", class: "button" %>
+      </div>
+    <% end %>'
+)

data/app/overrides/spree/admin/products/order_price_flow_message.rb

@@ -0,0 +1,9 @@
+Deface::Override.new(
+  virtual_path: 'spree/admin/prices/index',
+  name: 'spree_admin_prices_flow_mesage',
+  insert_top: '.no-border-top',
+  text: "
+  <div class='spree-admin-info' >
+    To check localized pricing, please click <a href='#{"https://console.flow.io/#{ENV['FLOW_ORGANIZATION']}/price-books"}' target='_blank'>here</a>.
+  </div>"
+)

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}"
 
@@ -33,14 +33,6 @@ module FlowcommerceSpree
           item_hash = item.to_hash
           next unless (variant = Spree::Variant.find_by(sku: item_hash.delete(:number)))
 
-          status_in_experience = item_hash.dig(:local, :status)
-
-          if status_in_experience != 'included'
-            log_str << "[#{status_in_experience.red}]:"
-          else # If at least a variant is included in experience, include the product too
-            adjust_product_zone(variant)
-          end
-
           variant.flow_import_item(item_hash, experience_key: @experience_key)
 
           log_str << "#{variant.sku}, "
@@ -60,17 +52,5 @@ module FlowcommerceSpree
       @organization = organization
       @zone = zone
     end
-
-    def adjust_product_zone(variant)
-      return unless (product = variant.product)
-
-      zone_ids = product.zone_ids || []
-      zone_id_string = @zone.id.to_s
-      return if zone_ids.include?(zone_id_string)
-
-      zone_ids << zone_id_string
-      product.zone_ids = zone_ids
-      product.update_columns(meta: product.meta.to_json)
-    end
   end
 end

data/app/services/flowcommerce_spree/import_item.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  # A service object to import the data for product variants belonging to a flow.io Experience
+  class ImportItem
+    def self.run(variant, client: FlowcommerceSpree.client, organization: ORGANIZATION)
+      new(variant, client: client, organization: organization).run
+    end
+
+    def run
+      @client.experiences.get(@organization, status: 'active').each do |experience|
+        experience_key = experience.key
+        zone = Spree::Zones::Product.find_by(name: experience_key.titleize)
+        next unless zone
+
+        import_data(zone)
+      end
+    end
+
+    private
+
+    def initialize(variant, client:, organization:)
+      @client = client
+      @logger = client.instance_variable_get(:@http_handler).logger
+      @organization = organization
+      @variant = variant
+    end
+
+    def import_data(zone)
+      experience_key = zone.flow_io_experience
+      item = begin
+               @client.experiences.get_items_by_number(@organization, @variant.sku, experience: experience_key)
+             rescue Io::Flow::V0::HttpClient::PreconditionException, Io::Flow::V0::HttpClient::ServerError => e
+               @logger.info "flow.io API error: #{e.message}"
+             end
+      return unless item
+
+      item_hash = item.to_hash
+
+      @variant.flow_import_item(item_hash, experience_key: @experience_key)
+
+      @logger.info "[#{@variant.sku}][#{experience_key}] Variant experience imported successfully."
+    end
+  end
+end

data/app/services/flowcommerce_spree/order_sync.rb

@@ -2,108 +2,39 @@
 
 module FlowcommerceSpree
   # represents flow.io order syncing service
-  # for easy integration we are currently passing:
-  # - flow experience
-  # - spree order
-  # - current customer, if present as  @order.user
-  #
-  # example:
-  #  flow_order = FlowcommerceSpree::OrderSync.new    # init flow-order object
-  #    order: Spree::Order.last,
-  #    experience: @flow_session.experience
-  #    customer: @order.user
-  #  flow_order.build_flow_request           # builds json body to be posted to flow.io api
-  #  flow_order.synchronize!                 # sends order to flow
-  class OrderSync # rubocop:disable Metrics/ClassLength
+  class OrderSync
     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:)
-      raise(ArgumentError, 'Experience not defined or not active') unless order.zone&.flow_io_active_experience?
+    # @param [Object] order
+    # @param [String] flow_session_id
+    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(default_headers: { "Authorization": "Session #{flow_session_id}" },
+                                         authorization: nil)
     end
 
     # helper method to send complete order from Spree to flow.io
     def synchronize!
-      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
-    end
+      return unless @order.state == 'cart' && @order.line_items.size > 0
 
-    def error
-      @response['messages'].join(', ')
-    end
+      sync_body!
+      write_response_to_order
 
-    def error_code
-      @response['code']
+      @order.update_columns(total: @order.total, meta: @order.meta.to_json)
+      refresh_checkout_token
     end
 
     def error?
       @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
+    private
 
     # builds object that can be sent to api.flow.io to sync order data
     def build_flow_request
@@ -112,97 +43,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
-
-        if @order.adjustment_total != 0
-          # discount on full order is applied
-          @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency }
-        end
-      end
-
-      # calculate digest body and cache it
-      @digest = Digest::SHA1.hexdigest(@opts.to_json + @body.to_json)
-    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
+      return unless (flow_data = @order.flow_data['order'])
 
-    def flow_io_session_expired?(expiration_time)
-      return nil if expiration_time == 0
+      @body[:selections] = flow_data['selections'].presence
+      @body[:delivered_duty] = flow_data['delivered_duty'].presence
+      @body[:attributes] = flow_data['attributes'].presence
 
-      expiration_time - Time.zone.now.utc.to_i < SESSION_EXPIRATION_THRESHOLD
+      # discount on full order is applied
+      @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency } if @order.adjustment_total != 0
     end
 
     def refresh_checkout_token
-      root_url = url_helpers.root_url
+      root_url = Rails.application.routes.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(
-        FlowcommerceSpree::ORGANIZATION,
-        discriminator: 'checkout_token_reference_form',
-        order_number: order_number,
-        session_id: @order.flow_data['session_id'],
-        urls: { continue_shopping: root_url,
-                confirmation: confirmation_url,
-                invalid_checkout: root_url }
-      )
-      @order.add_flow_checkout_token(checkout_token.id)
-
+      confirmation_url = "#{root_url}flow/order-completed?order=#{order_number}&t=#{@order.guest_token}"
       @order.flow_io_attribute_add('flow_return_url', confirmation_url)
       @order.flow_io_attribute_add('checkout_continue_shopping_url', root_url)
+
+      FlowcommerceSpree.client.checkout_tokens.post_checkout_and_tokens_by_organization(
+        FlowcommerceSpree::ORGANIZATION, discriminator: 'checkout_token_reference_form',
+                                         order_number: order_number,
+                                         session_id: @flow_session_id,
+                                         urls: { continue_shopping: root_url,
+                                                 confirmation: confirmation_url,
+                                                 invalid_checkout: root_url }
+      )&.id
     end
 
     # if customer is defined, add customer info
@@ -214,13 +79,14 @@ module FlowcommerceSpree
       customer_ship_address = customer.ship_address
       address = customer_ship_address if customer_ship_address&.country&.iso3 == @order.zone.flow_io_experience_country
 
+      customer_profile = customer.user_profile
       unless address
-        user_profile_address = customer.user_profile&.address
+        user_profile_address = customer_profile&.address
         address = user_profile_address if user_profile_address&.country&.iso3 == @order.zone.flow_io_experience_country
       end
 
-      @body[:customer] = { name: { first: address&.firstname,
-                                   last: address&.lastname },
+      @body[:customer] = { name: { first: address&.firstname || customer_profile&.first_name,
+                                   last: address&.lastname || customer_profile&.last_name },
                            email: customer.email,
                            number: customer.flow_number,
                            phone: address&.phone }
@@ -230,52 +96,24 @@ module FlowcommerceSpree
 
     def add_customer_address(address)
       streets = []
-      streets.push address.address1 if address&.address1.present?
-      streets.push address.address2 if address&.address2.present?
+      streets.push address.address1 if address.address1.present?
+      streets.push address.address2 if address.address2.present?
 
       @body[:destination] = { streets: streets,
-                              city: address&.city,
-                              province: address&.state_name,
-                              postal: address&.zipcode,
-                              country: (address&.country&.iso3 || ''),
+                              city: address.city,
+                              province: address.state_name,
+                              postal: address.zipcode,
+                              country: (address.country&.iso3 || ''),
                               contact: @body[:customer] }
 
       @body[:destination].delete_if { |_k, v| v.nil? }
     end
 
     def sync_body!
-      build_flow_request if @body.blank?
-
-      @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']
-
-      if @use_get
-        @response ||= @client.orders.get_by_number(ORGANIZATION, @order.number).to_hash
-      else
-        @response = @client.orders.put_by_number(ORGANIZATION, @order.number,
-                                                 Io::Flow::V0::Models::OrderPutForm.new(@body), @opts).to_hash
-      end
-    end
+      build_flow_request
 
-    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'
+      @response = @client.orders.put_by_number(ORGANIZATION, @order.number,
+                                               Io::Flow::V0::Models::OrderPutForm.new(@body), @opts).to_hash
     end
 
     def add_item(line_item)
@@ -290,22 +128,12 @@ module FlowcommerceSpree
                  currency: price_root['currency'] || variant.cost_currency } }
     end
 
-    # set cache for total order amount
-    # 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')
-
-        # return if total is not changed, no products removed or added
-        return if @use_get && response_total == cache_total
+    def write_response_to_order
+      return @order.flow_data.delete('order') if !@response || error?
 
-        # update local order
-        @order.flow_data.merge!('digest' => @digest, 'order' => @response)
-      end
+      # update local order
+      @order.total = @response[:total]&.[](:amount)
+      @order.flow_data.merge!('order' => @response)
     end
   end
 end