solidus_core 4.3.4 → 4.4.0

data/app/models/spree/promotion/rules/item_total.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      # A rule to apply to an order greater than (or greater than or equal to)
-      # a specific amount
-      #
-      # To add extra operators please override `self.operators_map` or any other helper method.
-      # To customize the error message you can also override `ineligible_message`.
-      class ItemTotal < PromotionRule
-        preference :amount, :decimal, default: 100.00
-        preference :currency, :string, default: ->{ Spree::Config[:currency] }
-        preference :operator, :string, default: 'gt'
-
-        # The list of allowed operators names mapped to their symbols.
-        def self.operators_map
-          {
-            gte: :>=,
-            gt: :>,
-          }
-        end
-
-        def self.operator_options
-          operators_map.map do |name, _method|
-            [I18n.t(name, scope: 'spree.item_total_rule.operators'), name]
-          end
-        end
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          return false unless order.currency == preferred_currency
-
-          unless total_for_order(order).send(operator, threshold)
-            eligibility_errors.add(:base, ineligible_message, error_code: ineligible_error_code)
-          end
-
-          eligibility_errors.empty?
-        end
-
-        private
-
-        def operator
-          self.class.operators_map.fetch(
-            preferred_operator.to_sym,
-            preferred_operator_default,
-          )
-        end
-
-        def total_for_order(order)
-          order.item_total
-        end
-
-        def threshold
-          BigDecimal(preferred_amount.to_s)
-        end
-
-        def formatted_amount
-          Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
-        end
-
-        def ineligible_message
-          case preferred_operator.to_s
-          when 'gte'
-            eligibility_error_message(:item_total_less_than, amount: formatted_amount)
-          when 'gt'
-            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount)
-          else
-            eligibility_error_message(:item_total_doesnt_match_with_operator, amount: formatted_amount, operator: preferred_operator)
-          end
-        end
-
-        def ineligible_error_code
-          if preferred_operator == 'gte'
-            :item_total_less_than
-          else
-            :item_total_less_than_or_equal
-          end
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/minimum_quantity.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion
-    module Rules
-      # Promotion rule for ensuring an order contains a minimum quantity of
-      # actionable items.
-      #
-      # This promotion rule is only compatible with the "all" match policy. It
-      # doesn't make a lot of sense to use it without that policy as it reduces
-      # it to a simple quantity check across the entire order which would be
-      # better served by an item total rule.
-      class MinimumQuantity < PromotionRule
-        validates :preferred_minimum_quantity, numericality: { only_integer: true, greater_than: 0 }
-
-        preference :minimum_quantity, :integer, default: 1
-
-        # What type of objects we should run our eligiblity checks against. In
-        # this case, our rule only applies to an entire order.
-        #
-        # @param promotable [Spree::Order,Spree::LineItem]
-        # @return [Boolean] true if promotable is a Spree::Order, false
-        #   otherwise
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        # Will look at all of the "actionable" line items in the order and
-        # determine if the sum of their quantity is greater than the minimum.
-        #
-        # "Actionable" items are ones where they pass the "actionable?" check of
-        # all rules on the promotion. (e.g.: Match product/taxon when one of
-        # those rules is present.)
-        #
-        # When false is returned, the reason will be included in the
-        # `eligibility_errors` object.
-        #
-        # @param order [Spree::Order] the order we want to check eligibility on
-        # @param _options [Hash] ignored
-        # @return [Boolean] true if promotion is eligible, false otherwise
-        def eligible?(order, _options = {})
-          actionable_line_items = order.line_items.select do |line_item|
-            promotion.rules.all? { _1.actionable?(line_item) }
-          end
-
-          if actionable_line_items.sum(&:quantity) < preferred_minimum_quantity
-            eligibility_errors.add(
-              :base,
-              eligibility_error_message(:quantity_less_than_minimum, count: preferred_minimum_quantity),
-              error_code: :quantity_less_than_minimum
-            )
-          end
-
-          eligibility_errors.empty?
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/nth_order.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion
-    module Rules
-      class NthOrder < PromotionRule
-        preference :nth_order, :integer, default: 2
-        # It does not make sense to have this apply to the first order using preferred_nth_order == 1
-        # Instead we could use the first_order rule
-        validates :preferred_nth_order, numericality: { only_integer: true, greater_than: 1 }
-
-        # This promotion is applicable to orders only.
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        # This is never eligible if the order does not have a user, and that user does not have any previous completed orders.
-        #
-        # Use the first order rule if you want a promotion to be applied to the first order for a user.
-        # @param order [Spree::Order]
-        def eligible?(order, _options = {})
-          return false unless order.user
-
-          nth_order?(order)
-        end
-
-        private
-
-        def completed_order_count(order)
-          order.
-            user.
-            orders.
-            complete.
-            where(Spree::Order.arel_table[:completed_at].lt(order.completed_at || Time.current)).
-            count
-        end
-
-        def nth_order?(order)
-          count = completed_order_count(order) + 1
-          count == preferred_nth_order
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/one_use_per_user.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class OneUsePerUser < PromotionRule
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          if order.user.present?
-            if promotion.used_by?(order.user, [order])
-              eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user), error_code: :limit_once_per_user)
-            end
-          else
-            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
-          end
-
-          eligibility_errors.empty?
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/option_value.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class OptionValue < PromotionRule
-        MATCH_POLICIES = %w(any)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
-        preference :eligible_values, :hash
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(promotable, _options = {})
-          case preferred_match_policy
-          when 'any'
-            promotable.line_items.any? { |item| actionable?(item) }
-          end
-        end
-
-        def actionable?(line_item)
-          pid = line_item.product.id
-          ovids = line_item.variant.option_values.pluck(:id)
-
-          product_ids.include?(pid) && (value_ids(pid) & ovids).present?
-        end
-
-        def preferred_eligible_values
-          values = preferences[:eligible_values] || {}
-          Hash[values.keys.map(&:to_i).zip(
-            values.values.map do |value|
-              (value.is_a?(Array) ? value : value.split(",")).map(&:to_i)
-            end
-          )]
-        end
-
-        private
-
-        def product_ids
-          preferred_eligible_values.keys
-        end
-
-        def value_ids(product_id)
-          preferred_eligible_values[product_id]
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/product.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      # A rule to limit a promotion based on products in the order.  Can
-      # require all or any of the products to be present.  Valid products
-      # either come from assigned product group or are assingned directly to
-      # the rule.
-      class Product < PromotionRule
-        has_many :product_promotion_rules, dependent: :destroy, foreign_key: :promotion_rule_id,
-                                           class_name: 'Spree::ProductPromotionRule'
-        has_many :products, class_name: 'Spree::Product', through: :product_promotion_rules
-
-        def preload_relations
-          [:products]
-        end
-
-        MATCH_POLICIES = %w(any all none)
-
-        validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
-
-        preference :match_policy, :string, default: MATCH_POLICIES.first
-
-        # scope/association that is used to test eligibility
-        def eligible_products
-          products
-        end
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          return true if eligible_products.empty?
-
-          case preferred_match_policy
-          when "all"
-            unless eligible_products.all? { |product| order_products(order).include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
-            end
-          when "any"
-            unless order_products(order).any? { |product| eligible_products.include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products),
-                                     error_code: :no_applicable_products)
-            end
-          when "none"
-            unless order_products(order).none? { |product| eligible_products.include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product),
-                                     error_code: :has_excluded_product)
-            end
-          else
-            raise "unexpected match policy: #{preferred_match_policy.inspect}"
-          end
-
-          eligibility_errors.empty?
-        end
-
-        def actionable?(line_item)
-          case preferred_match_policy
-          when 'any', 'all'
-            product_ids.include? line_item.variant.product_id
-          when 'none'
-            product_ids.exclude? line_item.variant.product_id
-          else
-            raise "unexpected match policy: #{preferred_match_policy.inspect}"
-          end
-        end
-
-        def product_ids_string
-          product_ids.join(',')
-        end
-
-        def product_ids_string=(product_ids)
-          self.product_ids = product_ids.to_s.split(',').map(&:strip)
-        end
-
-        private
-
-        def order_products(order)
-          order.line_items.map(&:variant).map(&:product)
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/store.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion
-    module Rules
-      class Store < PromotionRule
-        has_many :promotion_rule_stores, class_name: "Spree::PromotionRuleStore",
-                                         foreign_key: :promotion_rule_id,
-                                         dependent: :destroy
-        has_many :stores, through: :promotion_rule_stores, class_name: "Spree::Store"
-
-        def preload_relations
-          [:stores]
-        end
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          stores.none? || stores.include?(order.store)
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/taxon.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class Taxon < PromotionRule
-        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: :promotion_rule_id,
-          dependent: :destroy
-        has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
-
-        def preload_relations
-          [:taxons]
-        end
-
-        MATCH_POLICIES = %w(any all none)
-
-        validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
-
-        preference :match_policy, :string, default: MATCH_POLICIES.first
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          order_taxons = taxons_in_order(order)
-
-          case preferred_match_policy
-          when 'all'
-            matches_all = taxons.all? do |rule_taxon|
-              order_taxons.where(id: rule_taxon.self_and_descendants.ids).exists?
-            end
-
-            unless matches_all
-              eligibility_errors.add(:base, eligibility_error_message(:missing_taxon), error_code: :missing_taxon)
-            end
-          when 'any'
-            unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
-              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons), error_code: :no_matching_taxons)
-            end
-          when 'none'
-            if order_taxons.where(id: rule_taxon_ids_with_children).exists?
-              eligibility_errors.add(:base, eligibility_error_message(:has_excluded_taxon), error_code: :has_excluded_taxon)
-            end
-          else
-            raise "unexpected match policy: #{preferred_match_policy.inspect}"
-          end
-
-          eligibility_errors.empty?
-        end
-
-        def actionable?(line_item)
-          found = Spree::Classification.where(
-            product_id: line_item.variant.product_id,
-            taxon_id: rule_taxon_ids_with_children
-          ).exists?
-
-          case preferred_match_policy
-          when 'any', 'all'
-            found
-          when 'none'
-            !found
-          else
-            raise "unexpected match policy: #{preferred_match_policy.inspect}"
-          end
-        end
-
-        def taxon_ids_string
-          taxons.pluck(:id).join(',')
-        end
-
-        def taxon_ids_string=(taxon_ids)
-          taxon_ids = taxon_ids.to_s.split(',').map(&:strip)
-          self.taxons = Spree::Taxon.find(taxon_ids)
-        end
-
-        private
-
-        # All taxons in an order
-        def taxons_in_order(order)
-          Spree::Taxon.joins(products: { variants_including_master: :line_items })
-            .where(spree_line_items: { order_id: order.id }).distinct
-        end
-
-        # ids of taxons rules and taxons rules children
-        def rule_taxon_ids_with_children
-          taxons.flat_map { |taxon| taxon.self_and_descendants.ids }.uniq
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/user.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class User < PromotionRule
-        has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
-                                        foreign_key: :promotion_rule_id,
-                                        dependent: :destroy
-        has_many :users, through: :promotion_rule_users, class_name: Spree::UserClassHandle.new
-
-        def preload_relations
-          [:users]
-        end
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          users.include?(order.user)
-        end
-
-        def user_ids_string
-          user_ids.join(',')
-        end
-
-        def user_ids_string=(user_ids)
-          self.user_ids = user_ids.to_s.split(',').map(&:strip)
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/user_logged_in.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class UserLoggedIn < PromotionRule
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          unless order.user.present?
-            eligibility_errors.add(:base, eligibility_error_message(:no_user_specified), error_code: :no_user_specified)
-          end
-          eligibility_errors.empty?
-        end
-      end
-    end
-  end
-end

data/app/models/spree/promotion/rules/user_role.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class UserRole < PromotionRule
-        preference :role_ids, :array, default: []
-
-        MATCH_POLICIES = %w(any all)
-        preference :match_policy, default: MATCH_POLICIES.first
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          return false unless order.user
-          if all_match_policy?
-            match_all_roles?(order)
-          else
-            match_any_roles?(order)
-          end
-        end
-
-        private
-
-        def all_match_policy?
-          preferred_match_policy == 'all' && preferred_role_ids.present?
-        end
-
-        def user_roles(order)
-          order.user.spree_roles.where(id: preferred_role_ids)
-        end
-
-        def match_all_roles?(order)
-          user_roles(order).count == preferred_role_ids.count
-        end
-
-        def match_any_roles?(order)
-          user_roles(order).exists?
-        end
-      end
-    end
-  end
-end