spree_core 3.2.9 → 3.3.0.rc1

data/app/models/spree/refund.rb

@@ -2,7 +2,7 @@ module Spree
   class Refund < Spree::Base
     with_options inverse_of: :refunds do
       belongs_to :payment
-      belongs_to :reimbursement
+      belongs_to :reimbursement, optional: true
     end
     belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
 
@@ -43,7 +43,7 @@ module Spree
     def perform!
       return true if transaction_id.present?
 
-      credit_cents = Spree::Money.new(amount.to_f, currency: payment.currency).amount_in_cents
+      credit_cents = Spree::Money.new(amount.to_f, currency: payment.currency).money.cents
 
       @response = process!(credit_cents)
 

data/app/models/spree/reimbursement.rb

@@ -6,7 +6,7 @@ module Spree
 
     with_options inverse_of: :reimbursements do
       belongs_to :order
-      belongs_to :customer_return, touch: true
+      belongs_to :customer_return, touch: true, optional: true
     end
 
     with_options inverse_of: :reimbursement do
@@ -15,6 +15,7 @@ module Spree
       has_many :return_items
     end
 
+    validates :number, uniqueness: true
     validates :order, presence: true
     validate :validate_return_items_belong_to_same_order
 

data/app/models/spree/reimbursement_type.rb

@@ -10,7 +10,7 @@ module Spree
 
     has_many :return_items
 
-    # This method will reimburse the return items based on however it child implements it
+    # This method will reimburse the return items based on however its child implements it
     # By default it takes a reimbursement, the return items it needs to reimburse, and if
     # it is a simulation or a real reimbursement. This should return an array
     def self.reimburse(reimbursement, return_items, simulate)

data/app/models/spree/return_authorization.rb

@@ -17,6 +17,7 @@ module Spree
 
     accepts_nested_attributes_for :return_items, allow_destroy: true
 
+    validates :number, uniqueness: true
     validates :order, :reason, :stock_location, presence: true
     validate :must_have_shipped_units, on: :create
 

data/app/models/spree/return_item.rb

@@ -5,6 +5,14 @@ module Spree
     class_attribute :return_eligibility_validator
     self.return_eligibility_validator = ReturnItem::EligibilityValidator::Default
 
+    def return_quantity=(value)
+      @_return_quantity = value.to_i
+    end
+
+    def return_quantity
+      @_return_quantity.nil? ? inventory_unit.quantity : @_return_quantity
+    end
+
     class_attribute :exchange_variant_engine
     self.exchange_variant_engine = ReturnItem::ExchangeVariantEligibility::SameProduct
 
@@ -17,8 +25,10 @@ module Spree
       belongs_to :customer_return
       belongs_to :reimbursement
     end
+    has_many :exchange_inventory_units, class_name: 'Spree::InventoryUnit',
+                                        foreign_key: :original_return_item_id,
+                                        inverse_of: :original_return_item
     belongs_to :exchange_variant, class_name: 'Spree::Variant'
-    belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item
     belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType'
     belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType'
 
@@ -27,6 +37,8 @@ module Spree
     validate :validate_acceptance_status_for_reimbursement
     validates :inventory_unit, presence: true
     validate :validate_no_other_completed_return_items, on: :create
+    validates :return_quantity, numericality: { greater_than_or_equal_to: 1 }
+    validate :sufficient_quantity_for_return
 
     after_create :cancel_others, unless: :cancelled?
 
@@ -42,8 +54,8 @@ module Spree
     scope :reimbursed, -> { where.not(reimbursement_id: nil) }
     scope :not_reimbursed, -> { where(reimbursement_id: nil) }
     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 :exchange_processed, -> { joins(:exchange_inventory_units).distinct }
+    scope :exchange_required, -> { eager_load(:exchange_inventory_units).where(spree_inventory_units: { original_return_item_id: nil }).distinct }
     scope :resellable, -> { where resellable: true }
 
     serialize :acceptance_status_errors
@@ -52,7 +64,9 @@ module Spree
     delegate :variant, to: :inventory_unit
     delegate :shipment, to: :inventory_unit
 
+    before_create :extract_inventory_unit, unless: -> { inventory_unit.quantity == return_quantity }
     before_create :set_default_pre_tax_amount, unless: :pre_tax_amount_changed?
+
     before_save :set_exchange_pre_tax_amount
 
     state_machine :reception_status, initial: :awaiting do
@@ -115,7 +129,7 @@ module Spree
     end
 
     def exchange_processed?
-      exchange_inventory_unit.present?
+      exchange_inventory_units.present?
     end
 
     def exchange_required?
@@ -130,17 +144,19 @@ module Spree
       exchange_variant_engine.eligible_variants(variant)
     end
 
-    def build_exchange_inventory_unit
+    def build_default_exchange_inventory_unit
       # The inventory unit needs to have the new variant
       # but it also needs to know the original line item
       # for pricing information for if the inventory unit is
       # ever returned. This means that the inventory unit's line_item
       # will have a different variant than the inventory unit itself
-      super(variant: exchange_variant, line_item: inventory_unit.line_item, order: inventory_unit.order) if exchange_required?
+      return unless exchange_required?
+      exchange_inventory_units.build(variant: exchange_variant, line_item: inventory_unit.line_item,
+                                      order: inventory_unit.order, quantity: return_quantity)
     end
 
-    def exchange_shipment
-      exchange_inventory_unit.try(:shipment)
+    def exchange_shipments
+      exchange_inventory_units.map(&:shipment).uniq
     end
 
     def set_default_pre_tax_amount
@@ -170,7 +186,7 @@ module Spree
       inventory_unit.return!
       Spree::StockMovement.create!(
         stock_item_id: stock_item.id,
-        quantity: 1,
+        quantity: inventory_unit.quantity,
         originator: return_authorization
       ) if should_restock?
     end
@@ -206,6 +222,16 @@ module Spree
       end
     end
 
+    def sufficient_quantity_for_return
+      # Only perform the check if everything is good so far
+      return unless errors.empty? && return_quantity > inventory_unit.quantity
+      errors.add(:return_quantity, Spree.t(:cannot_return_more_than_bought_quantity))
+    end
+
+    def extract_inventory_unit
+      self.inventory_unit = inventory_unit.split_inventory!(return_quantity)
+    end
+
     def set_exchange_pre_tax_amount
       self.pre_tax_amount = 0.0.to_d if exchange_requested?
     end

data/app/models/spree/role.rb

@@ -3,6 +3,6 @@ module Spree
     has_many :role_users, class_name: 'Spree::RoleUser', dependent: :destroy
     has_many :users, through: :role_users, class_name: Spree.user_class.to_s
 
-    validates :name, presence: true, uniqueness: { allow_blank: true }
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
   end
 end

data/app/models/spree/role_user.rb

@@ -1,6 +1,6 @@
 module Spree
   class RoleUser < Spree::Base
     belongs_to :role, class_name: 'Spree::Role'
-    belongs_to :user, class_name: Spree.user_class
+    belongs_to :user, class_name: Spree.user_class.to_s
   end
 end

data/app/models/spree/shipment.rb

@@ -4,8 +4,7 @@ module Spree
   class Shipment < Spree::Base
     include Spree::Core::NumberGenerator.new(prefix: 'H', length: 11)
 
-    extend FriendlyId
-    friendly_id :number, slug_column: :number, use: :slugged
+    include NumberAsParam
 
     with_options inverse_of: :shipments do
       belongs_to :address, class_name: 'Spree::Address'
@@ -20,14 +19,14 @@ module Spree
       has_many :state_changes, as: :stateful
     end
     has_many :shipping_methods, through: :shipping_rates
-    has_one :selected_shipping_rate, -> { where(selected: true).order(:cost) }, class_name: Spree::ShippingRate
-
+    has_one :selected_shipping_rate, -> { where(selected: true).order(:cost) }, class_name: Spree::ShippingRate.to_s
 
     after_save :update_adjustments
 
     before_validation :set_cost_zero_when_nil
 
     validates :stock_location, presence: true
+    validates :number, uniqueness: true
 
     attr_accessor :special_instructions
 
@@ -56,12 +55,12 @@ module Spree
       end
 
       event :ship do
-        transition from: [:ready, :canceled], to: :shipped
+        transition from: %i(ready canceled), to: :shipped
       end
       after_transition to: :shipped, do: :after_ship
 
       event :cancel do
-        transition to: :canceled, from: [:pending, :ready]
+        transition to: :canceled, from: %i(pending ready)
       end
       after_transition to: :canceled, do: :after_cancel
 
@@ -71,7 +70,7 @@ module Spree
         }
         transition from: :canceled, to: :pending
       end
-      after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
+      after_transition from: :canceled, to: %i(pending ready shipped), do: :after_resume
 
       after_transition do |shipment, transition|
         shipment.state_changes.create!(
@@ -101,7 +100,7 @@ module Spree
     end
 
     def backordered?
-      inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
+      inventory_units.any?(&:backordered?)
     end
 
     def currency
@@ -126,7 +125,7 @@ module Spree
     end
     alias discounted_amount discounted_cost
 
-    def editable_by?(user)
+    def editable_by?(_user)
       !shipped?
     end
 
@@ -168,22 +167,21 @@ module Spree
     def manifest
       # Grouping by the ID means that we don't have to call out to the association accessor
       # This makes the grouping by faster because it results in less SQL cache hits.
-      inventory_units.group_by(&:variant_id).map do |variant_id, units|
-        units.group_by(&:line_item_id).map do |line_item_id, units|
-
+      inventory_units.group_by(&:variant_id).map do |_variant_id, units|
+        units.group_by(&:line_item_id).map do |_line_item_id, units|
           states = {}
-          units.group_by(&:state).each { |state, iu| states[state] = iu.size }
+          units.group_by(&:state).each { |state, iu| states[state] = iu.sum(&:quantity) }
 
           line_item = units.first.line_item
           variant = units.first.variant
-          ManifestItem.new(line_item, variant, units.length, states)
+          ManifestItem.new(line_item, variant, units.sum(&:quantity), states)
         end
       end.flatten
     end
 
     def process_order_payments
-      pending_payments =  order.pending_payments
-                            .sort_by(&:uncaptured_amount).reverse
+      pending_payments = order.pending_payments.
+                         sort_by(&:uncaptured_amount).reverse
 
       shipment_to_pay = final_price_with_items
       payments_amount = 0
@@ -208,7 +206,7 @@ module Spree
     end
 
     def ready_or_pending?
-      self.ready? || self.pending?
+      ready? || pending?
     end
 
     def refresh_rates(shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
@@ -219,12 +217,12 @@ module Spree
       original_shipping_method_id = shipping_method.try(:id)
 
       self.shipping_rates = Stock::Estimator.new(order).
-      shipping_rates(to_package, shipping_method_filter)
+                            shipping_rates(to_package, shipping_method_filter)
 
       if shipping_method
-        selected_rate = shipping_rates.detect { |rate|
+        selected_rate = shipping_rates.detect do |rate|
           rate.shipping_method_id == original_shipping_method_id
-        }
+        end
         self.selected_shipping_rate_id = selected_rate.id if selected_rate
       end
 
@@ -238,11 +236,11 @@ module Spree
     def selected_shipping_rate_id=(id)
       shipping_rates.update_all(selected: false)
       shipping_rates.update(id, selected: true)
-      self.save!
+      save!
     end
 
     def set_up_inventory(state, variant, order, line_item)
-      self.inventory_units.create(
+      inventory_units.create(
         state: state,
         variant_id: variant.id,
         order_id: order.id,
@@ -284,7 +282,7 @@ module Spree
 
     def update_amounts
       if selected_shipping_rate
-        self.update_columns(
+        update_columns(
           cost: selected_shipping_rate.cost,
           adjustment_total: adjustments.additional.map(&:update!).compact.sum,
           updated_at: Time.current,
@@ -294,20 +292,20 @@ module Spree
 
     # Update Shipment and make sure Order states follow the shipment changes
     def update_attributes_and_order(params = {})
-      if self.update_attributes params
-        if params.has_key? :selected_shipping_rate_id
+      if update_attributes params
+        if params.key? :selected_shipping_rate_id
           # Changing the selected Shipping Rate won't update the cost (for now)
           # so we persist the Shipment#cost before calculating order shipment
           # total and updating payment state (given a change in shipment cost
           # might change the Order#payment_state)
-          self.update_amounts
+          update_amounts
 
           order.updater.update_shipment_total
           order.updater.update_payment_state
 
           # Update shipment state only after order total is updated because it
           # (via Order#paid?) affects the shipment state (YAY)
-          self.update_columns(
+          update_columns(
             state: determine_state(order),
             updated_at: Time.current
           )
@@ -332,7 +330,7 @@ module Spree
         state: new_state,
         updated_at: Time.current,
       )
-      after_ship if new_state == 'shipped' and old_state != 'shipped'
+      after_ship if new_state == 'shipped' && old_state != 'shipped'
     end
 
     def transfer_to_location(variant, quantity, stock_location)
@@ -343,8 +341,8 @@ module Spree
       transaction do
         new_shipment = order.shipments.create!(stock_location: stock_location)
 
-        order.contents.remove(variant, quantity, {shipment: self})
-        order.contents.add(variant, quantity, {shipment: new_shipment})
+        order.contents.remove(variant, quantity, shipment: self)
+        order.contents.add(variant, quantity, shipment: new_shipment)
 
         refresh_rates
         save!
@@ -353,16 +351,18 @@ module Spree
     end
 
     def transfer_to_shipment(variant, quantity, shipment_to_transfer_to)
-      quantity_already_shipment_to_transfer_to = shipment_to_transfer_to.manifest.find{|mi| mi.line_item.variant == variant}.try(:quantity) || 0
+      quantity_already_shipment_to_transfer_to = shipment_to_transfer_to.manifest.find do |mi|
+        mi.line_item.variant == variant
+      end.try(:quantity) || 0
       final_quantity = quantity + quantity_already_shipment_to_transfer_to
 
-      if (quantity <= 0 || self == shipment_to_transfer_to)
+      if quantity <= 0 || self == shipment_to_transfer_to
         raise ArgumentError
       end
 
       transaction do
-        order.contents.remove(variant, quantity, {shipment: self})
-        order.contents.add(variant, quantity, {shipment: shipment_to_transfer_to})
+        order.contents.remove(variant, quantity, shipment: self)
+        order.contents.add(variant, quantity, shipment: shipment_to_transfer_to)
 
         refresh_rates
         save!
@@ -373,45 +373,44 @@ module Spree
 
     private
 
-      def after_ship
-        ShipmentHandler.factory(self).perform
-      end
-
-      def can_get_rates?
-        order.ship_address && order.ship_address.valid?
-      end
+    def after_ship
+      ShipmentHandler.factory(self).perform
+    end
 
-      def manifest_restock(item)
-        if item.states["on_hand"].to_i > 0
-         stock_location.restock item.variant, item.states["on_hand"], self
-        end
+    def can_get_rates?
+      order.ship_address && order.ship_address.valid?
+    end
 
-        if item.states["backordered"].to_i > 0
-          stock_location.restock_backordered item.variant, item.states["backordered"]
-        end
+    def manifest_restock(item)
+      if item.states["on_hand"].to_i.positive?
+        stock_location.restock item.variant, item.states["on_hand"], self
       end
 
-      def manifest_unstock(item)
-        stock_location.unstock item.variant, item.quantity, self
+      if item.states["backordered"].to_i.positive?
+        stock_location.restock_backordered item.variant, item.states["backordered"]
       end
+    end
 
-      def recalculate_adjustments
-        Adjustable::AdjustmentsUpdater.update(self)
-      end
+    def manifest_unstock(item)
+      stock_location.unstock item.variant, item.quantity, self
+    end
 
-      def send_shipped_email
-        ShipmentMailer.shipped_email(id).deliver_later
-      end
+    def recalculate_adjustments
+      Adjustable::AdjustmentsUpdater.update(self)
+    end
 
-      def set_cost_zero_when_nil
-        self.cost = 0 unless self.cost
-      end
+    def send_shipped_email
+      ShipmentMailer.shipped_email(id).deliver_later
+    end
 
-      def update_adjustments
-        if cost_changed? && state != 'shipped'
-          recalculate_adjustments
-        end
-      end
+    def set_cost_zero_when_nil
+      self.cost = 0 unless cost
+    end
 
+    def update_adjustments
+      if saved_change_to_cost? && state != 'shipped'
+        recalculate_adjustments
+      end
+    end
   end
 end