spree_core 3.0.10 → 3.1.0.rc1

data/app/models/spree/order/checkout.rb

@@ -74,6 +74,9 @@ module Spree
                 transition to: :awaiting_return
               end
 
+              before_transition to: :complete, do: :ensure_line_item_variants_are_not_discontinued
+              before_transition to: :complete, do: :ensure_line_items_are_in_stock
+
               if states[:payment]
                 before_transition to: :complete do |order|
                   if order.payment_required? && order.payments.valid.empty?
@@ -86,12 +89,12 @@ module Spree
                 after_transition to: :complete, do: :persist_user_credit_card
                 before_transition to: :payment, do: :set_shipments_cost
                 before_transition to: :payment, do: :create_tax_charge!
-                before_transition to: :payment, do: :assign_default_credit_card
               end
 
               before_transition from: :cart, do: :ensure_line_items_present
 
               if states[:address]
+                before_transition from: :address, do: :update_line_item_prices!
                 before_transition from: :address, do: :create_tax_charge!
                 before_transition to: :address, do: :assign_default_addresses!
                 before_transition from: :address, do: :persist_user_address!
@@ -104,12 +107,9 @@ module Spree
                 before_transition from: :delivery, do: :apply_free_shipping_promotions
               end
 
-              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_discontinued
               before_transition to: :resumed, do: :ensure_line_items_are_in_stock
 
-              before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
-              before_transition to: :complete, do: :ensure_line_items_are_in_stock
-
               after_transition to: :complete, do: :finalize!
               after_transition to: :resumed, do: :after_resume
               after_transition to: :canceled, do: :after_cancel
@@ -282,15 +282,12 @@ module Spree
 
           def persist_user_credit_card
             if !temporary_credit_card && user_id && valid_credit_cards.present?
-              default_cc = valid_credit_cards.first
-              default_cc.user_id = user_id
-              default_cc.default = true
-              default_cc.save
+              valid_credit_cards.first.update(user_id: user_id, default: true)
             end
           end
 
           def assign_default_credit_card
-            if payments.from_credit_card.count == 0 && user_has_valid_default_card? && payment_required?
+            if payments.from_credit_card.size == 0 && user_has_valid_default_card? && payment_required?
               cc = user.default_credit_card
               payments.create!(payment_method_id: cc.payment_method_id, source: cc, amount: total)
             end
@@ -329,7 +326,7 @@ module Spree
             if @updating_params[:order] && (@updating_params[:order][:payments_attributes] ||
                                             @updating_params[:order][:existing_card])
               @updating_params[:order][:payments_attributes] ||= [{}]
-              @updating_params[:order][:payments_attributes].first[:amount] = total
+              @updating_params[:order][:payments_attributes].first[:amount] = order_total_after_store_credit
             end
           end
         end

data/app/models/spree/order/currency_updater.rb

@@ -7,7 +7,7 @@ module Spree
 
         def homogenize_line_item_currencies
           update_line_item_currencies!
-          update!
+          update_with_updater!
         end
 
       end

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

@@ -0,0 +1,96 @@
+module Spree
+  class Order < Spree::Base
+    module StoreCredit
+      def add_store_credit_payments
+        payments.store_credits.where(state: 'checkout').map(&:invalidate!)
+
+        remaining_total = outstanding_balance
+
+        if user && user.store_credits.any?
+          payment_method = Spree::PaymentMethod::StoreCredit.available.first
+          raise "Store credit payment method could not be found" unless payment_method
+
+          user.store_credits.order_by_priority.each do |credit|
+            break if remaining_total.zero?
+            next if credit.amount_remaining.zero?
+
+            amount_to_take = store_credit_amount(credit, remaining_total)
+            create_store_credit_payment(payment_method, credit, amount_to_take)
+            remaining_total -= amount_to_take
+          end
+        end
+      end
+
+      def covered_by_store_credit?
+        return false unless user
+        user.total_available_store_credit >= total
+      end
+      alias_method :covered_by_store_credit, :covered_by_store_credit?
+
+      def total_available_store_credit
+        return 0.0 unless user
+        user.total_available_store_credit
+      end
+
+      def could_use_store_credit?
+        total_available_store_credit > 0
+      end
+
+      def order_total_after_store_credit
+        total - total_applicable_store_credit
+      end
+
+      def total_applicable_store_credit
+        if payment? || confirm? || complete?
+          total_applied_store_credit
+        else
+          [total, (user.try(:total_available_store_credit) || 0.0)].min
+        end
+      end
+
+      def total_applied_store_credit
+        payments.store_credits.valid.sum(:amount)
+      end
+
+      def using_store_credit?
+        total_applied_store_credit > 0
+      end
+
+      def display_total_applicable_store_credit
+        Spree::Money.new(-total_applicable_store_credit, currency: currency)
+      end
+
+      def display_total_applied_store_credit
+        Spree::Money.new(-total_applied_store_credit, currency: currency)
+      end
+
+      def display_order_total_after_store_credit
+        Spree::Money.new(order_total_after_store_credit, currency: currency)
+      end
+
+      def display_total_available_store_credit
+        Spree::Money.new(total_available_store_credit, currency: currency)
+      end
+
+      def display_store_credit_remaining_after_capture
+        Spree::Money.new(total_available_store_credit - total_applicable_store_credit, currency: currency)
+      end
+
+      private
+
+      def create_store_credit_payment(payment_method, credit, amount)
+        payments.create!(
+          source: credit,
+          payment_method: payment_method,
+          amount: amount,
+          state: 'checkout',
+          response_code: credit.generate_authorization_code
+        )
+      end
+
+      def store_credit_amount(credit, total)
+        [credit.amount_remaining, total].min
+      end
+    end
+  end
+end

data/app/models/spree/order_contents.rb

@@ -7,7 +7,7 @@ module Spree
     end
 
     def add(variant, quantity = 1, options = {})
-      timestamp = Time.now
+      timestamp = Time.current
       line_item = add_to_line_item(variant, quantity, options)
       options[:line_item_created] = true if timestamp <= line_item.created_at
       after_add_or_remove(line_item, options)
@@ -18,6 +18,11 @@ module Spree
       after_add_or_remove(line_item, options)
     end
 
+    def remove_line_item(line_item, options = {})
+      line_item.destroy!
+      after_add_or_remove(line_item, options)
+    end
+
     def update_cart(params)
       if order.update_attributes(filter_order_items(params))
         order.line_items = order.line_items.select { |li| li.quantity > 0 }

data/app/models/spree/order_inventory.rb

@@ -8,6 +8,8 @@ module Spree
       @variant = line_item.variant
     end
 
+    delegate :inventory_units, to: :line_item
+
     # Only verify inventory for completed orders (as orders in frontend checkout
     # have inventory assigned via +order.create_proposed_shipment+) or when
     # shipment is explicitly passed
@@ -29,10 +31,6 @@ module Spree
       end
     end
 
-    def inventory_units
-      line_item.inventory_units
-    end
-
     private
       def remove(item_units, shipment = nil)
         quantity = item_units.size - line_item.quantity
@@ -82,9 +80,7 @@ module Spree
       def remove_from_shipment(shipment, quantity)
         return 0 if quantity == 0 || shipment.shipped?
 
-        shipment_units = shipment.inventory_units_for_item(line_item, variant).reject do |variant_unit|
-          variant_unit.state == 'shipped'
-        end.sort_by(&:state)
+        shipment_units = shipment.inventory_units_for_item(line_item, variant).reject(&:shipped?).sort_by(&:state)
 
         removed_quantity = 0
 
@@ -94,7 +90,7 @@ module Spree
           removed_quantity += 1
         end
 
-        shipment.destroy if shipment.inventory_units.count == 0
+        shipment.destroy if shipment.inventory_units.count.zero?
 
         # removing this from shipment, and adding to stock_location
         if order.completed?

data/app/models/spree/order_promotion.rb

@@ -0,0 +1,6 @@
+module Spree
+  class OrderPromotion < Spree::Base
+    belongs_to :order, class_name: 'Spree::Order'
+    belongs_to :promotion, class_name: 'Spree::Promotion'
+  end
+end

data/app/models/spree/order_updater.rb

@@ -110,7 +110,7 @@ module Spree
         shipment_total: order.shipment_total,
         promo_total: order.promo_total,
         total: order.total,
-        updated_at: Time.now,
+        updated_at: Time.current,
       )
     end
 
@@ -161,7 +161,7 @@ module Spree
       last_state = order.payment_state
       if payments.present? && payments.valid.size == 0
         order.payment_state = 'failed'
-      elsif order.state == 'canceled' && order.payment_total == 0
+      elsif order.canceled? && order.payment_total == 0
         order.payment_state = 'void'
       else
         order.payment_state = 'balance_due' if order.outstanding_balance > 0
@@ -171,10 +171,5 @@ module Spree
       order.state_changed('payment') if last_state != order.payment_state
       order.payment_state
     end
-
-    private
-      def round_money(n)
-        (n * 100).round / 100.0
-      end
   end
 end

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,7 +23,7 @@ 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?
@@ -36,6 +33,7 @@ module Spree
 
     # invalidate previously entered payments
     after_create :invalidate_old_payments
+    after_create :create_eligible_credit_event
 
     attr_accessor :source_attributes, :request_env
 
@@ -43,7 +41,8 @@ module Spree
 
     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
@@ -245,5 +249,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/gateway_options.rb

@@ -26,19 +26,19 @@ module Spree
       end
 
       def shipping
-        order.ship_total * 100
+        order.ship_total * exchange_multiplier
       end
 
       def tax
-        order.additional_tax_total * 100
+        order.additional_tax_total * exchange_multiplier
       end
 
       def subtotal
-        order.item_total * 100
+        order.item_total * exchange_multiplier
       end
 
       def discount
-        order.promo_total * 100
+        order.promo_total * exchange_multiplier
       end
 
       def currency
@@ -81,6 +81,10 @@ module Spree
       def order
         @payment.order
       end
+
+      def exchange_multiplier
+        @payment.payment_method.try(:exchange_multiplier) || 1.0
+      end
     end
   end
 end