spree_core 2.4.10 → 3.0.0.rc1

data/app/models/spree/product_property.rb

@@ -1,7 +1,5 @@
 module Spree
   class ProductProperty < Spree::Base
-    acts_as_list scope: :product
-
     belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
     belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
 
@@ -9,9 +7,7 @@ module Spree
 
     validates_with Spree::Validations::DbMaximumLengthValidator, field: :value
 
-    default_scope -> { order("#{self.table_name}.position") }
-
-    self.whitelisted_ransackable_attributes = ['value']
+    default_scope { order("#{self.table_name}.position") }
 
     # virtual attributes for use with AJAX completion stuff
     def property_name

data/app/models/spree/promotion.rb

@@ -32,8 +32,6 @@ module Spree
 
     scope :applied, -> { joins("INNER JOIN #{order_join_table} ON #{order_join_table}.promotion_id = #{table_name}.id").uniq }
 
-    self.whitelisted_ransackable_attributes = ['code', 'path', 'promotion_category_id']
-
     def self.advertised
       where(advertise: true)
     end
@@ -43,8 +41,8 @@ module Spree
     end
 
     def self.active
-      where('spree_promotions.starts_at IS NULL OR spree_promotions.starts_at < ?', Time.now).
-        where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.now)
+      where('starts_at IS NULL OR starts_at < ?', Time.now).
+        where('expires_at IS NULL OR expires_at > ?', Time.now)
     end
 
     def self.order_activatable?(order)
@@ -93,28 +91,23 @@ module Spree
       # Promotions without rules are eligible by default.
       return [] if rules.none?
       eligible = lambda { |r| r.eligible?(promotable, options) }
-      specific_rules = rules.select { |rule| rule.applicable?(promotable) }
+      specific_rules = rules.for(promotable)
       return [] if specific_rules.none?
 
-      rule_eligibility = Hash[specific_rules.map do |rule|
-        [rule, rule.eligible?(promotable, options)]
-      end]
-
       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 rule_eligibility.values.all?
+        unless specific_rules.all?(&eligible)
           @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
           return nil
         end
         specific_rules
       else
-        unless rule_eligibility.values.any?
+        unless specific_rules.any?(&eligible)
           @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
           return nil
         end
-
-        [rule_eligibility.detect { |_, eligibility| eligibility }.first]
+        specific_rules.select(&eligible)
       end
     end
 
@@ -127,8 +120,7 @@ module Spree
     end
 
     def adjusted_credits_count(promotable)
-      adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
-      credits_count - adjustments.promotion.where(:source_id => actions.pluck(:id)).count
+      credits_count - promotable.adjustments.promotion.where(:source_id => actions.pluck(:id)).count
     end
 
     def credits

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

@@ -5,57 +5,16 @@ module Spree
         include Spree::CalculatedAdjustments
         include Spree::AdjustmentSource
 
-        has_many :adjustments, as: :source
+        before_validation -> { self.calculator ||= Calculator::FlatPercentItemTotal.new }
 
-        delegate :eligible?, to: :promotion
-
-        before_validation :ensure_action_has_calculator
-        before_destroy :deals_with_adjustments_for_deleted_source
-
-        # Creates the adjustment related to a promotion for the order passed
-        # through options hash
-        #
-        # Returns `true` if an adjustment is applied to an order,
-        # `false` if the promotion has already been applied.
         def perform(options = {})
           order = options[:order]
-          return if promotion_credit_exists?(order)
-
-          amount = compute_amount(order)
-          return if amount == 0
-          Spree::Adjustment.create!(
-            amount: amount,
-            order: order,
-            adjustable: order,
-            source: self,
-            label: "#{Spree.t(:promotion)} (#{promotion.name})"
-          )
-          true
+          create_unique_adjustment(order, order)
         end
 
-        # Ensure a negative amount which does not exceed the sum of the order's
-        # item_total and ship_total
-        def compute_amount(calculable)
-          amount = self.calculator.compute(calculable).to_f.abs
-          [(calculable.item_total + calculable.ship_total), amount].min * -1
+        def compute_amount(order)
+          [(order.item_total + order.ship_total), compute(order)].min * -1
         end
-
-        private
-          # Tells us if there if the specified promotion is already associated with the line item
-          # regardless of whether or not its currently eligible. Useful because generally
-          # you would only want a promotion action to apply to order no more than once.
-          #
-          # Receives an adjustment +source+ (here a PromotionAction object) and tells
-          # if the order has adjustments from that already
-          def promotion_credit_exists?(adjustable)
-            self.adjustments.where(:adjustable_id => adjustable.id).exists?
-          end
-
-          def ensure_action_has_calculator
-            return if self.calculator
-            self.calculator = Calculator::FlatPercentItemTotal.new
-          end
-
       end
     end
   end

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

@@ -5,74 +5,19 @@ module Spree
         include Spree::CalculatedAdjustments
         include Spree::AdjustmentSource
 
-        has_many :adjustments, as: :source
+        before_validation -> { self.calculator ||= Calculator::PercentOnLineItem.new }
 
-        delegate :eligible?, to: :promotion
-
-        before_validation :ensure_action_has_calculator
-        before_destroy :deals_with_adjustments_for_deleted_source
-
-        def perform(payload = {})
-          order = payload[:order]
-          promotion = payload[:promotion]
-
-          result = false
-
-          line_items_to_adjust(promotion, order).each do |line_item|
-            current_result = self.create_adjustment(line_item, order)
-            result ||= current_result
+        def perform(options = {})
+          order, promotion = options[:order], options[:promotion]
+          create_unique_adjustments(order, order.line_items) do |line_item|
+            promotion.line_item_actionable?(order, line_item)
           end
-          return result
         end
 
-        def create_adjustment(adjustable, order)
-          amount = self.compute_amount(adjustable)
-          return if amount == 0
-          self.adjustments.create!(
-            amount: amount,
-            adjustable: adjustable,
-            order: order,
-            label: "#{Spree.t(:promotion)} (#{promotion.name})",
-          )
-          true
+        def compute_amount(line_item)
+          return 0 unless promotion.line_item_actionable?(line_item.order, line_item)
+          [line_item.amount, compute(line_item)].min * -1
         end
-
-        # Ensure a negative amount which does not exceed the sum of the order's
-        # item_total and ship_total
-        def compute_amount(adjustable)
-          order = adjustable.is_a?(Order) ? adjustable : adjustable.order
-          return 0 unless promotion.line_item_actionable?(order, adjustable)
-          promotion_amount = self.calculator.compute(adjustable).to_f.abs
-
-          [adjustable.amount, promotion_amount].min * -1
-        end
-
-        private
-          # Tells us if there if the specified promotion is already associated with the line item
-          # regardless of whether or not its currently eligible. Useful because generally
-          # you would only want a promotion action to apply to line item no more than once.
-          #
-          # Receives an adjustment +source+ (here a PromotionAction object) and tells
-          # if the order has adjustments from that already
-          def promotion_credit_exists?(adjustable)
-            self.adjustments.where(:adjustable_id => adjustable.id).exists?
-          end
-
-          def ensure_action_has_calculator
-            return if self.calculator
-            self.calculator = Calculator::PercentOnLineItem.new
-          end
-
-          def line_items_to_adjust(promotion, order)
-            excluded_ids = self.adjustments.
-              where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
-              pluck(:adjustable_id)
-
-            order.line_items.where.not(id: excluded_ids).select do |line_item|
-              promotion.line_item_actionable? order, line_item
-            end
-          end
-
       end
     end
   end

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

@@ -39,23 +39,14 @@ module Spree
           order = options[:order]
           return unless self.eligible? order
 
-          action_taken = false
           promotion_action_line_items.each do |item|
             current_quantity = order.quantity_of(item.variant)
-            if current_quantity < item.quantity && item_available?(item)
-              line_item = order.contents.add(item.variant, item.quantity - current_quantity)
-              action_taken = true if line_item.try(:valid?)
+            if current_quantity < item.quantity
+              order.contents.add(item.variant, item.quantity - current_quantity)
             end
           end
-          action_taken
+          true
         end
-
-        # Checks that there's enough stock to add the line item to the order
-        def item_available?(item)
-          quantifier = Spree::Stock::Quantifier.new(item.variant)
-          quantifier.can_supply? item.quantity
-        end
-
       end
     end
   end

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

@@ -2,37 +2,17 @@ module Spree
   class Promotion
     module Actions
       class FreeShipping < Spree::PromotionAction
+        include Spree::AdjustmentSource
+
         def perform(payload={})
           order = payload[:order]
-          results = order.shipments.map do |shipment|
-            return false if promotion_credit_exists?(shipment)
-            shipment.adjustments.create!(
-              order: shipment.order, 
-              amount: compute_amount(shipment),
-              source: self,
-              label: label,
-            )
-            true
-          end
-          # Did we actually end up applying any adjustments?
-          # If so, then this action should be classed as 'successful'
-          results.any? { |r| r == true }
-        end
-
-        def label
-          "#{Spree.t(:promotion)} (#{promotion.name})"
+          create_unique_adjustments(order, order.shipments)
         end
 
         def compute_amount(shipment)
           shipment.cost * -1
         end
-
-        private
-
-        def promotion_credit_exists?(shipment)
-          shipment.adjustments.where(:source_id => self.id).exists?
-        end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,49 @@
+module Spree
+  class Promotion
+    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).empty?
+        end
+
+        def preferred_eligible_values_with_numerification
+          values = preferred_eligible_values_without_numerification || {}
+          Hash[values.keys.map(&:to_i).zip(
+            values.values.map do |v|
+              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            end
+          )]
+        end
+        alias_method_chain :preferred_eligible_values, :numerification
+
+        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_action.rb

@@ -15,5 +15,11 @@ module Spree
     def perform(options = {})
       raise 'perform should be implemented in a sub-class of PromotionAction'
     end
+
+    protected
+
+    def label(amount)
+      "#{Spree.t(:promotion)} (#{promotion.name})"
+    end
   end
 end

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

@@ -29,26 +29,22 @@ module Spree
       end
 
       private
+        def promotions
+          promo_table = Promotion.arel_table
+          join_table = Arel::Table.new(:spree_orders_promotions)
 
-      def promotions
-        # AR cannot bind raw ASTs to prepared statements. There always must be a manager around.
-        # Also Postgresql requires an aliased table for `SELECT * FROM (subexpression) AS alias`.
-        # And Sqlite3 cannot work on outher parenthesis from `(left UNION right)`.
-        # So this construct makes both happy.
-        select = Arel::SelectManager.new(
-          Promotion,
-          Promotion.arel_table.create_table_alias(
-            order.promotions.active.union(Promotion.active.where(code: nil, path: nil)),
-            Promotion.table_name
-          ),
-        )
-        select.project(Arel.star)
+          join_condition = promo_table.join(join_table, Arel::Nodes::OuterJoin).on(
+            promo_table[:id].eq(join_table[:promotion_id])
+          ).join_sources
 
-        Promotion.find_by_sql(
-          select,
-          order.promotions.bind_values
-        )
-      end
+          Promotion.active.includes(:promotion_rules).
+            joins(join_condition).
+            where(
+              promo_table[:code].eq(nil).and(
+                promo_table[:path].eq(nil)
+              ).or(join_table[:order_id].eq(order.id))
+            ).distinct
+        end
     end
   end
 end

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

@@ -86,7 +86,7 @@ module Spree
         }
 
         # Check for applied adjustments.
-        discount = order.line_item_adjustments.promotion.eligible.detect(&detector)
+        discount = order.line_item_adjustments.promotion.detect(&detector)
         discount ||= order.shipment_adjustments.promotion.detect(&detector)
         discount ||= order.adjustments.promotion.detect(&detector)
 

data/app/models/spree/promotion_rule.rb

@@ -5,7 +5,6 @@ module Spree
 
     scope :of_type, ->(t) { where(type: t) }
 
-    validate :promotion, presence: true
     validate :unique_per_promotion, on: :create
 
     def self.for(promotable)

data/app/models/spree/property.rb

@@ -11,8 +11,6 @@ module Spree
 
     after_touch :touch_all_products
 
-    self.whitelisted_ransackable_attributes = ['presentation']
-
     private
 
     def touch_all_products

data/app/models/spree/refund.rb

@@ -11,7 +11,6 @@ module Spree
     validates :transaction_id, presence: true, on: :update # can't require this on create because the before_create needs to run first
     validates :amount, presence: true, numericality: {greater_than: 0}
 
-    validate :check_payment_environment, on: :create, if: :payment
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
 
     after_create :perform!
@@ -47,7 +46,6 @@ module Spree
 
       self.transaction_id = @response.authorization
       update_columns(transaction_id: transaction_id)
-      update_order
     end
 
     # return an activemerchant response object if successful or else raise an error
@@ -70,15 +68,6 @@ module Spree
       raise Core::GatewayError.new(Spree.t(:unable_to_connect_to_gateway))
     end
 
-    # Saftey check to make sure we're not accidentally performing operations on a live gateway.
-    # Ex. When testing in staging environment with a copy of production data.
-    def check_payment_environment
-      if payment.payment_method.environment != Rails.env
-        message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
-        errors.add(:base, message)
-      end
-    end
-
     def create_log_entry
       log_entries.create!(details: @response.to_yaml)
     end
@@ -88,9 +77,5 @@ module Spree
         errors.add(:amount, :greater_than_allowed)
       end
     end
-
-    def update_order
-      payment.order.updater.update
-    end
   end
 end