workarea-storefront 3.4.12

data/app/view_models/workarea/storefront/product_view_model/cache_key.rb

@@ -0,0 +1,44 @@
+module Workarea
+  module Storefront
+    class ProductViewModel
+      class CacheKey
+        def initialize(product, options = {})
+          @product = product
+          @options = options
+        end
+
+        def to_s
+          (product_parts + option_parts).join('/')
+        end
+
+        private
+
+        # This method exists to duplicate Mongoid cache for a Catalog::Product
+        # that has been loaded from Elasticsearch. Since not persisted, Mongoid
+        # returns a hardcoded cache key.
+        def product_parts
+          [
+            @product.send(:model_key), # Mongoid has this as a private method
+            "#{@product.id}-#{@product.updated_at.utc.to_s(:nsec)}"
+          ]
+        end
+
+        def option_parts
+          common_options.values + details_in_options.values
+        end
+
+        def details_in_options
+          @options.select { |option, _value| detail_keys.include?(option&.systemize) }
+        end
+
+        def common_options
+          @options.slice(:current_sku, :via)
+        end
+
+        def detail_keys
+          @product.variants.flat_map(&:detail_names).map(&:systemize).uniq
+        end
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/product_view_model/image_collection.rb

@@ -0,0 +1,58 @@
+module Workarea
+  module Storefront
+    class ProductViewModel
+      class ImageCollection
+        include Enumerable
+
+        attr_reader :all
+
+        def initialize(product, options = {}, images = nil)
+          @product = product
+          @options = options.with_indifferent_access
+          @all = images || @product.images
+        end
+
+        def primary
+          @primary ||= selected_facet_images ||
+                       first ||
+                       Catalog::ProductPlaceholderImage.cached
+        end
+
+        def +(other)
+          ImageCollection.new(@product, @options, @all + other.all)
+        end
+
+        def respond_to_missing?(method_name, include_private = false)
+          super || @all.respond_to?(method_name)
+        end
+
+        def method_missing(sym, *args, &block)
+          if @all.respond_to?(sym)
+            @all.send(sym, *args, &block)
+          else
+            super
+          end
+        end
+
+        private
+
+        def selected_facet_images
+          return unless selected_facet_values.present?
+          @all.detect { |i| i.option.to_s.systemize.in?(selected_facet_values) }
+        end
+
+        def selected_facet_values
+          @selected_facet_values ||=
+            if @options[:sku].present?
+              variant = @product.variants.find_by(sku: @options[:sku])
+              variant.details.values.flatten.map(&:systemize)
+            else
+              @options.values.flat_map do |value|
+                Array.wrap(value).map(&:to_s).map(&:optionize)
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/product_view_model/option.rb

@@ -0,0 +1,24 @@
+module Workarea
+  module Storefront
+    class ProductViewModel
+      class Option
+        attr_reader :product, :slug, :selections, :options
+
+        def initialize(product, slug, selections, options = {})
+          @product = product
+          @slug = slug.optionize
+          @selections = selections
+          @options = options
+        end
+
+        def name
+          slug.titleize
+        end
+
+        def current
+          options[slug].presence_in(selections)
+        end
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/product_view_model/option_set.rb

@@ -0,0 +1,97 @@
+module Workarea
+  module Storefront
+    class ProductViewModel
+      class OptionSet
+        attr_reader :product, :options
+
+        def self.from_sku(product, sku, options = {})
+          matching_variant = product.variants.detect { |v| v.sku == sku }
+          sku_options = matching_variant&.details&.transform_values(&:first) || {}
+          new(product, sku_options.merge(options))
+        end
+
+        def initialize(product, options = {})
+          @product = product
+          @options = options.transform_keys { |k| k.to_s.optionize }
+        end
+
+        def all_options
+          @all_options ||= product
+            .variants
+            .flat_map { |v| v.details.keys }
+            .uniq
+            .map { |o| o.to_s.optionize }
+        end
+
+        def currently_selected_options
+          @currently_selected_options ||= options_with_one_value.merge(
+            options.select do |key|
+              key.optionize.in?(all_options) && options[key.optionize].present?
+            end
+          )
+        end
+
+        def options_for_selection
+          @options_for_selection ||=
+            begin
+              result = all_options.reduce([]) do |memo, key|
+                variants_with_this = product.variants.select { |v| v.has_detail?(key) }
+                all_values = variants_with_this.map { |v| v.fetch_detail(key) }.flatten.uniq
+                values = values_based_on_other_options(key, all_values)
+
+                if values.any?
+                  memo << Option.new(
+                    product,
+                    key,
+                    values,
+                    currently_selected_options
+                  )
+                end
+
+                memo
+              end
+
+              Workarea.config.option_selections_sort.call(product, result)
+            end
+        end
+
+        def current_variant
+          return nil if currently_selected_options.blank?
+
+          @current_variant ||= product.variants.detect do |variant|
+            variant.details.size == currently_selected_options.size &&
+              variant.matches_details?(currently_selected_options)
+          end
+        end
+
+        def current_sku
+          return nil if currently_selected_options.blank?
+          current_variant.try(:sku)
+        end
+
+        private
+
+        def values_based_on_other_options(key, values)
+          values.select do |value|
+            product.variants.any? do |variant|
+              variant.matches_details?(
+                currently_selected_options.merge(key => value)
+              )
+            end
+          end
+        end
+
+        def options_with_one_value
+          all_options.each_with_object({}) do |key, memo|
+            variants_with_this = product.variants.select { |v| v.has_detail?(key) }
+            all_values = product.variants.flat_map { |v| v.fetch_detail(key) }.uniq
+
+            if variants_with_this.size == product.variants.size && all_values.one?
+              memo.merge!(key => all_values.first)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/product_view_model/sku_options.rb

@@ -0,0 +1,53 @@
+module Workarea
+  module Storefront
+    class ProductViewModel
+      class SkuOptions
+        def initialize(variants)
+          @variants = variants
+        end
+
+        def to_a
+          if options.one?
+            options
+          else
+            [[::I18n.t('workarea.storefront.products.select_options'), nil]] +
+              options
+          end
+        end
+
+        private
+
+        def options
+          @variants.map { |variant| [text_for_variant(variant), variant.sku, options_for_variant(variant)] }
+        end
+
+        def options_for_variant(variant)
+          {
+            data: {
+              sku_option_details: json_details_for_variant(variant)
+            }
+          }
+        end
+
+        def json_details_for_variant(variant)
+          return {}.to_json unless variant.details.present?
+          variant.details.map { |k, v| [k.systemize, v] }.to_h.to_json
+        end
+
+        def text_for_variant(variant)
+          if variant.name != variant.sku
+            variant.name
+          elsif variant.details.blank?
+            variant.sku
+          else
+            details = variant.details.map do |k, v|
+              "#{k.titleize}: #{[v].flatten.join(', ')}"
+            end
+
+            "#{variant.sku} - #{details.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/recommendations_view_model.rb

@@ -0,0 +1,39 @@
+module Workarea
+  module Storefront
+    class RecommendationsViewModel < ApplicationViewModel
+      include Enumerable
+      delegate :each, :size, :length, to: :products
+
+      def products
+        @products ||=
+          begin
+            results = Catalog::Product.active.purchasable.find_ordered(product_ids)
+
+            if results.size < result_count
+              results.push(
+                *Catalog::Product.active.purchasable.find_ordered(popular_product_ids)
+              )
+            end
+
+            ProductViewModel.wrap(results.uniq).take(result_count)
+          end
+      end
+
+      def popular_product_ids
+        Insights::TopProducts
+          .current
+          .results
+          .map { |r| r['product_id'] }
+          .take(result_count)
+      end
+
+      def product_ids
+        raise NotImplementedError
+      end
+
+      def result_count
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/refund_view_model.rb

@@ -0,0 +1,16 @@
+module Workarea
+  module Storefront
+    class RefundViewModel < ApplicationViewModel
+      def tenders
+        @tenders ||= Hash[
+          model.amounts.map do |tender_id, amount|
+            tender = payment.tenders.detect { |t| t.id.to_s == tender_id.to_s }
+            amount = Money.demongoize(amount)
+
+            [tender, amount]
+          end
+        ]
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/search_content.rb

@@ -0,0 +1,19 @@
+module Workarea
+  module Storefront
+    module SearchContent
+      include DisplayContent
+
+      def results_content
+        content_blocks_for('results')
+      end
+
+      def no_results_content
+        content_blocks_for('no_results')
+      end
+
+      def content_lookup
+        'search'
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/search_customization_content.rb

@@ -0,0 +1,15 @@
+module Workarea
+  module Storefront
+    module SearchCustomizationContent
+
+      def customization
+        @customization ||= SearchCustomizationViewModel.new(model.customization)
+      end
+
+      def customization_content_blocks_for(area)
+        return [] unless customization.persisted?
+        customization.content_blocks_for(area)
+      end
+    end
+  end
+end

data/app/view_models/workarea/storefront/search_customization_view_model.rb

@@ -0,0 +1,7 @@
+module Workarea
+  module Storefront
+    class SearchCustomizationViewModel < ApplicationViewModel
+      include DisplayContent
+    end
+  end
+end

data/app/view_models/workarea/storefront/search_suggestion_view_model.rb

@@ -0,0 +1,87 @@
+module Workarea
+  module Storefront
+    class SearchSuggestionViewModel < ApplicationViewModel
+      include I18n::DefaultUrlOptions
+      include Storefront::Engine.routes.url_helpers
+      include Search::LoadProductResults
+      include AnalyticsHelper
+
+      def to_h
+        {
+          value: name,
+          type: type,
+          image: image,
+          url: url,
+          analytics: analytics
+        }
+      end
+
+      def source
+        model['_source']
+      end
+
+      def name
+        source['content']['name']
+      end
+
+      def type
+        t("workarea.storefront.searches.#{suggestion_type.pluralize}")
+      end
+
+      # TODO this can be simplified in v4, when we can be confident the index
+      # will always have relative paths stored for image cache.
+      def image
+        return if source['cache']['image'].blank?
+
+        image_url = URI.parse(source['cache']['image'])
+
+        if asset_host.present?
+          image_url.scheme = asset_host.scheme
+          image_url.host = asset_host.host
+        end
+
+        image_url.to_s
+      end
+
+      def asset_host
+        URI.parse(Rails.application.config.action_controller.asset_host)
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def suggestion_type
+        source['type']
+      end
+
+      def analytics
+        return unless suggestion_type == 'product'
+
+        product_analytics_data(product)
+      end
+
+      def product
+        @product ||=
+          begin
+            loaded = load_model_from(model)
+
+            Storefront::ProductViewModel.wrap(
+              loaded[:model],
+              loaded.slice(:inventory, :pricing)
+            )
+          end
+      end
+
+      def url
+        if suggestion_type == 'product'
+          product_path(product)
+        elsif suggestion_type == 'search'
+          search_path(q: name)
+        elsif suggestion_type == 'category'
+          category_path(source['slug'])
+        elsif suggestion_type == 'page'
+          page_path(source['slug'])
+        end
+      end
+    end
+  end
+end