spree_core 3.0.9 → 3.2.0

data/app/models/spree/payment.rb

@@ -1,24 +1,21 @@
 module Spree
   class Payment < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'P', letters: true, length: 7)
+
     extend FriendlyId
     friendly_id :number, slug_column: :number, use: :slugged
 
     include Spree::Payment::Processing
-    include Spree::NumberGenerator
-
-    def generate_number(options = {})
-      options[:prefix] ||= 'P'
-      options[:letters] ||= true
-      options[:length] ||= 7
-      super(options)
-    end
 
     NON_RISKY_AVS_CODES = ['B', 'D', 'H', 'J', 'M', 'Q', 'T', 'V', 'X', 'Y'].freeze
     RISKY_AVS_CODES     = ['A', 'C', 'E', 'F', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'R', 'S', 'U', 'W', 'Z'].freeze
+    INVALID_STATES      = %w(failed invalid).freeze
 
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments
+    with_options inverse_of: :payments do
+      belongs_to :order, class_name: 'Spree::Order', touch: true
+      belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
+    end
     belongs_to :source, polymorphic: true
-    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', inverse_of: :payments
 
     has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
@@ -26,24 +23,26 @@ module Spree
     has_many :capture_events, class_name: 'Spree::PaymentCaptureEvent'
     has_many :refunds, inverse_of: :payment
 
-    validates_presence_of :payment_method
+    validates :payment_method, presence: true
     before_validation :validate_source
 
     after_save :create_payment_profile, if: :profiles_supported?
 
     # update the order totals, etc.
-    after_save :update_order
+    set_callback :save, :after, :update_order, unless: -> { capture_on_dispatch }
 
     # invalidate previously entered payments
     after_create :invalidate_old_payments
+    after_create :create_eligible_credit_event
 
-    attr_accessor :source_attributes, :request_env
+    attr_accessor :source_attributes, :request_env, :capture_on_dispatch
 
     after_initialize :build_source
 
     validates :amount, numericality: true
 
-    default_scope { order("#{self.table_name}.created_at") }
+    delegate :store_credit?, to: :payment_method, allow_nil: true
+    default_scope { order(:created_at) }
 
     scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
     scope :with_state, ->(s) { where(state: s.to_s) }
@@ -57,13 +56,18 @@ module Spree
     scope :failed, -> { with_state('failed') }
 
     scope :risky, -> { where("avs_response IN (?) OR (cvv_response_code IS NOT NULL and cvv_response_code != 'M') OR state = 'failed'", RISKY_AVS_CODES) }
-    scope :valid, -> { where.not(state: %w(failed invalid)) }
+    scope :valid, -> { where.not(state: INVALID_STATES) }
+
+    scope :store_credits, -> { where(source_type: Spree::StoreCredit.to_s) }
+    scope :not_store_credits, -> { where(arel_table[:source_type].not_eq(Spree::StoreCredit.to_s).or(arel_table[:source_type].eq(nil))) }
 
     # transaction_id is much easier to understand
     def transaction_id
       response_code
     end
 
+    delegate :currency, to: :order
+
     # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine initial: :checkout do
       # With card payments, happens before purchase or authorization happens
@@ -103,10 +107,6 @@ module Spree
       end
     end
 
-    def currency
-      order.currency
-    end
-
     def money
       Spree::Money.new(amount, { currency: currency })
     end
@@ -180,6 +180,10 @@ module Spree
 
     private
 
+    def has_invalid_state?
+      INVALID_STATES.include?(state)
+    end
+
       def validate_source
         if source && !source.valid?
           source.errors.each do |field, error|
@@ -196,7 +200,7 @@ module Spree
 
       def create_payment_profile
         # Don't attempt to create on bad payments.
-        return if %w(invalid failed).include?(state)
+        return if has_invalid_state?
         # Payment profile cannot be created without source
         return unless source
         # Imported payments shouldn't create a payment profile.
@@ -208,7 +212,7 @@ module Spree
       end
 
       def invalidate_old_payments
-        if state != 'invalid' and state != 'failed'
+        unless has_invalid_state?
           order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
             payment.invalidate!
           end
@@ -217,14 +221,13 @@ module Spree
 
       def split_uncaptured_amount
         if uncaptured_amount > 0
-          order.payments.create! amount: uncaptured_amount,
-                                 avs_response: avs_response,
-                                 cvv_response_code: cvv_response_code,
-                                 cvv_response_message: cvv_response_message,
-                                 payment_method: payment_method,
-                                 response_code: response_code,
-                                 source: source,
-                                 state: 'pending'
+          order.payments.create!(
+            amount: uncaptured_amount,
+            payment_method: payment_method,
+            source: source,
+            state: 'pending',
+            capture_on_dispatch: true
+          ).authorize!
           update_attributes(amount: captured_amount)
         end
       end
@@ -245,5 +248,28 @@ module Spree
         end
       end
 
+      def create_eligible_credit_event
+        # When cancelling an order, a payment with the negative amount
+        # of the payment total is created to refund the customer. That
+        # payment has a source of itself (Spree::Payment) no matter the
+        # type of payment getting refunded, hence the additional check
+        # if the source is a store credit.
+        return unless store_credit? && source.is_a?(Spree::StoreCredit)
+
+        # creates the store credit event
+        source.update_attributes!({
+          action: Spree::StoreCredit::ELIGIBLE_ACTION,
+          action_amount: amount,
+          action_authorization_code: response_code,
+        })
+      end
+
+      def invalidate_old_payments
+        return if store_credit? # store credits shouldn't invalidate other payment types
+        order.payments.with_state('checkout').where("id != ?", self.id).each do |payment|
+          payment.invalidate! unless payment.store_credit?
+        end
+      end
+
   end
 end

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

@@ -0,0 +1,130 @@
+module Spree
+  class PaymentMethod::StoreCredit < PaymentMethod
+    def payment_source_class
+      ::Spree::StoreCredit
+    end
+
+    def can_capture?(payment)
+      ['checkout', 'pending'].include?(payment.state)
+    end
+
+    def can_void?(payment)
+      payment.pending?
+    end
+
+    def authorize(amount_in_cents, store_credit, gateway_options = {})
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        action = -> (store_credit) do
+          store_credit.authorize(
+            amount_in_cents / 100.0.to_d,
+            gateway_options[:currency],
+            action_originator: gateway_options[:originator]
+          )
+        end
+        handle_action_call(store_credit, action, :authorize)
+      end
+    end
+
+    def capture(amount_in_cents, auth_code, gateway_options = {})
+      action = -> (store_credit) do
+        store_credit.capture(
+          amount_in_cents / 100.0.to_d,
+          auth_code,
+          gateway_options[:currency],
+          action_originator: gateway_options[:originator]
+        )
+      end
+      handle_action(action, :capture, auth_code)
+    end
+
+    def purchase(amount_in_cents, store_credit, gateway_options = {})
+      eligible_events = store_credit.store_credit_events.where(
+        amount: amount_in_cents / 100.0.to_d,
+        action: Spree::StoreCredit::ELIGIBLE_ACTION
+      )
+      event = eligible_events.detect do |eligible_event|
+        store_credit.store_credit_events.where(authorization_code: eligible_event.authorization_code).
+          where.not(action: Spree::StoreCredit::ELIGIBLE_ACTION).empty?
+      end
+
+      if event.blank?
+        ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        capture(amount_in_cents, event.authorization_code, gateway_options)
+      end
+    end
+
+    def void(auth_code, gateway_options = {})
+      action = -> (store_credit) do
+        store_credit.void(auth_code, action_originator: gateway_options[:originator])
+      end
+      handle_action(action, :void, auth_code)
+    end
+
+    def credit(amount_in_cents, auth_code, gateway_options)
+      action = -> (store_credit) do
+        currency = gateway_options[:currency] || store_credit.currency
+        originator = gateway_options[:originator]
+
+        store_credit.credit(amount_in_cents / 100.0.to_d, auth_code, currency, action_originator: originator)
+      end
+
+      handle_action(action, :credit, auth_code)
+    end
+
+    def cancel(auth_code)
+      store_credit_event = StoreCreditEvent.find_by(authorization_code: auth_code,
+                                                    action: Spree::StoreCredit::CAPTURE_ACTION)
+      store_credit = store_credit_event.try(:store_credit)
+
+      if !store_credit_event || !store_credit
+        handle_action(nil, :cancel, false)
+      else
+        action = -> (store_credit) do
+          store_credit.credit(store_credit_event.amount, auth_code, store_credit.currency)
+        end
+        handle_action(action, :cancel, auth_code)
+      end
+    end
+
+    def source_required?
+      true
+    end
+
+    private
+
+    def handle_action_call(store_credit, action, action_name, auth_code = nil)
+      store_credit.with_lock do
+        if response = action.call(store_credit)
+          # note that we only need to return the auth code on an 'auth', but it's innocuous to always return
+          ActiveMerchant::Billing::Response.new(
+            true,
+            Spree.t('store_credit_payment_method.successful_action', action: action_name),
+            {},
+            authorization: auth_code || response
+          )
+        else
+          ActiveMerchant::Billing::Response.new(false, store_credit.errors.full_messages.join, {}, {})
+        end
+      end
+    end
+
+    def handle_action(action, action_name, auth_code)
+      # Find first event with provided auth_code
+      store_credit = StoreCreditEvent.find_by_authorization_code(auth_code).try(:store_credit)
+
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(
+          false,
+          Spree.t('store_credit_payment_method.unable_to_find_for_action', auth_code: auth_code, action: action_name),
+          {},
+          {}
+        )
+      else
+        handle_action_call(store_credit, action, action_name, auth_code)
+      end
+    end
+  end
+end

data/app/models/spree/payment_method.rb

@@ -1,8 +1,14 @@
 module Spree
   class PaymentMethod < Spree::Base
     acts_as_paranoid
-    DISPLAY = [:both, :front_end, :back_end]
-    default_scope { where(deleted_at: nil) }
+    acts_as_list
+
+    DISPLAY = [:both, :front_end, :back_end].freeze
+
+    scope :active,                 -> { where(active: true).order(position: :asc) }
+    scope :available,              -> { active.where(display_on: [:front_end, :back_end, :both]) }
+    scope :available_on_front_end, -> { active.where(display_on: [:front_end, :both]) }
+    scope :available_on_back_end,  -> { active.where(display_on: [:back_end, :both]) }
 
     validates :name, presence: true
 
@@ -24,17 +30,6 @@ module Spree
       raise ::NotImplementedError, 'You must implement payment_source_class method for this gateway.'
     end
 
-    def self.available(display_on = 'both')
-      all.select do |p|
-        p.active &&
-        (p.display_on == display_on.to_s || p.display_on.blank?)
-      end
-    end
-
-    def self.active?
-      where(type: self.to_s, active: true).count > 0
-    end
-
     def method_type
       type.demodulize.downcase
     end
@@ -68,5 +63,15 @@ module Spree
     def cancel(response)
       raise ::NotImplementedError, 'You must implement cancel method for this payment method.'
     end
+
+    def store_credit?
+      self.class == Spree::PaymentMethod::StoreCredit
+    end
+
+    # Custom PaymentMethod/Gateway can redefine this method to check method
+    # availability for concrete order.
+    def available_for_order?(_order)
+      true
+    end
   end
 end

data/app/models/spree/preference.rb

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

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

@@ -24,7 +24,7 @@ module Spree::Preferences
 
     def exist?(key)
       @cache.exist?(key) ||
-      should_persist? && Spree::Preference.where(:key => key).exists?
+      should_persist? && Spree::Preference.where(key: key).exists?
     end
 
     def get(key)
@@ -73,7 +73,7 @@ module Spree::Preferences
     def persist(cache_key, value)
       return unless should_persist?
 
-      preference = Spree::Preference.where(:key => cache_key).first_or_initialize
+      preference = Spree::Preference.where(key: cache_key).first_or_initialize
       preference.value = value
       preference.save
     end

data/app/models/spree/price.rb

@@ -1,12 +1,15 @@
 module Spree
   class Price < Spree::Base
+    include VatPriceCalculation
+
     acts_as_paranoid
 
     MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
 
     belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
 
-    validate :check_price
+    before_validation :ensure_currency
+
     validates :amount, allow_nil: true, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
@@ -21,12 +24,19 @@ module Spree
       Spree::Money.new(amount || 0, { currency: currency })
     end
 
-    def price
-      amount
+    def amount=(amount)
+      self[:amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
+    alias_attribute :price, :amount
+
+    def price_including_vat_for(price_options)
+      options = price_options.merge(tax_category: variant.tax_category)
+      gross_amount(price, options)
     end
 
-    def price=(price)
-      self[:amount] = Spree::LocalizedNumber.parse(price)
+    def display_price_including_vat_for(price_options)
+      Spree::Money.new(price_including_vat_for(price_options), currency: currency)
     end
 
     # Remove variant default_scope `deleted_at: nil`
@@ -36,7 +46,7 @@ module Spree
 
     private
 
-    def check_price
+    def ensure_currency
       self.currency ||= Spree::Config[:currency]
     end
   end

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

@@ -39,34 +39,34 @@ module Spree
     add_simple_scopes simple_scopes
 
     add_search_scope :ascend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount ASC")
+      joins(master: :default_price).order("#{price_table_name}.amount ASC")
     end
 
     add_search_scope :descend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount DESC")
+      joins(master: :default_price).order("#{price_table_name}.amount DESC")
     end
 
     add_search_scope :price_between do |low, high|
-      joins(:master => :default_price).where(Price.table_name => { :amount => low..high })
+      joins(master: :default_price).where(Price.table_name => { amount: low..high })
     end
 
     add_search_scope :master_price_lte do |price|
-      joins(:master => :default_price).where("#{price_table_name}.amount <= ?", price)
+      joins(master: :default_price).where("#{price_table_name}.amount <= ?", price)
     end
 
     add_search_scope :master_price_gte do |price|
-      joins(:master => :default_price).where("#{price_table_name}.amount >= ?", price)
+      joins(master: :default_price).where("#{price_table_name}.amount >= ?", price)
     end
 
     # This scope selects products in taxon AND all its descendants
     # If you need products only within one taxon use
     #
-    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { :id => taxon.id })
+    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { id: taxon.id })
     #
     # If you're using count on the result of this scope, you must use the
     # `:distinct` option as well:
     #
-    #   Spree::Product.in_taxon(taxon).count(:distinct => true)
+    #   Spree::Product.in_taxon(taxon).count(distinct: true)
     #
     # This is so that the count query is distinct'd:
     #
@@ -162,8 +162,8 @@ module Spree
     # there is alternative faster and more elegant solution, it has small drawback though,
     # it doesn stack with other scopes :/
     #
-    # :joins => "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
-    # :order => 'COALESCE(cnt, 0) DESC'
+    # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
+    # order: 'COALESCE(cnt, 0) DESC'
     add_search_scope :descend_by_popularity do
       joins(:master).
       order(%Q{
@@ -186,14 +186,23 @@ module Spree
       where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.zone.now)
     end
 
+    def self.not_discontinued(only_not_discontinued = true)
+      if only_not_discontinued != '0' && only_not_discontinued
+        where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
+      else
+        all
+      end
+    end
+    search_scopes << :not_discontinued
     # Can't use add_search_scope for this as it needs a default argument
     def self.available(available_on = nil, currency = nil)
-      joins(:master => :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on || Time.now)
+      available_on ||= Time.current
+      not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on).distinct
     end
     search_scopes << :available
 
     def self.active(currency = nil)
-      not_deleted.available(nil, currency)
+      available(nil, currency)
     end
     search_scopes << :active
 
@@ -219,7 +228,7 @@ module Spree
       #
       # Don't allow sort_column, a variable coming from params,
       # to be anything but a column in the database
-      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
+      if ApplicationRecord.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
         all
       else
         distinct
@@ -251,7 +260,7 @@ module Spree
         ids_or_records_or_names.flatten.map { |t|
           case t
           when Integer then Taxon.find_by(id: t)
-          when ActiveRecord::Base then t
+          when ApplicationRecord then t
           when String
             Taxon.find_by(name: t) ||
             Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first