spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/payment/processing.rb

@@ -2,37 +2,20 @@ module Spree
   class Payment < Spree::Base
     module Processing
       def process!
-        if payment_method && payment_method.source_required?
-          if source
-            if !processing?
-              if payment_method.supports?(source) || token_based?
-                if payment_method.auto_capture?
-                  purchase!
-                else
-                  authorize!
-                end
-              else
-                invalidate!
-                raise Core::GatewayError.new(Spree.t(:payment_method_not_supported))
-              end
-            end
-          else
-            raise Core::GatewayError.new(Spree.t(:payment_processing_failed))
-          end
+        if payment_method && payment_method.auto_capture?
+          purchase!
+        else
+          authorize!
         end
       end
 
       def authorize!
-        started_processing!
-        gateway_action(source, :authorize, :pend)
+        handle_payment_preconditions { process_authorization }
       end
 
       # Captures the entire amount of a payment.
       def purchase!
-        started_processing!
-        result = gateway_action(source, :purchase, :complete)
-        # This won't be called if gateway_action raises a GatewayError
-        capture_events.create!(amount: amount)
+        handle_payment_preconditions { process_purchase }
       end
 
       # Takes the amount in cents to capture.
@@ -80,56 +63,8 @@ module Spree
         end
       end
 
-      def credit!(credit_amount=nil)
-        raise Core::GatewayError.new(Spree.t(:payment_processing_failed)) if processing?
-
-        # Calculate credit amount before marking as processing since it messes up the order totals not having payment in completed state.
-        credit_amount ||= credit_allowed >= order.outstanding_balance.abs ? order.outstanding_balance.abs : credit_allowed.abs
-        credit_amount = credit_amount.to_f
-
-        # Mark as processing to avoid race condition that could send multiple credits to the gateway.
-        started_processing!
-        protect_from_connection_error do
-          check_environment
-
-          credit_cents = Spree::Money.new(credit_amount, currency: currency).money.cents
-
-          if payment_method.payment_profiles_supported?
-            response = payment_method.credit(credit_cents, source, response_code, gateway_options)
-          else
-            response = payment_method.credit(credit_cents, response_code, gateway_options)
-          end
-
-          record_response(response)
-          # Always set back to 'completed' as initial payment record was successful.
-          self.update_column(:state, 'completed')
-
-          if response.success?
-            self.class.create!(
-              :order => order,
-              :source => self,
-              :payment_method => payment_method,
-              :amount => credit_amount.abs * -1,
-              :response_code => response.authorization,
-              :state => 'completed'
-            )
-          else
-            gateway_error(response)
-          end
-        end
-      end
-
       def cancel!
-        if payment_method.respond_to?(:cancel)
-          payment_method.cancel(response_code)
-        else
-          credit!(credit_allowed.abs)
-        end
-      end
-
-      def partial_credit(amount)
-        return if amount > credit_allowed
-        credit!(amount)
+        payment_method.cancel(response_code)
       end
 
       def gateway_options
@@ -158,6 +93,39 @@ module Spree
 
       private
 
+      def process_authorization
+        started_processing!
+        gateway_action(source, :authorize, :pend)
+      end
+
+      def process_purchase
+        started_processing!
+        result = gateway_action(source, :purchase, :complete)
+        # This won't be called if gateway_action raises a GatewayError
+        capture_events.create!(amount: amount)
+      end
+
+      def handle_payment_preconditions(&block)
+        unless block_given?
+          raise ArgumentError.new("handle_payment_preconditions must be called with a block")
+        end
+
+        if payment_method && payment_method.source_required?
+          if source
+            if !processing?
+              if payment_method.supports?(source) || token_based?
+                yield
+              else
+                invalidate!
+                raise Core::GatewayError.new(Spree.t(:payment_method_not_supported))
+              end
+            end
+          else
+            raise Core::GatewayError.new(Spree.t(:payment_processing_failed))
+          end
+        end
+      end
+
       def gateway_action(source, action, success_state)
         protect_from_connection_error do
           check_environment

data/app/models/spree/payment_method.rb

@@ -8,7 +8,7 @@ module Spree
 
     validates :name, presence: true
 
-    has_many :payments, class_name: "Spree::Payment", inverse_of: :payment_method
+    has_many :payments, class_name: "Spree::Payment"
     has_many :credit_cards, class_name: "Spree::CreditCard"
 
     def self.providers

data/app/models/spree/payment_method/check.rb

@@ -18,8 +18,6 @@ module Spree
       ActiveMerchant::Billing::Response.new(true, "", {}, {})
     end
 
-    def cancel(response); end
-
     def void(*args)
       ActiveMerchant::Billing::Response.new(true, "", {}, {})
     end

data/app/models/spree/preference.rb

@@ -1,5 +1,5 @@
 class Spree::Preference < Spree::Base
   serialize :value
 
-  validates :key, presence: true
+  validates :key, presence: true, uniqueness: true
 end

data/app/models/spree/preferences/preferable.rb

@@ -106,6 +106,26 @@ module Spree::Preferences::Preferable
       else
          true
       end
+    when :array
+      value.is_a?(Array) ? value : Array.wrap(value)
+    when :hash
+      case value.class.to_s
+      when "Hash"
+        value
+      when "String"
+        # only works with hashes whose keys are strings
+        JSON.parse value.gsub('=>', ':')
+      when "Array"
+        begin
+          value.try(:to_h)
+        rescue TypeError
+          Hash[*value]
+        rescue ArgumentError
+          raise 'An even count is required when passing an array to be converted to a hash'
+        end
+      else
+        value.class.ancestors.include?(Hash) ? value : {}
+      end
     else
       value
     end

data/app/models/spree/price.rb

@@ -12,8 +12,6 @@ module Spree
     end
     alias :display_price :display_amount
 
-    self.whitelisted_ransackable_attributes = ['amount']
-
     def money
       Spree::Money.new(amount || 0, { currency: currency })
     end
@@ -23,7 +21,7 @@ module Spree
     end
 
     def price=(price)
-      self[:amount] = Spree::LocalizedNumber.parse(price)
+      self[:amount] = parse_price(price)
     end
 
     # Remove variant default_scope `deleted_at: nil`
@@ -41,6 +39,18 @@ module Spree
       end
     end
 
+    # strips all non-price-like characters from the price, taking into account locale settings
+    def parse_price(price)
+      return price unless price.is_a?(String)
+
+      separator, delimiter = I18n.t([:'number.currency.format.separator', :'number.currency.format.delimiter'])
+      non_price_characters = /[^0-9\-#{separator}]/
+      price.gsub!(non_price_characters, '') # strip everything else first
+      price.gsub!(separator, '.') unless separator == '.' # then replace the locale-specific decimal separator with the standard separator if necessary
+
+      price.to_d
+    end
+
     def maximum_amount
       BigDecimal '999999.99'
     end

data/app/models/spree/product.rb

@@ -21,7 +21,7 @@
 module Spree
   class Product < Spree::Base
     extend FriendlyId
-    friendly_id :slug_candidates, use: :slugged
+    friendly_id :slug_candidates, use: :history
 
     acts_as_paranoid
 
@@ -40,7 +40,8 @@ module Spree
     has_one :master,
       -> { where is_master: true },
       inverse_of: :product,
-      class_name: 'Spree::Variant'
+      class_name: 'Spree::Variant',
+      dependent: :destroy
 
     has_many :variants,
       -> { where(is_master: false).order("#{::Spree::Variant.quoted_table_name}.position ASC") },
@@ -56,7 +57,7 @@ module Spree
     has_many :prices, -> { order('spree_variants.position, spree_variants.id, currency') }, through: :variants
 
     has_many :stock_items, through: :variants_including_master
-
+    
     has_many :line_items, through: :variants_including_master
     has_many :orders, through: :line_items
 
@@ -64,32 +65,29 @@ module Spree
 
     delegate_belongs_to :master, :cost_price
 
-    delegate :images, to: :master, prefix: true
-    alias_method :images, :master_images
-
-    has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
-
     after_create :set_master_variant_defaults
     after_create :add_properties_and_option_types_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
-    after_destroy :punch_slug
-
-    after_initialize :ensure_master
-
     after_save :save_master
     after_save :run_touch_callbacks, if: :anything_changed?
     after_save :reset_nested_changes
     after_touch :touch_taxons
 
-    before_validation :normalize_slug, on: :update
-    before_validation :validate_master
+    delegate :images, to: :master, prefix: true
+    alias_method :images, :master_images
+
+    has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
 
-    validates :meta_keywords, length: { maximum: 255 }
     validates :name, presence: true
     validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
     validates :shipping_category_id, presence: true
-    validates :slug, length: { minimum: 3 }, uniqueness: { allow_blank: true }
+    validates :slug, length: { minimum: 3 }
+    validates :slug, uniqueness: true
+
+    before_validation :normalize_slug, on: :update
+
+    after_destroy :punch_slug
 
     attr_accessor :option_values_hash
 
@@ -97,8 +95,7 @@ module Spree
 
     alias :options :product_option_types
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[slug]
+    after_initialize :ensure_master
 
     # the master variant is not a member of the variants array
     def has_variants?
@@ -279,21 +276,19 @@ module Spree
     # when saving so we force a save using a hook
     # Fix for issue #5306
     def save_master
-      if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed? || master.default_price.new_record?)))
-        master.save!
-        @nested_changes = true
-      end
-    end
+      begin
+        if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed? || master.default_price.new_record?)))
+          master.save!
+          @nested_changes = true
+        end
 
-    # If the master cannot be saved, the Product object will get its errors
-    # and will be destroyed
-    def validate_master
-      # We call master.default_price here to ensure price is initialized.
-      # Required to avoid Variant#check_price validation failing on create.
-      unless master.default_price && master.valid?
+      # If the master cannot be saved, the Product object will get its errors
+      # and will be destroyed
+      rescue ActiveRecord::RecordInvalid
         master.errors.each do |att, error|
           self.errors.add(att, error)
         end
+        raise
       end
     end
 

data/app/models/spree/product_property.rb

@@ -9,8 +9,6 @@ module Spree
 
     default_scope -> { order("#{self.table_name}.position") }
 
-    self.whitelisted_ransackable_attributes = ['value']
-
     # virtual attributes for use with AJAX completion stuff
     def property_name
       property.name if property

data/app/models/spree/promotion.rb

@@ -3,6 +3,10 @@ module Spree
     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
     alias_method :rules, :promotion_rules
 
@@ -16,23 +20,24 @@ module Spree
     validates_associated :rules
 
     validates :name, presence: true
-    validates :path, uniqueness: { allow_blank: true }
+    validates :path, uniqueness: true, allow_blank: true
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }
 
     before_save :normalize_blank_values
 
     scope :coupons, ->{ where("#{table_name}.code IS NOT NULL") }
-    scope :applied, -> { joins(:orders).uniq }
 
-    self.whitelisted_ransackable_attributes = ['code', 'path', 'promotion_category_id']
+    order_join_table = reflect_on_association(:orders).join_table
+
+    scope :applied, -> { joins("INNER JOIN #{order_join_table} ON #{order_join_table}.promotion_id = #{table_name}.id").uniq }
 
     def self.advertised
       where(advertise: true)
     end
 
     def self.with_coupon_code(coupon_code)
-      where("lower(#{self.table_name}.code) = ?", coupon_code.strip.downcase).first
+      where("lower(code) = ?", coupon_code.strip.downcase).first
     end
 
     def self.active
@@ -52,6 +57,8 @@ module Spree
       order = payload[:order]
       return unless self.class.order_activatable?(order)
 
+      payload[:promotion] = self
+
       # 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.
@@ -73,36 +80,39 @@ module Spree
 
     # called anytime order.update! happens
     def eligible?(promotable)
-      return false if expired? || usage_limit_exceeded?(promotable)
-      rules_are_eligible?(promotable, {})
+      return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
+      !!eligible_rules(promotable, {})
     end
 
-    def rules_are_eligible?(promotable, options = {})
+    # 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 true if rules.none?
+      return [] if rules.none?
       eligible = lambda { |r| r.eligible?(promotable, options) }
       specific_rules = rules.for(promotable)
-      return true if specific_rules.none?
-      if match_policy == 'all'
+      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.
-        specific_rules.any? && specific_rules.all?(&eligible)
+        unless specific_rules.all?(&eligible)
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules
       else
-        # If there are no rules for this promotable, then this will return false.
-        # If there are rules for this promotable, but they are ineligible, this will return false.
-        specific_rules.any?(&eligible)
+        unless specific_rules.any?(&eligible)
+          @eligibility_errors = specific_rules.map(&:eligibility_errors).detect(&:present?)
+          return nil
+        end
+        specific_rules.select(&eligible)
       end
     end
 
-    # Products assigned to all product rules
     def products
-      @products ||= self.rules.to_a.inject([]) do |products, rule|
-        rule.respond_to?(:products) ? products << rule.products : products
-      end.flatten.uniq
-    end
-
-    def product_ids
-      products.map(&:id)
+      rules.where(type: "Spree::Promotion::Rules::Product").map(&:products).flatten.uniq
     end
 
     def usage_limit_exceeded?(promotable)
@@ -110,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
@@ -122,11 +131,44 @@ module Spree
       credits.count
     end
 
+    def line_item_actionable?(order, line_item)
+      if eligible? order
+        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 = [])
+      orders.where.not(id: excluded_orders.map(&:id)).complete.where(user_id: user.id).exists?
+    end
+
     private
+    def blacklisted?(promotable)
+      case promotable
+      when Spree::LineItem
+        !promotable.product.promotionable?
+      when Spree::Order
+        promotable.line_items.any? &&
+          !promotable.line_items.joins(:product).where(spree_products: {promotionable: true}).any?
+      end
+    end
+
     def normalize_blank_values
       [:code, :path].each do |column|
         self[column] = nil if self[column].blank?
       end
     end
+
+    def match_all?
+      match_policy == 'all'
+    end
   end
 end