spree_core 2.4.10 → 3.0.0.rc1

data/app/models/spree/reimbursement.rb

@@ -83,9 +83,9 @@ module Spree
     end
 
     def calculated_total
-      # rounding every return item individually to handle edge cases for consecutive partial
-      # returns where rounding might cause us to try to reimburse more than was originally billed
-      return_items.map { |ri| ri.total.to_d.round(2) }.sum
+      # rounding down to handle edge cases for consecutive partial returns where rounding
+      # might cause us to try to reimburse more than was originally billed
+      return_items.to_a.sum(&:total).to_d.round(2, :down)
     end
 
     def paid_amount
@@ -144,7 +144,7 @@ module Spree
     end
 
     def send_reimbursement_email
-      Spree::ReimbursementMailer.reimbursement_email(self.id).deliver
+      Spree::ReimbursementMailer.reimbursement_email(id).deliver_later
     end
 
     # If there are multiple different reimbursement types for a single

data/app/models/spree/reimbursement_type/credit.rb

@@ -4,7 +4,7 @@ module Spree
 
     class << self
       def reimburse(reimbursement, return_items, simulate)
-        unpaid_amount = return_items.map { |ri| ri.total.to_d.round(2) }.sum
+        unpaid_amount = return_items.sum(&:total).round(2, :down)
         reimbursement_list, unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate)
         reimbursement_list
       end

data/app/models/spree/reimbursement_type/original_payment.rb

@@ -3,7 +3,7 @@ class Spree::ReimbursementType::OriginalPayment < Spree::ReimbursementType
 
   class << self
     def reimburse(reimbursement, return_items, simulate)
-      unpaid_amount = return_items.map { |ri| ri.total.to_d.round(2) }.sum
+      unpaid_amount = return_items.sum(&:total).round(2, :down)
       payments = reimbursement.order.payments.completed
 
       refund_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount, simulate)

data/app/models/spree/return_authorization.rb

@@ -29,21 +29,18 @@ module Spree
       before_transition to: :canceled, do: :cancel_return_items
 
       event :cancel do
-        transition to: :canceled, from: :authorized, if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
+        transition to: :canceled, from: :authorized
       end
 
     end
 
-    self.whitelisted_ransackable_attributes = ['memo']
+    extend DisplayMoney
+    money_methods :pre_tax_total
 
     def pre_tax_total
       return_items.sum(:pre_tax_amount)
     end
 
-    def display_pre_tax_total
-      Spree::Money.new(pre_tax_total, { currency: currency })
-    end
-
     def currency
       order.nil? ? Spree::Config[:currency] : order.currency
     end
@@ -56,10 +53,6 @@ module Spree
       customer_returns.exists?
     end
 
-    def can_cancel_return_items?
-      return_items.any?(&:can_cancel?) || return_items.blank?
-    end
-
     private
 
       def must_have_shipped_units
@@ -76,7 +69,7 @@ module Spree
       end
 
       def cancel_return_items
-        return_items.each { |item| item.cancel! if item.can_cancel? }
+        return_items.each(&:cancel!)
       end
 
       def generate_expedited_exchange_reimbursements

data/app/models/spree/return_item.rb

@@ -20,6 +20,7 @@ module Spree
     belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType'
     belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType'
 
+    validate :eligible_exchange_variant
     validate :belongs_to_same_customer_order
     validate :validate_acceptance_status_for_reimbursement
     validates :inventory_unit, presence: true
@@ -28,6 +29,7 @@ module Spree
     after_create :cancel_others, unless: :cancelled?
 
     scope :awaiting_return, -> { where(reception_status: 'awaiting') }
+    scope :received, -> { where(reception_status: 'received') }
     scope :not_cancelled, -> { where.not(reception_status: 'cancelled') }
     scope :pending, -> { where(acceptance_status: 'pending') }
     scope :accepted, -> { where(acceptance_status: 'accepted') }
@@ -40,6 +42,7 @@ module Spree
     scope :exchange_requested, -> { where.not(exchange_variant: nil) }
     scope :exchange_processed, -> { where.not(exchange_inventory_unit: nil) }
     scope :exchange_required, -> { exchange_requested.where(exchange_inventory_unit: nil) }
+    scope :resellable, -> { where resellable: true }
 
     serialize :acceptance_status_errors
 
@@ -51,8 +54,8 @@ module Spree
     before_save :set_exchange_pre_tax_amount
 
     state_machine :reception_status, initial: :awaiting do
-      before_transition to: :received, do: :process_inventory_unit!
       after_transition to: :received, do: :attempt_accept
+      after_transition to: :received, do: :process_inventory_unit!
 
       event :receive do
         transition to: :received, from: :awaiting
@@ -67,6 +70,9 @@ module Spree
       end
     end
 
+    extend DisplayMoney
+    money_methods :pre_tax_amount, :total
+
     def reception_completed?
       COMPLETED_RECEPTION_STATUSES.include?(reception_status)
     end
@@ -114,16 +120,8 @@ module Spree
       exchange_requested? && !exchange_processed?
     end
 
-    def display_pre_tax_amount
-      Spree::Money.new(pre_tax_amount, { currency: currency })
-    end
-
     def total
-      pre_tax_amount + included_tax_total + additional_tax_total
-    end
-
-    def display_total
-      Spree::Money.new(total, { currency: currency })
+      pre_tax_amount + additional_tax_total
     end
 
     def eligible_exchange_variants
@@ -186,6 +184,13 @@ module Spree
       end
     end
 
+    def eligible_exchange_variant
+      return unless exchange_variant && exchange_variant_id_changed?
+      unless eligible_exchange_variants.include?(exchange_variant)
+        errors.add(:base, Spree.t(:invalid_exchange_variant))
+      end
+    end
+
     def validator
       @validator ||= return_eligibility_validator.new(self)
     end
@@ -224,7 +229,7 @@ module Spree
     end
 
     def should_restock?
-      variant.should_track_inventory? && stock_item && Spree::Config[:restock_inventory]
+      resellable? && variant.should_track_inventory? && stock_item && Spree::Config[:restock_inventory]
     end
   end
 end

data/app/models/spree/return_item/eligibility_validator/default.rb

@@ -5,6 +5,8 @@ module Spree
                                               ReturnItem::EligibilityValidator::OrderCompleted,
                                               ReturnItem::EligibilityValidator::TimeSincePurchase,
                                               ReturnItem::EligibilityValidator::RMARequired,
+                                              ReturnItem::EligibilityValidator::InventoryShipped,
+                                              ReturnItem::EligibilityValidator::NoReimbursements,
                                             ]
 
     def eligible_for_return?

data/app/models/spree/return_item/eligibility_validator/inventory_shipped.rb

@@ -0,0 +1,16 @@
+module Spree
+  class ReturnItem::EligibilityValidator::InventoryShipped < Spree::ReturnItem::EligibilityValidator::BaseValidator
+    def eligible_for_return?
+      if @return_item.inventory_unit.shipped?
+        return true
+      else
+        add_error(:inventory_unit_shipped, Spree.t('return_item_inventory_unit_ineligible'))
+        return false
+      end
+    end
+
+    def requires_manual_intervention?
+      @errors.present?
+    end
+  end
+end

data/app/models/spree/return_item/eligibility_validator/no_reimbursements.rb

@@ -0,0 +1,16 @@
+module Spree
+  class ReturnItem::EligibilityValidator::NoReimbursements < Spree::ReturnItem::EligibilityValidator::BaseValidator
+    def eligible_for_return?
+      if Spree::ReturnItem.where(inventory_unit: @return_item.inventory_unit).where.not(reimbursement_id: nil).any?
+        add_error(:inventory_unit_reimbursed, Spree.t('return_item_inventory_unit_reimbursed'))
+        return false
+      else
+        return true
+      end
+    end
+
+    def requires_manual_intervention?
+      @errors.present?
+    end
+  end
+end

data/app/models/spree/shipment.rb

@@ -2,6 +2,17 @@ require 'ostruct'
 
 module Spree
   class Shipment < Spree::Base
+    extend FriendlyId
+    friendly_id :number, slug_column: :number, use: :slugged
+
+    include Spree::NumberGenerator
+
+    def generate_number(options = {})
+      options[:prefix] ||= 'H'
+      options[:length] ||= 11
+      super(options)
+    end
+
     belongs_to :address, class_name: 'Spree::Address', inverse_of: :shipments
     belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
@@ -16,15 +27,11 @@ module Spree
 
     before_validation :set_cost_zero_when_nil
 
-    validates :stock_location, presence: true
-
     attr_accessor :special_instructions
 
     accepts_nested_attributes_for :address
     accepts_nested_attributes_for :inventory_units
 
-    make_permalink field: :number, length: 11, prefix: 'H'
-
     scope :pending, -> { with_state('pending') }
     scope :ready,   -> { with_state('ready') }
     scope :shipped, -> { with_state('shipped') }
@@ -76,7 +83,9 @@ module Spree
       end
     end
 
-    self.whitelisted_ransackable_attributes = ['number']
+    extend DisplayMoney
+    money_methods :cost, :discounted_cost, :final_price, :item_cost
+    alias display_amount display_cost
 
     def add_shipping_method(shipping_method, selected = false)
       shipping_rates.create(shipping_method: shipping_method, selected: selected, cost: cost)
@@ -116,23 +125,6 @@ module Spree
     end
     alias discounted_amount discounted_cost
 
-    def display_cost
-      Spree::Money.new(cost, { currency: currency })
-    end
-    alias display_amount display_cost
-
-    def display_discounted_cost
-      Spree::Money.new(discounted_cost, { currency: currency })
-    end
-
-    def display_final_price
-      Spree::Money.new(final_price, { currency: currency })
-    end
-
-    def display_item_cost
-      Spree::Money.new(item_cost, { currency: currency })
-    end
-
     def editable_by?(user)
       !shipped?
     end
@@ -163,7 +155,7 @@ module Spree
     end
 
     def item_cost
-      manifest.map { |m| (m.line_item.price + (m.line_item.adjustment_total / m.line_item.quantity)) * m.quantity }.sum
+      line_items.map(&:final_amount).sum
     end
 
     def line_items
@@ -218,14 +210,15 @@ module Spree
       self.ready? || self.pending?
     end
 
-    def refresh_rates
+    def refresh_rates(shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
       return shipping_rates if shipped?
       return [] unless can_get_rates?
 
       # StockEstimator.new assigment below will replace the current shipping_method
       original_shipping_method_id = shipping_method.try(:id)
 
-      self.shipping_rates = Stock::Estimator.new(order).shipping_rates(to_package)
+      self.shipping_rates = Stock::Estimator.new(order).
+      shipping_rates(to_package, shipping_method_filter)
 
       if shipping_method
         selected_rate = shipping_rates.detect { |rate|
@@ -288,10 +281,6 @@ module Spree
       package
     end
 
-    def to_param
-      number
-    end
-
     def tracking_url
       @tracking_url ||= shipping_method.build_tracking_url(tracking)
     end
@@ -410,11 +399,11 @@ module Spree
       end
 
       def recalculate_adjustments
-        Spree::ItemAdjustments.new(self).update
+        Adjustable::AdjustmentsUpdater.update(self)
       end
 
       def send_shipped_email
-        ShipmentMailer.shipped_email(self.id).deliver
+        ShipmentMailer.shipped_email(id).deliver_later
       end
 
       def set_cost_zero_when_nil

data/app/models/spree/shipment_handler.rb

@@ -27,7 +27,7 @@ module Spree
 
     private
       def send_shipped_email
-        ShipmentMailer.shipped_email(@shipment.id).deliver
+        ShipmentMailer.shipped_email(@shipment.id).deliver_later
       end
 
       def update_order_shipment_state

data/app/models/spree/shipping_method.rb

@@ -4,7 +4,12 @@ module Spree
     include Spree::CalculatedAdjustments
     DISPLAY = [:both, :front_end, :back_end]
 
-    default_scope -> { where(deleted_at: nil) }
+    # Used for #refresh_rates
+    DISPLAY_ON_FRONT_AND_BACK_END = 0
+    DISPLAY_ON_FRONT_END = 1
+    DISPLAY_ON_BACK_END = 2
+
+    default_scope { where(deleted_at: nil) }
 
     has_many :shipping_method_categories, :dependent => :destroy
     has_many :shipping_categories, through: :shipping_method_categories
@@ -46,23 +51,17 @@ module Spree
       Spree::TaxCategory.unscoped { super }
     end
 
-    private
-      def compute_amount(calculable)
-        self.calculator.compute(calculable)
-      end
+    def available_to_display(display_filter)
+      display_filter == DISPLAY_ON_FRONT_AND_BACK_END ||
+      (frontend? && display_filter == DISPLAY_ON_FRONT_END) ||
+      (!frontend? && display_filter == DISPLAY_ON_BACK_END)
+    end
 
+    private
       def at_least_one_shipping_category
         if self.shipping_categories.empty?
           self.errors[:base] << "You need to select at least one shipping category"
         end
       end
-
-      def self.on_backend_query
-        "#{table_name}.display_on != 'front_end' OR #{table_name}.display_on IS NULL"
-      end
-
-      def self.on_frontend_query
-        "#{table_name}.display_on != 'back_end' OR #{table_name}.display_on IS NULL"
-      end
   end
 end

data/app/models/spree/state.rb

@@ -3,6 +3,13 @@ module Spree
     belongs_to :country, class_name: 'Spree::Country'
     has_many :addresses, dependent: :nullify
 
+    has_many :zone_members,
+      -> { where(zoneable_type: 'Spree::State') },
+      class_name: 'Spree::ZoneMember',
+      foreign_key: :zoneable_id
+
+    has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
+
     validates :country, :name, presence: true
 
     def self.find_all_by_name_or_abbr(name_or_abbr)

data/app/models/spree/state_change.rb

@@ -1,15 +1,10 @@
 module Spree
   class StateChange < Spree::Base
-    belongs_to :user
+    belongs_to :user, class_name: Spree.user_class.to_s
     belongs_to :stateful, polymorphic: true
-    before_create :assign_user
 
     def <=>(other)
       created_at <=> other.created_at
     end
-
-    def assign_user
-      true   # don't stop the filters
-    end
   end
 end

data/app/models/spree/stock/availability_validator.rb

@@ -5,20 +5,19 @@ module Spree
         unit_count = line_item.inventory_units.size
         return if unit_count >= line_item.quantity
         quantity = line_item.quantity - unit_count
-        return if quantity.zero?
 
         quantifier = Stock::Quantifier.new(line_item.variant)
 
-        return if quantifier.can_supply?(quantity)
+        unless quantifier.can_supply? quantity
+          variant = line_item.variant
+          display_name = %Q{#{variant.name}}
+          display_name += %Q{ (#{variant.options_text})} unless variant.options_text.blank?
 
-        variant = line_item.variant
-        display_name = "#{variant.name}"
-        display_name += " (#{variant.options_text})" unless variant.options_text.blank?
-
-        line_item.errors[:quantity] << Spree.t(
-          :selected_quantity_not_available,
-          item: display_name.inspect
-        )
+          line_item.errors[:quantity] << Spree.t(
+            :selected_quantity_not_available,
+            item: display_name.inspect
+          )
+        end
       end
     end
   end