flowcommerce_spree 0.0.1

data/app/models/spree/line_item_decorator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Flow (2017)
+# Enable this modifications if you want to display flow localized line item
+# Example: https://i.imgur.com/7v2ix2G.png
+module Spree
+  LineItem.class_eval do
+    # admin show line item price
+    def single_money
+      price  = display_price.to_s
+      price += " (#{order.flow_line_item_price(self)})" if order.flow_order
+      price
+    end
+  end
+end

data/app/models/spree/order_decorator.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+# `:display_total` modifications to display total prices beside Spree default. Example: https://i.imgur.com/7v2ix2G.png
+module Spree # rubocop:disable Metrics/ModuleLength
+  # Added flow specific methods to Spree::Order
+  Order.class_eval do
+    serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+    store_accessor :meta, :flow_data
+
+    before_save :sync_to_flow_io
+    after_touch :sync_to_flow_io
+
+    def sync_to_flow_io
+      return unless zone&.flow_io_active_experience? && state == 'cart' && line_items.size > 0
+
+      flow_io_order = FlowcommerceSpree::OrderSync.new(order: self)
+      flow_io_order.build_flow_request
+      flow_io_order.synchronize! if flow_data['digest'] != flow_io_order.digest
+    end
+
+    def display_total
+      price = FlowcommerceSpree::Api.format_default_price total
+      price += " (#{flow_total})" if flow_order
+      price.html_safe
+    end
+
+    def flow_order
+      return unless flow_data&.[]('order')
+
+      Hashie::Mash.new flow_data['order']
+    end
+
+    # accepts line item, usually called from views
+    def flow_line_item_price(line_item, total = false)
+      result = if flow_order
+                 id = line_item.variant.sku
+
+                 lines = flow_order.lines || []
+                 item  = lines.find { |el| el['item_number'] == id }
+
+                 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
+
+    # prepares array of prices that can be easily renderd in templates
+    def flow_cart_breakdown
+      prices = []
+
+      price_model = Struct.new(:name, :label)
+
+      if flow_order
+        # duty, vat, ...
+        unless flow_order.prices
+          message = Flow::Error.format_order_message flow_order
+          raise Flow::Error, message
+        end
+
+        flow_order.prices.each do |price|
+          prices.push price_model.new(price['name'], price['label'])
+        end
+      else
+        price_elements =
+          %i[item_total adjustment_total included_tax_total additional_tax_total tax_total shipment_total promo_total]
+        price_elements.each do |el|
+          price = send(el)
+          if price > 0
+            label = FlowcommerceSpree::Api.format_default_price price
+            prices.push price_model.new(el.to_s.humanize.capitalize, label)
+          end
+        end
+
+        # discount is applied and we allways show it in default currency
+        if adjustment_total != 0
+          formated_discounted_price = FlowcommerceSpree::Api.format_default_price adjustment_total
+          prices.push price_model.new('Discount', formated_discounted_price)
+        end
+      end
+
+      # total
+      prices.push price_model.new(Spree.t(:total), flow_total)
+
+      prices
+    end
+
+    # shows localized total, if possible. if not, fall back to Spree default
+    def flow_total
+      # r flow_order.total.label
+      price = flow_order&.total&.label
+      price || FlowcommerceSpree::Api.format_default_price(total)
+    end
+
+    def flow_experience
+      model = Struct.new(:key)
+      model.new flow_order.experience.key
+    rescue StandardError => _e
+      model.new ENV.fetch('FLOW_BASE_COUNTRY')
+    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 add_user_consent_to_flow_data(consent, value)
+      self.flow_data['order'] ||= {}
+      self.flow_data['order']['attributes'] ||= {}
+      self.flow_data['order']['attributes'][consent] = 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_user_uuid
+      flow_data&.dig('order', 'attributes', 'user_uuid')
+    end
+
+    def checkout_url
+      "https://checkout.flow.io/#{FlowcommerceSpree::ORGANIZATION}/checkout/#{number}/" \
+        "contact-info?flow_session_id=#{flow_data['session_id']}"
+    end
+
+    # clear invalid zero amount payments. Solidus bug?
+    def clear_zero_amount_payments!
+      # class attribute that can be set to true
+      return unless Flow::Order.clear_zero_amount_payments
+
+      payments.where(amount: 0, state: %w[invalid processing pending]).map(&:destroy)
+    end
+
+    def flow_order_authorized?
+      flow_data&.[]('authorization') ? true : false
+    end
+
+    def flow_order_captured?
+      flow_data['capture'] ? true : false
+    end
+
+    # completes order and sets all states to finalized and complete
+    # used when we have confirmed capture from Flow API or PayPal
+    def flow_finalize!
+      finalize! unless state == 'complete'
+      update_column :payment_state, 'paid' if payment_state != 'paid'
+      update_column :state, 'complete'     if state != 'complete'
+    end
+
+    def flow_payment_method
+      if flow_data['payment_type'] == 'paypal'
+        'paypal'
+      else
+        'cc' # creait card is default
+      end
+    end
+  end
+end

data/app/models/spree/promotion_decorator.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Flow specific methods for Spree::Promotion
+module Spree
+  Promotion.class_eval do
+    serialize :meta, ActiveRecord::Coders::JSON.new(symbolize_keys: true)
+
+    store_accessor :meta, :flow_data
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Spree
+  module PromotionHandler
+    Coupon.class_eval do
+      def apply
+        if order.coupon_code.present?
+          if promotion&.actions.exists?
+            experience_key  = order.flow_order&.dig('experience', 'key')
+            forbiden_keys   = promotion.flow_data&.dig('filter', 'experience') || []
+
+            if experience_key.present? && !forbiden_keys.include?(experience_key)
+              self.error = 'Promotion is not available in current country'
+            else
+              handle_present_promotion(promotion)
+            end
+          else
+            self.error = if Promotion.with_coupon_code(order.coupon_code)&.expired?
+                           Spree.t(:coupon_code_expired)
+                         else
+                           Spree.t(:coupon_code_not_found)
+                         end
+          end
+        end
+
+        self
+      end
+    end
+  end
+end

data/app/models/spree/spree_user_decorator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# added flow specific methods to Spree.user_class
+# which is for Spree in same time
+# - user object (for admins as well)
+# - customer object
+
+Spree.user_class.class_eval do
+  def flow_number
+    return unless id
+
+    token = ENV.fetch('ENCRYPTION_KEY')
+    "su-#{Digest::SHA1.hexdigest(format('%d-%s', id, token))}"
+  end
+end

data/app/models/spree/taxon_decorator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# module Spree
+#   Taxon.class_eval do
+#     def products_by_zone(product_zone)
+#       flow_experience_key = product_zone.flow_data&.[]('key')
+#       sku_regex = product_zone.sku_regex
+#
+#       if flow_experience_key.present?
+#         products_by_experience(product_zone, sku_regex)
+#       else
+#         products.joins(:master).where('spree_variants.sku ~ ?', sku_regex)
+#       end
+#     end
+#
+#     def products_by_experience(flow_experience_key, sku_regex)
+#       # To make the following query return a distinct array of products, raw SQL had to be used:
+#       # object.products.joins(:variants).where(
+#       #   "spree_variants.meta -> 'flow_data' -> 'exp' ->> '#{flow_experience_key}' IS NOT NULL"
+#       # )
+#       query = <<~SQL
+#           SELECT DISTINCT spree_products.* FROM spree_products
+#             INNER JOIN spree_variants ON spree_variants.product_id = spree_products.id AND
+#               spree_variants.is_master = 'f' AND spree_variants.deleted_at IS NULL AND
+#               (spree_variants.sku ~ '#{sku_regex}')
+#             INNER JOIN (
+#               SELECT spree_products_taxons.*, spree_products_taxons.position as position from spree_products_taxons
+#                 ORDER BY position ASC
+#             ) I2 ON spree_products.id = I2.product_id
+#               WHERE spree_products.deleted_at IS NULL AND I2.taxon_id = #{id} AND
+#                 (spree_variants.meta -> 'flow_data' -> 'exp' ->> '#{flow_experience_key}' IS NOT NULL)
+#       SQL
+#
+#       Spree::Product.find_by_sql(query)
+#     end
+#   end
+# end

data/app/models/spree/zone_decorator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Spree
+  Zone.class_eval do
+    store_accessor :meta, :flow_data
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Spree
+  module Zones
+    module FlowIoProductZoneDecorator
+      def self.prepended(base)
+        base.after_update :update_on_flow, if: -> { flow_data&.[]('key').present? }
+        base.before_destroy :remove_on_flow_io, if: -> { flow_data&.[]('key').present? }
+      end
+
+      def available_currencies
+        ((currencies || []) + [flow_data&.[]('currency')]).compact.uniq.reject(&:empty?)
+      end
+
+      def flow_io_experience
+        flow_data&.[]('key')
+      end
+
+      def flow_io_experience_currency
+        flow_data&.[]('currency')
+      end
+
+      def flow_io_active_experience?
+        flow_data&.[]('key').present? && flow_data['status'] == 'active'
+      end
+
+      def update_on_flow; end
+
+      def remove_on_flow_io
+        client = FlowcommerceSpree.client
+        client.experiences.delete_by_key(FlowcommerceSpree::ORGANIZATION, flow_data['key'])
+
+        # Flowcommerce `delete_by_key` methods are always returning `nil`, that's why this hack of fetching
+        # @http_handler from client. This handler is a LoggingHttpHandler, which got the http_client attr_reader
+        # implemented specifically for this purpose.
+        false if client.instance_variable_get(:@http_handler).http_client.error
+      end
+
+      def store_flow_io_data(received_experience, logger: FlowcommerceSpree.logger)
+        self.flow_data = received_experience.is_a?(Hash) ? received_experience : received_experience.to_hash
+        self.status = flow_data['status']
+
+        if new_record? && update_attributes(meta: meta, status: status, kind: 'country')
+          logger.info "\nNew flow.io experience imported as product zone: #{name}"
+        elsif update_columns(meta: meta.to_json, status: status, kind: 'country')
+          logger.info "\nProduct zone `#{name}` has been updated from flow.io"
+        end
+
+        self
+      end
+
+      Spree::Zones::Product.prepend(self) if Spree::Zones::Product.included_modules.exclude?(self)
+    end
+  end
+end

data/app/services/flowcommerce_spree/import_experience_items.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  # A service object to import the data for product variants belonging to a flow.io Experience
+  class ImportExperienceItems
+    def self.run(zone, client: FlowcommerceSpree.client, organization: ORGANIZATION)
+      new(zone, client: client, organization: organization).run
+    end
+
+    def run
+      page_size  = 100
+      offset     = 0
+      items      = []
+      total = 0
+
+      while offset == 0 || items.length == 100
+        # show current list size
+        @logger.info "\nGetting items: #{@experience_key.green}, rows #{offset} - #{offset + page_size}"
+
+        begin
+          items = @client.experiences
+                         .get_items(@organization, experience: @experience_key, limit: page_size, offset: offset)
+        rescue Io::Flow::V0::HttpClient::PreconditionException => e
+          @logger.info "flow.io API error: #{e.message}"
+          break
+        end
+
+        offset += page_size
+        log_str = +''
+
+        items.each do |item|
+          total += 1
+          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}, "
+        end
+        @logger.info log_str
+      end
+
+      @logger.info "\nData for #{total.to_s.green} products was imported."
+    end
+
+    private
+
+    def initialize(zone, client:, organization:)
+      @client = client
+      @experience_key = zone.flow_io_experience
+      @logger = client.instance_variable_get(:@http_handler).logger
+      @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_experiences.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FlowcommerceSpree
+  # A service object to import the data for of flow.io Experience into Spree::Zones::Product
+  class ImportExperiences
+    def self.run(client: FlowcommerceSpree.client, organization: ORGANIZATION, with_items: nil, refresher: nil)
+      new(client: client, organization: organization, with_items: with_items, refresher: refresher).run
+    end
+
+    def run
+      # we have to log start, so that another process does not start while this one is running
+      @refresher.log_refresh!
+
+      @client.experiences.get(@organization, status: 'active').each do |experience|
+        experience_key = experience.key
+        zone = Spree::Zones::Product.find_or_initialize_by(name: experience_key.titleize)
+        zone.store_flow_io_data(experience, logger: @refresher.logger)
+
+        next @refresher.logger.info "Error: storing flow.io experience #{experience_key}" if zone.errors.any?
+
+        ImportExperienceItems.run(zone, client: @client) if @with_items
+      end
+
+      # Log sync end time
+      @refresher.log_refresh!(has_ended: true)
+    end
+
+    private
+
+    def initialize(client:, organization:, with_items: nil, refresher: Refresher.new)
+      @refresher = refresher
+      @client = client
+      @organization = organization
+      @with_items = with_items
+    end
+  end
+end