solidus_core 3.0.0 → 4.5.1

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class FirstOrder < PromotionRule
-        attr_reader :user, :email
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, options = {})
-          @user = order.try(:user) || options[:user]
-          @email = order.email
-
-          if user || email
-            if !completed_orders.blank? && completed_orders.first != order
-              eligibility_errors.add(:base, eligibility_error_message(:not_first_order), error_code: :not_first_order)
-            end
-          end
-
-          eligibility_errors.empty?
-        end
-
-        private
-
-        def completed_orders
-          user ? user.orders.complete : orders_by_email
-        end
-
-        def orders_by_email
-          Spree::Order.where(email: email).complete
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Spree
-  class Promotion < Spree::Base
-    module Rules
-      class FirstRepeatPurchaseSince < PromotionRule
-        preference :days_ago, :integer, default: 365
-        validates :preferred_days_ago, numericality: { only_integer: true, greater_than: 0 }
-
-        # 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.
-        #
-        # This is eligible if the user's most recently completed order is more than the preferred days ago
-        # @param order [Spree::Order]
-        def eligible?(order, _options = {})
-          return false unless order.user
-
-          last_order = last_completed_order(order.user)
-          return false unless last_order
-
-          last_order.completed_at < preferred_days_ago.days.ago
-        end
-
-        private
-
-        def last_completed_order(user)
-          user.orders.complete.order(:completed_at).last
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +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
-      class ItemTotal < PromotionRule
-        preference :amount, :decimal, default: 100.00
-        preference :currency, :string, default: ->{ Spree::Config[:currency] }
-        preference :operator, :string, default: '>'
-
-        OPERATORS = ['gt', 'gte']
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order)
-        end
-
-        def eligible?(order, _options = {})
-          return false unless order.currency == preferred_currency
-          item_total = order.item_total
-          unless item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal(preferred_amount.to_s))
-            eligibility_errors.add(:base, ineligible_message, error_code: ineligible_error_code)
-          end
-
-          eligibility_errors.empty?
-        end
-
-        private
-
-        def formatted_amount
-          Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
-        end
-
-        def ineligible_message
-          if preferred_operator == 'gte'
-            eligibility_error_message(:item_total_less_than, amount: formatted_amount)
-          else
-            eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount)
-          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/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,74 +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
-
-        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.include?(product) }
-              eligibility_errors.add(:base, eligibility_error_message(:missing_product), error_code: :missing_product)
-            end
-          when 'any'
-            unless order.products.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.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
-      end
-    end
-  end
-end

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

@@ -1,22 +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 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,87 +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'
-
-        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,30 +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 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