solidus_core 1.3.2 → 1.4.0.beta1

data/app/models/spree/order_contents.rb

@@ -6,6 +6,19 @@ module Spree
       @order = order
     end
 
+    # Add a line items to the order if there is inventory to do so
+    # and populate Promotions
+    #
+    # @params [Spree::Variant] :variant The variant the line_item should
+    #   be associated with
+    # @params [Integer] :quantity The line_item quantity
+    # @param [Hash] :options Options for the adding proccess
+    #   Valid options:
+    #     shipment: [Spree::Shipment] LineItem target shipment
+    #     stock_location_quantities:
+    #       stock_location_id: The stock location to source from
+    #
+    # @return [Spree::LineItem]
     def add(variant, quantity = 1, options = {})
       line_item = add_to_line_item(variant, quantity, options)
       after_add_or_remove(line_item, options)
@@ -17,12 +30,26 @@ module Spree
     end
 
     def remove_line_item(line_item, options = {})
-      line_item.destroy!
+      order.line_items.destroy(line_item)
       after_add_or_remove(line_item, options)
     end
 
     def update_cart(params)
+      # We need old_tax_address / new_tax_address because we can't rely on methods
+      # offered by ActiveRecord::Dirty to determine if tax_address was updated
+      # because if we update the address, a new record will be created
+      # by the Address.factory instead of the old record being updated
+
+      old_tax_address = order.tax_address
+
       if order.update_attributes(params)
+
+        new_tax_address = order.tax_address
+
+        if should_recalculate_taxes?(old_tax_address, new_tax_address)
+          order.create_tax_charge!
+        end
+
         unless order.completed?
           order.line_items = order.line_items.select { |li| li.quantity > 0 }
           # Update totals, then check if the order is eligible for any cart promotions.
@@ -57,6 +84,36 @@ module Spree
 
     private
 
+    def should_recalculate_taxes?(old_address, new_address)
+      # Related to Solidus issue #894
+      # This is needed because if you update the shipping_address
+      # from the backend on an order that completed checkout,
+      # Taxes were not being recalculated if the Order tax zone
+      # was updated
+      #
+      # Possible cases:
+      #
+      # Case 1:
+      #
+      # If old_address is a TaxLocation it means that the order has not passed
+      # the address checkout state so taxes will be computed by the Order
+      # state machine, so we do not calculate taxes here.
+      #
+      # Case 2 :
+      # If new_address is a TaxLocation, but old_address is not, it means that
+      # an order has somehow lost his TaxAddress. Since it's not supposed to happen,
+      # we do not compute taxes.
+      #
+      # Case 3
+      # Both old_address and new_address are Spree::Address so the order
+      # has completed the checkout or that a registered user has updated his
+      # default addresses. We need to recalculate the taxes.
+
+      return if old_address.is_a?(Spree::Tax::TaxLocation) || new_address.is_a?(Spree::Tax::TaxLocation)
+
+      old_address.try!(:taxation_attributes) != new_address.try!(:taxation_attributes)
+    end
+
     def after_add_or_remove(line_item, options = {})
       reload_totals
       shipment = options[:shipment]
@@ -73,7 +130,6 @@ module Spree
 
     def reload_totals
       order_updater.update
-      order.reload
     end
 
     def add_to_line_item(variant, quantity, options = {})
@@ -86,7 +142,7 @@ module Spree
       )
 
       line_item.quantity += quantity.to_i
-      line_item.options = ActionController::Parameters.new(options).permit(PermittedAttributes.line_item_attributes)
+      line_item.options = ActionController::Parameters.new(options).permit(PermittedAttributes.line_item_attributes).to_h
 
       if line_item.new_record?
         create_order_stock_locations(line_item, options[:stock_location_quantities])
@@ -103,7 +159,7 @@ module Spree
       line_item.target_shipment = options[:shipment]
 
       if line_item.quantity == 0
-        line_item.destroy
+        order.line_items.destroy(line_item)
       else
         line_item.save!
       end

data/app/models/spree/order_merger.rb

@@ -111,7 +111,7 @@ module Spree
         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
+        order.line_items << other_order_line_item
         handle_error(other_order_line_item) unless other_order_line_item.save
       end
     end
@@ -135,9 +135,7 @@ module Spree
     # @api private
     # @return [void]
     def persist_merge
-      updater.update_item_count
-      updater.update_item_total
-      updater.persist_totals
+      updater.update
     end
   end
 end

data/app/models/spree/order_shipping.rb

@@ -17,7 +17,7 @@ class Spree::OrderShipping
     ship(
       inventory_units: shipment.inventory_units.shippable,
       stock_location: shipment.stock_location,
-      address: shipment.address,
+      address: shipment.order.ship_address,
       shipping_method: shipment.shipping_method,
       shipped_at: Time.current,
       external_number: external_number,

data/app/models/spree/order_update_attributes.rb

@@ -14,8 +14,6 @@ module Spree
     # Assign the attributes to the order and save the order
     # @return true if saved, otherwise false and errors will be set on the order
     def apply
-      order.validate_payments_attributes(@payments_attributes)
-
       assign_order_attributes
       assign_payments_attributes
 

data/app/models/spree/order_updater.rb

@@ -31,7 +31,11 @@ module Spree
     end
 
     def recalculate_adjustments
-      all_adjustments.includes(:adjustable).map(&:adjustable).uniq.each { |adjustable| Spree::ItemAdjustments.new(adjustable).update }
+      adjustables = [*line_items, *shipments, order]
+
+      adjustables.each do |adjustable|
+        Spree::ItemAdjustments.new(adjustable).update
+      end
     end
 
     # Updates the following Order total values:
@@ -63,7 +67,7 @@ module Spree
     end
 
     def update_shipment_total
-      order.shipment_total = shipments.sum(:cost)
+      order.shipment_total = shipments.to_a.sum(&:cost)
       update_order_total
     end
 
@@ -73,15 +77,14 @@ module Spree
 
     def update_adjustment_total
       recalculate_adjustments
-      order.adjustment_total = line_items.sum(:adjustment_total) +
-      shipments.sum(:adjustment_total) +
-      adjustments.eligible.sum(:amount)
-      order.included_tax_total = line_items.sum(:included_tax_total) + shipments.sum(:included_tax_total)
-      order.additional_tax_total = line_items.sum(:additional_tax_total) + shipments.sum(:additional_tax_total)
 
-      order.promo_total = line_items.sum(:promo_total) +
-      shipments.sum(:promo_total) +
-      adjustments.promotion.eligible.sum(:amount)
+      all_items = line_items + shipments
+
+      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.eligible.sum(:amount)
+      order.included_tax_total = all_items.sum(&:included_tax_total)
+      order.additional_tax_total = all_items.sum(&:additional_tax_total)
+
+      order.promo_total = all_items.sum(&:promo_total) + adjustments.promotion.eligible.sum(:amount)
 
       update_order_total
     end
@@ -91,7 +94,7 @@ module Spree
     end
 
     def update_item_total
-      order.item_total = line_items.sum('price * quantity')
+      order.item_total = line_items.to_a.sum(&:amount)
       update_order_total
     end
 

data/app/models/spree/payment.rb

@@ -11,7 +11,7 @@ module Spree
 
     belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :payments
     belongs_to :source, polymorphic: true
-    belongs_to :payment_method, class_name: 'Spree::PaymentMethod', inverse_of: :payments
+    belongs_to :payment_method, -> { with_deleted }, class_name: 'Spree::PaymentMethod', inverse_of: :payments
 
     has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
@@ -39,7 +39,6 @@ module Spree
 
     validates :amount, numericality: true
     validates :source, presence: true, if: :source_required?
-    validates :payment_method, presence: true
 
     default_scope -> { order(:created_at) }
 
@@ -156,7 +155,7 @@ module Spree
       return unless new_record?
       return if source_attributes.blank?
 
-      ActiveSupport::Deprecation.warn(<<WARN.squish)
+      Spree::Deprecation.warn(<<WARN.squish)
 Building payment sources by assigning source_attributes on payments is
 deprecated. Instead use either the PaymentCreate class or the
 OrderUpdateAttributes class.

data/app/models/spree/payment_create.rb

@@ -2,7 +2,7 @@ module Spree
   # Service object for creating new payments on an Order
   class PaymentCreate
     # @param order [Order] The order for the new payment
-    # @param attributes [Hash] attributes which are assigned to the new payment
+    # @param attributes [Hash,ActionController::Parameters] attributes which are assigned to the new payment
     #   * :payment_method_id Id of payment method used for this payment
     #   * :source_attributes Attributes used to build the source of this payment. Usually a {CreditCard}
     #     * :existing_card_id (Integer) The id of an existing {CreditCard} object to use
@@ -11,7 +11,10 @@ module Spree
     def initialize(order, attributes, payment: nil, request_env: {})
       @order = order
       @payment = payment
-      @attributes = attributes.dup.with_indifferent_access
+
+      # If AC::Params are passed in, attributes.to_h gives us a hash of only
+      # the permitted attributes.
+      @attributes = attributes.to_h.with_indifferent_access
       @source_attributes = @attributes.delete(:source_attributes) || {}
       @request_env = request_env
     end

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

@@ -61,7 +61,7 @@ module Spree
       handle_action(action, :void, auth_code)
     end
 
-    def credit(amount_in_cents, auth_code, gateway_options)
+    def credit(amount_in_cents, auth_code, gateway_options = {})
       action = -> (store_credit) do
         currency = gateway_options[:currency] || store_credit.currency
         originator = gateway_options[:originator]
@@ -77,13 +77,14 @@ module Spree
       store_credit = store_credit_event.try(:store_credit)
 
       if store_credit_event.nil? || store_credit.nil?
-        return false
+        ActiveMerchant::Billing::Response.new(false, '', {}, {})
       elsif store_credit_event.capture_action?
-        store_credit.credit(store_credit_event.amount, auth_code, store_credit.currency)
+        amount_in_cents = (store_credit_event.amount * 100).round
+        credit(amount_in_cents, auth_code)
       elsif store_credit_event.authorization_action?
-        store_credit.void(auth_code)
+        void(auth_code)
       else
-        return false
+        ActiveMerchant::Billing::Response.new(false, '', {}, {})
       end
     end
 

data/app/models/spree/product/scopes.rb

@@ -172,7 +172,8 @@ module Spree
     end
 
     # Can't use add_search_scope for this as it needs a default argument
-    def self.available(available_on = nil, _currency = nil)
+    def self.available(available_on = nil, currency = nil)
+      Spree::Deprecation.warn("The second currency argument on Product.available has no effect, and is deprecated", caller) if currency
       joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
     end
     search_scopes << :available

data/app/models/spree/product.rb

@@ -132,10 +132,7 @@ module Spree
     def ensure_option_types_exist_for_values_hash
       return if option_values_hash.nil?
       required_option_type_ids = option_values_hash.keys.map(&:to_i)
-      missing_option_type_ids = required_option_type_ids - option_type_ids
-      missing_option_type_ids.each do |id|
-        product_option_types.create(option_type_id: id)
-      end
+      self.option_type_ids |= required_option_type_ids
     end
 
     # Creates a new product with the same attributes, variants, etc.
@@ -259,7 +256,7 @@ module Spree
     # @return [Array] all advertised and not-rejected promotions
     def possible_promotions
       promotion_ids = promotion_rules.map(&:promotion_id).uniq
-      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:expired?)
+      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:inactive?)
     end
 
     # The number of on-hand stock items; Infinity if any variant does not track

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -68,10 +68,12 @@ module Spree
         def line_items_to_adjust(promotion, order)
           excluded_ids = adjustments.
             where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
-            pluck(:adjustable_id)
+            pluck(:adjustable_id).
+            to_set
 
-          order.line_items.where.not(id: excluded_ids).select do |line_item|
-            promotion.line_item_actionable? order, line_item
+          order.line_items.select do |line_item|
+            !excluded_ids.include?(line_item.id) &&
+              promotion.line_item_actionable?(order, line_item)
           end
         end
       end

data/app/models/spree/promotion/actions/free_shipping.rb

@@ -33,7 +33,7 @@ module Spree
         private
 
         def promotion_credit_exists?(shipment)
-          shipment.adjustments.where(source_id: id).exists?
+          shipment.adjustments.where(source: self).exists?
         end
       end
     end

data/app/models/spree/promotion/rules/option_value.rb

@@ -24,15 +24,14 @@ module Spree
           product_ids.include?(pid) && (value_ids(pid) & ovids).present?
         end
 
-        def preferred_eligible_values_with_numerification
-          values = preferred_eligible_values_without_numerification || {}
+        def preferred_eligible_values
+          values = preferences[:eligible_values] || {}
           Hash[values.keys.map(&:to_i).zip(
             values.values.map do |v|
               (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
             end
           )]
         end
-        alias_method_chain :preferred_eligible_values, :numerification
 
         private
 

data/app/models/spree/promotion/rules/product.rb

@@ -11,6 +11,9 @@ module Spree
         has_many :products, class_name: 'Spree::Product', through: :product_promotion_rules
 
         MATCH_POLICIES = %w(any all none)
+
+        validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
+
         preference :match_policy, :string, default: MATCH_POLICIES.first
 
         # scope/association that is used to test eligibility
@@ -25,18 +28,21 @@ module Spree
         def eligible?(order, _options = {})
           return true if eligible_products.empty?
 
-          if preferred_match_policy == 'all'
+          case preferred_match_policy
+          when 'all'
             unless eligible_products.all? { |p| order.products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product))
             end
-          elsif preferred_match_policy == 'any'
+          when 'any'
             unless order.products.any? { |p| eligible_products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products))
             end
-          else
+          when 'none'
             unless order.products.none? { |p| eligible_products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product))
             end
+          else
+            raise "unexpected match policy: #{preferred_match_policy.inspect}"
           end
 
           eligibility_errors.empty?

data/app/models/spree/promotion/rules/taxon.rb

@@ -2,33 +2,52 @@ module Spree
   class Promotion
     module Rules
       class Taxon < PromotionRule
-        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: :promotion_rule_id
+        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: :promotion_rule_id,
+          dependent: :destroy
         has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
 
         MATCH_POLICIES = %w(any all)
-        preference :match_policy, default: MATCH_POLICIES.first
+
+        validates_inclusion_of :preferred_match_policy, in: MATCH_POLICIES
+
+        preference :match_policy, :string, default: MATCH_POLICIES.first
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
 
         def eligible?(order, _options = {})
-          if preferred_match_policy == 'all'
-            unless (taxons.to_a - taxons_in_order_including_parents(order)).empty?
+          order_taxons = taxons_in_order_including_parents(order)
+
+          case preferred_match_policy
+          when 'all'
+            unless (taxons.to_a - order_taxons).empty?
               eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
             end
-          else
-            order_taxons = taxons_in_order_including_parents(order)
+          when 'any'
             unless taxons.any?{ |taxon| order_taxons.include? taxon }
               eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
             end
+          else
+            # Change this to an exception in a future version of Solidus
+            warn_invalid_match_policy(assume: 'any')
+            unless taxons.any? { |taxon| order_taxons.include? taxon }
+              eligibility_errors.add(:base, eligibility_error_message(:no_matching_taxons))
+            end
           end
 
           eligibility_errors.empty?
         end
 
         def actionable?(line_item)
-          taxon_product_ids.include? line_item.variant.product_id
+          case preferred_match_policy
+          when 'any', 'all'
+            taxon_product_ids.include?(line_item.variant.product_id)
+          else
+            # Change this to an exception in a future version of Solidus
+            warn_invalid_match_policy(assume: 'any')
+            taxon_product_ids.include?(line_item.variant.product_id)
+          end
         end
 
         def taxon_ids_string
@@ -42,6 +61,13 @@ module Spree
 
         private
 
+        def warn_invalid_match_policy(assume:)
+          Spree::Deprecation.warn(
+            "#{self.class.name} id=#{id} has unexpected match policy #{preferred_match_policy.inspect}. "\
+            "Interpreting it as '#{assume}'."
+          )
+        end
+
         # All taxons in an order
         def order_taxons(order)
           Spree::Taxon.joins(products: { variants_including_master: :line_items }).where(spree_line_items: { order_id: order.id }).distinct

data/app/models/spree/promotion/rules/user.rb

@@ -2,10 +2,9 @@ module Spree
   class Promotion
     module Rules
       class User < PromotionRule
-        belongs_to :user, class_name: Spree::UserClassHandle.new
-
         has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
-                                        foreign_key: :promotion_rule_id
+                                        foreign_key: :promotion_rule_id,
+                                        dependent: :destroy
         has_many :users, through: :promotion_rule_users, class_name: Spree::UserClassHandle.new
 
         def applicable?(promotable)

data/app/models/spree/promotion.rb

@@ -73,15 +73,24 @@ module Spree
       super
     end
 
-    def expired?
-      !active?
-    end
-
     def active?
       (starts_at.nil? || starts_at < Time.current) &&
         (expires_at.nil? || expires_at > Time.current)
     end
 
+    def inactive?
+      !active?
+    end
+
+    def expired?
+      Spree::Deprecation.warn <<-WARN.squish, caller
+        #expired? is deprecated, and will be removed in Solidus 2.0.
+        Please use #inactive? instead.
+      WARN
+
+      inactive?
+    end
+
     def activate(order:, line_item: nil, user: nil, path: nil, promotion_code: nil)
       return unless self.class.order_activatable?(order)
 
@@ -116,7 +125,7 @@ module Spree
 
     # called anytime order.update! happens
     def eligible?(promotable, promotion_code: nil)
-      return false if expired?
+      return false if inactive?
       return false if usage_limit_exceeded?
       return false if promotion_code && promotion_code.usage_limit_exceeded?
       return false if blacklisted?(promotable)
@@ -176,8 +185,9 @@ module Spree
         count(:order_id)
     end
 
-    # TODO: specs
     def line_item_actionable?(order, line_item, promotion_code: nil)
+      return false if blacklisted?(line_item)
+
       if eligible?(order, promotion_code: promotion_code)
         rules = eligible_rules(order)
         if rules.blank?

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

@@ -12,7 +12,7 @@ module Spree
         if order.coupon_code.present?
           if promotion.present? && promotion.actions.exists?
             handle_present_promotion(promotion)
-          elsif promotion_code && promotion_code.promotion.expired?
+          elsif promotion_code && promotion_code.promotion.inactive?
             set_error_code :coupon_code_expired
           else
             set_error_code :coupon_code_not_found

data/app/models/spree/shipment.rb

@@ -1,7 +1,6 @@
 module Spree
   class Shipment < Spree::Base
     belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
-    belongs_to :address, class_name: 'Spree::Address'
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
     has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :delete_all
@@ -11,8 +10,6 @@ module Spree
     has_many :state_changes, as: :stateful
     has_many :cartons, -> { uniq }, through: :inventory_units
 
-    after_save :update_adjustments
-
     before_validation :set_cost_zero_when_nil
 
     before_destroy :ensure_can_destroy
@@ -21,7 +18,6 @@ module Spree
     # from outside of the state machine and can actually pass variables through.
     attr_accessor :special_instructions, :suppress_mailer
 
-    accepts_nested_attributes_for :address
     accepts_nested_attributes_for :inventory_units
 
     make_permalink field: :number, length: 11, prefix: 'H'
@@ -210,8 +206,13 @@ module Spree
     end
 
     def selected_shipping_rate_id=(id)
-      shipping_rates.update_all(selected: false)
-      shipping_rates.update(id, selected: true)
+      selected_shipping_rate.update(selected: false) if selected_shipping_rate
+      new_rate = shipping_rates.detect { |rate| rate.id == id.to_i }
+      fail(
+        ArgumentError,
+        "Could not find shipping rate id #{id} for shipment #{number}"
+      ) unless new_rate
+      new_rate.update(selected: true)
       save!
     end
 
@@ -372,6 +373,11 @@ module Spree
       !stock_location || stock_location.fulfillable?
     end
 
+    def address
+      Spree::Deprecation.warn("Calling Shipment#address is deprecated. Use Order#ship_address instead", caller)
+      order.ship_address if order
+    end
+
     private
 
     def after_ship
@@ -396,20 +402,10 @@ module Spree
       stock_location.unstock item.variant, item.quantity, self
     end
 
-    def recalculate_adjustments
-      Spree::ItemAdjustments.new(self).update
-    end
-
     def set_cost_zero_when_nil
       self.cost = 0 unless cost
     end
 
-    def update_adjustments
-      if cost_changed? && state != 'shipped'
-        recalculate_adjustments
-      end
-    end
-
     def ensure_can_destroy
       unless pending?
         errors.add(:state, :cannot_destroy, state: state)

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

@@ -45,7 +45,7 @@ module Spree
 
       def shipping_methods(package)
         package.shipping_methods
-          .available_for_address(package.shipment.address)
+          .available_for_address(package.shipment.order.ship_address)
           .includes(:calculator, tax_category: :tax_rates)
           .to_a
           .select do |ship_method|

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

@@ -123,7 +123,6 @@ module Spree
 
         Spree::Shipment.new(
           order: order,
-          address: order.ship_address,
           stock_location: stock_location,
           inventory_units: contents.map(&:inventory_unit)
         )

data/app/models/spree/stock_item.rb

@@ -8,7 +8,7 @@ module Spree
 
     validates :stock_location, :variant, presence: true
     validates :variant_id, uniqueness: { scope: [:stock_location_id, :deleted_at] }, allow_blank: true, unless: :deleted_at
-    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, if: :verify_count_on_hand?
+    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, unless: :backorderable?
 
     delegate :weight, :should_track_inventory?, to: :variant
 
@@ -83,10 +83,6 @@ module Spree
 
     private
 
-    def verify_count_on_hand?
-      count_on_hand_changed? && !backorderable? && (count_on_hand < count_on_hand_was) && (count_on_hand < 0)
-    end
-
     def count_on_hand=(value)
       write_attribute(:count_on_hand, value)
     end
@@ -114,7 +110,7 @@ module Spree
     def inventory_cache_threshold
       # only warn if store is setting binary_inventory_cache (default = false)
       @cache_threshold ||= if Spree::Config.binary_inventory_cache
-        ActiveSupport::Deprecation.warn "Spree::Config.binary_inventory_cache=true is DEPRECATED. Instead use Spree::Config.inventory_cache_threshold=1"
+        Spree::Deprecation.warn "Spree::Config.binary_inventory_cache=true is DEPRECATED. Instead use Spree::Config.inventory_cache_threshold=1"
         1
       else
         Spree::Config.inventory_cache_threshold