workarea-flow_io 1.2.1

data/app/controllers/workarea/storefront/searches_controller.decorator

@@ -0,0 +1,11 @@
+module Workarea
+  decorate Storefront::SearchesController, with: :flow_io do
+    decorated { before_action :add_flow_experience }
+
+    private
+
+      def add_flow_experience
+        params.merge!(experience: flow_experience)
+      end
+  end
+end

data/app/helpers/workarea/admin/flow_helper.rb

@@ -0,0 +1,13 @@
+module Workarea
+  module Admin
+    module FlowHelper
+      def default_currency
+        Money.default_currency
+      end
+
+      def flow_currencies
+        FlowIo::Experiences.all_currencies.map { |currency| Money::Currency.new(currency) }
+      end
+    end
+  end
+end

data/app/helpers/workarea/storefront/flow_analytics_helper.rb

@@ -0,0 +1,23 @@
+module Workarea
+  module Storefront
+    module FlowAnalyticsHelper
+      def product_analytics_data(product)
+        super.merge(
+          currency_code: product.sell_min_price&.currency&.iso_code,
+        ).compact
+      end
+
+      def order_item_analytics_data(item)
+        super.merge(currency_code: item.current_unit_price.currency.iso_code)
+      end
+
+      def order_analytics_data(order)
+        super.merge(
+          total_price_currency_code: order.total_price.currency.iso_code,
+          shipping_total_currency_code: order.shipping_total.currency.iso_code,
+          tax_total_currency_code: order.tax_total.currency.iso_code
+        )
+      end
+    end
+  end
+end

data/app/helpers/workarea/storefront/flow_content_helper.rb

@@ -0,0 +1,21 @@
+module Workarea
+  module Storefront
+    module FlowContentHelper
+      def render_content_blocks(blocks)
+        if current_user.try(:admin?)
+          render_content_blocks_without_cache(blocks)
+        else
+          cache_key = [
+            flow_experience&.key,
+            blocks.map(&:cache_key).join('/')
+          ].compact.join('/')
+
+          Rails.cache.fetch(
+            cache_key,
+            expires_in: Workarea.config.cache_expirations.render_content_blocks
+          ) { render_content_blocks_without_cache(blocks) }
+        end
+      end
+    end
+  end
+end

data/app/middleware/workarea/flow_io/session_middleware.rb

@@ -0,0 +1,68 @@
+module Workarea
+  module FlowIo
+    class SessionMiddleware
+      include Rack::Utils
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        flow_session = FlowIo::Session.new(env)
+
+        env['Vary'] = 'X-Requested-With, X-Flash-Messages, X-Flow-Experience'
+        begin
+          env['HTTP_X_FLOW_EXPERIENCE'] = flow_session.experience&.key
+          env['flow.io.experience'] = flow_session.experience
+          env['flow.io.country'] = flow_session.flow_country
+        rescue => error
+          capture_exception error
+          return @app.call env
+        end
+
+        status, headers, body = @app.call env
+
+        if %r{text/html}.match? headers['Content-Type']
+          if flow_session.set_f60_session_cookie?
+            set_cookie_header!(headers, "_f60_session", {
+              value: flow_session.id,
+              path: "/",
+              expires: 1.year.from_now
+            })
+          end
+
+          if flow_session.set_flow_experience_cookie?
+            experince_cookie_value =
+              if flow_session.experience.present?
+                JSON.generate(flow_session.experience.to_hash)
+              else
+                ""
+              end
+
+            set_cookie_header!(headers, "flow_experience", {
+              value: experince_cookie_value,
+              path: "/",
+              expires: 1.year.from_now
+            })
+          end
+
+          if flow_session.set_flow_country_cookie?
+            set_cookie_header!(headers, "flow_country", flow_session.flow_country)
+          end
+        end
+
+        [status, headers, body]
+      end
+
+      private
+
+        def capture_exception(exception)
+          if defined?(::Raven)
+            Raven.capture_exception(exception)
+          else
+            Rails.logger.warn "Error in FlowIo::SessionMiddleware: #{exception}"
+          end
+        end
+    end
+  end
+end

data/app/models/workarea/address.decorator

@@ -0,0 +1,12 @@
+module Workarea
+  decorate Address, with: :flow_io do
+    decorated do
+      field :flow, type: Boolean, default: false
+    end
+
+    def region_presence
+      return if flow?
+      super
+    end
+  end
+end

data/app/models/workarea/catalog/category.decorator

@@ -0,0 +1,8 @@
+module Workarea
+  decorate Catalog::Category, with: :flow_io do
+    decorated do
+      # price facets for currencies other than the default transacting currency
+      field :currency_localized_facets, type: Hash, default: {}
+    end
+  end
+end

data/app/models/workarea/checkout.decorator

@@ -0,0 +1,26 @@
+module Workarea
+  decorate Checkout, with: :flow_io do
+    decorated do
+      delegate :experience, to: :order
+    end
+
+    def shippings
+      super.tap do |workarea_shippings|
+        next unless experience.present?
+
+        workarea_shippings.each do |shipping|
+          shipping.build_experience experience.as_document
+        end
+      end
+    end
+
+    def shippable?
+      # WA does not have all the available shipping methods
+      # that flow supports, So by default the order will be
+      # shippable from flow
+      return true if order.flow?
+      super
+    end
+  end
+end
+

data/app/models/workarea/flow_io/experience_geo.rb

@@ -0,0 +1,18 @@
+module Workarea
+  module FlowIo
+    class ExperienceGeo
+      include ApplicationDocument
+
+      field :key, type: String
+      field :name, type: String
+      field :region, type: Hash
+      field :country, type: Country
+      field :currency, type: String
+      field :language, type: String
+      field :measurement_system, type: String
+
+      embedded_in :experienceable, polymorphic: true
+      validates_presence_of :key, :name
+    end
+  end
+end

data/app/models/workarea/flow_io/experience_summary.rb

@@ -0,0 +1,15 @@
+module Workarea
+  module FlowIo
+    class ExperienceSummary
+      include ApplicationDocument
+
+      field :key, type: String
+      field :name, type: String
+      field :country, type: Country
+      field :currency, type: String
+      field :language, type: String
+
+      validates_presence_of :key, :name
+    end
+  end
+end

data/app/models/workarea/flow_io/import.rb

@@ -0,0 +1,31 @@
+module Workarea
+  module FlowIo
+    # Where import CSV is stored, as well as some other metadata
+    # surrounding the processing of the aformentioned data.
+    class Import
+      include ApplicationDocument
+      extend Dragonfly::Model
+
+      field :name, type: String
+      field :file_uid, type: String
+      field :started_at, type: Time
+      field :completed_at, type: Time
+
+      dragonfly_accessor :file, app: :workarea
+
+      delegate :path, to: :file, prefix: true
+
+      validates :name, presence: true, uniqueness: true
+
+      index({ name: 1 }, { unique: true, background: true })
+      index(
+        { created_at: 1 },
+        { expire_after_seconds: Workarea.config.data_file_operation_ttl.seconds.to_i }
+      )
+
+      def complete?
+        completed_at.present?
+      end
+    end
+  end
+end

data/app/models/workarea/flow_io/imported_item.rb

@@ -0,0 +1,124 @@
+module Workarea
+  module FlowIo
+    # Represents a local item imported by the CSV importer.
+    class ImportedItem
+      attr_reader :params, :experiences
+
+      def initialize(row, experiences)
+        # HACK needed to parse params with keys like
+        # `parent[child][param]`, since that's what they come in
+        # as from the CSV.
+        @params = Rack::Utils.default_query_parser
+                             .parse_nested_query(row.to_h.to_query)
+                             .deep_symbolize_keys
+        @experiences = experiences
+      end
+
+      def self.process(row, experiences)
+        new(row, experiences).tap(&:save!)
+      end
+
+      def save!
+        # We don't care about world experience since it it needs to be converted
+        # by Flows javascript on the storefront
+        return if experience_key.match?(/world/i)
+
+        Sidekiq::Callbacks.disable(Workarea::FlowIo::ItemExporter) do
+          if local_item.present?
+            local_item.update_attributes(local_item_attributes)
+          else
+            sku.flow_io_local_items.create!(local_item_attributes)
+          end
+
+          sku.save!
+        end
+      end
+
+      private
+
+      def experience_key
+        params[:experience][:key]
+      end
+
+      def experience
+        @experience ||=
+          begin
+            exp = experiences.detect { |e| e.key == experience_key }
+
+            ExperienceSummary.new(
+              key: experience_key,
+              name: exp.name,
+              country: exp.country,
+              currency: Country.find_country_by_alpha3(exp.currency),
+              language: exp.language
+            )
+          end
+      end
+
+      def sku
+        @sku ||= Pricing::Sku.find_or_create_by!(_id: params[:item][:number])
+      end
+
+      def local_item
+        @local_item ||= sku.flow_io_local_items
+          .detect { |li| li.experience.key == experience.key }
+      end
+
+      def local_item_attributes
+        {
+          experience: experience,
+          prices: prices
+        }.merge(msrp)
+      end
+
+      def pricing_attributes
+         params[:prices][:price_attributes]
+      end
+
+      def msrp
+        return {} unless msrp_attributes = pricing_attributes[:msrp]
+
+        {
+          msrp: {
+            price: Money.from_amount(msrp_attributes[:amount].to_f, msrp_attributes[:currency]),
+            label: msrp_attributes[:label],
+            base_currency: {
+              price: Money.from_amount(msrp_attributes[:base][:amount].to_f, msrp_attributes[:base][:currency]),
+              label: msrp_attributes[:base][:label]
+            }
+          }
+        }
+      end
+
+      def prices
+        regular = pricing_attributes[:regular_price]
+        sale    = pricing_attributes[:sale_price]
+
+        price = {
+          min_quantity: 1,
+          regular: {
+            price: Money.from_amount(regular[:amount].to_f, regular[:currency]),
+            label: regular[:label],
+            base_currency: {
+              price: Money.from_amount(regular[:base][:amount].to_f, regular[:base][:currency]),
+              label: regular[:base][:label]
+            }
+          }
+        }
+
+        if sale.present?
+          price[:sale] = {
+            price: Money.from_amount(sale[:amount].to_f, sale[:currency]),
+            label: sale[:label],
+            base_currency: {
+              price: Money.from_amount(sale[:base][:amount].to_f, sale[:base][:currency]),
+              label: sale[:base][:label]
+            }
+          }
+        end
+
+        [price]
+      end
+    end
+  end
+end

data/app/models/workarea/flow_io/local_item.rb

@@ -0,0 +1,28 @@
+module Workarea
+  module FlowIo
+    class LocalItem
+      include ApplicationDocument
+
+      field :included_levies, type: Hash, default: {}
+
+      embedded_in :sku, class_name: "Workarea::Pricing::Sku"
+
+      embeds_one :experience, class_name: "Workarea::FlowIo::ExperienceSummary"
+      embeds_one :msrp, class_name: "Workarea::FlowIo::PriceWithBase"
+      embeds_many :prices, class_name: "Workarea::FlowIo::LocalizedPrice"
+
+      validates_presence_of :experience
+
+      # Creates a Pricing::Price from this local item
+      # used in Pricing::Sku#find_price
+      #
+      # @return [Pricing::Price]
+      #
+      def to_price(quantity = 1)
+        prices.sort_by(&:min_quantity).reverse.detect do |localized_price|
+          quantity >= localized_price.min_quantity
+        end&.to_price || Workarea::Pricing::Price.new(regular: 0.to_m(experience.currency))
+      end
+    end
+  end
+end

data/app/models/workarea/flow_io/localized_price.rb

@@ -0,0 +1,30 @@
+module Workarea
+  module FlowIo
+    class LocalizedPrice
+      include ApplicationDocument
+
+      field :min_quantity, type: Integer, default: 1
+
+      embeds_one :regular, class_name: "Workarea::FlowIo::PriceWithBase"
+      embeds_one :sale, class_name: "Workarea::FlowIo::PriceWithBase"
+
+      embedded_in :local_item, class_name: "Workarea::FlowIo::LocalItem"
+
+      validates_presence_of :regular
+
+       # Creates a Pricing::Price from this local item
+       # used in Pricing::Sku#find_price
+       #
+       # @return [Workarea::Pricing::Price]
+       #
+       def to_price
+         Workarea::Pricing::Price.new(
+           sku: self.local_item.sku.clone, # clone the sku so this price isn't added to #prices on real record
+           min_quantity: min_quantity,
+           regular: regular.price,
+           sale: sale&.price
+         )
+       end
+    end
+  end
+end