spree_core 3.0.9 → 3.2.0

data/app/models/spree/gateway/bogus_simple.rb

@@ -8,17 +8,17 @@ module Spree
 
     def authorize(money, credit_card, options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
     def purchase(money, credit_card, options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 

data/app/models/spree/gateway.rb

@@ -1,8 +1,10 @@
 module Spree
   class Gateway < PaymentMethod
+    FROM_DOLLAR_TO_CENT_RATE = 100.0
+
     delegate :authorize, :purchase, :capture, :void, :credit, to: :provider
 
-    validates :name, :type, presence: true
+    validates :type, presence: true
 
     preference :server, :string, default: 'test'
     preference :test_mode, :boolean, default: true
@@ -11,16 +13,11 @@ module Spree
       CreditCard
     end
 
-    # instantiates the selected gateway and configures with the options stored in the database
-    def self.current
-      super
-    end
-
     def provider
       gateway_options = options
       gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
       if gateway_options[:server]
-        ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+        ActiveMerchant::Billing::Base.mode = gateway_options[:server].to_sym
       end
       @provider ||= provider_class.new(gateway_options)
     end
@@ -45,6 +42,10 @@ module Spree
       'gateway'
     end
 
+    def exchange_multiplier
+      FROM_DOLLAR_TO_CENT_RATE
+    end
+
     def supports?(source)
       return true unless provider_class.respond_to? :supports?
       return false unless source.brand

data/app/models/spree/image.rb

@@ -9,12 +9,12 @@ module Spree
                       path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
                       convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
     validates_attachment :attachment,
-      :presence => true,
-      :content_type => { :content_type => %w(image/jpeg image/jpg image/png image/gif) }
+      presence: true,
+      content_type: { content_type: %w(image/jpeg image/jpg image/png image/gif) }
 
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet
-    after_post_process :find_dimensions
+    before_save :find_dimensions, if: :attachment_updated_at_changed?
 
     #used by admin products autocomplete
     def mini_url

data/app/models/spree/inventory_unit.rb

@@ -1,23 +1,27 @@
 module Spree
   class InventoryUnit < Spree::Base
-    belongs_to :variant, class_name: "Spree::Variant", inverse_of: :inventory_units
-    belongs_to :order, class_name: "Spree::Order", inverse_of: :inventory_units
-    belongs_to :shipment, class_name: "Spree::Shipment", touch: true, inverse_of: :inventory_units
-    belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization", inverse_of: :inventory_units
-    belongs_to :line_item, class_name: "Spree::LineItem", inverse_of: :inventory_units
+
+    with_options inverse_of: :inventory_units do
+      belongs_to :variant, class_name: "Spree::Variant"
+      belongs_to :order, class_name: "Spree::Order"
+      belongs_to :shipment, class_name: "Spree::Shipment", touch: true, optional: true
+      belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization"
+      belongs_to :line_item, class_name: "Spree::LineItem"
+    end
 
     has_many :return_items, inverse_of: :inventory_unit
     has_one :original_return_item, class_name: "Spree::ReturnItem", foreign_key: :exchange_inventory_unit_id
 
     scope :backordered, -> { where state: 'backordered' }
     scope :on_hand, -> { where state: 'on_hand' }
+    scope :on_hand_or_backordered, -> { where state: ['backordered', 'on_hand'] }
     scope :shipped, -> { where state: 'shipped' }
     scope :returned, -> { where state: 'returned' }
     scope :backordered_per_variant, ->(stock_item) do
       includes(:shipment, :order)
-        .where("spree_shipments.state != 'canceled'").references(:shipment)
+        .where.not(spree_shipments: { state: 'canceled' })
         .where(variant_id: stock_item.variant_id)
-        .where('spree_orders.completed_at is not null')
+        .where.not(spree_orders: { completed_at: nil })
         .backordered.order("spree_orders.completed_at ASC")
     end
 
@@ -49,13 +53,8 @@ module Spree
       end
     end
 
-    def self.finalize_units!(inventory_units)
-      inventory_units.map do |iu|
-        iu.update_columns(
-          pending: false,
-          updated_at: Time.now,
-        )
-      end
+    def self.finalize_units!
+      update_all(pending: false, updated_at: Time.current)
     end
 
     def find_stock_item

data/app/models/spree/legacy_user.rb

@@ -3,24 +3,11 @@ module Spree
   class LegacyUser < Spree::Base
     include UserAddress
     include UserPaymentSource
+    include UserMethods
 
     self.table_name = 'spree_users'
 
-    has_many :orders, foreign_key: :user_id
-
-    before_destroy :check_completed_orders
-
-    def has_spree_role?(role)
-      true
-    end
-
     attr_accessor :password
     attr_accessor :password_confirmation
-
-    private
-
-      def check_completed_orders
-        raise Spree::Core::DestroyWithOrdersError if orders.complete.present?
-      end
   end
 end

data/app/models/spree/line_item.rb

@@ -1,8 +1,11 @@
 module Spree
   class LineItem < Spree::Base
-    before_validation :invalid_quantity_check
-    belongs_to :order, class_name: "Spree::Order", inverse_of: :line_items, touch: true
-    belongs_to :variant, class_name: "Spree::Variant", inverse_of: :line_items
+    before_validation :ensure_valid_quantity
+
+    with_options inverse_of: :line_items do
+      belongs_to :order, class_name: "Spree::Order", touch: true
+      belongs_to :variant, class_name: "Spree::Variant"
+    end
     belongs_to :tax_category, class_name: "Spree::TaxCategory"
 
     has_one :product, through: :variant
@@ -13,17 +16,15 @@ module Spree
     before_validation :copy_price
     before_validation :copy_tax_category
 
-    validates :variant, presence: true
-    validates :quantity, numericality: {
-      only_integer: true,
-      greater_than: -1,
-      message: Spree.t('validation.must_be_int')
-    }
+    validates :variant, :order, presence: true
+    validates :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
     validates :price, numericality: true
+
     validates_with Stock::AvailabilityValidator
+    validate :ensure_proper_currency, if: -> { order.present? }
+
+    before_destroy :verify_order_inventory, if: -> { order.has_checkout_step?("delivery") }
 
-    validate :ensure_proper_currency
-    before_destroy :update_inventory
     before_destroy :destroy_inventory_units
 
     after_save :update_inventory
@@ -31,7 +32,9 @@ module Spree
 
     after_create :update_tax_charge
 
-    delegate :name, :description, :sku, :should_track_inventory?, to: :variant
+    delegate :name, :description, :sku, :should_track_inventory?, :product, :options_text, to: :variant
+    delegate :brand, :category, to: :product
+    delegate :tax_zone, to: :order
 
     attr_accessor :target_shipment
 
@@ -40,49 +43,51 @@ module Spree
 
     def copy_price
       if variant
-        self.price = variant.price if price.nil?
+        update_price if price.nil?
         self.cost_price = variant.cost_price if cost_price.nil?
         self.currency = variant.currency if currency.nil?
       end
     end
 
+    def update_price
+      self.price = variant.price_including_vat_for(tax_zone: tax_zone)
+    end
+
     def copy_tax_category
       if variant
         self.tax_category = variant.tax_category
       end
     end
 
+    extend DisplayMoney
+    money_methods :amount, :subtotal, :discounted_amount, :final_amount, :total, :price
+
+    alias single_money display_price
+    alias single_display_amount display_price
+
     def amount
       price * quantity
     end
+
     alias subtotal amount
 
-    def discounted_amount
-      amount + promo_total
+    def taxable_amount
+      amount + taxable_adjustment_total
     end
 
-    def discounted_money
-      Spree::Money.new(discounted_amount, { currency: currency })
-    end
+    alias discounted_money display_discounted_amount
+    alias_method :discounted_amount, :taxable_amount
 
     def final_amount
       amount + adjustment_total
     end
-    alias total final_amount
 
-    def single_money
-      Spree::Money.new(price, { currency: currency })
-    end
-    alias single_display_amount single_money
-
-    def money
-      Spree::Money.new(amount, { currency: currency })
-    end
-    alias display_total money
-    alias display_amount money
+    alias total final_amount
+    alias money display_total
 
     def invalid_quantity_check
-      self.quantity = 0 if quantity.nil? || quantity < 0
+      warn "`invalid_quantity_check` is deprecated. Use private `ensure_valid_quantity` instead."
+      ensure_valid_quantity
     end
 
     def sufficient_stock?
@@ -93,9 +98,15 @@ module Spree
       !sufficient_stock?
     end
 
-    # Remove product default_scope `deleted_at: nil`
-    def product
-      variant.product
+    def options=(options = {})
+      return unless options.present?
+
+      opts = options.dup # we will be deleting from the hash, so leave the caller's copy intact
+
+      currency = opts.delete(:currency) || order.try(:currency)
+
+      update_price_from_modifier(currency, opts)
+      assign_attributes opts
     end
 
     # Remove variant default_scope `deleted_at: nil`
@@ -103,55 +114,56 @@ module Spree
       Spree::Variant.unscoped { super }
     end
 
-    def options=(options={})
-      return unless options.present?
-
-      opts = options.dup # we will be deleting from the hash, so leave the caller's copy intact
+    private
 
-      currency = opts.delete(:currency) || order.try(:currency)
+    def ensure_valid_quantity
+      self.quantity = 0 if quantity.nil? || quantity < 0
+    end
 
+    def update_price_from_modifier(currency, opts)
       if currency
         self.currency = currency
-        self.price    = variant.price_in(currency).amount +
-                        variant.price_modifier_amount_in(currency, opts)
+        self.price = variant.price_in(currency).amount +
+          variant.price_modifier_amount_in(currency, opts)
       else
-        self.price    = variant.price +
-                        variant.price_modifier_amount(opts)
+        self.price = variant.price +
+          variant.price_modifier_amount(opts)
       end
-
-      self.assign_attributes opts
     end
 
-    private
-      def update_inventory
-        if (changed? || target_shipment.present?) && self.order.has_checkout_step?("delivery")
-          Spree::OrderInventory.new(self.order, self).verify(target_shipment)
-        end
+    def update_inventory
+      if (changed? || target_shipment.present?) && order.has_checkout_step?("delivery")
+        verify_order_inventory
       end
+    end
 
-      def destroy_inventory_units
-        inventory_units.destroy_all
-      end
+    def verify_order_inventory
+      Spree::OrderInventory.new(order, self).verify(target_shipment)
+    end
 
-      def update_adjustments
-        if quantity_changed?
-          recalculate_adjustments
-          update_tax_charge # Called to ensure pre_tax_amount is updated.
-        end
-      end
+    def destroy_inventory_units
+      throw(:abort) unless inventory_units.destroy_all
+    end
 
-      def recalculate_adjustments
-        Adjustable::AdjustmentsUpdater.update(self)
+    def update_adjustments
+      if quantity_changed?
+        recalculate_adjustments
+        update_tax_charge # Called to ensure pre_tax_amount is updated.
       end
+    end
 
-      def update_tax_charge
-        Spree::TaxRate.adjust(order, [self])
-      end
+    def recalculate_adjustments
+      Adjustable::AdjustmentsUpdater.update(self)
+    end
 
-      def ensure_proper_currency
-        unless currency == order.currency
-          errors.add(:currency, :must_match_order_currency)
-        end
+    def update_tax_charge
+      Spree::TaxRate.adjust(order, [self])
+    end
+
+    def ensure_proper_currency
+      unless currency == order.currency
+        errors.add(:currency, :must_match_order_currency)
       end
+    end
   end
 end

data/app/models/spree/log_entry.rb

@@ -7,10 +7,7 @@ module Spree
     after_rollback :save_anyway
 
     def save_anyway
-      log = Spree::LogEntry.new
-      log.source  = source
-      log.details = details
-      log.save!
+      Spree::LogEntry.create!(source: source, details: details)
     end
 
     def parsed_details

data/app/models/spree/option_type.rb

@@ -2,20 +2,29 @@ module Spree
   class OptionType < Spree::Base
     acts_as_list
 
-    has_many :option_values, -> { order(:position) }, dependent: :destroy, inverse_of: :option_type
-    has_many :product_option_types, dependent: :destroy, inverse_of: :option_type
+    with_options dependent: :destroy, inverse_of: :option_type do
+      has_many :option_values, -> { order(:position) }
+      has_many :product_option_types
+    end
+
     has_many :products, through: :product_option_types
-    has_and_belongs_to_many :prototypes, join_table: 'spree_option_types_prototypes'
 
-    validates :name, presence: true, uniqueness: true
-    validates :presentation, presence: true
+    has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
+    has_many :prototypes, through: :option_type_prototypes, class_name: 'Spree::Prototype'
 
-    default_scope { order("#{self.table_name}.position") }
+    with_options presence: true do
+      validates :name, uniqueness: { allow_blank: true }
+      validates :presentation
+    end
+
+    default_scope { order(:position) }
 
     accepts_nested_attributes_for :option_values, reject_if: lambda { |ov| ov[:name].blank? || ov[:presentation].blank? }, allow_destroy: true
 
     after_touch :touch_all_products
 
+    private
+
     def touch_all_products
       products.update_all(updated_at: Time.current)
     end

data/app/models/spree/option_type_prototype.rb

@@ -0,0 +1,9 @@
+module Spree
+  class OptionTypePrototype < Spree::Base
+    belongs_to :option_type, class_name: 'Spree::OptionType'
+    belongs_to :prototype, class_name: 'Spree::Prototype'
+
+    validates :prototype, :option_type, presence: true
+    validates :prototype_id, uniqueness: { scope: :option_type_id }, allow_nil: true
+  end
+end

data/app/models/spree/option_value.rb

@@ -2,15 +2,23 @@ module Spree
   class OptionValue < Spree::Base
     belongs_to :option_type, class_name: 'Spree::OptionType', touch: true, inverse_of: :option_values
     acts_as_list scope: :option_type
-    has_and_belongs_to_many :variants, join_table: 'spree_option_values_variants', class_name: "Spree::Variant"
 
-    validates :name, presence: true, uniqueness: { scope: :option_type_id }
-    validates :presentation, presence: true
+    has_many :option_value_variants, class_name: 'Spree::OptionValueVariant'
+    has_many :variants, through: :option_value_variants, class_name: 'Spree::Variant'
+
+    with_options presence: true do
+      validates :name, uniqueness: { scope: :option_type_id, allow_blank: true }
+      validates :presentation
+    end
 
     after_touch :touch_all_variants
 
+    delegate :name, :presentation, to: :option_type, prefix: true, allow_nil: true
+
     self.whitelisted_ransackable_attributes = ['presentation']
 
+    private
+
     def touch_all_variants
       variants.update_all(updated_at: Time.current)
     end

data/app/models/spree/option_value_variant.rb

@@ -0,0 +1,6 @@
+module Spree
+  class OptionValueVariant < Spree::Base
+    belongs_to :option_value, class_name: 'Spree::OptionValue'
+    belongs_to :variant, class_name: 'Spree::Variant'
+  end
+end

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

@@ -62,7 +62,7 @@ module Spree
 
               event :return do
                 transition to: :returned,
-                           from: [:complete, :awaiting_return, :canceled],
+                           from: [:complete, :awaiting_return, :canceled, :resumed],
                            if: :all_inventory_units_returned?
               end
 
@@ -74,6 +74,9 @@ module Spree
                 transition to: :awaiting_return
               end
 
+              before_transition to: :complete, do: :ensure_line_item_variants_are_not_discontinued
+              before_transition to: :complete, do: :ensure_line_items_are_in_stock
+
               if states[:payment]
                 before_transition to: :complete do |order|
                   if order.payment_required? && order.payments.valid.empty?
@@ -86,12 +89,12 @@ module Spree
                 after_transition to: :complete, do: :persist_user_credit_card
                 before_transition to: :payment, do: :set_shipments_cost
                 before_transition to: :payment, do: :create_tax_charge!
-                before_transition to: :payment, do: :assign_default_credit_card
               end
 
               before_transition from: :cart, do: :ensure_line_items_present
 
               if states[:address]
+                before_transition from: :address, do: :update_line_item_prices!
                 before_transition from: :address, do: :create_tax_charge!
                 before_transition to: :address, do: :assign_default_addresses!
                 before_transition from: :address, do: :persist_user_address!
@@ -104,12 +107,9 @@ module Spree
                 before_transition from: :delivery, do: :apply_free_shipping_promotions
               end
 
-              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_discontinued
               before_transition to: :resumed, do: :ensure_line_items_are_in_stock
 
-              before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
-              before_transition to: :complete, do: :ensure_line_items_are_in_stock
-
               after_transition to: :complete, do: :finalize!
               after_transition to: :resumed, do: :after_resume
               after_transition to: :canceled, do: :after_cancel
@@ -214,7 +214,7 @@ module Spree
             checkout_step_index(state) > checkout_step_index(self.state)
           end
 
-          define_callbacks :updating_from_params, terminator: ->(_target, result) { result == false }
+          define_callbacks :updating_from_params
 
           set_callback :updating_from_params, :before, :update_params_payment_source
 
@@ -282,15 +282,12 @@ module Spree
 
           def persist_user_credit_card
             if !temporary_credit_card && user_id && valid_credit_cards.present?
-              default_cc = valid_credit_cards.first
-              default_cc.user_id = user_id
-              default_cc.default = true
-              default_cc.save
+              valid_credit_cards.first.update(user_id: user_id, default: true)
             end
           end
 
           def assign_default_credit_card
-            if payments.from_credit_card.count == 0 && user_has_valid_default_card? && payment_required?
+            if payments.from_credit_card.size == 0 && user_has_valid_default_card? && payment_required?
               cc = user.default_credit_card
               payments.create!(payment_method_id: cc.payment_method_id, source: cc, amount: total)
             end
@@ -329,7 +326,7 @@ module Spree
             if @updating_params[:order] && (@updating_params[:order][:payments_attributes] ||
                                             @updating_params[:order][:existing_card])
               @updating_params[:order][:payments_attributes] ||= [{}]
-              @updating_params[:order][:payments_attributes].first[:amount] = total
+              @updating_params[:order][:payments_attributes].first[:amount] = order_total_after_store_credit
             end
           end
         end

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

@@ -7,7 +7,7 @@ module Spree
 
         def homogenize_line_item_currencies
           update_line_item_currencies!
-          update!
+          update_with_updater!
         end
 
       end

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

@@ -0,0 +1,96 @@
+module Spree
+  class Order < Spree::Base
+    module StoreCredit
+      def add_store_credit_payments
+        payments.store_credits.where(state: 'checkout').map(&:invalidate!)
+
+        remaining_total = outstanding_balance
+
+        if user && user.store_credits.any?
+          payment_method = Spree::PaymentMethod::StoreCredit.available.first
+          raise "Store credit payment method could not be found" unless payment_method
+
+          user.store_credits.order_by_priority.each do |credit|
+            break if remaining_total.zero?
+            next if credit.amount_remaining.zero?
+
+            amount_to_take = store_credit_amount(credit, remaining_total)
+            create_store_credit_payment(payment_method, credit, amount_to_take)
+            remaining_total -= amount_to_take
+          end
+        end
+      end
+
+      def covered_by_store_credit?
+        return false unless user
+        user.total_available_store_credit >= total
+      end
+      alias_method :covered_by_store_credit, :covered_by_store_credit?
+
+      def total_available_store_credit
+        return 0.0 unless user
+        user.total_available_store_credit
+      end
+
+      def could_use_store_credit?
+        total_available_store_credit > 0
+      end
+
+      def order_total_after_store_credit
+        total - total_applicable_store_credit
+      end
+
+      def total_applicable_store_credit
+        if payment? || confirm? || complete?
+          total_applied_store_credit
+        else
+          [total, (user.try(:total_available_store_credit) || 0.0)].min
+        end
+      end
+
+      def total_applied_store_credit
+        payments.store_credits.valid.sum(:amount)
+      end
+
+      def using_store_credit?
+        total_applied_store_credit > 0
+      end
+
+      def display_total_applicable_store_credit
+        Spree::Money.new(-total_applicable_store_credit, currency: currency)
+      end
+
+      def display_total_applied_store_credit
+        Spree::Money.new(-total_applied_store_credit, currency: currency)
+      end
+
+      def display_order_total_after_store_credit
+        Spree::Money.new(order_total_after_store_credit, currency: currency)
+      end
+
+      def display_total_available_store_credit
+        Spree::Money.new(total_available_store_credit, currency: currency)
+      end
+
+      def display_store_credit_remaining_after_capture
+        Spree::Money.new(total_available_store_credit - total_applicable_store_credit, currency: currency)
+      end
+
+      private
+
+      def create_store_credit_payment(payment_method, credit, amount)
+        payments.create!(
+          source: credit,
+          payment_method: payment_method,
+          amount: amount,
+          state: 'checkout',
+          response_code: credit.generate_authorization_code
+        )
+      end
+
+      def store_credit_amount(credit, total)
+        [credit.amount_remaining, total].min
+      end
+    end
+  end
+end