workarea-core 3.4.45 → 3.5.0.beta.1

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

@@ -0,0 +1,13 @@
+module Workarea
+  class Segment
+    module Rules
+      class LoggedIn < Base
+        field :logged_in, type: Boolean, default: false
+
+        def qualifies?(visit)
+          logged_in? == visit.logged_in?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Workarea
+  class Segment
+    module Rules
+      class Orders < Base
+        field :minimum, type: Integer
+        field :maximum, type: Integer
+
+        def qualifies?(visit)
+          return false if minimum.blank? && maximum.blank?
+
+          (minimum.blank? || visit.metrics.orders >= minimum) &&
+            (maximum.blank? || visit.metrics.orders <= maximum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Workarea
+  class Segment
+    module Rules
+      class Revenue < Base
+        field :minimum, type: Money
+        field :maximum, type: Money
+
+        def qualifies?(visit)
+          return false if minimum.blank? && maximum.blank?
+
+          (minimum.blank? || visit.metrics.revenue.to_m >= minimum) &&
+            (maximum.blank? || visit.metrics.revenue.to_m <= maximum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Workarea
+  class Segment
+    module Rules
+      class Sessions < Base
+        field :minimum, type: Integer
+        field :maximum, type: Integer
+
+        def qualifies?(visit)
+          return false if minimum.blank? && maximum.blank?
+
+          (minimum.blank? || visit.sessions >= minimum) &&
+            (maximum.blank? || visit.sessions <= maximum)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Workarea
+  class Segment
+    module Rules
+      class Tags < Base
+        include Mongoid::Document::Taggable
+
+        def qualifies?(visit)
+          return false if tags.blank? || visit.metrics.tags.blank?
+          (tags & visit.metrics.tags).any?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Workarea
+  class Segment
+    module Rules
+      class TrafficReferrer < Base
+        field :medium, type: String
+        field :source, type: String
+
+        def qualifies?(visit)
+          return false if medium.blank? && source.blank?
+          return false unless visit.referrer[:known]
+
+          (medium.blank? || medium.strip.casecmp?(visit.referrer[:medium])) &&
+            (source.blank? || visit.referrer[:source].to_s =~ /#{source.strip}/i)
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/segment.rb

@@ -0,0 +1,54 @@
+module Workarea
+  class Segment
+    include ApplicationDocument
+    include Commentable
+    include Mongoid::Document::Taggable
+
+    field :name, type: String
+    embeds_many :rules, class_name: 'Workarea::Segment::Rules::Base', inverse_of: :segment
+
+    validates :name, presence: true
+    validate do |segment| # Don't decorate this
+      if Segment.count >= 15
+        segment.errors.add(:base, I18n.t('workarea.errors.messages.max_allowed_segments'))
+      end
+    end
+
+    def self.find_qualifying(visit)
+      all.select { |s| s.qualifies?(visit) }
+    end
+
+    def self.current
+      Thread.current[:current_segments] || []
+    end
+
+    def self.current=(*segments)
+      Thread.current[:current_segments] = Array.wrap(segments).flatten
+    end
+
+    def self.enabled?
+      !!Thread.current[:enable_segmentation]
+    end
+
+    def self.enabled
+      Thread.current[:enable_segmentation] = true
+      yield
+    ensure
+      Thread.current[:enable_segmentation] = nil
+    end
+
+    def self.with_current(*segments)
+      previous = current
+
+      self.current = segments
+      enabled { yield }
+    ensure
+      self.current = previous
+    end
+
+    def qualifies?(visit)
+      return false if visit.blank?
+      rules.all? { |r| r.qualifies?(visit) }
+    end
+  end
+end

data/app/models/workarea/segmentable.rb

@@ -0,0 +1,66 @@
+module Workarea
+  module Segmentable
+    extend ActiveSupport::Concern
+
+    included do
+      field :active_segment_ids, type: Array, default: [], localize: true
+      after_find :mark_segmented_content
+    end
+
+    class_methods do
+      def active
+        if embedded?
+          scoped.select(&:active?)
+        else
+          Workarea.deprecation.warn(
+            <<~eos.squish
+              The active scope is being called on a root document. This won't
+              respect segments. Rewrite this to use #active?, like: scope.select(&:active?)
+            eos
+          )
+          scoped.where(active: true)
+        end
+      end
+
+      def inactive
+        if embedded?
+          scoped.reject(&:active?)
+        else
+          Workarea.deprecation.warn(
+            <<~eos.squish
+              The inactive scope is being called on a root document. This won't
+              respect segments. Rewrite this to use !#active?, like: scope.reject(&:active?)
+            eos
+          )
+          scoped.where(active: false)
+        end
+      end
+    end
+
+    def active?
+      default = super
+      return default unless Segment.enabled?
+      return false unless default
+
+      if active_segment_ids.blank?
+        true
+      else
+        allowed_ids = active_segment_ids.map(&:to_s)
+        Segment.current.any? { |s| allowed_ids.include?(s.id.to_s) }
+      end
+    end
+
+    def segments
+      @segments ||= active_segment_ids.blank? ? [] : Segment.in(id: active_segment_ids)
+    end
+
+    private
+
+    def mark_segmented_content
+      # If loaded with `.only` this might be missing
+      return if attribute_missing?(:active_segment_ids)
+
+      CurrentSegments.has_segmented_content! if active_segment_ids.any?
+    end
+  end
+end

data/app/models/workarea/sort.rb

@@ -34,6 +34,10 @@ module Workarea
       new(I18n.t('workarea.sorts.end'),               :end,           :active_ends_at,        :desc)
     end
 
+    def self.downloads
+      new(I18n.t('workarea.sorts.downloads'),        :downloads,     :downloads,              :desc)
+    end
+
     def self.last_updated
       new(I18n.t('workarea.sorts.last_updated'),      :last_updated,  :updated_at,            :desc)
     end
@@ -146,8 +150,16 @@ module Workarea
       new(I18n.t('workarea.sorts.published_date'),    :published_date, :published_at,         :desc)
     end
 
-    def self.undo_date
-      new(I18n.t('workarea.sorts.undo_date'),         :undo_date,     :undo_at,               :asc)
+    def self.country
+      new(I18n.t('workarea.sorts.country'),           :country, :country,       :asc)
+    end
+
+    def self.postal_code
+      new(I18n.t('workarea.sorts.postal_code'),       :postal_code, :postal_code,   :asc)
+    end
+
+    def self.region
+      new(I18n.t('workarea.sorts.region'),            :region, :region,        :asc)
     end
   end
 end

data/app/models/workarea/tax/rate.rb

@@ -3,7 +3,10 @@ module Workarea
     class Rate
       include ApplicationDocument
 
-      field :percentage, type: Float, default: 0
+
+      field :country_percentage, type: Float, default: 0
+      field :region_percentage, type: Float, default: 0
+      field :postal_code_percentage, type: Float, default: 0
       field :country, type: Country
       field :region, type: String
       field :postal_code, type: String
@@ -11,13 +14,37 @@ module Workarea
       field :tier_min, type: Money
       field :tier_max, type: Money
 
+      # This field is deprecated in favor of the more specific percentage fields
+      # TODO: Remove in v3.6,
+      field :percentage, type: Float, default: 0
+      alias_method :percentage=, :postal_code_percentage=
+
       index({ category_id: 1, country: 1, region: 1, postal_code: 1 })
+      index({ country: 1 })
+      index({ region: 1 })
+      index({ postal_code: 1 })
 
       belongs_to :category,
         class_name: 'Workarea::Tax::Category',
         inverse_of: :rates,
         index: true
 
+      def self.search(query)
+        return all unless query.present?
+
+        regex = /^#{::Regexp.quote(query)}/i
+        country = Country[query]
+
+        clauses = [{ region: regex }, { postal_code: regex }]
+        clauses << { country: country } if country.present?
+
+        any_of(clauses)
+      end
+
+      def self.sorts
+        [Sort.country, Sort.region, Sort.postal_code, Sort.newest, Sort.modified]
+      end
+
       def valid?(*)
         super.tap do
           self.region = nil if region.blank?
@@ -25,6 +52,13 @@ module Workarea
           self.percentage ||= 0
         end
       end
+
+      def percentage
+        percentage_field = super
+        return percentage_field unless percentage_field.zero?
+
+        country_percentage + region_percentage + postal_code_percentage
+      end
     end
   end
 end

data/app/models/workarea/user/authorization.rb

@@ -18,6 +18,7 @@ module Workarea
         field :marketing_access, type: Boolean, default: false
         field :help_admin, type: Boolean, default: false
         field :permissions_manager, type: Boolean, default: false
+        field :orders_manager, type: Boolean, default: false
         field :can_publish_now, type: Boolean
         field :can_restore, type: Boolean
         field :status_email_recipient, type: Boolean, default: false
@@ -26,7 +27,8 @@ module Workarea
 
         before_validation :set_all_permissions, if: :super_admin?
         before_validation :set_default_admin_permissions, if: :admin?
-        before_save :reset_permissions_if_no_longer_admin
+        before_validation :unset_all_permissions, if: :no_longer_admin?
+        before_save :reset_token, if: :no_longer_admin?
 
         scope :admins, -> { where(admin: true) }
         index({ admin: 1 })
@@ -34,7 +36,7 @@ module Workarea
 
       class_methods do
         def status_email_recipients
-          admins.where(status_email_recipient: true).pluck(:email)
+          admins.where(status_email_recipient: true)
         end
       end
 
@@ -45,12 +47,22 @@ module Workarea
         )
       end
 
+      def super_admin=(value)
+        super.tap { super_admin ? set_all_permissions : unset_all_permissions }
+      end
+
+      def no_longer_admin?
+        !admin? && !super_admin && (admin_was || super_admin_was)
+      end
+
       private
 
       def set_all_permissions
-        Workarea.config.permissions_fields.each do |field|
-          send("#{field}=", true)
-        end
+        Workarea.config.permissions_fields.each { |field| send("#{field}=", true) }
+      end
+
+      def unset_all_permissions
+        Workarea.config.permissions_fields.each { |field| send("#{field}=", false) }
       end
 
       def set_default_admin_permissions
@@ -58,14 +70,8 @@ module Workarea
         self.can_restore = true if can_restore.nil?
       end
 
-      def reset_permissions_if_no_longer_admin
-        if admin_was && !admin
-          Workarea.config.permissions_fields.each do |field|
-            send("#{field}=", false)
-          end
-
-          self.token = self.class.generate_unique_secure_token
-        end
+      def reset_token
+        self.token = self.class.generate_unique_secure_token
       end
     end
   end

data/app/models/workarea/user/login.rb

@@ -50,6 +50,10 @@ module Workarea
           last_login_attempt_at >= Workarea.config.lockout_period.ago
       end
 
+      def unlock_login!
+        update!(failed_login_count: 0)
+      end
+
       def update_login!(request)
         update_attributes!(
           ip_address: request.ip,

data/app/models/workarea/user/password_reset.rb

@@ -4,7 +4,7 @@ module Workarea
       include ApplicationDocument
       include UrlToken
 
-      belongs_to :user, class_name: 'Workarea::User', index: true
+      belongs_to :user, class_name: 'Workarea::User'
 
       index(
         { created_at: 1 },
@@ -14,8 +14,6 @@ module Workarea
       def self.setup!(email)
         user = User.find_by_email(email)
         return nil unless user
-
-        where(user_id: user.id).destroy_all
         create!(user: user)
       end
 

data/app/queries/workarea/categorization.rb

@@ -12,7 +12,7 @@ module Workarea
     end
 
     def default_model
-      key = "#{@product.cache_key}/default_category"
+      key = [@product.cache_key, 'default_category', Release.current&.id].compact.join('/')
 
       @default_model ||= Rails.cache.fetch(key, expires_in: Workarea.config.cache_expirations.products_default_category) do
         manual_default_model ||
@@ -30,7 +30,7 @@ module Workarea
 
     def queries
       return [] if @product.blank?
-      @queries ||= Search::Storefront::Product.find_categories(@product)
+      @queries ||= Search::Storefront::CategoryQuery.find_by_product(@product)
     end
 
     def to_models
@@ -57,7 +57,7 @@ module Workarea
 
     def manual_models
       return [] if @product.blank?
-      @manual_models ||= Catalog::Category.by_product(@product.id).to_a
+      @manual_models ||= FeaturedCategorization.new(@product.id).to_a
     end
   end
 end

data/app/queries/workarea/featured_categorization.rb

@@ -0,0 +1,53 @@
+module Workarea
+  class FeaturedCategorization
+    include Enumerable
+    delegate :blank?, :present?, :size, :length, :to_a, to: :all
+
+    def initialize(*product_ids)
+      @product_ids = product_ids
+    end
+
+    def all
+      @all ||= begin
+        result = live
+
+        categories_affected_by_current_release.each do |category|
+          if product_featured_in_category?(category)
+            result += [category] unless result.include?(category)
+          else
+            result -= [category]
+          end
+        end
+
+        result
+      end
+    end
+
+    def live
+      @live ||= Catalog::Category.by_product(@product_ids).to_a
+    end
+
+    def categories_affected_by_current_release
+      return [] if Release.current.blank?
+
+      Catalog::Category.in(
+        id: category_changesets_affecting_current_release.map(&:releasable_id)
+      )
+    end
+
+    def category_changesets_affecting_current_release
+      return [] if Release.current.blank?
+
+      FeaturedProducts
+        .changesets(*@product_ids)
+        .where(releasable_type: Catalog::Category.name)
+        .in(release_id: Release.current.preview.releases.map(&:id))
+    end
+
+    private
+
+    def product_featured_in_category?(category)
+      @product_ids.any? { |id| category.featured_product?(id) }
+    end
+  end
+end

data/app/queries/workarea/order_cancellation_metrics.rb

@@ -0,0 +1,155 @@
+module Workarea
+  class OrderCancellationMetrics
+    attr_reader :order, :occured_at
+    delegate_missing_to :order
+
+    def initialize(order, item_values: {}, shipping_value: nil, occured_at: Time.current)
+      @order = order
+      @item_values = item_values
+      @shipping_value = shipping_value
+      @occured_at = occured_at&.to_time
+    end
+
+    def sales_data
+      @sales_data ||= begin
+        based_on_items = calculate_based_on_items(items)
+        refund = based_on_items[:refund] + shipping_refund_total
+        {
+          cancellations: 1,
+          units_canceled: based_on_items[:units_canceled],
+          refund: refund,
+          revenue: refund
+        }
+      end
+    end
+
+    def user_data
+      {
+        email: email,
+        refund: sales_data[:refund]
+      }
+    end
+
+    def products
+      @products ||= order.items
+         .group_by(&:product_id)
+         .transform_values { |items| calculate_based_on_items(items) }
+         .reject { |_, v| v.blank? }
+    end
+
+    def categories
+      @categories ||= items_by_via
+        .select { |gid| gid.model_class.name == 'Workarea::Catalog::Category' }
+        .transform_keys(&:model_id)
+    end
+
+    def searches
+      @searches ||= items_by_via
+        .select { |gid| gid.model_class.name == 'Workarea::Navigation::SearchResults' }
+        .each_with_object({}) do |(gid, data), memo|
+          query_id = gid.find.query_string.id
+
+          memo[query_id] ||= Hash.new(0)
+          memo[query_id].merge!(data) { |_, total, current| total + current }
+        end
+    end
+
+    def skus
+      @skus ||= order.items
+        .group_by(&:sku)
+        .transform_values { |items| calculate_based_on_items(items) }
+        .reject { |_, v| v.blank? }
+    end
+
+    def menus
+      @menus ||= categories.each_with_object({}) do |(category_id, data), memo|
+        category = category_models[category_id]
+        taxon_ids = [category&.taxon&.id, *category&.taxon&.parent_ids].compact
+
+        Navigation::Menu.any_in(taxon_id: taxon_ids).pluck(:id).map(&:to_s).each do |menu_id|
+          memo[menu_id] ||= Hash.new(0)
+          memo[menu_id].merge!(data) { |_, total, current| total + current }
+        end
+
+        memo
+      end.reject { |_, v| v.blank? }
+    end
+
+    def country
+      payment.address&.country&.alpha2
+    end
+
+    def shipping_refund_total
+      (@shipping_value || shipping_total || 0) * -1
+    end
+
+    def segments
+      @segments ||= order.segment_ids.each_with_object({}) do |segment_id, data|
+        data[segment_id] = sales_data
+      end
+    end
+
+    private
+
+    def payment
+      @payment ||= Payment.find_or_initialize_by(id: order.id)
+    end
+
+    def shippings
+      @shippings ||= Shipping.by_order(order.id)
+    end
+
+    def all_price_adjustments
+      @all_price_adjustments ||= order.price_adjustments +
+        shippings.map(&:price_adjustments).flatten
+    end
+
+    def calculate_based_on_items(items)
+      Array.wrap(items).each_with_object(Hash.new(0)) do |item, memo|
+        data = item_data[item.id.to_s]&.with_indifferent_access
+        next unless data.present?
+
+        memo[:units_canceled] += data[:quantity]
+        memo[:refund] += data[:amount] * -1
+        memo[:revenue] += data[:amount] * -1
+      end
+    end
+
+    def item_data
+      return @item_values if @item_values.present?
+
+      @item_data ||= items.each_with_object({}) do |item, data|
+        adjustments = PriceAdjustmentSet.new(item.price_adjustments)
+        before_tax = adjustments.sum - adjustments.adjusting('tax').sum
+
+        data[item.id.to_s] = {
+          quantity: item.quantity,
+          amount: before_tax + tax_total_for(item.id)
+        }
+      end
+    end
+
+    def items_by_via
+      @items_by_via ||= order.items.each_with_object({}) do |item, memo|
+        global_id = GlobalID.parse(item.via)
+        next unless global_id.present?
+
+        memo[global_id] ||= Hash.new(0)
+        values = calculate_based_on_items(item)
+
+        memo[global_id].merge!(values) { |_, sum, item| sum + item }
+      end.reject { |_, v| v.blank? }
+    end
+
+    def tax_total_for(item_id)
+      all_price_adjustments
+        .adjusting('tax')
+        .select { |a| a.data['order_item_id'].to_s == item_id.to_s }
+        .sum
+    end
+
+    def category_models
+      @category_models ||= Catalog::Category.any_in(id: categories.keys).to_lookup_hash
+    end
+  end
+end

data/app/queries/workarea/order_item_details.rb

@@ -4,8 +4,6 @@ module Workarea
 
     attr_reader :product, :sku
 
-    delegate :digital?, to: :product
-
     def self.find!(sku, product_id: nil)
       product =
         if product_id.present?
@@ -43,12 +41,27 @@ module Workarea
       @pricing ||= Pricing::Sku.find(sku)
     end
 
+    def fulfillment
+      @fulfillment ||= Fulfillment::Sku.find_or_initialize_by(id: sku)
+    end
+
+    # This is a stop-gap for transitioning away from a digital flag for
+    # determining checkout behavior for items not requiring
+    # physical fulfillment.
+    #
+    # TODO: remove #digital? usage in v3.6
+    #
+    def requires_shipping?
+      !product.digital? && fulfillment.requires_shipping?
+    end
+
     def to_h
       {
         product_id: product.id,
         product_attributes: product.as_document,
         category_ids: category_ids,
-        discountable: pricing.discountable?
+        discountable: pricing.discountable?,
+        requires_shipping: requires_shipping?
       }
     end
   end