flowcommerce_spree 0.0.2 → 0.0.3

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

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/services/flowcommerce_spree/order_sync.rb

@@ -5,20 +5,23 @@ module FlowcommerceSpree
   # for easy integration we are currently passing:
   # - flow experience
   # - spree order
-  # - current customer, present as  @current_spree_user controller instance variable
+  # - 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: Spree::User.last
+  #    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
+  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
 
+    delegate :url_helpers, to: 'Rails.application.routes'
+
     class << self
       def clear_cache(order)
         return unless order.flow_data['order']
@@ -31,11 +34,9 @@ module FlowcommerceSpree
     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      = []
+      @order = order
+      @client = FlowcommerceSpree.client(session_id: fetch_session_id)
     end
 
     # helper method to send complete order from Spree to flow.io
@@ -43,6 +44,12 @@ module FlowcommerceSpree
       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
 
@@ -64,13 +71,12 @@ module FlowcommerceSpree
 
     # delivery methods are defined in flow console
     def deliveries
-      # if we have erorr with an order, but still using this method
+      # 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']
-      delivery_list = delivery_list.map do |opts|
+      delivery_list = @order.flow_order['deliveries'][0]['options'].map do |opts|
         name = opts['tier']['name']
 
         # add original Flow ID
@@ -101,15 +107,10 @@ module FlowcommerceSpree
 
     # 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 = {}
-      @opts[:experience]   = @experience
-      @opts[:expand]       = ['experience']
+      @opts = { experience: @experience, expand: ['experience'] }
+      @body = { items: @order.line_items.map { |line_item| add_item(line_item) } }
 
-      @body = { items: @items, number: @order.number }
-
-      add_customer if @customer
+      try_to_add_customer
 
       if (flow_data = @order.flow_data['order'])
         @body[:selections] = flow_data['selections'].presence
@@ -128,35 +129,118 @@ module FlowcommerceSpree
 
     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(
+        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)
+
+      @order.flow_io_attribute_add('flow_return_url', confirmation_url)
+      @order.flow_io_attribute_add('checkout_continue_shopping_url', root_url)
+    end
+
     # 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? }
+    def try_to_add_customer
+      return unless (customer = @order.user)
+
+      address = nil
+      customer_ship_address = customer.ship_address
+      address = customer_ship_address if customer_ship_address&.country&.iso3 == @order.zone.flow_io_experience_country
+
+      unless address
+        user_profile_address = customer.user_profile&.address
+        address = user_profile_address if user_profile_address&.country&.iso3 == @order.zone.flow_io_experience_country
       end
 
-      @body
+      @body[:customer] = { name: { first: address&.firstname,
+                                   last: address&.lastname },
+                           email: customer.email,
+                           number: customer.flow_number,
+                           phone: address&.phone }
+
+      add_customer_address(address) if address
+    end
+
+    def add_customer_address(address)
+      streets = []
+      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 || ''),
+                              contact: @body[:customer] }
+
+      @body[:destination].delete_if { |_k, v| v.nil? }
     end
 
     def sync_body!
@@ -165,7 +249,7 @@ module FlowcommerceSpree
       @use_get = false
 
       # use get if order is completed and closed
-      @use_get = true if @order.state == 'complete'
+      @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
@@ -174,9 +258,9 @@ module FlowcommerceSpree
       @use_get = false unless @order.flow_data['order']
 
       if @use_get
-        @response ||= FlowcommerceSpree::Api.run :get, "/:organization/orders/#{@body[:number]}", expand: 'experience'
+        @response ||= @client.orders.get_by_number(ORGANIZATION, @order.number).to_hash
       else
-        @response = @client.orders.put_by_number(FlowcommerceSpree::ORGANIZATION, @order.number,
+        @response = @client.orders.put_by_number(ORGANIZATION, @order.number,
                                                  Io::Flow::V0::Models::OrderPutForm.new(@body), @opts).to_hash
       end
     end
@@ -199,16 +283,14 @@ 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
+    # set cache for total order amount
     # written in flow_data field inside spree_orders table
     def write_response_in_cache
       if !@response || error?
@@ -222,10 +304,8 @@ module FlowcommerceSpree
         return if @use_get && response_total == cache_total
 
         # update local order
-        @order.flow_data.merge!('digest' => @digest, 'order' => @response.to_hash)
+        @order.flow_data.merge!('digest' => @digest, 'order' => @response)
       end
-
-      @order.update_column(:meta, @order.meta.to_json)
     end
   end
 end

data/config/rails_best_practices.yml

@@ -0,0 +1,51 @@
+AddModelVirtualAttributeCheck: { }
+AlwaysAddDbIndexCheck: { }
+#CheckSaveReturnValueCheck: { }
+#CheckDestroyReturnValueCheck: { }
+DefaultScopeIsEvilCheck: { }
+DryBundlerInCapistranoCheck: { }
+#HashSyntaxCheck: { }
+IsolateSeedDataCheck: { }
+KeepFindersOnTheirOwnModelCheck: { }
+LawOfDemeterCheck: { }
+#LongLineCheck: { max_line_length: 80 }
+MoveCodeIntoControllerCheck: { }
+MoveCodeIntoHelperCheck: { array_count: 3 }
+MoveCodeIntoModelCheck: { use_count: 2 }
+MoveFinderToNamedScopeCheck: { }
+MoveModelLogicIntoModelCheck: { use_count: 4 }
+NeedlessDeepNestingCheck: { nested_count: 2 }
+NotRescueExceptionCheck: { }
+NotUseDefaultRouteCheck: { }
+NotUseTimeAgoInWordsCheck: { }
+OveruseRouteCustomizationsCheck: { customize_count: 3 }
+ProtectMassAssignmentCheck: { }
+RemoveEmptyHelpersCheck: { }
+#RemoveTabCheck: { }
+RemoveTrailingWhitespaceCheck: { }
+RemoveUnusedMethodsInControllersCheck: { except_methods: [] }
+RemoveUnusedMethodsInHelpersCheck: { except_methods: [] }
+RemoveUnusedMethodsInModelsCheck: { except_methods: 
+  [
+  'Spree::Calculator::FlowIo#compute_shipment', # Used by Spree::Calculator
+  'Spree::Calculator::FlowIo#compute_line_item', # Used by Spree::Calculator
+  'Spree::Calculator::FlowIo#description', # Used by Spree
+  'Spree::Shipping::FlowIo#compute_package', # Used by Spree
+  'Spree::Shipping::FlowIo#default_charge', # Used by Spree
+  'Spree::Shipping::FlowIo#threshold', # Used by Spree
+  'Spree::Shipping::FlowIo#description', # Used by Spree
+  ] }
+ReplaceComplexCreationWithFactoryMethodCheck: { attribute_assignment_count: 2 }
+ReplaceInstanceVariableWithLocalVariableCheck: { }
+RestrictAutoGeneratedRoutesCheck: { }
+SimplifyRenderInControllersCheck: { }
+SimplifyRenderInViewsCheck: { }
+#UseBeforeFilterCheck: { customize_count: 2 }
+UseModelAssociationCheck: { }
+UseMultipartAlternativeAsContentTypeOfEmailCheck: { }
+#UseParenthesesInMethodDefCheck: { }
+UseObserverCheck: { }
+UseQueryAttributeCheck: { }
+UseSayWithTimeInMigrationsCheck: { }
+UseScopeAccessCheck: { }
+UseTurboSprocketsRails3Check: { }

data/lib/flowcommerce_spree.rb

@@ -9,6 +9,7 @@ require 'flowcommerce_spree/logging_http_handler'
 require 'flowcommerce_spree/webhook_service'
 require 'flowcommerce_spree/session'
 require 'flow/simple_gateway'
+require 'request_store'
 
 module FlowcommerceSpree
   def self.client(logger: FlowcommerceSpree.logger, **opts)
@@ -20,11 +21,20 @@ module FlowcommerceSpree
   end
 
   def self.logger
-    logger = ActiveSupport::Logger.new(STDOUT, 3, 10_485_760)
+    logger = ActiveSupport::Logger.new(STDOUT)
+
+    logger_formatter = proc do |severity, datetime, _progname, msg|
+      "\n#{datetime}, #{severity}: #{msg}\n"
+    end
+
+    logger.formatter = logger_formatter
 
     # Broadcast the log into the file besides STDOUT, if `log` folder exists
     if Dir.exist?('log')
-      logger.extend(ActiveSupport::Logger.broadcast(ActiveSupport::Logger.new('log/flowcommerce_spree.log')))
+      file_logger = ActiveSupport::Logger.new('log/flowcommerce_spree.log', 3, 10_485_760)
+      file_logger.formatter = logger_formatter
+
+      logger.extend(ActiveSupport::Logger.broadcast(file_logger))
     end
     logger
   end

data/lib/flowcommerce_spree/engine.rb

@@ -6,14 +6,34 @@ module FlowcommerceSpree
     isolate_namespace FlowcommerceSpree
 
     config.before_initialize do
+      FlowcommerceSpree::ORGANIZATION = ENV.fetch('FLOW_ORGANIZATION', 'flow.io')
+      FlowcommerceSpree::BASE_COUNTRY = ENV.fetch('FLOW_BASE_COUNTRY', 'USA')
+      FlowcommerceSpree::API_KEY = ENV.fetch('FLOW_TOKEN', 'test_key')
+
       FlowcommerceSpree::Config = FlowcommerceSpree::Settings.new
     end
 
-    config.after_initialize do
+    config.flowcommerce_spree = ActiveSupport::OrderedOptions.new
+
+    initializer 'flowcommerce_spree.configuration' do |app|
+      # If some Rake tasks will fail in development environment, the cause could be the autoloading.
+      # Uncommenting the following 3 lines will enable eager-loading for the flowcommerce_spree Rake tasks.
+      # if Rails.env.development?
+      #   app.config.eager_load = Rake.application.top_level_tasks.any? { |t| t.start_with?('flowcommerce_spree') }
+      # end
+
+      app.config.flowcommerce_spree[:mounted_path] = ENV.fetch('FLOW_MOUNT_PATH', '/flow')
+
+      app.routes.append do
+        mount FlowcommerceSpree::Engine => app.config.flowcommerce_spree[:mounted_path]
+      end
+    end
+
+    config.after_initialize do |app|
       # init Flow payments as an option
-      # app.config.spree.payment_methods << Spree::Gateway::Flow
+      app.config.spree.payment_methods << Spree::Gateway::FlowIo
 
-      Flow::SimpleGateway.clear_zero_amount_payments = true
+      # Flow::SimpleGateway.clear_zero_amount_payments = true
     end
 
     def self.activate
@@ -23,5 +43,10 @@ module FlowcommerceSpree
     end
 
     config.to_prepare(&method(:activate).to_proc)
+
+    initializer 'spree.flowcommerce_spree.calculators', after: 'spree.register.calculators' do |_app|
+      Rails.application.config.spree.calculators.tax_rates << Spree::Calculator::FlowIo
+      Rails.application.config.spree.calculators.shipping_methods << Spree::Calculator::Shipping::FlowIo
+    end
   end
 end