flowcommerce_spree 0.0.1 → 0.0.6

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

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}"
 

data/app/services/flowcommerce_spree/order_sync.rb

@@ -2,196 +2,118 @@
 
 module FlowcommerceSpree
   # represents flow.io order syncing service
-  # for easy integration we are currently passing:
-  # - flow experience
-  # - spree order
-  # - current customer, present as  @current_spree_user controller instance variable
-  #
-  # example:
-  #  flow_order = FlowcommerceSpree::OrderSync.new    # init flow-order object
-  #    order: Spree::Order.last,
-  #    experience: @flow_session.experience
-  #    customer: Spree::User.last
-  #  flow_order.build_flow_request           # builds json body to be posted to flow.io api
-  #  flow_order.synchronize!                 # sends order to flow
   class OrderSync
     FLOW_CENTER = 'default'
 
-    attr_reader :digest, :order, :response
+    attr_reader :order, :response
 
-    class << self
-      def clear_cache(order)
-        return unless order.flow_data['order']
+    # @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?
 
-        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?
-
-      @client = FlowcommerceSpree.client(session_id: order.flow_data['session_id'])
       @experience = order.flow_io_experience_key
-      @order      = order
-      @customer   = order.user
-      @items      = []
+      @flow_session_id = flow_session_id
+      @order = order
+      @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
-      @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 erorr with an order, but still using this method
-      return [] unless @order.flow_order
-
-      @order.flow_data ||= {}
-
-      delivery_list = @order.flow_order['deliveries'][0]['options']
-      delivery_list = delivery_list.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
-      @order.line_items.each { |line_item| add_item(line_item) }
+      @opts = { experience: @experience, expand: ['experience'] }
+      @body = { items: @order.line_items.map { |line_item| add_item(line_item) } }
 
-      @opts = {}
-      @opts[:experience]   = @experience
-      @opts[:expand]       = ['experience']
+      try_to_add_customer
 
-      @body = { items: @items, number: @order.number }
+      return unless (flow_data = @order.flow_data['order'])
 
-      add_customer if @customer
+      @body[:selections] = flow_data['selections'].presence
+      @body[:delivered_duty] = flow_data['delivered_duty'].presence
+      @body[:attributes] = flow_data['attributes'].presence
 
-      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
+      # discount on full order is applied
+      @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency } if @order.adjustment_total != 0
+    end
 
-        if @order.adjustment_total != 0
-          # discount on full order is applied
-          @body[:discount] = { amount: @order.adjustment_total, currency: @order.currency }
-        end
-      end
+    def refresh_checkout_token
+      root_url = Rails.application.routes.url_helpers.root_url
+      order_number = @order.number
+      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)
 
-      # calculate digest body and cache it
-      @digest = Digest::SHA1.hexdigest(@opts.to_json + @body.to_json)
+      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
 
-    private
-
     # if customer is defined, add customer info
     # it is possible to have order in Spree without customer info (new guest session)
-    def add_customer
-      return unless @customer
-
-      address = @customer.ship_address
-      # address = nil
-      if address
-        @body[:customer] = { name: { first: address.firstname,
-                                     last: address.lastname },
-                             email: @customer.email,
-                             number: @customer.flow_number,
-                             phone: address.phone }
-
-        streets = []
-        streets.push address.address1 unless address.address1.blank?
-        streets.push address.address2 unless address.address2.blank?
-
-        @body[:destination] = { streets: streets,
-                                city: address.city,
-                                province: address.state_name,
-                                postal: address.zipcode,
-                                country: (address.country.iso3 || 'USA'),
-                                contact: @body[:customer] }
-
-        @body[:destination].delete_if { |_k, v| v.nil? }
-      end
+    def try_to_add_customer
+      return unless (customer = @order.user)
 
-      @body
-    end
+      address = nil
+      customer_ship_address = customer.ship_address
+      address = customer_ship_address if customer_ship_address&.country&.iso3 == @order.zone.flow_io_experience_country
 
-    def sync_body!
-      build_flow_request if @body.blank?
+      customer_profile = customer.user_profile
+      unless address
+        user_profile_address = customer_profile&.address
+        address = user_profile_address if user_profile_address&.country&.iso3 == @order.zone.flow_io_experience_country
+      end
 
-      @use_get = false
+      @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 }
 
-      # use get if order is completed and closed
-      @use_get = true if @order.state == 'complete'
+      add_customer_address(address) if address
+    end
 
-      # use get if local digest hash check said there is no change
-      @use_get ||= true if @order.flow_data['digest'] == @digest
+    def add_customer_address(address)
+      streets = []
+      streets.push address.address1 if address.address1.present?
+      streets.push address.address2 if address.address2.present?
 
-      # do not use get if there is no local order cache
-      @use_get = false unless @order.flow_data['order']
+      @body[:destination] = { streets: streets,
+                              city: address.city,
+                              province: address.state_name,
+                              postal: address.zipcode,
+                              country: (address.country&.iso3 || ''),
+                              contact: @body[:customer] }
 
-      if @use_get
-        @response ||= FlowcommerceSpree::Api.run :get, "/:organization/orders/#{@body[:number]}", expand: 'experience'
-      else
-        @response = @client.orders.put_by_number(FlowcommerceSpree::ORGANIZATION, @order.number,
-                                                 Io::Flow::V0::Models::OrderPutForm.new(@body), @opts).to_hash
-      end
+      @body[:destination].delete_if { |_k, v| v.nil? }
     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
+    def sync_body!
+      build_flow_request
 
-      @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)
@@ -199,33 +121,19 @@ module FlowcommerceSpree
       price_root = variant.flow_data&.dig('exp', @experience, 'prices')&.[](0) || {}
 
       # create flow order line item
-      item = { center: FLOW_CENTER,
-               number: variant.sku,
-               quantity: line_item.quantity,
-               price: { amount: price_root['amount'] || variant.cost_price,
-                        currency: price_root['currency'] || variant.cost_currency } }
-
-      @items.push item
+      { center: FLOW_CENTER,
+        number: variant.sku,
+        quantity: line_item.quantity,
+        price: { amount: price_root['amount'] || variant.cost_price,
+                 currency: price_root['currency'] || variant.cost_currency } }
     end
 
-    # set cache for total order ammount
-    # 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
-
-        # update local order
-        @order.flow_data.merge!('digest' => @digest, 'order' => @response.to_hash)
-      end
+    def write_response_to_order
+      return @order.flow_data.delete('order') if !@response || error?
 
-      @order.update_column(:meta, @order.meta.to_json)
+      # update local order
+      @order.total = @response[:total]&.[](:amount)
+      @order.flow_data.merge!('order' => @response)
     end
   end
 end