spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/calculator/returns/default_refund_amount.rb

@@ -0,0 +1,36 @@
+require_dependency 'spree/returns_calculator'
+
+module Spree
+  module Calculator::Returns
+    class DefaultRefundAmount < ReturnsCalculator
+
+      def self.description
+        Spree.t(:default_refund_amount)
+      end
+
+      def compute(return_item)
+        return 0.0.to_d if return_item.exchange_requested?
+        weighted_order_adjustment_amount(return_item.inventory_unit) + weighted_line_item_pre_tax_amount(return_item.inventory_unit)
+      end
+
+      private
+
+      def weighted_order_adjustment_amount(inventory_unit)
+        inventory_unit.order.adjustments.eligible.non_tax.sum(:amount) * percentage_of_order_total(inventory_unit)
+      end
+
+      def weighted_line_item_pre_tax_amount(inventory_unit)
+        inventory_unit.line_item.pre_tax_amount * percentage_of_line_item(inventory_unit)
+      end
+
+      def percentage_of_order_total(inventory_unit)
+       return 0.0 if inventory_unit.order.pre_tax_item_amount.zero?
+       weighted_line_item_pre_tax_amount(inventory_unit) / inventory_unit.order.pre_tax_item_amount
+     end
+
+     def percentage_of_line_item(inventory_unit)
+       1 / BigDecimal.new(inventory_unit.line_item.quantity)
+     end
+   end
+ end
+end

data/app/models/spree/classification.rb

@@ -1,7 +1,7 @@
 module Spree
   class Classification < Spree::Base
     self.table_name = 'spree_products_taxons'
-    acts_as_list scope: :taxon
+    acts_as_list
     belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications
     belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications
 

data/app/models/spree/credit_card.rb

@@ -1,9 +1,12 @@
 module Spree
   class CreditCard < Spree::Base
     belongs_to :payment_method
+    belongs_to :user, class_name: Spree.user_class, foreign_key: 'user_id'
     has_many :payments, as: :source
 
-    before_create :set_missing_info
+    before_save :set_last_digits
+
+    after_save :ensure_one_default
 
     attr_accessor :encrypted_data,
                     :number,
@@ -18,6 +21,7 @@ module Spree
     validate :expiry_not_in_the_past
 
     scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+    scope :default, -> { where(default: true) }
 
     # needed for some of the ActiveMerchant gateways (eg. SagePay)
     alias_attribute :brand, :cc_type
@@ -35,7 +39,7 @@ module Spree
       return unless expiry.present?
 
       self[:month], self[:year] =
-      if expiry.match(/\d\s?\/\s?\d/) # will match mm/yy and mm / yyyy
+      if expiry.match(/\d{2}\s?\/\s?\d{2,4}/) # will match mm/yy and mm / yyyy
         expiry.delete(' ').split('/')
       elsif match = expiry.match(/(\d{2})(\d{2,4})/) # will match mmyy and mmyyyy
         [match[1], match[2]]
@@ -44,7 +48,7 @@ module Spree
         self[:year] = "20" + self[:year] if self[:year].length == 2
         self[:year] = self[:year].to_i
       end
-      self[:month] = self[:month].to_i
+      self[:month] = self[:month].to_i if self[:month]
     end
 
     def number=(num)
@@ -63,6 +67,12 @@ module Spree
       end
     end
 
+    def set_last_digits
+      number.to_s.gsub!(/\s/,'')
+      verification_value.to_s.gsub!(/\s/,'')
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+    end
+
     def try_type_from_number
       numbers = number.delete(' ') if number
       CARD_TYPES.find{|type, pattern| return type.to_s if numbers =~ pattern}.to_s
@@ -94,9 +104,7 @@ module Spree
     # Indicates whether its possible to credit the payment.  Note that most gateways require that the
     # payment be settled first which generally happens within 12-24 hours of the transaction.
     def can_credit?(payment)
-      return false unless payment.completed?
-      return false unless payment.order.payment_state == 'credit_owed'
-      payment.credit_allowed > 0
+      payment.completed? && payment.credit_allowed > 0
     end
 
     def has_payment_profile?
@@ -144,24 +152,12 @@ module Spree
       !self.encrypted_data.present? && !self.has_payment_profile?
     end
 
-    def set_last_digits
-      number.to_s.gsub!(/\s/,'')
-      verification_value.to_s.gsub!(/\s/,'')
-      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
-    end
-
-    def set_missing_info
-      set_last_digits
-      if has_payment_profile?
-        if matching_card = self.class.where(gateway_customer_profile_id: self.gateway_customer_profile_id, gateway_payment_profile_id: self.gateway_payment_profile_id).first
-          self.cc_type     = matching_card.cc_type
-          self.last_digits = matching_card.last_digits
-          self.month       = matching_card.month
-          self.name        = matching_card.name
-          self.year        = matching_card.year
+    def ensure_one_default
+      if self.user_id && self.default
+        CreditCard.where(default: true).where.not(id: self.id).where(user_id: self.user_id).each do |ucc|
+          ucc.update_columns(default: false)
         end
       end
     end
-
   end
 end

data/app/models/spree/customer_return.rb

@@ -0,0 +1,70 @@
+module Spree
+  class CustomerReturn < Spree::Base
+    belongs_to :stock_location
+
+    has_many :return_items, inverse_of: :customer_return
+    has_many :return_authorizations, through: :return_items
+    has_many :reimbursements, inverse_of: :customer_return
+
+    after_create :process_return!
+    before_create :generate_number
+
+    validates :return_items, presence: true
+    validates :stock_location, presence: true
+    validate :return_items_belong_to_same_order
+
+    accepts_nested_attributes_for :return_items
+
+    def pre_tax_total
+      return_items.sum(:pre_tax_amount)
+    end
+
+    def display_pre_tax_total
+      Spree::Money.new(pre_tax_total, { currency: Spree::Config[:currency] })
+    end
+
+    # Temporarily tie a customer_return to one order
+    def order
+      return nil if return_items.blank?
+      return_items.first.inventory_unit.order
+    end
+
+    def order_id
+      order.try(:id)
+    end
+
+    def fully_reimbursed?
+      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
+    end
+
+    def completely_decided?
+      !return_items.undecided.exists?
+    end
+
+    private
+
+    def generate_number
+      self.number ||= loop do
+        random = "CR#{Array.new(9){rand(9)}.join}"
+        break random unless self.class.exists?(number: random)
+      end
+    end
+
+    def process_return!
+      return_items.each(&:receive!)
+      order.return! if order.all_inventory_units_returned?
+    end
+
+    def return_items_belong_to_same_order
+      if return_items.select{ |return_item| return_item.inventory_unit.order_id != order_id }.any?
+        errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
+      end
+    end
+
+    def inventory_units
+      return_items.flat_map(&:inventory_unit)
+    end
+
+  end
+end
+

data/app/models/spree/exchange.rb

@@ -0,0 +1,42 @@
+module Spree
+  class Exchange
+
+    def initialize(order, reimbursement_objects)
+      @order = order
+      @reimbursement_objects = reimbursement_objects
+    end
+
+    def description
+      @reimbursement_objects.map do |reimbursement_object|
+        "#{reimbursement_object.variant.options_text} => #{reimbursement_object.exchange_variant.options_text}"
+      end.join(" | ")
+    end
+
+    def display_amount
+      Spree::Money.new @reimbursement_objects.map(&:total).sum
+    end
+
+    def perform!
+      shipments = Spree::Stock::Coordinator.new(@order, @reimbursement_objects.map(&:build_exchange_inventory_unit)).shipments
+      @order.shipments += shipments
+      @order.save!
+      shipments.each do |shipment|
+        shipment.update!(@order)
+        shipment.finalize!
+      end
+    end
+
+    def to_key
+      nil
+    end
+
+    def self.param_key
+      "spree_exchange"
+    end
+
+    def self.model_name
+      Spree::Exchange
+    end
+
+  end
+end

data/app/models/spree/gateway/bogus.rb

@@ -18,10 +18,10 @@ module Spree
     end
 
     def create_profile(payment)
+      return if payment.source.has_payment_profile?
       # simulate the storage of credit card profile using remote service
-      if success = VALID_CCS.include?(payment.source.number)
-        payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
-      end
+      success = VALID_CCS.include? payment.source.number
+      payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
     end
 
     def authorize(money, credit_card, options = {})

data/app/models/spree/image.rb

@@ -33,7 +33,7 @@ module Spree
     # if there are errors from the plugin, then add a more meaningful message
     def no_attachment_errors
       unless attachment.errors.empty?
-        # uncomment this to get rid of the less-than-useful interrim messages
+        # uncomment this to get rid of the less-than-useful interim messages
         # errors.clear
         errors.add :attachment, "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
         false

data/app/models/spree/inventory_unit.rb

@@ -3,11 +3,16 @@ module Spree
     belongs_to :variant, class_name: "Spree::Variant", inverse_of: :inventory_units
     belongs_to :order, class_name: "Spree::Order", inverse_of: :inventory_units
     belongs_to :shipment, class_name: "Spree::Shipment", touch: true, inverse_of: :inventory_units
-    belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization", inverse_of: :inventory_units
+    belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization"
     belongs_to :line_item, class_name: "Spree::LineItem", inverse_of: :inventory_units
 
+    has_many :return_items, inverse_of: :inventory_unit
+    has_one :original_return_item, class_name: "Spree::ReturnItem", foreign_key: :exchange_inventory_unit_id
+
     scope :backordered, -> { where state: 'backordered' }
+    scope :on_hand, -> { where state: 'on_hand' }
     scope :shipped, -> { where state: 'shipped' }
+    scope :returned, -> { where state: 'returned' }
     scope :backordered_per_variant, ->(stock_item) do
       includes(:shipment, :order)
         .where("spree_shipments.state != 'canceled'").references(:shipment)
@@ -21,7 +26,7 @@ module Spree
       event :fill_backorder do
         transition to: :on_hand, from: :backordered
       end
-      after_transition on: :fill_backorder, do: :fulfill_order
+      after_transition on: :fill_backorder, do: :update_order
 
       event :ship do
         transition to: :shipped, if: :allow_ship?
@@ -33,8 +38,8 @@ module Spree
     end
 
     # This was refactored from a simpler query because the previous implementation
-    # lead to issues once users tried to modify the objects returned. That's due
-    # to ActiveRecord `joins(shipment: :stock_location)` only return readonly
+    # led to issues once users tried to modify the objects returned. That's due
+    # to ActiveRecord `joins(shipment: :stock_location)` only returning readonly
     # objects
     #
     # Returns an array of backordered inventory units as per a given stock item
@@ -63,16 +68,35 @@ module Spree
       Spree::Variant.unscoped { super }
     end
 
+    def current_or_new_return_item
+      Spree::ReturnItem.from_inventory_unit(self)
+    end
+
+    def additional_tax_total
+      line_item.additional_tax_total * percentage_of_line_item
+    end
+
+    def included_tax_total
+      line_item.included_tax_total * percentage_of_line_item
+    end
+
     private
 
       def allow_ship?
-        Spree::Config[:allow_backorder_shipping] || self.on_hand?
+        self.on_hand?
       end
 
-      def fulfill_order
+      def update_order
         self.reload
-        order.fulfill!
+        order.update!
+      end
+
+      def percentage_of_line_item
+        1 / BigDecimal.new(line_item.quantity)
+      end
+
+      def current_return_item
+        return_items.not_cancelled.first
       end
   end
 end
-

data/app/models/spree/item_adjustments.rb

@@ -9,9 +9,8 @@ module Spree
 
     def initialize(item)
       @item = item
-
       # Don't attempt to reload the item from the DB if it's not there
-      @item.reload if @item.instance_of?(Shipment) && @item.persisted?
+      @item.reload if @item.persisted?
     end
 
     def update
@@ -28,20 +27,17 @@ module Spree
       #
       # It also fits the criteria for sales tax as outlined here:
       # http://www.boe.ca.gov/formspubs/pub113/
-      #
+      # 
       # Tax adjustments come in not one but *two* exciting flavours:
       # Included & additional
 
       # Included tax adjustments are those which are included in the price.
-      # These ones should not effect the eventual total price.
+      # These ones should not affect the eventual total price.
       #
-      # Additional tax adjustments are the opposite; effecting the final total.
+      # Additional tax adjustments are the opposite, affecting the final total.
       promo_total = 0
       run_callbacks :promo_adjustments do
-        promotion_total = adjustments.promotion.reload.map do |adjustment|
-          adjustment.update!(@item)
-        end.compact.sum
-
+        promotion_total = adjustments.promotion.reload.map(&:update!).compact.sum
         unless promotion_total == 0
           choose_best_promotion_adjustment
         end
@@ -52,7 +48,7 @@ module Spree
       additional_tax_total = 0
       run_callbacks :tax_adjustments do
         tax = (item.respond_to?(:all_adjustments) ? item.all_adjustments : item.adjustments).tax
-        included_tax_total = tax.is_included.reload.map(&:update!).compact.sum
+        included_tax_total = tax.included.reload.map(&:update!).compact.sum
         additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
       end
 
@@ -70,7 +66,7 @@ module Spree
     # have the same amount, then it will pick the latest one.
     def choose_best_promotion_adjustment
       if best_promotion_adjustment
-        other_promotions = self.adjustments.promotion.where("id NOT IN (?)", best_promotion_adjustment.id)
+        other_promotions = self.adjustments.promotion.where.not(id: best_promotion_adjustment.id)
         other_promotions.update_all(:eligible => false)
       end
     end

data/app/models/spree/legacy_user.rb

@@ -1,8 +1,8 @@
 # Default implementation of User.  This class is intended to be modified by extensions (ex. spree_auth_devise)
 module Spree
   class LegacyUser < Spree::Base
-    include Core::UserAddress
-    include Core::UserPaymentSource
+    include UserAddress
+    include UserPaymentSource
 
     self.table_name = 'spree_users'
 

data/app/models/spree/line_item.rb

@@ -1,6 +1,6 @@
 module Spree
   class LineItem < Spree::Base
-    before_validation :adjust_quantity
+    before_validation :invalid_quantity_check
     belongs_to :order, class_name: "Spree::Order", inverse_of: :line_items, touch: true
     belongs_to :variant, class_name: "Spree::Variant", inverse_of: :line_items
     belongs_to :tax_category, class_name: "Spree::TaxCategory"
@@ -24,7 +24,6 @@ module Spree
 
     validate :ensure_proper_currency
     before_destroy :update_inventory
-    before_destroy :destroy_inventory_units
 
     after_save :update_inventory
     after_save :update_adjustments
@@ -35,9 +34,6 @@ module Spree
 
     attr_accessor :target_shipment
 
-    self.whitelisted_ransackable_associations = ['variant']
-    self.whitelisted_ransackable_attributes = ['variant_id']
-
     def copy_price
       if variant
         self.price = variant.price if price.nil?
@@ -61,8 +57,12 @@ module Spree
       amount + promo_total
     end
 
+    def discounted_money
+      Spree::Money.new(discounted_amount, { currency: currency })
+    end
+
     def final_amount
-      amount + adjustment_total.to_f
+      amount + adjustment_total
     end
     alias total final_amount
 
@@ -77,7 +77,7 @@ module Spree
     alias display_total money
     alias display_amount money
 
-    def adjust_quantity
+    def invalid_quantity_check
       self.quantity = 0 if quantity.nil? || quantity < 0
     end
 
@@ -99,6 +99,23 @@ module Spree
       Spree::Variant.unscoped { super }
     end
 
+    def options=(options={})
+      opts = options.dup # we will be deleting from the hash, so leave the caller's copy intact
+
+      currency = opts.delete(:currency) || order.try(:currency)
+
+      if currency
+        self.currency = currency
+        self.price    = variant.price_in(currency).amount +
+                        variant.price_modifier_amount_in(currency, opts)
+      else
+        self.price    = variant.price +
+                        variant.price_modifier_amount(opts)
+      end
+
+      self.assign_attributes opts
+    end
+
     private
       def update_inventory
         if (changed? || target_shipment.present?) && self.order.has_checkout_step?("delivery")
@@ -106,13 +123,9 @@ module Spree
         end
       end
 
-      def destroy_inventory_units
-        inventory_units.destroy_all
-      end
-
       def update_adjustments
         if quantity_changed?
-          update_tax_charge # Called to ensure pre_tax_amount is updated. 
+          update_tax_charge # Called to ensure pre_tax_amount is updated.
           recalculate_adjustments
         end
       end