spree_core 2.1.12 → 2.2.0

data/app/models/spree/payment.rb

@@ -4,16 +4,19 @@ module Spree
 
     IDENTIFIER_CHARS = (('A'..'Z').to_a + ('0'..'9').to_a - %w(0 1 I O)).freeze
 
-    belongs_to :order, class_name: 'Spree::Order', touch: true
+    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments
     belongs_to :source, polymorphic: true
     belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
 
     has_many :offsets, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") },
       class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
+    has_many :state_changes, as: :stateful
+    has_many :capture_events, :class_name => 'Spree::PaymentCaptureEvent'
 
     before_validation :validate_source
     before_create :set_unique_identifier
+    before_save :update_uncaptured_amount
 
     after_save :create_payment_profile, if: :profiles_supported?
 
@@ -67,6 +70,14 @@ module Spree
       event :invalidate do
         transition from: [:checkout], to: :invalid
       end
+
+      after_transition do |payment, transition|
+        payment.state_changes.create!(
+          previous_state: transition.from,
+          next_state:     transition.to,
+          name:           'payment',
+        )
+      end
     end
 
     def currency
@@ -83,7 +94,7 @@ module Spree
         case amount
         when String
           separator = I18n.t('number.currency.format.separator')
-          number    = amount.delete("^0-9-#{separator}\.").tr(separator, '.')
+          number    = amount.delete("^0-9-#{separator}").tr(separator, '.')
           number.to_d if number.present?
         end || amount
     end
@@ -93,7 +104,7 @@ module Spree
     end
 
     def credit_allowed
-      amount - offsets_total.abs
+      amount - offsets_total
     end
 
     def can_credit?
@@ -102,8 +113,8 @@ module Spree
 
     # see https://github.com/spree/spree/issues/981
     def build_source
-      return unless new_record?
-      if source_attributes.present? && source.blank? && payment_method.try(:payment_source_class)
+      return if source_attributes.nil?
+      if payment_method and payment_method.payment_source_class
         self.source = payment_method.payment_source_class.new(source_attributes)
       end
     end
@@ -179,5 +190,9 @@ module Spree
       def generate_identifier
         Array.new(8){ IDENTIFIER_CHARS.sample }.join
       end
+
+      def update_uncaptured_amount
+        self.uncaptured_amount = amount - capture_events.sum(:amount)
+      end
   end
 end

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

@@ -27,28 +27,31 @@ module Spree
         gateway_action(source, :authorize, :pend)
       end
 
+      # Captures the entire amount of a payment.
       def purchase!
         started_processing!
-        gateway_action(source, :purchase, :complete)
+        result = gateway_action(source, :purchase, :complete)
+        # This won't be called if gateway_action raises a GatewayError
+        capture_events.create!(amount: amount)
       end
 
-      def capture!
+      # Takes the amount in cents to capture.
+      # Can be used to capture partial amounts of a payment.
+      def capture!(amount=nil)
+        amount ||= money.money.cents
         return true if completed?
         started_processing!
         protect_from_connection_error do
           check_environment
-
-          if payment_method.payment_profiles_supported?
-            # Gateways supporting payment profiles will need access to credit card object because this stores the payment profile information
-            # so supply the authorization itself as well as the credit card, rather than just the authorization code
-            response = payment_method.capture(self, source, gateway_options)
-          else
-            # Standard ActiveMerchant capture usage
-            response = payment_method.capture(money.money.cents,
-                                              response_code,
-                                              gateway_options)
-          end
-
+          # Standard ActiveMerchant capture usage
+          response = payment_method.capture(
+            amount,
+            response_code,
+            gateway_options
+          )
+
+          money = ::Money.new(amount, Spree::Config[:currency])
+          capture_events.create!(amount: money.to_f)
           handle_response(response, :complete, :failure)
         end
       end
@@ -108,14 +111,6 @@ module Spree
         end
       end
 
-      def cancel!
-        if payment_method.respond_to?(:cancel)
-          payment_method.cancel(response_code)
-        else
-          credit!
-        end
-      end
-
       def partial_credit(amount)
         return if amount > credit_allowed
         started_processing!
@@ -123,7 +118,6 @@ module Spree
       end
 
       def gateway_options
-        order.reload
         options = { :email       => order.email,
                     :customer    => order.email,
                     :customer_id => order.user_id,
@@ -135,9 +129,9 @@ module Spree
                     :order_id    => gateway_order_id }
 
         options.merge!({ :shipping => order.ship_total * 100,
-                         :tax      => order.tax_total * 100,
+                         :tax      => order.additional_tax_total * 100,
                          :subtotal => order.item_total * 100,
-                         :discount => order.discount_total * 100,
+                         :discount => order.promo_total * 100,
                          :currency => currency })
 
         options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),

data/app/models/spree/payment_capture_event.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PaymentCaptureEvent < ActiveRecord::Base
+    belongs_to :payment, class_name: 'Spree::Payment'
+
+    def display_amount
+      Spree::Money.new(amount, { currency: payment.currency })
+    end
+  end
+end

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/price.rb

@@ -1,7 +1,7 @@
 module Spree
   class Price < ActiveRecord::Base
     acts_as_paranoid
-    belongs_to :variant, class_name: 'Spree::Variant'
+    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices
 
     validate :check_price
     validates :amount, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true

data/app/models/spree/product.rb

@@ -20,18 +20,21 @@
 
 module Spree
   class Product < ActiveRecord::Base
+    extend FriendlyId
+    friendly_id :name, use: :slugged
+
     acts_as_paranoid
-    has_many :product_option_types, dependent: :destroy
+    has_many :product_option_types, dependent: :destroy, inverse_of: :product
     has_many :option_types, through: :product_option_types
-    has_many :product_properties, dependent: :destroy
+    has_many :product_properties, dependent: :destroy, inverse_of: :product
     has_many :properties, through: :product_properties
 
-    has_many :classifications, dependent: :delete_all
+    has_many :classifications, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications
     has_and_belongs_to_many :promotion_rules, join_table: :spree_products_promotion_rules
 
     belongs_to :tax_category, class_name: 'Spree::TaxCategory'
-    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory'
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
 
     has_one :master,
       -> { where is_master: true },
@@ -62,6 +65,8 @@ module Spree
     after_create :add_properties_and_option_types_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
     after_save :save_master
+    after_save :touch
+    after_touch :touch_taxons
 
     delegate :images, to: :master, prefix: true
     alias_method :images, :master_images
@@ -69,24 +74,20 @@ module Spree
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
 
     validates :name, presence: true
-    validates :permalink, presence: true
     validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
     validates :shipping_category_id, presence: true
+    validates :slug, length: { minimum: 3 }
 
     attr_accessor :option_values_hash
 
     accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp| pp[:property_name].blank? }
 
-    make_permalink order: :name
-
     alias :options :product_option_types
 
     after_initialize :ensure_master
 
-    before_destroy :punch_permalink
-
     def to_param
-      permalink.present? ? permalink : (permalink_was || name.to_s.to_url)
+      slug
     end
 
     # the master variant is not a member of the variants array
@@ -131,11 +132,8 @@ module Spree
       !!deleted_at
     end
 
-    # determine if product is available.
-    # deleted products and products with nil or future available_on date
-    # are not available
     def available?
-      !(available_on.nil? || available_on.future?) && !deleted?
+      !(available_on.nil? || available_on.future?)
     end
 
     # split variants list into hash which shows mapping of opt value onto matching variants
@@ -251,8 +249,8 @@ module Spree
         self.master ||= Variant.new
       end
 
-      def punch_permalink
-        update_attribute :permalink, "#{Time.now.to_i}_#{permalink}" # punch permalink with date prefix
+      def touch_taxons
+        self.taxons.each(&:touch)
       end
   end
 end

data/app/models/spree/product/scopes.rb

@@ -67,11 +67,9 @@ module Spree
     #
     #   SELECT COUNT(*) ...
     add_search_scope :in_taxon do |taxon|
-      select("spree_products.id, spree_products.*").
-      where(id: Classification.select('spree_products_taxons.product_id').
-            joins(:taxon).
-            where(Taxon.table_name => { :id => taxon.self_and_descendants.pluck(:id) })
-           )
+      includes(:classifications).
+      where("spree_products_taxons.taxon_id" => taxon.self_and_descendants.pluck(:id)).
+      order("spree_products_taxons.position ASC")
     end
 
     # This scope selects products in all taxons AND all its descendants
@@ -216,7 +214,7 @@ module Spree
           distinct_fields = ["id", sort_column].compact.join(",")
           select("DISTINCT ON(#{distinct_fields}) spree_products.*")
         else
-          scoped
+          all
         end
       else
         select("DISTINCT spree_products.*")

data/app/models/spree/product_option_type.rb

@@ -1,7 +1,7 @@
 module Spree
   class ProductOptionType < ActiveRecord::Base
-    belongs_to :product, class_name: 'Spree::Product'
-    belongs_to :option_type, class_name: 'Spree::OptionType'
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types
+    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
     acts_as_list scope: :product
   end
 end

data/app/models/spree/product_property.rb

@@ -1,7 +1,7 @@
 module Spree
   class ProductProperty < ActiveRecord::Base
-    belongs_to :product, touch: true, class_name: 'Spree::Product'
-    belongs_to :property, class_name: 'Spree::Property'
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
+    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
 
     validates :property, presence: true
     validates :value, length: { maximum: 255 }

data/app/models/spree/promotion.rb

@@ -1,75 +1,94 @@
 module Spree
-  class Promotion < Spree::Activator
+  class Promotion < ActiveRecord::Base
     MATCH_POLICIES = %w(all any)
     UNACTIVATABLE_ORDER_STATES = ["complete", "awaiting_return", "returned"]
 
-    Activator.event_names << 'spree.checkout.coupon_code_added'
-    Activator.event_names << 'spree.content.visited'
-
-    has_many :promotion_rules, foreign_key: :activator_id, autosave: true, dependent: :destroy
+    has_many :promotion_rules, autosave: true, dependent: :destroy
     alias_method :rules, :promotion_rules
 
-    has_many :promotion_actions, foreign_key: :activator_id, autosave: true, dependent: :destroy
+    has_many :promotion_actions, autosave: true, dependent: :destroy
     alias_method :actions, :promotion_actions
 
+    has_and_belongs_to_many :orders, join_table: 'spree_orders_promotions'
+
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
     validates_associated :rules
 
     validates :name, presence: true
-    validates :code, presence: true, if: lambda{|r| r.event_name == 'spree.checkout.coupon_code_added' }
-    validates :path, presence: true, if: lambda{|r| r.event_name == 'spree.content.visited' }
+    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
 
     def self.advertised
       where(advertise: true)
     end
 
-    def self.with_code
-      where(event_name: 'spree.checkout.coupon_code_added')
+    def self.with_coupon_code(coupon_code)
+      where("lower(code) = ?", coupon_code.strip.downcase).first
+    end
+
+    def self.active
+      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)
+      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
+    end
+
+    def expired?
+      starts_at && Time.now < starts_at || expires_at && Time.now > expires_at
     end
 
     def activate(payload)
-      if order_activatable?(payload[:order]) && eligible?(payload[:order])
-        # make sure code is always downcased (old databases might have mixed case codes)
-        if code.present?
-          event_code = payload[:coupon_code]
-          return unless event_code == self.code.downcase.strip
-        end
-
-        if path.present?
-          return unless path == payload[:path]
-        end
-
-        actions.each do |action|
-          action.perform(payload)
-        end
-
-        return true
+      order = payload[:order]
+      return unless self.class.order_activatable?(order)
+
+      # 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
-      false
+      # 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
+      # create the join_table entry.
+        self.orders << order
+        self.save
+      end
+
+      return action_taken
     end
 
     # called anytime order.update! happens
-    def eligible?(order)
-      return false if expired? || usage_limit_exceeded?(order)
-      rules_are_eligible?(order, {})
+    def eligible?(promotable)
+      return false if expired? || usage_limit_exceeded?(promotable)
+      rules_are_eligible?(promotable, {})
     end
 
-    def rules_are_eligible?(order, options = {})
+    def rules_are_eligible?(promotable, options = {})
+      # Promotions without rules are eligible by default.
       return true if rules.none?
-      eligible = lambda { |r| r.eligible?(order, options) }
+      eligible = lambda { |r| r.eligible?(promotable, options) }
+      specific_rules = rules.for(promotable)
+      return true if specific_rules.none?
       if match_policy == 'all'
-        rules.all?(&eligible)
+        # 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)
       else
-        rules.any?(&eligible)
+        # 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)
       end
     end
 
-    def order_activatable?(order)
-      order && !UNACTIVATABLE_ORDER_STATES.include?(order.state)
-    end
-
     # Products assigned to all product rules
     def products
       @products ||= self.rules.to_a.inject([]) do |products, rule|
@@ -77,29 +96,31 @@ module Spree
       end.flatten.uniq
     end
 
-    def usage_limit_exceeded?(order = nil)
-      usage_limit.present? && usage_limit > 0 && adjusted_credits_count(order) >= usage_limit
+    def product_ids
+      products.map(&:id)
     end
 
-    def adjusted_credits_count(order)
-      return credits_count if order.nil?
-      credits_count - (exists_on_order?(order) ? 1 : 0)
+    def usage_limit_exceeded?(promotable)
+      usage_limit.present? && usage_limit > 0 && adjusted_credits_count(promotable) >= usage_limit
+    end
+
+    def adjusted_credits_count(promotable)
+      credits_count - promotable.adjustments.promotion.where(:source_id => actions.pluck(:id)).count
     end
 
     def credits
-      Adjustment.eligible.promotion.where(originator_id: actions.map(&:id))
+      Adjustment.eligible.promotion.where(source_id: actions.map(&:id))
     end
 
     def credits_count
       credits.count
     end
 
-    def code=(coupon_code)
-      write_attribute(:code, (coupon_code.downcase.strip rescue nil))
-    end
-    
-    def exists_on_order?(order)
-      actions.any? { |a| a.credit_exists_on_order?(order) }
+    private
+    def normalize_blank_values
+      [:code, :path].each do |column|
+        self[column] = nil if self[column].blank?
+      end
     end
   end
 end