solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,74 @@
+# 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? { |p| order.products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:missing_product))
+            end
+          when 'any'
+            unless order.products.any? { |p| eligible_products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products))
+            end
+          when 'none'
+            unless order.products.none? { |p| eligible_products.include?(p) }
+              eligibility_errors.add(:base, eligibility_error_message(: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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,103 @@
+# 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))
+            end
+          when 'any'
+            unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
+              eligibility_errors.add(:base, eligibility_error_message(: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))
+            end
+          else
+            # Change this to an exception in a future version of Solidus
+            warn_invalid_match_policy(assume: 'any')
+            unless order_taxons.where(id: rule_taxon_ids_with_children).exists?
+              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
+            end
+          end
+
+          eligibility_errors.empty?
+        end
+
+        # TODO: Fix bug - well described by jhawthorn in #1409:
+        # `eligible?` checks the configured taxons and all descendants,
+        # `actionable?` only seems to check against the taxons themselves (not children)
+        def actionable?(line_item)
+          found = Spree::Classification.where(
+            product_id: line_item.variant.product_id,
+            taxon_id: taxon_ids
+          ).exists?
+
+          case preferred_match_policy
+          when 'any', 'all'
+            found
+          when 'none'
+            !found
+          else
+            # Change this to an exception in a future version of Solidus
+            warn_invalid_match_policy(assume: 'any')
+            found
+          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
+
+        def warn_invalid_match_policy(assume:)
+          Spree::Deprecation.warn(
+            "#{self.class.name} id=#{id} has unexpected match policy #{preferred_match_policy.inspect}. "\
+            "Interpreting it as '#{assume}'."
+          )
+        end
+
+        # 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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,20 @@
+# 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))
+          end
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# 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

data/app/models/spree/promotion.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module Spree
+  class Promotion < Spree::Base
+    MATCH_POLICIES = %w(all any)
+    UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
+
+    attr_reader :eligibility_errors
+
+    belongs_to :promotion_category
+
+    has_many :promotion_rules, autosave: true, dependent: :destroy, inverse_of: :promotion
+    alias_method :rules, :promotion_rules
+
+    has_many :promotion_actions, autosave: true, dependent: :destroy, inverse_of: :promotion
+    alias_method :actions, :promotion_actions
+
+    has_many :order_promotions, class_name: "Spree::OrderPromotion"
+    has_many :orders, through: :order_promotions
+
+    has_many :codes, class_name: "Spree::PromotionCode", inverse_of: :promotion, dependent: :destroy
+    alias_method :promotion_codes, :codes
+
+    has_many :promotion_code_batches, class_name: "Spree::PromotionCodeBatch", dependent: :destroy
+
+    accepts_nested_attributes_for :promotion_actions, :promotion_rules
+
+    validates_associated :rules
+
+    validates :name, presence: true
+    validates :path, uniqueness: { allow_blank: true }
+    validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
+    validates :per_code_usage_limit, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+    validates :description, length: { maximum: 255 }
+    validate :apply_automatically_disallowed_with_codes_or_paths
+
+    before_save :normalize_blank_values
+
+    scope :coupons, -> { where.not(code: nil) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :active, -> do
+      table = arel_table
+      time = Time.current
+      where(table[:starts_at].eq(nil).or(table[:starts_at].lt(time))).
+        where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
+    end
+    scope :applied, -> { joins(:order_promotions).distinct }
+
+    self.whitelisted_ransackable_associations = ['codes']
+    self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id']
+
+    # temporary code. remove after the column is dropped from the db.
+    def columns
+      super.reject { |column| column.name == "code" }
+    end
+
+    def self.order_activatable?(order)
+      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    def code
+      raise "Attempted to call code on a Spree::Promotion. Promotions are now tied to multiple code records"
+    end
+
+    def code=(_val)
+      raise "Attempted to call code= on a Spree::Promotion. Promotions are now tied to multiple code records"
+    end
+
+    def self.with_coupon_code(val)
+      joins(:codes).where(
+        PromotionCode.arel_table[:value].eq(val.downcase)
+      ).first
+    end
+
+    def as_json(options = {})
+      options[:except] ||= :code
+      super
+    end
+
+    def active?
+      (starts_at.nil? || starts_at < Time.current) &&
+        (expires_at.nil? || expires_at > Time.current)
+    end
+
+    def inactive?
+      !active?
+    end
+
+    def activate(order:, line_item: nil, user: nil, path: nil, promotion_code: nil)
+      return unless self.class.order_activatable?(order)
+
+      payload = {
+        order: order,
+        promotion: self,
+        line_item: line_item,
+        user: user,
+        path: path,
+        promotion_code: promotion_code
+      }
+
+      # Track results from actions to see if any action has been taken.
+      # Actions should return nil/false if no action has been taken.
+      # If an action returns true, then an action has been taken.
+      results = actions.map do |action|
+        action.perform(payload)
+      end
+      # If an action has been taken, report back to whatever activated this promotion.
+      action_taken = results.include?(true)
+
+      if action_taken
+        # connect to the order
+        order.order_promotions.find_or_create_by!(
+          promotion: self,
+          promotion_code: promotion_code,
+        )
+        order.promotions.reset
+        order_promotions.reset
+        orders.reset
+      end
+
+      action_taken
+    end
+
+    # called anytime order.recalculate happens
+    def eligible?(promotable, promotion_code: nil)
+      return false if inactive?
+      return false if usage_limit_exceeded?
+      return false if promotion_code && promotion_code.usage_limit_exceeded?
+      return false if blacklisted?(promotable)
+      !!eligible_rules(promotable, {})
+    end
+
+    # eligible_rules returns an array of promotion rules where eligible? is true for the promotable
+    # if there are no such rules, an empty array is returned
+    # if the rules make this promotable ineligible, then nil is returned (i.e. this promotable is not eligible)
+    def eligible_rules(promotable, options = {})
+      # Promotions without rules are eligible by default.
+      return [] if rules.none?
+      eligible = lambda { |r| r.eligible?(promotable, options) }
+      specific_rules = rules.for(promotable)
+      return [] if specific_rules.none?
+
+      if match_all?
+        # If there are rules for this promotion, but no rules for this
+        # particular promotable, then the promotion is ineligible by default.
+        unless specific_rules.all?(&eligible)
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules
+      else
+        unless specific_rules.any?(&eligible)
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules.select(&eligible)
+      end
+    end
+
+    def products
+      rules.where(type: "Spree::Promotion::Rules::Product").map(&:products).flatten.uniq
+    end
+
+    # Whether the promotion has exceeded it's usage restrictions.
+    #
+    # @return true or false
+    def usage_limit_exceeded?
+      if usage_limit
+        usage_count >= usage_limit
+      end
+    end
+
+    # Number of times the code has been used overall
+    #
+    # @return [Integer] usage count
+    def usage_count
+      Spree::Adjustment.eligible.
+        promotion.
+        where(source_id: actions.map(&:id)).
+        joins(:order).
+        merge(Spree::Order.complete).
+        distinct.
+        count(:order_id)
+    end
+
+    def line_item_actionable?(order, line_item, promotion_code: nil)
+      return false if blacklisted?(line_item)
+
+      if eligible?(order, promotion_code: promotion_code)
+        rules = eligible_rules(order)
+        if rules.blank?
+          true
+        else
+          rules.send(match_all? ? :all? : :any?) do |rule|
+            rule.actionable? line_item
+          end
+        end
+      else
+        false
+      end
+    end
+
+    def used_by?(user, excluded_orders = [])
+      [
+        :adjustments,
+        :line_item_adjustments,
+        :shipment_adjustments
+      ].any? do |adjustment_type|
+        user.orders.complete.joins(adjustment_type).where(
+          spree_adjustments: {
+            source_type: "Spree::PromotionAction",
+            source_id: actions.map(&:id),
+            eligible: true
+          }
+        ).where.not(
+          id: excluded_orders.map(&:id)
+        ).any?
+      end
+    end
+
+    # Removes a promotion and any adjustments or other side effects from an
+    # order.
+    # @param order [Spree::Order] the order to remove the promotion from.
+    # @return [void]
+    def remove_from(order)
+      actions.each do |action|
+        action.remove_from(order)
+      end
+      # note: this destroys the join table entry, not the promotion itself
+      order.promotions.destroy(self)
+      order.order_promotions.reset
+      order_promotions.reset
+    end
+
+    private
+
+    def blacklisted?(promotable)
+      case promotable
+      when Spree::LineItem
+        !promotable.product.promotionable?
+      when Spree::Order
+        promotable.line_items.joins(:product).where(spree_products: { promotionable: false }).exists?
+      end
+    end
+
+    def normalize_blank_values
+      self[:path] = nil if self[:path].blank?
+    end
+
+    def match_all?
+      match_policy == "all"
+    end
+
+    def apply_automatically_disallowed_with_codes_or_paths
+      return unless apply_automatically
+      errors.add(:apply_automatically, :disallowed_with_code) if codes.any?
+      errors.add(:apply_automatically, :disallowed_with_path) if path.present?
+    end
+  end
+end

data/app/models/spree/promotion_action.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  # 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.
+  class PromotionAction < Spree::Base
+    acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions
+
+    scope :of_type, ->(t) { where(type: Array.wrap(t).map(&:to_s)) }
+    scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }
+
+    # Updates the state of the order or performs some other action depending on
+    # the subclass options will contain the payload from the event that
+    # activated the promotion. This will include the key :user which allows
+    # user based actions to be performed in addition to actions on the order
+    #
+    # @note This method should be overriden in subclassses.
+    def perform(_options = {})
+      raise 'perform should be implemented in a sub-class of PromotionAction'
+    end
+
+    # Removes the action from an order
+    #
+    # @note This method should be overriden in subclassses.
+    #
+    # @param order [Spree::Order] the order to remove the action from
+    # @return [void]
+    def remove_from(order)
+      Spree::Deprecation.warn("#{self.class.name.inspect} does not define #remove_from. The default behavior may be incorrect and will be removed in a future version of Solidus.", caller)
+      [order, *order.line_items, *order.shipments].each do |item|
+        item.adjustments.each do |adjustment|
+          if adjustment.source == self
+            item.adjustments.destroy(adjustment)
+          end
+        end
+      end
+    end
+
+    def to_partial_path
+      "spree/admin/promotions/actions/#{model_name.element}"
+    end
+  end
+end

data/app/models/spree/promotion_category.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionCategory < Spree::Base
+    validates_presence_of :name
+    has_many :promotions
+  end
+end

data/app/models/spree/promotion_chooser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Spree
+  class PromotionChooser
+    def initialize(adjustments)
+      @adjustments = adjustments
+    end
+
+    # Picks the best promotion from this set of adjustments, all others are
+    # marked as ineligible.
+    #
+    # @return [BigDecimal] The amount of the best adjustment
+    def update
+      if best_promotion_adjustment
+        @adjustments.select(&:eligible?).each do |adjustment|
+          next if adjustment == best_promotion_adjustment
+          adjustment.update_columns(eligible: false, updated_at: Time.current)
+        end
+        best_promotion_adjustment.amount
+      else
+        BigDecimal('0')
+      end
+    end
+
+    private
+
+    # @return The best promotion from this set of adjustments.
+    def best_promotion_adjustment
+      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |a|
+        [a.amount, -a.id]
+      end
+    end
+  end
+end