spree_core 3.0.10 → 3.1.0.rc1

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,11 +13,6 @@ 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?
@@ -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

@@ -14,7 +14,7 @@ module Spree
 
     # 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,10 +1,13 @@
 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
+      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
@@ -53,7 +56,7 @@ module Spree
       inventory_units.map do |iu|
         iu.update_columns(
           pending: false,
-          updated_at: Time.now,
+          updated_at: Time.current,
         )
       end
     end

data/app/models/spree/legacy_user.rb

@@ -3,17 +3,12 @@ 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
 

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
@@ -14,15 +17,12 @@ module Spree
     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 :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
     validates :price, numericality: true
-    validates_with Stock::AvailabilityValidator
 
+    validates_with Stock::AvailabilityValidator
     validate :ensure_proper_currency
+
     before_destroy :update_inventory
     before_destroy :destroy_inventory_units
 
@@ -31,7 +31,8 @@ module Spree
 
     after_create :update_tax_charge
 
-    delegate :name, :description, :sku, :should_track_inventory?, to: :variant
+    delegate :name, :description, :sku, :should_track_inventory?, :product, to: :variant
+    delegate :tax_zone, to: :order
 
     attr_accessor :target_shipment
 
@@ -40,49 +41,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,65 +96,63 @@ module Spree
       !sufficient_stock?
     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
-
-    def options=(options={})
+    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
+
+    private
+
+    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")
+        Spree::OrderInventory.new(order, self).verify(target_shipment)
       end
+    end
 
-      def destroy_inventory_units
-        inventory_units.destroy_all
-      end
+    def destroy_inventory_units
+      inventory_units.destroy_all
+    end
 
-      def update_adjustments
-        if quantity_changed?
-          recalculate_adjustments
-          update_tax_charge # Called to ensure pre_tax_amount is updated.
-        end
+    def update_adjustments
+      if quantity_changed?
+        recalculate_adjustments
+        update_tax_charge # Called to ensure pre_tax_amount is updated.
       end
+    end
 
-      def recalculate_adjustments
-        Adjustable::AdjustmentsUpdater.update(self)
-      end
+    def recalculate_adjustments
+      Adjustable::AdjustmentsUpdater.update(self)
+    end
 
-      def update_tax_charge
-        Spree::TaxRate.adjust(order, [self])
-      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
+    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.rb

@@ -3,7 +3,7 @@ require 'spree/order/checkout'
 
 module Spree
   class Order < Spree::Base
-    PAYMENT_STATES = %w(balance_due checkout completed credit_owed failed paid pending processing void).freeze
+    PAYMENT_STATES = %w(balance_due credit_owed failed paid void).freeze
     SHIPMENT_STATES = %w(backorder canceled partial pending ready shipped).freeze
 
     extend FriendlyId
@@ -12,14 +12,10 @@ module Spree
     include Spree::Order::Checkout
     include Spree::Order::CurrencyUpdater
     include Spree::Order::Payments
-    include Spree::NumberGenerator
+    include Spree::Order::StoreCredit
+    include Spree::Core::NumberGenerator.new(prefix: 'R')
     include Spree::Core::TokenGenerator
 
-    def generate_number(options = {})
-      options[:prefix] ||= 'R'
-      super(options)
-    end
-
     extend Spree::DisplayMoney
     money_methods :outstanding_balance, :item_total,           :adjustment_total,
                   :included_tax_total,  :additional_tax_total, :tax_total,
@@ -28,6 +24,25 @@ module Spree
     alias :display_ship_total :display_shipment_total
     alias_attribute :ship_total, :shipment_total
 
+    MONEY_THRESHOLD  = 100_000_000
+    MONEY_VALIDATION = {
+      presence:     true,
+      numericality: {
+        greater_than: -MONEY_THRESHOLD,
+        less_than:     MONEY_THRESHOLD,
+        allow_blank:   true
+      },
+      format:       { with: /\A-?\d+(?:\.\d{1,2})?\z/, allow_blank: true }
+    }.freeze
+
+    POSITIVE_MONEY_VALIDATION = MONEY_VALIDATION.deep_dup.tap do |validation|
+      validation.fetch(:numericality)[:greater_than_or_equal_to] = 0
+    end.freeze
+
+    NEGATIVE_MONEY_VALIDATION = MONEY_VALIDATION.deep_dup.tap do |validation|
+      validation.fetch(:numericality)[:less_than_or_equal_to] = 0
+    end.freeze
+
     checkout_flow do
       go_to_state :address
       go_to_state :delivery
@@ -62,12 +77,15 @@ module Spree
     alias_attribute :shipping_address, :ship_address
 
     belongs_to :store, class_name: 'Spree::Store'
-    has_many :state_changes, as: :stateful, dependent: :destroy
-    has_many :line_items, -> { order("#{LineItem.table_name}.created_at ASC") }, dependent: :destroy, inverse_of: :order
-    has_many :payments, dependent: :destroy
-    has_many :return_authorizations, dependent: :destroy, inverse_of: :order
+
+    with_options dependent: :destroy do
+      has_many :state_changes, as: :stateful
+      has_many :line_items, -> { order(:created_at) }, inverse_of: :order
+      has_many :payments
+      has_many :return_authorizations, inverse_of: :order
+      has_many :adjustments, -> { order(:created_at) }, as: :adjustable
+    end
     has_many :reimbursements, inverse_of: :order
-    has_many :adjustments, -> { order("#{Adjustment.table_name}.created_at ASC") }, as: :adjustable, dependent: :destroy
     has_many :line_item_adjustments, through: :line_items, source: :adjustments
     has_many :shipment_adjustments, through: :shipments, source: :adjustments
     has_many :inventory_units, inverse_of: :order
@@ -80,7 +98,8 @@ module Spree
              dependent: :destroy,
              inverse_of: :order
 
-    has_and_belongs_to_many :promotions, join_table: 'spree_orders_promotions'
+    has_many :order_promotions, class_name: 'Spree::OrderPromotion'
+    has_many :promotions, through: :order_promotions, class_name: 'Spree::Promotion'
 
     has_many :shipments, dependent: :destroy, inverse_of: :order do
       def states
@@ -103,12 +122,26 @@ module Spree
     before_create :link_by_email
     before_update :homogenize_line_item_currencies, if: :currency_changed?
 
-    validates :email, presence: true, if: :require_email
-    validates :email, email: true, if: :require_email, allow_blank: true
-    validate :has_available_shipment
-
-    delegate :update_totals, :persist_totals, :to => :updater
+    with_options presence: true do
+      validates :number, length: { maximum: 32, allow_blank: true }, uniqueness: { allow_blank: true }
+      validates :email, length: { maximum: 254, allow_blank: true }, email: { allow_blank: true }, if: :require_email
+      validates :state, inclusion: { in: state_machine.states.map { |state| state.name.to_s }, allow_blank: true }
+      validates :item_count, numericality: { greater_than_or_equal_to: 0, less_than: 2**31, only_integer: true, allow_blank: true }
+    end
+    validates :payment_state,        inclusion:    { in: PAYMENT_STATES, allow_blank: true }
+    validates :shipment_state,       inclusion:    { in: SHIPMENT_STATES, allow_blank: true }
+    validates :item_total,           POSITIVE_MONEY_VALIDATION
+    validates :adjustment_total,     MONEY_VALIDATION
+    validates :included_tax_total,   POSITIVE_MONEY_VALIDATION
+    validates :additional_tax_total, POSITIVE_MONEY_VALIDATION
+    validates :payment_total,        MONEY_VALIDATION
+    validates :shipment_total,       MONEY_VALIDATION
+    validates :promo_total,          NEGATIVE_MONEY_VALIDATION
+    validates :total,                MONEY_VALIDATION
+
+    delegate :update_totals, :persist_totals, to: :updater
     delegate :merge!, to: :merger
+    delegate :firstname, :lastname, to: :bill_address, prefix: true, allow_nil: true
 
     class_attribute :update_hooks
     self.update_hooks = Set.new
@@ -118,18 +151,12 @@ module Spree
 
     scope :created_between, ->(start_date, end_date) { where(created_at: start_date..end_date) }
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
+    scope :complete, -> { where.not(completed_at: nil) }
+    scope :incomplete, -> { where(completed_at: nil) }
 
     # shows completed orders first, by their completed_at date, then uncompleted orders by their created_at
     scope :reverse_chronological, -> { order('spree_orders.completed_at IS NULL', completed_at: :desc, created_at: :desc) }
 
-    def self.complete
-      where.not(completed_at: nil)
-    end
-
-    def self.incomplete
-      where(completed_at: nil)
-    end
-
     # Use this method in other gems that wish to register their own custom logic
     # that should be called after Order#update
     def self.register_update_hook(hook)
@@ -184,7 +211,7 @@ module Spree
         # Little hacky fix for #4117
         # If this wasn't here, order would transition to address state on confirm failure
         # because there would be no valid payments any more.
-        state == 'confirm'
+        confirm?
     end
 
     def backordered?
@@ -206,10 +233,15 @@ module Spree
       @updater ||= OrderUpdater.new(self)
     end
 
-    def update!
+    def update_with_updater!
       updater.update
     end
 
+    def update!
+      warn "`update!` is deprecated as it conflicts with update! method of rails. Use `update_with_updater!` instead."
+      update_with_updater!
+    end
+
     def merger
       @merger ||= Spree::OrderMerger.new(self)
     end
@@ -224,7 +256,7 @@ module Spree
     end
 
     def allow_cancel?
-      return false unless completed? and state != 'canceled'
+      return false if !completed? || canceled?
       shipment_state.nil? || %w{ready backorder pending}.include?(shipment_state)
     end
 
@@ -287,8 +319,15 @@ module Spree
       Spree::TaxRate.adjust(self, shipments) if shipments.any?
     end
 
+    def update_line_item_prices!
+      transaction do
+        line_items.each(&:update_price)
+        save!
+      end
+    end
+
     def outstanding_balance
-      if state == 'canceled'
+      if canceled?
         -1 * payment_total
       elsif reimbursements.includes(:refunds).size > 0
         reimbursed = reimbursements.includes(:refunds).inject(0) do |sum, reimbursement|
@@ -308,7 +347,7 @@ module Spree
 
     def name
       if (address = bill_address || ship_address)
-        "#{address.firstname} #{address.lastname}"
+        address.full_name
       end
     end
 
@@ -367,15 +406,7 @@ module Spree
     end
 
     def available_payment_methods
-      @available_payment_methods ||= (PaymentMethod.available(:front_end) + PaymentMethod.available(:both)).uniq
-    end
-
-    def billing_firstname
-      bill_address.try(:firstname)
-    end
-
-    def billing_lastname
-      bill_address.try(:lastname)
+      @available_payment_methods ||= PaymentMethod.available_on_front_end
     end
 
     def insufficient_stock_lines
@@ -383,11 +414,11 @@ module Spree
     end
 
     ##
-    # Check to see if any line item variants are soft deleted.
+    # Check to see if any line item variants are discontinued.
     # If so add error and restart checkout.
-    def ensure_line_item_variants_are_not_deleted
-      if line_items.any?{ |li| !li.variant || li.variant.paranoia_destroyed? }
-        errors.add(:base, Spree.t(:deleted_variants_present))
+    def ensure_line_item_variants_are_not_discontinued
+      if line_items.any?{ |li| !li.variant || li.variant.discontinued? }
+        errors.add(:base, Spree.t(:discontinued_variants_present))
         restart_checkout_flow
         false
       else
@@ -406,14 +437,21 @@ module Spree
     end
 
     def empty!
-      line_items.destroy_all
-      updater.update_item_count
-      adjustments.destroy_all
-      shipments.destroy_all
-      state_changes.destroy_all
+      if completed?
+        raise Spree.t(:cannot_empty_completed_order)
+      else
+        line_items.destroy_all
+        updater.update_item_count
+        adjustments.destroy_all
+        shipments.destroy_all
+        state_changes.destroy_all
+        order_promotions.destroy_all
 
-      update_totals
-      persist_totals
+        update_totals
+        persist_totals
+        restart_checkout_flow
+        self
+      end
     end
 
     def has_step?(step)
@@ -478,7 +516,7 @@ module Spree
     def restart_checkout_flow
       self.update_columns(
         state: 'cart',
-        updated_at: Time.now,
+        updated_at: Time.current,
       )
       self.next! if self.line_items.size > 0
     end
@@ -498,7 +536,7 @@ module Spree
     end
 
     def is_risky?
-      self.payments.risky.count > 0
+      payments.risky.size > 0
     end
 
     def canceled_by(user)
@@ -506,7 +544,7 @@ module Spree
         cancel!
         self.update_columns(
           canceler_id: user.id,
-          canceled_at: Time.now,
+          canceled_at: Time.current,
         )
       end
     end
@@ -516,7 +554,7 @@ module Spree
         approve!
         self.update_columns(
           approver_id: user.id,
-          approved_at: Time.now,
+          approved_at: Time.current,
         )
       end
     end
@@ -573,6 +611,20 @@ module Spree
 
     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
+
     def link_by_email
       self.email = user.email if self.user
     end
@@ -588,13 +640,6 @@ module Spree
       end
     end
 
-    def has_available_shipment
-      return unless has_step?("delivery")
-      return unless has_step?(:address) && address?
-      return unless ship_address && ship_address.valid?
-      # errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
-    end
-
     def ensure_available_shipping_rates
       if shipments.empty? || shipments.any? { |shipment| shipment.shipping_rates.blank? }
         # After this point, order redirects back to 'address' state and asks user to pick a proper address
@@ -607,8 +652,12 @@ module Spree
     def after_cancel
       shipments.each { |shipment| shipment.cancel! }
       payments.completed.each { |payment| payment.cancel! }
+
+      # Free up authorized store credits
+      payments.store_credits.pending.each(&:void!)
+
       send_cancel_email
-      self.update!
+      self.update_with_updater!
     end
 
     def send_cancel_email
@@ -621,7 +670,7 @@ module Spree
     end
 
     def use_billing?
-      @use_billing == true || @use_billing == 'true' || @use_billing == '1'
+      use_billing.in?([true, 'true', '1'])
     end
 
     def set_currency