workarea-core 3.4.45 → 3.5.0.beta.1

data/app/models/workarea/search/admin.rb

@@ -5,49 +5,27 @@ module Workarea
 
       def self.jump_to(params, size = Workarea.config.default_admin_jump_to_result_count)
         query = {
-          aggs: {
-            grouped_by_type: {
-              filter: {
-                match_phrase_prefix: {
-                  jump_to_search_text: {
-                    query: params[:q],
-                    max_expansions: 10
-                  }
-                }
-              },
-              aggs: {
-                type: {
-                  terms: { field: 'facets.type', size: Workarea.config.jump_to_type_limit },
-                  aggs: {
-                    top: {
-                      top_hits: {
-                        size: Workarea.config.jump_to_results_per_type,
-                        sort: [
-                          { _score: { order: 'desc' } },
-                          { updated_at: { order: 'desc' } }
-                        ]
-                      }
-                    }
-                  }
-                }
+          query: {
+            match_phrase_prefix: {
+              jump_to_search_text: {
+                query: params[:q],
+                max_expansions: 10
               }
             }
-          }
+          },
+          size: size,
+          sort: [{ jump_to_position: :asc }]
         }
 
-        aggregation = search(query)['aggregations']['grouped_by_type']['type']
-        aggregation['buckets']
-          .reduce([]) { |m, b| m + b['top']['hits']['hits'] }
-          .sort_by { |r| [r['_source']['jump_to_position'] || 999, r['_score'] || 0] }
-          .map do |result|
-            {
-              label: result['_source']['jump_to_text'],
-              type: result['_source']['facets']['type'],
-              model_class: result['_source']['model_class'],
-              route_helper: result['_source']['jump_to_route_helper'],
-              to_param: result['_source']['jump_to_param']
-            }
-          end
+        search(query)['hits']['hits'].map do |result|
+          {
+            label: result['_source']['jump_to_text'],
+            type: result['_source']['facets']['type'],
+            model_class: result['_source']['model_class'],
+            route_helper: result['_source']['jump_to_route_helper'],
+            to_param: result['_source']['jump_to_param']
+          }
+        end
       end
 
       def self.for(model)

data/app/models/workarea/search/order_text.rb

@@ -28,13 +28,11 @@ module Workarea
         payment.try(:credit_card).try(:issuer)
       end
 
+      # Space-separated IDs for item-level and shipping-level discounts.
+      #
+      # @return [String]
       def discount_text
-        @order
-          .price_adjustments
-          .map { |pa| pa.data['discount_id'] }
-          .compact
-          .uniq
-          .join(' ')
+        (order_discounts + shipping_discounts).join(' ')
       end
 
       def shipping_text
@@ -70,6 +68,25 @@ module Workarea
       def addresses
         (shippings.map(&:address) + [payment.try(:address)]).reject(&:blank?)
       end
+
+      private
+
+      def order_discounts
+        @order
+          .price_adjustments
+          .map { |pa| pa.data['discount_id'] }
+          .compact
+          .uniq
+      end
+
+      def shipping_discounts
+        shippings
+         .map(&:price_adjustments)
+         .flatten
+         .map { |pa| pa.data['discount_id'] }
+         .compact
+         .uniq
+      end
     end
   end
 end

data/app/models/workarea/search/storefront/category_query.rb

@@ -0,0 +1,152 @@
+# For some reason, loading Search::Storefront::Product doesn't get triggered
+require_dependency 'workarea/search/storefront/product'
+
+module Workarea
+  module Search
+    class Storefront
+      class CategoryQuery
+        attr_reader :category
+
+        class << self
+          def find_by_product(product)
+            product = product.in_release(Release.current) if product.persisted?
+            search_model = Product.new(product, skip_categorization: true)
+
+            begin
+              find!(id: search_model.id)
+            rescue
+              begin
+                find!(document: search_model.as_document)
+              rescue ::Elasticsearch::Transport::Transport::ServerError
+                []
+              end
+            end
+          end
+
+          def find!(options)
+            results = Storefront.current_index.search(
+              size: Workarea.config.product_categories_by_rules_max_count,
+              query: {
+                percolate: options.merge(
+                  field: 'query',
+                  index: Storefront.current_index.name,
+                  type: Storefront.type,
+                  document_type: 'category'
+                )
+              },
+              post_filter: if Release.current.blank?
+                {
+                  bool: {
+                    minimum_should_match: 1,
+                    should: [
+                      { term: { release_id: 'live' } },
+                      { bool: { must_not: { exists: { field: 'release_id' } } } } # for upgrade compatiblity
+                    ]
+                  }
+                }
+              else
+                {
+                  bool: {
+                    minimum_should_match: 1,
+                    should: [
+                      { term: { release_id: Release.current.id } },
+                      {
+                        bool: {
+                          must_not: [{ term: { changeset_release_ids: Release.current.id } }],
+                          must: [
+                            {
+                              bool: {
+                                minimum_should_match: 1,
+                                should: [
+                                  { term: { release_id: 'live' } },
+                                  { bool: { must_not: { exists: { field: 'release_id' } } } } # for upgrade compatiblity
+                                ]
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  }
+                }
+              end
+            )
+
+            results['hits']['hits'].map { |h| h['_id'].split('-').first }
+          end
+        end
+
+        def initialize(category)
+          @category = category
+        end
+
+        def update
+          delete
+          create unless category.product_rules.blank?
+        end
+
+        def create
+          I18n.for_each_locale do
+            create_live
+            create_releases
+          end
+        end
+
+        def delete
+          I18n.for_each_locale do
+            begin
+              Storefront.current_index.delete(category.id, type: 'category')
+            rescue ::Elasticsearch::Transport::Transport::Errors::NotFound
+              # doesn't matter we want it deleted
+            end
+          end
+        end
+
+        private
+
+        def create_live
+          Release.without_current do
+            category.reload
+
+            if category.product_rules.present?
+              document = {
+                id: category.id,
+                release_id: 'live',
+                changeset_release_ids: changesets.map(&:release_id).uniq,
+                query: Categorization.new(rules: category.product_rules).query
+              }
+
+              Storefront.current_index.save(document, type: 'category')
+            end
+          end
+        end
+
+        def create_releases
+          changesets.each do |changeset|
+            changeset.release.as_current do
+              category.reload
+
+              if category.product_rules.present?
+                document = {
+                  id: "#{category.id}-#{changeset.release_id}",
+                  release_id: changeset.release_id,
+                  query: Categorization.new(rules: category.product_rules).query
+                }
+
+                Storefront.current_index.save(document, type: 'category')
+              end
+            end
+          end
+        end
+
+        def changesets
+          @changesets ||= Release::Changeset
+            .where(releasable_type: ProductRule.name)
+            .any_in(releasable_id: category.product_rules.map(&:id))
+            .includes(:release)
+            .to_a
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/search/storefront/product/categories.rb

@@ -5,59 +5,25 @@ module Workarea
         module Categories
           extend ActiveSupport::Concern
 
+          # TODO remove these in v3.6
           class_methods do
-            def add_category(category)
-              I18n.for_each_locale do
-                category.reload
-
-                if category.product_rules.present?
-                  document = {
-                    id: category.id,
-                    query: Workarea::Search::Categorization.new(rules: category.product_rules).query
-                  }
+            Workarea.deprecation.deprecate_methods(
+              self,
+              add_category: 'Use `Search::Storefront::CategoryQuery.new(category).create` instead',
+              delete_category: 'Use `Search::Storefront::CategoryQuery.new(category).delete` instead',
+              find_categories: 'Use `Workarea::Search::Storefront::CategoryQuery.find_by_product` instead'
+            )
 
-                  Storefront.current_index.save(document, type: 'category')
-                end
-              end
+            def add_category(category)
+              CategoryQuery.new(category).create
             end
 
             def delete_category(category_id)
-              I18n.for_each_locale do
-                current_index.delete(category_id, type: 'category')
-              end
-
-            rescue ::Elasticsearch::Transport::Transport::Errors::NotFound
-              # doesn't matter we want it deleted
+              CategoryQuery.new(category_id).delete
             end
 
             def find_categories(product)
-              search_model = Product.new(product, skip_categorization: true)
-
-              begin
-                find_categories!(id: search_model.id)
-              rescue
-                begin
-                  find_categories!(document: search_model.as_document)
-                rescue ::Elasticsearch::Transport::Transport::ServerError
-                  []
-                end
-              end
-            end
-
-            def find_categories!(options)
-              results = current_index.search(
-                size: Workarea.config.product_categories_by_rules_max_count,
-                query: {
-                  percolate: options.merge(
-                    field: 'query',
-                    index: current_index.name,
-                    type: Storefront.type,
-                    document_type: 'category'
-                  )
-                }
-              )
-
-              results['hits']['hits'].map { |h| h['_id'] }
+              CategoryQuery.find_by_product(product)
             end
           end
 

data/app/models/workarea/search/storefront.rb

@@ -21,7 +21,8 @@ module Workarea
       end
 
       def id
-        CGI.escape("#{type}-#{model.id}")
+        pieces = [type, model.id, model.try(:release_id)].reject(&:blank?)
+        CGI.escape(pieces.join('-'))
       end
 
       def type
@@ -32,23 +33,21 @@ module Workarea
         model.slug
       end
 
-      # Whether the product is active for a given release state. Storing
-      # active per-release allows accurate previewing of products in releases
-      # on the storefront.
+      def release_id
+        model.try(:release_id).presence || 'live'
+      end
+
+      # Whether the product is active. Stored as `:now` way for upgrade support
+      # to v3.5 without requiring reindexing.
       #
       # return [Hash]
       #
       def active
-        model.changesets.inject(now: model.active?) do |memo, changeset|
-          active = if changeset.changeset['active'].respond_to?(:[])
-            changeset.changeset['active'][I18n.locale]
-          else
-            !!changeset.changeset['active']
-          end
-
-          memo[changeset.release_id.to_s] = active
-          memo
-        end
+        { now: model.active? }
+      end
+
+      def active_segment_ids
+        model.try(:active_segment_ids)
       end
 
       def facets
@@ -80,21 +79,26 @@ module Workarea
       end
 
       def as_document
-        {
-          id: id,
-          type: type,
-          slug: slug,
-          active: active,
-          suggestion_content: suggestion_content,
-          created_at: model.created_at,
-          updated_at: model.updated_at,
-          facets: facets,
-          numeric: numeric,
-          keywords: keywords,
-          sorts: sorts,
-          content: content,
-          cache: cache
-        }
+        Release.with_current(release_id) do
+          {
+            id: id,
+            type: type,
+            slug: slug,
+            active: active,
+            active_segment_ids: active_segment_ids,
+            release_id: release_id,
+            changeset_release_ids: Array.wrap(model.try(:changesets)).map(&:release_id),
+            suggestion_content: suggestion_content,
+            created_at: model.created_at,
+            updated_at: model.updated_at,
+            facets: facets,
+            numeric: numeric,
+            keywords: keywords,
+            sorts: sorts,
+            content: content,
+            cache: cache
+          }
+        end
       end
     end
   end

data/app/models/workarea/segment/first_time_customer.rb

@@ -0,0 +1,8 @@
+module Workarea
+  class Segment
+    class FirstTimeCustomer < Segment
+      include LifeCycle
+      self.default_rules = [Rules::Orders.new(minimum: 1, maximum: 1)]
+    end
+  end
+end

data/app/models/workarea/segment/first_time_visitor.rb

@@ -0,0 +1,12 @@
+module Workarea
+  class Segment
+    class FirstTimeVisitor < Segment
+      include LifeCycle
+
+      self.default_rules = [
+        Rules::Sessions.new(minimum: 0, maximum: 1),
+        Rules::Orders.new(maximum: 0)
+      ]
+    end
+  end
+end

data/app/models/workarea/segment/life_cycle.rb

@@ -0,0 +1,44 @@
+module Workarea
+  class Segment
+    module LifeCycle
+      extend ActiveSupport::Concern
+
+      included do
+        field :_id, type: String, default: -> { self.class.instance_id }
+        cattr_accessor :default_rules
+      end
+
+      class_methods do
+        def model_name
+          Segment.model_name
+        end
+
+        def instance
+          first || create!(rules: default_rules)
+        end
+
+        def instance_id
+          name.demodulize.underscore.to_sym
+        end
+      end
+
+      def self.create!
+        [
+          FirstTimeVisitor,
+          ReturningVisitor,
+          FirstTimeCustomer,
+          ReturningCustomer,
+          LoyalCustomer
+        ].each(&:instance)
+      end
+
+      def name
+        self.class.name.demodulize.underscore.titleize
+      end
+
+      def destroy
+        false
+      end
+    end
+  end
+end

data/app/models/workarea/segment/loyal_customer.rb

@@ -0,0 +1,12 @@
+module Workarea
+  class Segment
+    class LoyalCustomer < Segment
+      include LifeCycle
+
+      self.default_rules = [
+        Rules::Orders.new(minimum: Workarea.config.loyal_customers_min_orders),
+        Rules::LastOrder.new(days: Workarea.config.loyal_customers_last_order_days_ago)
+      ]
+    end
+  end
+end

data/app/models/workarea/segment/returning_customer.rb

@@ -0,0 +1,14 @@
+module Workarea
+  class Segment
+    class ReturningCustomer < Segment
+      include LifeCycle
+
+      self.default_rules = [
+        Rules::Orders.new(
+          minimum: 2,
+          maximum: Workarea.config.loyal_customers_min_orders - 1
+        )
+      ]
+    end
+  end
+end

data/app/models/workarea/segment/returning_visitor.rb

@@ -0,0 +1,12 @@
+module Workarea
+  class Segment
+    class ReturningVisitor < Segment
+      include LifeCycle
+
+      self.default_rules = [
+        Rules::Sessions.new(minimum: 2),
+        Rules::Orders.new(maximum: 0)
+      ]
+    end
+  end
+end

data/app/models/workarea/segment/rules/base.rb

@@ -0,0 +1,16 @@
+module Workarea
+  class Segment
+    module Rules
+      class Base
+        include ApplicationDocument
+
+        embedded_in :segment, class_name: 'Workarea::Segment', inverse_of: :rules
+        delegate :slug, to: :class
+
+        def self.slug
+          name.demodulize.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/segment/rules/browser_info.rb

@@ -0,0 +1,29 @@
+module Workarea
+  class Segment
+    module Rules
+      class BrowserInfo < Base
+        field :general, type: Array, default: []
+        field :device, type: Array, default: []
+        field :platform, type: Array, default: []
+
+        def qualifies?(visit)
+          general_match?(visit.browser) ||
+            device_match?(visit.browser) ||
+            platform_match?(visit.browser)
+        end
+
+        def general_match?(browser)
+          general.any? { |g| browser.try("#{g}?") }
+        end
+
+        def device_match?(browser)
+          device.any? { |d| browser.device.try("#{d}?") }
+        end
+
+        def platform_match?(browser)
+          platform.any? { |p| browser.platform.try("#{p}?") }
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/segment/rules/geolocation.rb

@@ -0,0 +1,29 @@
+module Workarea
+  class Segment
+    module Rules
+      class Geolocation < Base
+        field :locations, type: Array, default: []
+
+        def qualifies?(visit)
+          return false if locations.blank?
+
+          visit_locations = matchable_locations_for(visit)
+          return false if visit_locations.blank?
+
+          matchable_locations = locations.map(&:downcase)
+          visit_locations.any? { |l| l.in?(matchable_locations) }
+        end
+
+        def matchable_locations_for(visit)
+          option_ids = [
+            visit.postal_code,
+            GeolocationOption.from_subdivision(visit.country, visit.subdivision)&.id,
+            GeolocationOption.from_country(visit.country)&.id
+          ]
+
+          (visit.location_names + option_ids).reject(&:blank?).map(&:downcase)
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/segment/rules/geolocation_option.rb

@@ -0,0 +1,53 @@
+module Workarea
+  class Segment
+    module Rules
+      class GeolocationOption
+        class << self
+          delegate :[], to: :all
+
+          def all
+            @all ||= Country.all.reduce({}) do |memo, country|
+              memo[country.alpha2] = from_country(country)
+
+              country.subdivisions.each do |id, subdivision|
+                if subdivision.name.present?
+                  location = from_subdivision(country, subdivision)
+                  memo[location.id] = location
+                end
+              end
+
+              memo
+            end
+          end
+
+          def from_country(country)
+            return if country.blank?
+            new(id: country.alpha2, name: country.name, model: country)
+          end
+
+          def from_subdivision(country, subdivision)
+            return if country.blank? || subdivision.blank?
+
+            id = "#{country.alpha2}-#{country.subdivisions.invert[subdivision]}"
+            name = "#{subdivision.name}, #{country.alpha2}"
+            new(id: id, name: name, model: subdivision)
+          end
+
+          def search(query)
+            return [] if query.blank?
+            regex = /^#{::Regexp.quote(query.to_s)}/i
+            all.values.select { |r| r.name =~ regex }
+          end
+        end
+
+        attr_reader :id, :name, :model
+
+        def initialize(options)
+          @id = options[:id]
+          @name = options[:name]
+          @model = options[:model]
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/segment/rules/last_order.rb

@@ -0,0 +1,14 @@
+module Workarea
+  class Segment
+    module Rules
+      class LastOrder < Base
+        field :days, type: Integer
+
+        def qualifies?(visit)
+          return false if visit.metrics.last_order_at.blank? || days.blank?
+          visit.metrics.last_order_at >= days.days.ago
+        end
+      end
+    end
+  end
+end