spree_core 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b435838b2a77628006e2e2885f5dbe2039958630
-  data.tar.gz: 1df2bcec2ac50c9d4716017752eb8c56ab2f9960
+  metadata.gz: 4eb6afc84186dd0b46d37daebea561e582412dfb
+  data.tar.gz: 96ad34a945d823c7f0ce6d17797c183eee5f4261
 SHA512:
-  metadata.gz: 1154f9c96163b14b0f85379e73718b6e5a95a6b60688399df8b724e109880d1e21deb4dbd77d44ae8dd29fe1cd98bd563d74c6ce191ac89eff57424dba437602
-  data.tar.gz: 5d008b1beae9dc20bf209bcc59063debee39ae36c6426569f970af0aad14b64287b61f9bed6454190e694ce96cb9b145be04b15066bc8abc80da9fb3c91c21fe
+  metadata.gz: 2a990089d87e7ed851394892fe747d8146fdd7992a1f1d70f1cb7447a6471c937dd1faf5380cbec891844f048049b5f8b65312bae912ae69cf46690f235e2dab
+  data.tar.gz: c13e7f2071ddac220493da65f4407b25e00cf0704a7d205637c67513487f7646e60ab209d43ed3a2365d81d473420c6fb56760331a7598dc2e66c7966837e9e6

data/app/mailers/spree/test_mailer.rb

@@ -1,8 +1,9 @@
 module Spree
   class TestMailer < BaseMailer
     def test_email(user)
+      recipient = user.respond_to?(:id) ? user : Spree.user_class.find(user)
       subject = "#{Spree::Config[:site_name]} #{Spree.t('test_mailer.test_email.subject')}"
-      mail(to: user.email, from: from_address, subject: subject)
+      mail(to: recipient.email, from: from_address, subject: subject)
     end
   end
 end

data/app/models/spree/adjustment.rb

@@ -60,10 +60,14 @@ module Spree
     scope :promotion, -> { where(originator_type: 'Spree::PromotionAction') }
     scope :return_authorization, -> { where(source_type: "Spree::ReturnAuthorization") }
 
+    def promotion?
+      originator_type == 'Spree::PromotionAction'
+    end
+
     # Update the boolean _eligible_ attribute which determines which adjustments
     # count towards the order's adjustment_total.
     def set_eligibility
-      result = self.mandatory || (self.amount != 0 && self.eligible_for_originator?)
+      result = mandatory || ((amount != 0 || promotion?) && eligible_for_originator?)
       update_attribute_without_callbacks(:eligible, result)
     end
 
@@ -74,20 +78,27 @@ module Spree
       !originator.respond_to?(:eligible?) || originator.eligible?(source)
     end
 
-    # Update both the eligibility and amount of the adjustment. Adjustments 
+    # Update both the eligibility and amount of the adjustment. Adjustments
     # delegate updating of amount to their Originator when present, but only if
     # +locked+ is false. Adjustments that are +locked+ will never change their amount.
     #
-    # order#update_adjustments passes self as the src, this is so calculations can
-    # be performed on the # current values. If we used source it would load the old
-    # record from db for the association
-    def update!
+    # Adjustments delegate updating of amount to their Originator when present,
+    # but only if when they're in "open" state, closed or finalized adjustments
+    # are not recalculated.
+    #
+    # It receives +calculable+ as the updated source here so calculations can be
+    # performed on the current values of that source. If we used +source+ it 
+    # could load the old record from db for the association. e.g. when updating
+    # more than on line items at once via accepted_nested_attributes the order
+    # object on the association would be in a old state and therefore the
+    # adjustment calculations would not performed on proper values
+    def update!(calculable = nil)
       return if immutable?
       # Fix for #3381
       # If we attempt to call 'source' before the reload, then source is currently
       # the order object. After calling a reload, the source is the Shipment.
       reload
-      originator.update_adjustment(self, source) if originator.present?
+      originator.update_adjustment(self, calculable || source) if originator.present?
       set_eligibility
     end
 

data/app/models/spree/alert.rb

@@ -11,7 +11,7 @@ module Spree
         rails_version: Rails.version
       }
 
-      HTTParty.get('http://alerts.spreecommerce.com/alerts.json', body: params).parsed_response
+      HTTParty.get('http://alerts.spreecommerce.com/alerts.json', query: params).parsed_response
     end
   end
 end

data/app/models/spree/credit_card.rb

@@ -105,9 +105,9 @@ module Spree
     private
 
     def expiry_not_in_the_past
-      if year && month
+      if year.present? && month.present?
         time = "#{year}-#{month}-1".to_time
-        if time < Time.zone.now.beginning_of_month
+        if time < Time.zone.now.to_time.beginning_of_month
           errors.add(:base, :card_expired)
         end
       end

data/app/models/spree/inventory_unit.rb

@@ -53,6 +53,11 @@ module Spree
         variant_id: variant_id).first
     end
 
+    # Remove variant default_scope `deleted_at: nil`
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
     private
 
       def allow_ship?

data/app/models/spree/line_item.rb

@@ -85,15 +85,29 @@ module Spree
       @preferred_shipment = shipment
     end
 
+    # Remove product default_scope `deleted_at: nil`
+    def product
+      variant.product
+    end
+
+    # Remove variant default_scope `deleted_at: nil`
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
     private
       def update_inventory
-        Spree::OrderInventory.new(self.order).verify(self, target_shipment)
+        if changed?
+          Spree::OrderInventory.new(self.order).verify(self, target_shipment)
+        end
       end
 
       def update_order
-        # update the order totals, etc.
-        order.create_tax_charge!
-        order.update!
+        if changed? || destroyed?
+          # update the order totals, etc.
+          order.create_tax_charge!
+          order.update!
+        end
       end
   end
 end

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

@@ -63,10 +63,12 @@ module Spree
                 transition :to => :awaiting_return
               end
 
-
-              before_transition :to => :complete do |order|
-                order.process_payments! if order.payment_required?
+              if states[:payment]
+                before_transition :to => :complete do |order|
+                  order.process_payments! if order.payment_required?
+                end
               end
+
               before_transition :from => :cart, :do => :ensure_line_items_present
 
               before_transition :to => :delivery, :do => :create_proposed_shipments
@@ -125,12 +127,11 @@ module Spree
 
           def self.remove_transition(options={})
             self.removed_transitions << options
-            if transition = find_transition(options)
-              self.next_event_transitions.delete(transition)
-            end
+            self.next_event_transitions.delete(find_transition(options))
           end
 
           def self.find_transition(options={})
+            return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
             self.next_event_transitions.detect do |transition|
               transition[options[:from].to_sym] == options[:to].to_sym
             end
@@ -149,15 +150,10 @@ module Spree
           end
 
           def checkout_steps
-            checkout_steps = []
-            # TODO: replace this with each_with_object once Ruby 1.9 is standard
-            self.class.checkout_steps.each do |step, options|
-              if options[:if]
-                next unless options[:if].call(self)
-              end
+            steps = self.class.checkout_steps.each_with_object([]) { |(step, options), checkout_steps|
+              next if options.include?(:if) && !options[:if].call(self)
               checkout_steps << step
-            end
-            steps = checkout_steps.map(&:to_s)
+            }.map(&:to_s)
             # Ensure there is always a complete step
             steps << "complete" unless steps.include?("complete")
             steps

data/app/models/spree/order.rb

@@ -47,9 +47,12 @@ module Spree
     belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address'
     alias_attribute :shipping_address, :ship_address
 
+    has_many :adjustments, as: :adjustable, dependent: :destroy, order: 'created_at ASC'
+    has_many :line_item_adjustments, through: :line_items, source: :adjustments
+    has_many :line_items, dependent: :destroy, order: 'created_at ASC'
+    has_many :payments, dependent: :destroy
+    has_many :return_authorizations, dependent: :destroy
     has_many :state_changes, as: :stateful
-    has_many :line_items, dependent: :destroy, order: "#{Spree::LineItem.table_name}.created_at ASC"
-    has_many :payments, dependent: :destroy, :class_name => "Spree::Payment"
 
     has_many :shipments, dependent: :destroy, :class_name => "Shipment" do
       def states
@@ -57,13 +60,6 @@ module Spree
       end
     end
 
-    has_many :return_authorizations, dependent: :destroy
-    has_many :adjustments, 
-      as: :adjustable,
-      dependent: :destroy,
-      order: "#{Spree::Adjustment.table_name}.created_at ASC",
-      inverse_of: :source
-
     accepts_nested_attributes_for :line_items
     accepts_nested_attributes_for :bill_address
     accepts_nested_attributes_for :ship_address
@@ -202,26 +198,26 @@ module Spree
       return tax_zone != Zone.default_tax
     end
 
-    # Array of adjustments that are inclusive in the variant price. Useful for when
-    # prices include tax (ex. VAT) and you need to record the tax amount separately.
     def price_adjustments
-      adjustments = []
-
-      line_items.each { |line_item| adjustments.concat line_item.adjustments }
-
-      adjustments
+      ActiveSupport::Deprecation.warn("Order#price_adjustments will be deprecated in Spree 2.1, please use Order#line_item_adjustments instead.")
+      self.line_item_adjustments
     end
 
-    # Array of totals grouped by Adjustment#label. Useful for displaying price
+    # Array of totals grouped by Adjustment#label. Useful for displaying line item
     # adjustments on an invoice. For example, you can display tax breakout for
     # cases where tax is included in price.
-    def price_adjustment_totals
-      Hash[price_adjustments.group_by(&:label).map do |label, adjustments|
+    def line_item_adjustment_totals
+      Hash[self.line_item_adjustments.eligible.group_by(&:label).map do |label, adjustments|
         total = adjustments.sum(&:amount)
         [label, Spree::Money.new(total, { currency: currency })]
       end]
     end
 
+    def price_adjustment_totals
+      ActiveSupport::Deprecation.warn("Order#price_adjustment_totals will be deprecated in Spree 2.1, please use Order#line_item_adjustment_totals instead.")
+      self.line_item_adjustment_totals
+    end
+
     def updater
       @updater ||= OrderUpdater.new(self)
     end
@@ -279,10 +275,11 @@ module Spree
     def associate_user!(user)
       self.user = user
       self.email = user.email
+      self.created_by = user if self.created_by.blank?
 
       if persisted?
         # immediately persist the changes we just made, but don't use save since we might have an invalid address associated
-        self.class.unscoped.where(id: id).update_all(email: user.email, user_id: user.id)
+        self.class.unscoped.where(id: id).update_all(email: user.email, user_id: user.id, created_by_id: self.created_by_id)
       end
     end
 
@@ -368,7 +365,7 @@ module Spree
       touch :completed_at
 
       # lock all adjustments (coupon promotions, etc.)
-      adjustments.each { |adjustment| adjustment.update_column('state', "closed") }
+      adjustments.update_all state: 'closed'
 
       # update payment and shipment(s) states, and save
       updater.update_payment_state
@@ -462,7 +459,7 @@ module Spree
     end
 
     def insufficient_stock_lines
-      line_items.select &:insufficient_stock?
+     @insufficient_stock_lines ||= line_items.select(&:insufficient_stock?)
     end
 
     def merge!(order)
@@ -487,11 +484,9 @@ module Spree
       adjustments.destroy_all
     end
 
-    # destroy any previous adjustments.
-    # Adjustments will be recalculated during order update.
     def clear_adjustments!
-      adjustments.tax.each(&:destroy)
-      price_adjustments.each(&:destroy)
+      self.adjustments.destroy_all
+      self.line_item_adjustments.destroy_all
     end
 
     def has_step?(step)
@@ -522,7 +517,7 @@ module Spree
     # Receives an adjustment +originator+ (here a PromotionAction object) and tells
     # if the order has adjustments from that already
     def promotion_credit_exists?(originator)
-      !! adjustments.promotion.reload.detect { |credit| credit.originator.id == originator.id }
+      !! adjustments.includes(:originator).promotion.reload.detect { |credit| credit.originator.id == originator.id }
     end
 
     def promo_total
@@ -534,6 +529,7 @@ module Spree
     end
 
     def create_proposed_shipments
+      adjustments.shipping.delete_all
       shipments.destroy_all
 
       packages = Spree::Stock::Coordinator.new(self).packages
@@ -544,6 +540,22 @@ module Spree
       shipments
     end
 
+    # Clean shipments and make order back to address state
+    #
+    # At some point the might need to force the order to transition from address
+    # to delivery again so that proper updated shipments are created.
+    # e.g. customer goes back from payment step and changes order items 
+    def ensure_updated_shipments
+      if shipments.any?
+        self.shipments.destroy_all
+        self.update_column(:state, "address")
+      end
+    end
+
+    def refresh_shipment_rates
+      shipments.map &:refresh_rates
+    end
+
     private
 
       def link_by_email

data/app/models/spree/order_contents.rb

@@ -8,14 +8,14 @@ module Spree
 
     # Get current line item for variant if exists
     # Add variant qty to line_item
-    def add(variant, quantity, currency=nil, shipment=nil)
+    def add(variant, quantity=1, currency=nil, shipment=nil)
       line_item = order.find_line_item_by_variant(variant)
       add_to_line_item(line_item, variant, quantity, currency, shipment)
     end
 
     # Get current line item for variant
     # Remove variant qty from line_item
-    def remove(variant, quantity, shipment=nil)
+    def remove(variant, quantity=1, shipment=nil)
       line_item = order.find_line_item_by_variant(variant)
 
       unless line_item

data/app/models/spree/order_inventory.rb

@@ -67,15 +67,8 @@ module Spree
     def add_to_shipment(shipment, variant, quantity)
       on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
 
-      on_hand.times do
-        shipment.inventory_units.create({variant_id: variant.id,
-                                          state: 'on_hand'}, without_protection: true)
-      end
-
-      back_order.times do
-        shipment.inventory_units.create({variant_id: variant.id,
-                                         state: 'backordered'}, without_protection: true)
-      end
+      on_hand.times { shipment.set_up_inventory('on_hand', variant, order) }
+      back_order.times { shipment.set_up_inventory('backordered', variant, order) }
 
       # adding to this shipment, and removing from stock_location
       if order.completed?

data/app/models/spree/order_updater.rb

@@ -16,12 +16,17 @@ module Spree
     # associations try to save and then in turn try to call +update!+ again.)
     def update
       update_totals
-      update_payment_state
 
-      # give each of the shipments a chance to update themselves
-      shipments.each { |shipment| shipment.update!(order) }#(&:update!)
-      update_shipment_state
-      update_adjustments
+      if order.completed?
+        update_payment_state
+
+        # give each of the shipments a chance to update themselves
+        shipments.each { |shipment| shipment.update!(order) }
+        update_shipment_state
+      end
+      
+      update_promotion_adjustments
+      update_shipping_adjustments
       # update totals a second time in case updated adjustments have an effect on the total
       update_totals
 
@@ -120,11 +125,17 @@ module Spree
     #
     # Adjustments will check if they are still eligible. Ineligible adjustments
     # are preserved but not counted towards adjustment_total.
-    def update_adjustments
-      order.adjustments.reload.each { |adjustment| adjustment.update! }
+    def update_promotion_adjustments
+      order.adjustments.reload.promotion.each { |adjustment| adjustment.update!(order) }
       choose_best_promotion_adjustment
     end
 
+    # Shipping adjustments don't receive order on update! because they calculated
+    # over a shipping / package object rather than an order object
+    def update_shipping_adjustments
+      order.adjustments.reload.shipping.each { |adjustment| adjustment.update! }
+    end
+
     private
 
       # Picks one (and only one) promotion to be eligible for this order

data/app/models/spree/payment/processing.rb

@@ -76,133 +76,133 @@ module Spree
           end
         end
       end
-    end
 
-    def credit!(credit_amount=nil)
-      protect_from_connection_error do
-        check_environment
+      def credit!(credit_amount=nil)
+        protect_from_connection_error do
+          check_environment
 
-        credit_amount ||= credit_allowed >= order.outstanding_balance.abs ? order.outstanding_balance.abs : credit_allowed.abs
-        credit_amount = credit_amount.to_f
+          credit_amount ||= credit_allowed >= order.outstanding_balance.abs ? order.outstanding_balance.abs : credit_allowed.abs
+          credit_amount = credit_amount.to_f
 
-        if payment_method.payment_profiles_supported?
-          response = payment_method.credit((credit_amount * 100).round, source, response_code, gateway_options)
-        else
-          response = payment_method.credit((credit_amount * 100).round, response_code, gateway_options)
-        end
+          if payment_method.payment_profiles_supported?
+            response = payment_method.credit((credit_amount * 100).round, source, response_code, gateway_options)
+          else
+            response = payment_method.credit((credit_amount * 100).round, response_code, gateway_options)
+          end
 
-        record_response(response)
+          record_response(response)
 
-        if response.success?
-          self.class.create({ :order => order,
-                              :source => self,
-                              :payment_method => payment_method,
-                              :amount => credit_amount.abs * -1,
-                              :response_code => response.authorization,
-                              :state => 'completed' }, :without_protection => true)
-        else
-          gateway_error(response)
+          if response.success?
+            self.class.create({ :order => order,
+                                :source => self,
+                                :payment_method => payment_method,
+                                :amount => credit_amount.abs * -1,
+                                :response_code => response.authorization,
+                                :state => 'completed' }, :without_protection => true)
+          else
+            gateway_error(response)
+          end
         end
       end
-    end
 
-    def partial_credit(amount)
-      return if amount > credit_allowed
-      started_processing!
-      credit!(amount)
-    end
+      def partial_credit(amount)
+        return if amount > credit_allowed
+        started_processing!
+        credit!(amount)
+      end
 
-    def gateway_options
-      options = { :email    => order.email,
-                  :customer => order.email,
-                  :ip       => order.last_ip_address,
-                  # Need to pass in a unique identifier here to make some
-                  # payment gateways happy.
-                  #
-                  # For more information, please see Spree::Payment#set_unique_identifier
-                  :order_id => gateway_order_id }
-
-      options.merge!({ :shipping => order.ship_total * 100,
-                       :tax      => order.tax_total * 100,
-                       :subtotal => order.item_total * 100,
-                       :discount => order.promo_total * 100,
-                       :currency => currency })
-
-      options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),
-                      :shipping_address => order.ship_address.try(:active_merchant_hash) })
-
-      options
-    end
+      def gateway_options
+        options = { :email    => order.email,
+                    :customer => order.email,
+                    :ip       => order.last_ip_address,
+                    # Need to pass in a unique identifier here to make some
+                    # payment gateways happy.
+                    #
+                    # For more information, please see Spree::Payment#set_unique_identifier
+                    :order_id => gateway_order_id }
+
+        options.merge!({ :shipping => order.ship_total * 100,
+                         :tax      => order.tax_total * 100,
+                         :subtotal => order.item_total * 100,
+                         :discount => order.promo_total * 100,
+                         :currency => currency })
+
+        options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),
+                        :shipping_address => order.ship_address.try(:active_merchant_hash) })
+
+        options
+      end
 
-    private
+      private
 
-    def gateway_action(source, action, success_state)
-      protect_from_connection_error do
-        check_environment
+      def gateway_action(source, action, success_state)
+        protect_from_connection_error do
+          check_environment
 
-        response = payment_method.send(action, (amount * 100).round,
-                                       source,
-                                       gateway_options)
-        handle_response(response, success_state, :failure)
+          response = payment_method.send(action, (amount * 100).round,
+                                         source,
+                                         gateway_options)
+          handle_response(response, success_state, :failure)
+        end
       end
-    end
 
-    def handle_response(response, success_state, failure_state)
-      record_response(response)
+      def handle_response(response, success_state, failure_state)
+        record_response(response)
 
-      if response.success?
-        unless response.authorization.nil?
-          self.response_code = response.authorization
-          self.avs_response = response.avs_result['code']
+        if response.success?
+          unless response.authorization.nil?
+            self.response_code = response.authorization
+            self.avs_response = response.avs_result['code']
 
-          if response.cvv_result
-            self.cvv_response_code = response.cvv_result['code']
-            self.cvv_response_message = response.cvv_result['message']
+            if response.cvv_result
+              self.cvv_response_code = response.cvv_result['code']
+              self.cvv_response_message = response.cvv_result['message']
+            end
           end
+          self.send("#{success_state}!")
+        else
+          self.send(failure_state)
+          gateway_error(response)
         end
-        self.send("#{success_state}!")
-      else
-        self.send(failure_state)
-        gateway_error(response)
       end
-    end
 
-    def record_response(response)
-      log_entries.create({:details => response.to_yaml}, :without_protection => true)
-    end
+      def record_response(response)
+        log_entries.create({:details => response.to_yaml}, :without_protection => true)
+      end
 
-    def protect_from_connection_error
-      begin
-        yield
-      rescue ActiveMerchant::ConnectionError => e
-        gateway_error(e)
+      def protect_from_connection_error
+        begin
+          yield
+        rescue ActiveMerchant::ConnectionError => e
+          gateway_error(e)
+        end
       end
-    end
 
-    def gateway_error(error)
-      if error.is_a? ActiveMerchant::Billing::Response
-        text = error.params['message'] || error.params['response_reason_text'] || error.message
-      elsif error.is_a? ActiveMerchant::ConnectionError
-        text = Spree.t(:unable_to_connect_to_gateway)
-      else
-        text = error.to_s
+      def gateway_error(error)
+        if error.is_a? ActiveMerchant::Billing::Response
+          text = error.params['message'] || error.params['response_reason_text'] || error.message
+        elsif error.is_a? ActiveMerchant::ConnectionError
+          text = Spree.t(:unable_to_connect_to_gateway)
+        else
+          text = error.to_s
+        end
+        logger.error(Spree.t(:gateway_error))
+        logger.error("  #{error.to_yaml}")
+        raise Core::GatewayError.new(text)
       end
-      logger.error(Spree.t(:gateway_error))
-      logger.error("  #{error.to_yaml}")
-      raise Core::GatewayError.new(text)
-    end
 
-    # Saftey check to make sure we're not accidentally performing operations on a live gateway.
-    # Ex. When testing in staging environment with a copy of production data.
-    def check_environment
-      return if payment_method.environment == Rails.env
-      message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
-      raise Core::GatewayError.new(message)
-    end
+      # Saftey check to make sure we're not accidentally performing operations on a live gateway.
+      # Ex. When testing in staging environment with a copy of production data.
+      def check_environment
+        return if payment_method.environment == Rails.env
+        message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
+        raise Core::GatewayError.new(message)
+      end
 
-    # The unique identifier to be passed in to the payment gateway
-    def gateway_order_id
-      "#{order.number}-#{self.identifier}"
+      # The unique identifier to be passed in to the payment gateway
+      def gateway_order_id
+        "#{order.number}-#{self.identifier}"
+      end
     end
   end
-end
+end