solidus_core 2.0.3 → 2.1.0.beta1

data/app/models/spree/order_merger.rb

@@ -26,7 +26,7 @@ module Spree
     #
     # The line items from `other_order` will be merged in to the `order` for
     # this OrderMerger object. If the line items are for the same variant, it
-    # will the quantity of the incoming line item to the existing line item.
+    # will add the quantity of the incoming line item to the existing line item.
     # Otherwise, it will assign the line item to the new order.
     #
     # After the orders have been merged the `other_order` will be destroyed.
@@ -46,11 +46,11 @@ module Spree
     # specified, the order user association will not be changed.
     # @return [void]
     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)
+      if other_order.currency == order.currency
+        other_order.line_items.each do |other_order_line_item|
+          current_line_item = find_matching_line_item(other_order_line_item)
+          handle_merge(current_line_item, other_order_line_item)
+        end
       end
 
       set_user(user)

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

@@ -15,27 +15,39 @@ module Spree
     # object with callbacks (otherwise you will end up in an infinite recursion as the
     # associations try to save and then in turn try to call +update!+ again.)
     def update
-      update_item_count
-      update_totals
-      if order.completed?
-        update_payment_state
-        update_shipments
-        update_shipment_state
+      @order.transaction do
+        update_item_count
+        update_totals
+        if order.completed?
+          update_payment_state
+          update_shipments
+          update_shipment_state
+        end
+        run_hooks
+        persist_totals
       end
-      run_hooks
-      persist_totals
     end
 
     def run_hooks
       update_hooks.each { |hook| order.send hook }
     end
 
+    # This will update and select the best promotion adjustment, update tax
+    # adjustments, update cancellation adjustments, and then update the total
+    # fields (promo_total, included_tax_total, additional_tax_total, and
+    # adjustment_total) on the item.
+    # @return [void]
     def recalculate_adjustments
-      adjustables = [*line_items, *shipments, order]
-
-      adjustables.each do |adjustable|
-        Spree::ItemAdjustments.new(adjustable).update
-      end
+      # Promotion adjustments must be applied first, then tax adjustments.
+      # This fits the criteria for VAT tax as outlined here:
+      # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
+      # It also fits the criteria for sales tax as outlined here:
+      # http://www.boe.ca.gov/formspubs/pub113/
+      update_item_promotions
+      update_order_promotions
+      update_taxes
+      update_cancellations
+      update_item_totals
     end
 
     # Updates the following Order total values:
@@ -164,5 +176,71 @@ module Spree
     def round_money(n)
       (n * 100).round / 100.0
     end
+
+    def update_item_promotions
+      [*line_items, *shipments].each do |item|
+        promotion_adjustments = item.adjustments.select(&:promotion?)
+
+        promotion_adjustments.each(&:update!)
+        Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
+
+        item.promo_total = promotion_adjustments.select(&:eligible?).sum(&:amount)
+      end
+    end
+
+    # Update and select the best promotion adjustment for the order.
+    # We don't update the order.promo_total yet. Order totals are updated later
+    # in #update_adjustment_total since they include the totals from the order's
+    # line items and/or shipments.
+    def update_order_promotions
+      promotion_adjustments = order.adjustments.select(&:promotion?)
+      promotion_adjustments.each(&:update!)
+      Spree::Config.promotion_chooser_class.new(promotion_adjustments).update
+    end
+
+    def update_taxes
+      Spree::Config.tax_adjuster_class.new(order).adjust!
+
+      [*line_items, *shipments].each do |item|
+        tax_adjustments = item.adjustments.select(&:tax?)
+        # Tax adjustments come in not one but *two* exciting flavours:
+        # Included & additional
+
+        # Included tax adjustments are those which are included in the price.
+        # These ones should not affect the eventual total price.
+        #
+        # Additional tax adjustments are the opposite, affecting the final total.
+        item.included_tax_total   = tax_adjustments.select(&:included?).sum(&:amount)
+        item.additional_tax_total = tax_adjustments.reject(&:included?).sum(&:amount)
+      end
+    end
+
+    def update_cancellations
+      line_items.each do |line_item|
+        line_item.adjustments.select(&:cancellation?).each(&:update!)
+      end
+    end
+
+    def update_item_totals
+      [*line_items, *shipments].each do |item|
+        # The cancellation_total isn't persisted anywhere but is included in
+        # the adjustment_total
+        item_cancellation_total = item.adjustments.select(&:cancellation?).sum(&:amount)
+
+        item.adjustment_total = item.promo_total +
+                                item.additional_tax_total +
+                                item_cancellation_total
+
+        if item.changed?
+          item.update_columns(
+            promo_total:          item.promo_total,
+            included_tax_total:   item.included_tax_total,
+            additional_tax_total: item.additional_tax_total,
+            adjustment_total:     item.adjustment_total,
+            updated_at:           Time.current,
+          )
+        end
+      end
+    end
   end
 end

data/app/models/spree/payment.rb

@@ -1,4 +1,8 @@
 module Spree
+  # Manage and process a payment for an order, from a specific
+  # source (e.g. `Spree::CreditCard`) using a specific payment method (e.g
+  # `Solidus::Gateway::Braintree`).
+  #
   class Payment < Spree::Base
     include Spree::Payment::Processing
 
@@ -39,7 +43,6 @@ module Spree
 
     validates :amount, numericality: true
     validates :source, presence: true, if: :source_required?
-    validates :payment_method, presence: true
 
     default_scope -> { order(:created_at) }
 
@@ -249,7 +252,11 @@ WARN
 
     def invalidate_old_payments
       if !store_credit? && !['invalid', 'failed'].include?(state)
-        order.payments.checkout.where(payment_method: payment_method).where("id != ?", id).each(&:invalidate!)
+        order.payments.select do |payment|
+          payment.state == 'checkout' &&
+            payment.payment_method_id == payment_method.try!(:id) &&
+            payment.id != id
+        end.each(&:invalidate!)
       end
     end
 

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

@@ -85,15 +85,21 @@ module Spree
 
       def gateway_options
         order.reload
-        options = { email: order.email,
-                    customer: order.email,
-                    customer_id: order.user_id,
-                    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 = {
+          email: order.email,
+          customer: order.email,
+          customer_id: order.user_id,
+          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,
+          # The originator is passed to options used by the payment method.
+          # One example of a place that it is used is in:
+          # app/models/spree/payment_method/store_credit.rb
+          originator: self
+        }
 
         options[:shipping] = order.ship_total * 100
         options[:tax] = order.additional_tax_total * 100

data/app/models/spree/payment_method.rb

@@ -1,4 +1,6 @@
 module Spree
+  # An abstract class which is implemented most commonly as a `Spree::Gateway`.
+  #
   class PaymentMethod < Spree::Base
     acts_as_paranoid
     acts_as_list
@@ -12,6 +14,10 @@ module Spree
     has_many :stores, through: :store_payment_methods
 
     scope :ordered_by_position, -> { order(:position) }
+    scope :active, -> { where(active: true) }
+    scope :available_to_users, -> { where(available_to_users: true) }
+    scope :available_to_admin, -> { where(available_to_admin: true) }
+    scope :available_to_store, -> (store) { (store.present? && store.payment_methods.empty?) ? self : store.payment_methods }
 
     include Spree::Preferences::StaticallyConfigurable
 
@@ -30,11 +36,48 @@ module Spree
       raise ::NotImplementedError, "You must implement payment_source_class method for #{self.class}."
     end
 
-    def self.available(display_on = 'both', store: nil)
-      all.select do |p|
-        p.active &&
-          (p.display_on == display_on.to_s || p.display_on.blank?) &&
-          (store.nil? || store.payment_methods.empty? || store.payment_methods.include?(p))
+    # @deprecated Use {#available_to_users=} and {#available_to_admin=} instead
+    def display_on=(value)
+      Spree::Deprecation.warn "Spree::PaymentMethod#display_on= is deprecated."\
+        "Please use #available_to_users= and #available_to_admin= instead."
+      self.available_to_users = value.blank? || value == 'front_end'
+      self.available_to_admin = value.blank? || value == 'back_end'
+    end
+
+    # @deprecated Use {#available_to_users} and {#available_to_admin} instead
+    def display_on
+      Spree::Deprecation.warn "Spree::PaymentMethod#display_on is deprecated."\
+        "Please use #available_to_users and #available_to_admin instead."
+      if available_to_users? && available_to_admin?
+        ''
+      elsif available_to_users?
+        'front_end'
+      elsif available_to_admin?
+        'back_end'
+      else
+        'none'
+      end
+    end
+
+    def self.available(display_on=nil, store: nil)
+      Spree::Deprecation.warn "Spree::PaymentMethod.available is deprecated."\
+        "Please use .active, .available_to_users, and .available_to_admin scopes instead."\
+        "For payment methods associated with a specific store, use Spree::PaymentMethod.available_to_store(your_store)"\
+        " as the base applying any further filtering"
+
+      display_on = display_on.to_s
+
+      available_payment_methods =
+        case display_on
+        when 'front_end'
+          active.available_to_users
+        when 'back_end'
+          active.available_to_admin
+        else
+          active.available_to_users.available_to_admin
+        end
+      available_payment_methods.select do |p|
+        store.nil? || store.payment_methods.empty? || store.payment_methods.include?(p)
       end
     end
 

data/app/models/spree/price.rb

@@ -18,10 +18,11 @@ module Spree
     validates :currency, inclusion: { in: ::Money::Currency.all.map(&:iso_code), message: :invalid_code }
     validates :country, presence: true, unless: -> { for_any_country? }
 
-    scope :currently_valid, -> { where(is_default: true).order("country_iso IS NULL") }
+    scope :currently_valid, -> { order("country_iso IS NULL, updated_at DESC") }
+    scope :for_master, -> { joins(:variant).where(spree_variants: { is_master: true }) }
+    scope :for_variant, -> { joins(:variant).where(spree_variants: { is_master: false }) }
     scope :for_any_country, -> { where(country: nil) }
     scope :with_default_attributes, -> { where(Spree::Config.default_pricing_options.desired_attributes) }
-    after_save :set_default_price
 
     extend DisplayMoney
     money_methods :amount, :price
@@ -58,6 +59,10 @@ module Spree
       end
     end
 
+    def country_iso=(country_iso)
+      self[:country_iso] = country_iso.presence
+    end
+
     private
 
     def sum_of_vat_amounts
@@ -69,13 +74,6 @@ module Spree
       self.currency ||= Spree::Config[:currency]
     end
 
-    def set_default_price
-      if is_default?
-        other_default_prices = variant.prices.currently_valid.where(pricing_options.desired_attributes).where.not(id: id)
-        other_default_prices.update_all(is_default: false)
-      end
-    end
-
     def pricing_options
       Spree::Config.pricing_options_class.from_price(self)
     end

data/app/models/spree/product.rb

@@ -74,7 +74,6 @@ module Spree
 
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
 
-    after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
     after_destroy :punch_slug
@@ -114,17 +113,6 @@ module Spree
       super || TaxCategory.find_by(is_default: true)
     end
 
-    # Overrides the prototype_id setter in order to ensure it is cast to an
-    # integer.
-    #
-    # @param value [#to_i] the intended new value
-    # @!attribute [rw] prototype_id
-    #   @return [Fixnum]
-    attr_reader :prototype_id
-    def prototype_id=(value)
-      @prototype_id = value.to_i
-    end
-
     # Ensures option_types and product_option_types exist for keys in
     # option_values_hash.
     #
@@ -227,9 +215,7 @@ module Spree
 
     # @return [Boolean] true if there are no option values
     def empty_option_values?
-      options.empty? || options.any? do |opt|
-        opt.option_type.option_values.empty?
-      end
+      options.empty? || !option_types.left_joins(:option_values).where('spree_option_values.id IS NULL').empty?
     end
 
     # @param property_name [String] the name of the property to find
@@ -292,16 +278,6 @@ module Spree
 
     private
 
-    def add_associations_from_prototype
-      if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
-        prototype.properties.each do |property|
-          product_properties.create(property: property)
-        end
-        self.option_types = prototype.option_types
-        self.taxons = prototype.taxons
-      end
-    end
-
     def any_variants_not_track_inventory?
       if variants_including_master.loaded?
         variants_including_master.any? { |v| !v.should_track_inventory? }

data/app/models/spree/promotion.rb

@@ -7,10 +7,10 @@ module Spree
 
     belongs_to :promotion_category
 
-    has_many :promotion_rules, autosave: true, dependent: :destroy
+    has_many :promotion_rules, autosave: true, dependent: :destroy, inverse_of: :promotion
     alias_method :rules, :promotion_rules
 
-    has_many :promotion_actions, autosave: true, dependent: :destroy
+    has_many :promotion_actions, autosave: true, dependent: :destroy, inverse_of: :promotion
     alias_method :actions, :promotion_actions
 
     has_many :order_promotions, class_name: "Spree::OrderPromotion"
@@ -82,15 +82,6 @@ module Spree
       !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)
 
@@ -114,10 +105,13 @@ module Spree
 
       if action_taken
         # connect to the order
-        order_promotions.find_or_create_by!(
-          order_id: order.id,
-          promotion_code_id: promotion_code.try!(:id)
+        order.order_promotions.find_or_create_by!(
+          promotion: self,
+          promotion_code: promotion_code,
         )
+        order.promotions.reset
+        order_promotions.reset
+        orders.reset
       end
 
       action_taken
@@ -220,6 +214,20 @@ module Spree
       end
     end
 
+    # Removes a promotion and any adjustments or other side effects from an
+    # order.
+    # @param order [Spree::Order] the order to remove the promotion from.
+    # @return [void]
+    def remove_from(order)
+      actions.each do |action|
+        action.remove_from(order)
+      end
+      # note: this destroys the join table entry, not the promotion itself
+      order.promotions.destroy(self)
+      order.order_promotions.reset
+      order_promotions.reset
+    end
+
     private
 
     def blacklisted?(promotable)