spree_core 3.0.1 → 3.0.2

data/app/models/spree/order_contents.rb

@@ -7,7 +7,9 @@ module Spree
     end
 
     def add(variant, quantity = 1, options = {})
+      timestamp = Time.now
       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)
     end
 
@@ -22,10 +24,10 @@ module Spree
         # Update totals, then check if the order is eligible for any cart promotions.
         # If we do not update first, then the item total will be wrong and ItemTotal
         # promotion rules would not be triggered.
-        reload_totals
+        persist_totals
         PromotionHandler::Cart.new(order).activate
         order.ensure_updated_shipments
-        reload_totals
+        persist_totals
         true
       else
         false
@@ -33,80 +35,81 @@ module Spree
     end
 
     private
-      def after_add_or_remove(line_item, options = {})
-        reload_totals
-        shipment = options[:shipment]
-        shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
-        PromotionHandler::Cart.new(order, line_item).activate
-        Adjustable::AdjustmentsUpdater.update(line_item)
-        reload_totals
-        line_item
-      end
 
-      def filter_order_items(params)
-        filtered_params = params.symbolize_keys
-        return filtered_params if filtered_params[:line_items_attributes].nil? || filtered_params[:line_items_attributes][:id]
+    def after_add_or_remove(line_item, options = {})
+      persist_totals
+      shipment = options[:shipment]
+      shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
+      PromotionHandler::Cart.new(order, line_item).activate
+      Adjustable::AdjustmentsUpdater.update(line_item)
+      TaxRate.adjust(order, [line_item]) if options[:line_item_created]
+      persist_totals
+      line_item
+    end
+
+    def filter_order_items(params)
+      filtered_params = params.symbolize_keys
+      return filtered_params if filtered_params[:line_items_attributes].nil? || filtered_params[:line_items_attributes][:id]
 
-        line_item_ids = order.line_items.pluck(:id)
+      line_item_ids = order.line_items.pluck(:id)
 
-        params[:line_items_attributes].each_pair do |id, value|
-          unless line_item_ids.include?(value[:id].to_i) || value[:variant_id].present?
-            filtered_params[:line_items_attributes].delete(id)
-          end
+      params[:line_items_attributes].each_pair do |id, value|
+        unless line_item_ids.include?(value[:id].to_i) || value[:variant_id].present?
+          filtered_params[:line_items_attributes].delete(id)
         end
-        filtered_params
       end
+      filtered_params
+    end
 
-      def order_updater
-        @updater ||= OrderUpdater.new(order)
-      end
+    def order_updater
+      @updater ||= OrderUpdater.new(order)
+    end
 
-      def reload_totals
-        order_updater.update_item_count
-        order_updater.update
-        order.reload
-      end
+    def persist_totals
+      order_updater.update_item_count
+      order_updater.update
+    end
 
-      def add_to_line_item(variant, quantity, options = {})
-        line_item = grab_line_item_by_variant(variant, false, options)
-
-        if line_item
-          line_item.quantity += quantity.to_i
-          line_item.currency = currency unless currency.nil?
-        else
-          opts = { currency: order.currency }.merge ActionController::Parameters.new(options).
-                                              permit(PermittedAttributes.line_item_attributes)
-          line_item = order.line_items.new(quantity: quantity,
-                                            variant: variant,
-                                            options: opts)
-        end
-        line_item.target_shipment = options[:shipment] if options.has_key? :shipment
-        line_item.save!
-        line_item
-      end
+    def add_to_line_item(variant, quantity, options = {})
+      line_item = grab_line_item_by_variant(variant, false, options)
 
-      def remove_from_line_item(variant, quantity, options = {})
-        line_item = grab_line_item_by_variant(variant, true, options)
-        line_item.quantity -= quantity
-        line_item.target_shipment= options[:shipment]
+      if line_item
+        line_item.quantity += quantity.to_i
+        line_item.currency = currency unless currency.nil?
+      else
+        opts = { currency: order.currency }.merge ActionController::Parameters.new(options).
+                                            permit(PermittedAttributes.line_item_attributes)
+        line_item = order.line_items.new(quantity: quantity,
+                                          variant: variant,
+                                          options: opts)
+      end
+      line_item.target_shipment = options[:shipment] if options.has_key? :shipment
+      line_item.save!
+      line_item
+    end
 
-        if line_item.quantity == 0
-          line_item.destroy
-        else
-          line_item.save!
-        end
+    def remove_from_line_item(variant, quantity, options = {})
+      line_item = grab_line_item_by_variant(variant, true, options)
+      line_item.quantity -= quantity
+      line_item.target_shipment= options[:shipment]
 
-        line_item
+      if line_item.quantity.zero?
+        order.line_items.destroy(line_item)
+      else
+        line_item.save!
       end
 
-      def grab_line_item_by_variant(variant, raise_error = false, options = {})
-        line_item = order.find_line_item_by_variant(variant, options)
+      line_item
+    end
 
-        if !line_item.present? && raise_error
-          raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"
-        end
+    def grab_line_item_by_variant(variant, raise_error = false, options = {})
+      line_item = order.find_line_item_by_variant(variant, options)
 
-        line_item
+      if !line_item.present? && raise_error
+        raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"
       end
+
+      line_item
+    end
   end
 end

data/app/models/spree/order_merger.rb

@@ -0,0 +1,65 @@
+module Spree
+  class OrderMerger
+    attr_accessor :order
+    delegate :updater, to: :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    def merge!(other_order, user = nil)
+      other_order.line_items.each do |other_order_line_item|
+        next unless other_order_line_item.currency == order.currency
+
+        current_line_item = find_matching_line_item(other_order_line_item)
+        handle_merge(current_line_item, other_order_line_item)
+      end
+
+      set_user(user)
+      persist_merge
+
+      # So that the destroy doesn't take out line items which may have been re-assigned
+      other_order.line_items.reload
+      other_order.destroy
+    end
+
+    # Compare the line item of the other order with mine.
+    # Make sure you allow any extensions to chime in on whether or
+    # not the extension-specific parts of the line item match
+    def find_matching_line_item(other_order_line_item)
+      order.line_items.detect do |my_li|
+        my_li.variant == other_order_line_item.variant &&
+          order.line_item_comparison_hooks.all? do |hook|
+            order.send(hook, my_li, other_order_line_item.serializable_hash)
+          end
+      end
+    end
+
+    def set_user(user = nil)
+      order.associate_user!(user) if !order.user && !user.blank?
+    end
+
+    # The idea is the end developer can choose to override the merge
+    # to their own choosing. Default is merge with errors.
+    def handle_merge(current_line_item, other_order_line_item)
+      if current_line_item
+        current_line_item.quantity += other_order_line_item.quantity
+        handle_error(current_line_item) unless current_line_item.save
+      else
+        other_order_line_item.order_id = order.id
+        handle_error(other_order_line_item) unless other_order_line_item.save
+      end
+    end
+
+    # Change the error messages as you choose.
+    def handle_error(line_item)
+      order.errors[:base] << line_item.errors.full_messages
+    end
+
+    def persist_merge
+      updater.update_item_count
+      updater.update_item_total
+      updater.persist_totals
+    end
+  end
+end

data/app/models/spree/payment.rb

@@ -26,6 +26,7 @@ module Spree
     has_many :capture_events, class_name: 'Spree::PaymentCaptureEvent'
     has_many :refunds, inverse_of: :payment
 
+    validates_presence_of :payment_method
     before_validation :validate_source
 
     after_save :create_payment_profile, if: :profiles_supported?
@@ -173,6 +174,10 @@ module Spree
       amount - captured_amount
     end
 
+    def editable?
+      checkout? || pending?
+    end
+
     private
 
       def validate_source

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

@@ -69,7 +69,8 @@ module Spree
       end
 
       def cancel!
-        payment_method.cancel(response_code)
+        response = payment_method.cancel(response_code)
+        handle_response(response, :void, :failure)
       end
 
       def gateway_options

data/app/models/spree/payment_method/check.rb

@@ -15,17 +15,27 @@ module Spree
     end
 
     def capture(*args)
-      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+      simulated_successful_billing_response
     end
 
     def cancel(response); end
 
     def void(*args)
-      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+      simulated_successful_billing_response
     end
 
     def source_required?
       false
     end
+
+    def credit(*args)
+      simulated_successful_billing_response
+    end
+
+    private
+
+    def simulated_successful_billing_response
+      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    end
   end
 end

data/app/models/spree/product.rb

@@ -74,6 +74,7 @@ module Spree
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
     after_destroy :punch_slug
+    after_restore :update_slug_history
 
     after_initialize :ensure_master
 
@@ -267,6 +268,10 @@ module Spree
       update_column :slug, "#{Time.now.to_i}_#{slug}"[0..254] unless frozen?
     end
 
+    def update_slug_history
+      self.save!
+    end
+
     def anything_changed?
       changed? || @nested_changes
     end

data/app/models/spree/promotion_handler/cart.rb

@@ -29,22 +29,26 @@ module Spree
       end
 
       private
-        def promotions
-          promo_table = Promotion.arel_table
-          join_table = Arel::Table.new(:spree_orders_promotions)
 
-          join_condition = promo_table.join(join_table, Arel::Nodes::OuterJoin).on(
-            promo_table[:id].eq(join_table[:promotion_id])
-          ).join_sources
+      def promotions
+        # AR cannot bind raw ASTs to prepared statements. There always must be a manager around.
+        # Also Postgresql requires an aliased table for `SELECT * FROM (subexpression) AS alias`.
+        # And Sqlite3 cannot work on outher parenthesis from `(left UNION right)`.
+        # So this construct makes both happy.
+        select = Arel::SelectManager.new(
+          Promotion,
+          Promotion.arel_table.create_table_alias(
+            order.promotions.active.union(Promotion.active.where(code: nil, path: nil)),
+            Promotion.table_name
+          ),
+        )
+        select.project(Arel.star)
 
-          Promotion.active.includes(:promotion_rules).
-            joins(join_condition).
-            where(
-              promo_table[:code].eq(nil).and(
-                promo_table[:path].eq(nil)
-              ).or(join_table[:order_id].eq(order.id))
-            ).distinct
-        end
+        Promotion.find_by_sql(
+          select,
+          order.promotions.bind_values
+        )
+      end
     end
   end
 end

data/app/models/spree/shipment.rb

@@ -157,7 +157,7 @@ module Spree
     end
 
     def item_cost
-      line_items.map(&:final_amount).sum
+      manifest.map { |m| (m.line_item.price + (m.line_item.adjustment_total / m.line_item.quantity)) * m.quantity }.sum
     end
 
     def line_items

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

@@ -5,19 +5,20 @@ 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)
 
-        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?
+        return if quantifier.can_supply?(quantity)
 
-          line_item.errors[:quantity] << Spree.t(
-            :selected_quantity_not_available,
-            item: display_name.inspect
-          )
-        end
+        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
+        )
       end
     end
   end

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

@@ -43,6 +43,14 @@ module Spree
         # but this massively simplifies things for now
         1
       end
+
+      def volume
+        variant.volume * quantity
+      end
+
+      def dimension
+        variant.dimension * quantity
+      end
     end
   end
 end

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

@@ -91,6 +91,14 @@ module Spree
       def contents_by_weight
         contents.sort { |x, y| y.weight <=> x.weight }
       end
+
+      def volume
+        contents.sum(&:volume)
+      end
+
+      def dimension
+        contents.sum(&:dimension)
+      end
     end
   end
 end

data/app/models/spree/stock_item.rb

@@ -8,7 +8,11 @@ module Spree
 
     validates_presence_of :stock_location, :variant
     validates_uniqueness_of :variant_id, scope: [:stock_location_id, :deleted_at]
-    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, if: :verify_count_on_hand?
+
+    validates_numericality_of :count_on_hand,
+                              greater_than_or_equal_to: 0,
+                              less_than_or_equal_to: 2**31 - 1,
+                              only_integer: true, if: :verify_count_on_hand?
 
     delegate :weight, :should_track_inventory?, to: :variant
 

data/app/models/spree/stock_movement.rb

@@ -6,7 +6,12 @@ module Spree
     after_create :update_stock_item_quantity
 
     validates :stock_item, presence: true
-    validates :quantity, presence: true
+    validates :quantity, presence: true, numericality: {
+                 greater_than_or_equal_to: -2**31,
+                 less_than_or_equal_to: 2**31-1,
+                 only_integer: true,
+                 allow_nil: true
+              }
 
     scope :recent, -> { order('created_at DESC') }