spree_core 4.10.1 → 5.0.0.rc1

data/app/models/spree/promotion/actions/create_line_items.rb

@@ -2,8 +2,11 @@ module Spree
   class Promotion
     module Actions
       class CreateLineItems < PromotionAction
-        has_many :promotion_action_line_items, foreign_key: :promotion_action_id
-        accepts_nested_attributes_for :promotion_action_line_items
+        has_many :promotion_action_line_items, foreign_key: :promotion_action_id, dependent: :destroy
+
+        attribute :promotion_action_line_items_attributes
+
+        after_save :handle_promotion_action_line_items
 
         delegate :eligible?, to: :promotion
 
@@ -79,6 +82,38 @@ module Spree
           quantifier = Spree::Stock::Quantifier.new(item.variant)
           quantifier.can_supply? item.quantity
         end
+
+        private
+
+        # Handles the creation and updating of promotion action line items
+        #
+        # This is a hacky replacement for accepts_nested_attributes_for
+        # that allows us to save the PromotionAction and PromotionActionLineItems
+        # at the same time.
+        def handle_promotion_action_line_items
+          return unless promotion_action_line_items_attributes
+
+          # remove the ones marked for destruction
+          ids_for_destruction = promotion_action_line_items_attributes.map { |key, params| params["_destroy"] == "1" ? params["id"] : nil }.compact
+          promotion_action_line_items.where(id: ids_for_destruction).delete_all if ids_for_destruction.present?
+
+          # upsert the rest
+          records_for_upsert = promotion_action_line_items_attributes.map { |key, params| params["_destroy"] != "1" ? params : nil }.compact
+
+          opts = {}
+          opts[:unique_by] = [:promotion_action_id, :variant_id] unless ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+
+          promotion_action_line_items.upsert_all(
+            records_for_upsert.map do |params|
+              {
+                variant_id: params["variant_id"],
+                quantity: params["quantity"],
+                promotion_action_id: id
+              }
+            end,
+            **opts
+          )
+        end
       end
     end
   end

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

@@ -4,18 +4,36 @@ module Spree
     module Rules
       class Country < PromotionRule
         preference :country_id, :integer
+        preference :country_iso, :string # Alternative way to configure the rule
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
 
         def eligible?(order, options = {})
-          country_id = options[:country_id] || order.ship_address.try(:country_id)
-          unless country_id.eql?(preferred_country_id || order.store.default_country_id)
-            eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
+          if preferred_country_iso.present?
+            validate_eligibility_by_country_iso(order)
+          else
+            validate_eligibility_by_country_id(order, options)
           end
+        end
+
+        private
+
+        def validate_eligibility_by_country_id(order, options)
+          country_id = options[:country_id] || order.ship_address.try(:country_id)
+          return true if country_id == (preferred_country_id || order.store.default_country_id)
+
+          eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
+          false
+        end
+
+        def validate_eligibility_by_country_iso(order)
+          country_iso = order.ship_address&.country_iso
+          return true if country_iso == (preferred_country_iso || order.store.default_country_iso)
 
-          eligibility_errors.empty?
+          eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
+          false
         end
       end
     end

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

@@ -0,0 +1,21 @@
+# A rule to limit a promotion based on order currency.
+module Spree
+  class Promotion
+    module Rules
+      class Currency < PromotionRule
+        preference :currency, :string
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          return true if order.currency == preferred_currency
+
+          eligibility_errors.add(:base, eligibility_error_message(:wrong_currency))
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Spree
       class ItemTotal < PromotionRule
         preference :amount_min, :decimal, default: 100.00
         preference :operator_min, :string, default: '>'
-        preference :amount_max, :decimal, default: 1000.00
+        preference :amount_max, :decimal, default: nil, nullable: true
         preference :operator_max, :string, default: '<'
 
         OPERATORS_MIN = ['gt', 'gte']
@@ -20,7 +20,12 @@ module Spree
           item_total = order.item_total
 
           lower_limit_condition = item_total.send(preferred_operator_min == 'gte' ? :>= : :>, BigDecimal(preferred_amount_min.to_s))
-          upper_limit_condition = item_total.send(preferred_operator_max == 'lte' ? :<= : :<, BigDecimal(preferred_amount_max.to_s))
+
+          if preferred_amount_max.present?
+            upper_limit_condition = item_total.send(preferred_operator_max == 'lte' ? :<= : :<, BigDecimal(preferred_amount_max.to_s))
+          else
+            upper_limit_condition = true
+          end
 
           eligibility_errors.add(:base, ineligible_message_max) unless upper_limit_condition
           eligibility_errors.add(:base, ineligible_message_min) unless lower_limit_condition
@@ -35,7 +40,11 @@ module Spree
         end
 
         def formatted_amount_max
-          Spree::Money.new(preferred_amount_max).to_s
+          if preferred_amount_max.present?
+            Spree::Money.new(preferred_amount_max).to_s
+          else
+            Spree.t('no_maximum')
+          end
         end
 
         def ineligible_message_max

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

@@ -1,23 +1,12 @@
 module Spree
   class Promotion
     module Rules
-      module OptionValueWithNumerificationSupport
-        def preferred_eligible_values
-          values = super || {}
-          Hash[values.keys.zip(
-            values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(','))
-            end
-          )]
-        end
-      end
-
       class OptionValue < PromotionRule
-        prepend OptionValueWithNumerificationSupport
-
         MATCH_POLICIES = %w(any)
         preference :match_policy, :string, default: MATCH_POLICIES.first
-        preference :eligible_values, :hash
+        preference :eligible_values, :array, default: [], parse_on_set: lambda { |values|
+          values.flat_map { |v| v.to_s.split(',').compact_blank.map(&:strip) }
+        }
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
@@ -31,12 +20,8 @@ module Spree
         end
 
         def actionable?(line_item)
-          product_id = line_item.product_id
-          option_values_ids = line_item.variant.option_value_ids
-          eligible_product_ids = preferred_eligible_values.keys
-          eligible_value_ids = preferred_eligible_values[product_id]
-
-          eligible_product_ids.include?(product_id) && (eligible_value_ids & option_values_ids).present?
+          option_value_variant_ids = line_item.variant.option_value_variant_ids.map(&:to_s)
+          (preferred_eligible_values & option_value_variant_ids).any?
         end
       end
     end

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

@@ -5,14 +5,30 @@ module Spree
   class Promotion
     module Rules
       class Product < PromotionRule
+        #
+        # Associations
+        #
         has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule',
                                            foreign_key: :promotion_rule_id,
                                            dependent: :destroy
         has_many :products, through: :product_promotion_rules, class_name: 'Spree::Product'
 
+        #
+        # Preferences
+        #
         MATCH_POLICIES = %w(any all none)
         preference :match_policy, :string, default: MATCH_POLICIES.first
 
+        #
+        # Attributes
+        #
+        attr_accessor :product_ids_to_add
+
+        #
+        # Callbacks
+        #
+        after_save :add_products
+
         # scope/association that is used to test eligibility
         def eligible_products
           products
@@ -54,13 +70,29 @@ module Spree
         end
 
         def product_ids_string
+          ActiveSupport::Deprecation.warn(
+            'Please use `product_ids=` instead.'
+          )
           product_ids.join(',')
         end
 
         def product_ids_string=(s)
-          # check this
+          ActiveSupport::Deprecation.warn(
+            'Please use `product_ids=` instead.'
+          )
           self.product_ids = s
         end
+
+        private
+
+        def add_products
+          return if product_ids_to_add.nil?
+
+          product_promotion_rules.delete_all
+          product_promotion_rules.insert_all(
+            product_ids_to_add.map { |product_id| { product_id: product_id, promotion_rule_id: id } }
+          )
+        end
       end
     end
   end

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

@@ -2,14 +2,30 @@ module Spree
   class Promotion
     module Rules
       class Taxon < PromotionRule
+        #
+        # Associations
+        #
         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'
 
+        #
+        # Preferences
+        #
         MATCH_POLICIES = %w(any all)
         preference :match_policy, default: MATCH_POLICIES.first
 
+        #
+        # Attributes
+        #
+        attr_accessor :taxon_ids_to_add
+
+        #
+        # Callbacks
+        #
+        after_save :add_taxons
+
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
@@ -39,10 +55,16 @@ module Spree
         end
 
         def taxon_ids_string
+          ActiveSupport::Deprecation.warn(
+            'Please use `taxon_ids=` instead.'
+          )
           taxons.pluck(:id).join(',')
         end
 
         def taxon_ids_string=(s)
+          ActiveSupport::Deprecation.warn(
+            'Please use `taxon_ids=` instead.'
+          )
           ids = s.to_s.split(',').map(&:strip)
           self.taxons = Spree::Taxon.for_stores(stores).find(ids)
         end
@@ -69,6 +91,15 @@ module Spree
         def taxons_in_order_including_parents(order)
           order_taxons_in_taxons_and_children(order).inject([]) { |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
         end
+
+        def add_taxons
+          return if taxon_ids_to_add.nil?
+
+          promotion_rule_taxons.delete_all
+          promotion_rule_taxons.insert_all(
+            taxon_ids_to_add.map { |taxon_id| { taxon_id: taxon_id, promotion_rule_id: id } }
+          )
+        end
       end
     end
   end

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

@@ -2,29 +2,58 @@ module Spree
   class Promotion
     module Rules
       class User < PromotionRule
-        belongs_to :user, class_name: "::#{Spree.user_class}"
-
+        #
+        # Associations
+        #
         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.user_class}"
 
+        #
+        # Attributes
+        #
+        attr_accessor :user_ids_to_add
+
+        #
+        # Callbacks
+        #
+        after_save :add_users
+
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
 
         def eligible?(order, _options = {})
-          users.include?(order.user)
+          user_ids.include?(order.user_id)
         end
 
         def user_ids_string
+          ActiveSupport::Deprecation.warn(
+            'Spree::Promotion::Rules::User#user_ids_string is deprecated and will be removed in Spree 6.0. ' \
+            'Please use `user_ids` instead.'
+          )
           user_ids.join(',')
         end
 
         def user_ids_string=(s)
-          # check this
+          ActiveSupport::Deprecation.warn(
+            'Spree::Promotion::Rules::User#user_ids_string= is deprecated and will be removed in Spree 6.0. ' \
+            'Please use `user_ids=` instead.'
+          )
           self.user_ids = s
         end
+
+        private
+
+        def add_users
+          return if user_ids_to_add.nil?
+
+          promotion_rule_users.delete_all
+          promotion_rule_users.insert_all(
+            user_ids_to_add.map { |user_id| { user_id: user_id, promotion_rule_id: id } }
+          )
+        end
       end
     end
   end

data/app/models/spree/promotion.rb

@@ -1,5 +1,5 @@
 module Spree
-  class Promotion < Spree::Base
+  class Promotion < Spree.base_class
     include Spree::MultiStoreResource
     include Spree::Metadata
     if defined?(Spree::Webhooks::HasWebhooks)
@@ -14,32 +14,64 @@ module Spree
 
     attr_reader :eligibility_errors, :generate_code
 
-    belongs_to :promotion_category, optional: true
+    #
+    # Magic methods
+    #
+    auto_strip_attributes :code, :path, :name
 
+    #
+    # Enums
+    #
+    enum :kind, { coupon_code: 0, automatic: 1 }
+
+    #
+    # Associations
+    #
+    belongs_to :promotion_category, optional: true
     has_many :promotion_rules, autosave: true, dependent: :destroy
     alias rules promotion_rules
-
     has_many :promotion_actions, autosave: true, dependent: :destroy
     alias actions promotion_actions
-
+    has_many :coupon_codes, -> { order(created_at: :asc) }, dependent: :destroy, class_name: 'Spree::CouponCode'
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
-
     has_many :store_promotions, class_name: 'Spree::StorePromotion'
     has_many :stores, class_name: 'Spree::Store', through: :store_promotions
-
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
+    #
+    # Callbacks
+    #
+    before_validation :set_code_to_nil, if: -> { multi_codes? || automatic? }
+    before_validation :set_number_of_codes_to_nil, if: -> { automatic? || !multi_codes? }
+    before_validation :set_usage_limit_to_nil, if: -> { multi_codes? }
+    before_validation :set_kind
+    before_validation :downcase_code, if: -> { code.present? }
+    before_validation :set_starts_at_to_current_time, if: -> { starts_at.blank? }
+    after_commit :generate_coupon_codes, if: -> { multi_codes? }, on: [:create, :update]
+    after_commit :remove_coupons, unless: -> { multi_codes? }, on: :update
+    before_destroy :not_used?
+
+    #
+    # Validations
+    #
     validates_associated :rules
-
     validates :name, presence: true
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }, allow_blank: true
     validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }
-
-    auto_strip_attributes :code, :path, :name
-
-    scope :coupons, -> { where.not(code: nil) }
+    validates :code, presence: true, if: -> { coupon_code? && !multi_codes? }
+    validates :number_of_codes, numericality: {
+      only_integer: true,
+      greater_than: 0,
+      less_than_or_equal_to: Spree::Config.coupon_codes_total_limit
+    }, if: -> { multi_codes? }
+
+    #
+    # Scopes
+    #
+    scope :expired, -> { where('expires_at < ?', Time.current) }
+    scope :coupons, -> { where(kind: :coupon_code) }
     scope :advertised, -> { where(advertise: true) }
     scope :applied, lambda {
       joins(<<-SQL).distinct
@@ -48,12 +80,22 @@ module Spree
       SQL
     }
 
-    self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id', 'code']
+    #
+    # Ransack
+    #
+    self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id', 'code', 'starts_at', 'expires_at']
+    self.whitelisted_ransackable_associations = %w[coupon_codes]
 
     def self.with_coupon_code(coupon_code)
-      where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase).
-        includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil }).
-        last
+      return nil unless coupon_code.present?
+
+      coupon_code = coupon_code.strip.downcase
+
+      coupons.includes(:promotion_actions).
+        where.not(spree_promotion_actions: { id: nil }).
+        where(code: coupon_code).or(
+          where(id: Spree::CouponCode.where(code: coupon_code).select(:promotion_id))
+        ).last
     end
 
     def self.active
@@ -71,10 +113,22 @@ module Spree
       end
     end
 
+    def active?
+      starts_at.present? && starts_at < Time.current && (expires_at.blank? || !expired?)
+    end
+
+    def inactive?
+      !active?
+    end
+
     def expired?
       !!(starts_at && Time.current < starts_at || expires_at && Time.current > expires_at)
     end
 
+    def all_codes_used?
+      coupon_codes.used.count == coupon_codes.count
+    end
+
     def activate(payload)
       order = payload[:order]
       return unless self.class.order_activatable?(order)
@@ -209,8 +263,75 @@ module Spree
         where(spree_adjustments: { source_type: 'Spree::PromotionAction', eligible: true }).any?
     end
 
+    def name_for_order(order)
+      if coupon_code?
+        code_for_order(order)
+      else
+        name
+      end.to_s.upcase
+    end
+
+    def code_for_order(order)
+      if multi_codes?
+        coupon_codes.find_by(order: order)&.code
+      else
+        code
+      end
+    end
+
     private
 
+    def not_used?
+      return true if orders.empty?
+
+      errors.add(:base, Spree.t('promotion_already_used'))
+      throw(:abort)
+    end
+
+    def set_kind
+      if (code.present? || (multi_codes? && number_of_codes.present?)) && kind == 'automatic'
+        self.kind = :coupon_code
+      end
+    end
+
+    def downcase_code
+      self.code = code.downcase.strip
+    end
+
+    def set_code_to_nil
+      self.code = nil
+    end
+
+    def set_usage_limit_to_nil
+      self.usage_limit = nil
+    end
+
+    def set_number_of_codes_to_nil
+      self.number_of_codes = nil
+      self.code_prefix = nil
+      self.multi_codes = false
+    end
+
+    def set_starts_at_to_current_time
+      self.starts_at = Time.current
+    end
+
+    def generate_coupon_codes
+      return if number_of_codes.nil?
+      return if number_of_codes <= coupon_codes.count
+      return unless saved_change_to_number_of_codes?
+
+      if number_of_codes > Spree::Config.coupon_codes_web_limit
+        Spree::CouponCodes::BulkGenerateJob.perform_later(id, number_of_codes - coupon_codes.count)
+      else
+        Spree::CouponCodes::BulkGenerate.call(promotion: self, quantity: number_of_codes - coupon_codes.count)
+      end
+    end
+
+    def remove_coupons
+      coupon_codes.where(deleted_at: nil).update_all(deleted_at: Time.current)
+    end
+
     def blacklisted?(promotable)
       case promotable
       when Spree::LineItem

data/app/models/spree/promotion_action.rb

@@ -1,11 +1,13 @@
 ## Base class for all types of promotion action.
 # PromotionActions perform the necessary tasks when a promotion is activated by an event and determined to be eligible.
 module Spree
-  class PromotionAction < Spree::Base
+  class PromotionAction < Spree.base_class
     acts_as_paranoid
 
     belongs_to :promotion, class_name: 'Spree::Promotion'
 
+    validates :promotion, :type, presence: true
+
     scope :of_type, ->(t) { where(type: t) }
 
     # This method should be overridden in subclass
@@ -16,6 +18,34 @@ module Spree
       raise 'perform should be implemented in a sub-class of PromotionAction'
     end
 
+    # Returns true if the promotion action is a free shipping action
+    #
+    # @return [Boolean]
+    def free_shipping?
+      type == 'Spree::Promotion::Actions::FreeShipping'
+    end
+
+    # Returns the human name of the promotion action
+    #
+    # @return [String] eg. Free Shipping
+    def human_name
+      Spree.t("promotion_action_types.#{key}.name")
+    end
+
+    # Returns the human description of the promotion action
+    #
+    # @return [String]
+    def human_description
+      Spree.t("promotion_action_types.#{key}.description")
+    end
+
+    # Returns the key of the promotion action
+    #
+    # @return [String] eg. free_shipping
+    def key
+      type.demodulize.underscore
+    end
+
     protected
 
     def label

data/app/models/spree/promotion_action_line_item.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PromotionActionLineItem < Spree::Base
+  class PromotionActionLineItem < Spree.base_class
     belongs_to :promotion_action, class_name: 'Spree::Promotion::Actions::CreateLineItems'
     belongs_to :variant, class_name: 'Spree::Variant'
 

data/app/models/spree/promotion_category.rb

@@ -1,5 +1,5 @@
 module Spree
-  class PromotionCategory < Spree::Base
+  class PromotionCategory < Spree.base_class
     validates :name, presence: true
     has_many :promotions
   end

data/app/models/spree/promotion_handler/cart.rb

@@ -35,7 +35,7 @@ module Spree
       private
 
       def promotions
-        promotion_scope.find_by_sql("#{order.promotions.active.to_sql} UNION #{promotion_scope.active.where(code: nil, path: nil).to_sql}")
+        promotion_scope.find_by_sql("#{order.promotions.active.to_sql} UNION #{promotion_scope.active.automatic.to_sql}")
       end
 
       def promotion_scope