spree_core 2.1.12 → 2.2.0

data/app/models/spree/calculator/free_shipping.rb

@@ -1,3 +1,7 @@
+# TODO: Deprecate this class.
+# This calculator will be removed in future versions of Spree.
+# The only case where it was used was for Free Shipping Promotions.
+# There is now a Promotion Action which deals with these types of promotions instead.
 module Spree
   class Calculator::FreeShipping < Calculator
     def self.description
@@ -15,5 +19,4 @@ module Spree
       order.ship_total
     end
   end
-end
-
+end

data/app/models/spree/calculator/percent_on_line_item.rb

@@ -0,0 +1,15 @@
+module Spree
+  class Calculator
+    class PercentOnLineItem < Calculator
+      preference :percent, :decimal, default: 0
+
+      def self.description
+        Spree.t(:percent_per_item)
+      end
+
+      def compute(object)
+        ((object.price * object.quantity) * preferred_percent) / 100
+      end
+    end
+  end
+end

data/app/models/spree/calculator/percent_per_item.rb

@@ -4,6 +4,9 @@ module Spree
   # for all matching products in an order. This should not be used as a
   # shipping calculator since it would be the same thing as a flat percent
   # off the entire order.
+  #
+  #
+  # TODO Should be deprecated now that we have adjustments at the line item level in spree core
 
   class Calculator::PercentPerItem < Calculator
     preference :percent, :decimal, default: 0

data/app/models/spree/classification.rb

@@ -1,8 +1,9 @@
 module Spree
   class Classification < ActiveRecord::Base
     self.table_name = 'spree_products_taxons'
-    belongs_to :product, class_name: "Spree::Product"
-    belongs_to :taxon, class_name: "Spree::Taxon"
+    acts_as_list
+    belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications
+    belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications
 
     # For #3494
     validates_uniqueness_of :taxon_id, :scope => :product_id, :message => :already_linked

data/app/models/spree/credit_card.rb

@@ -8,6 +8,7 @@ module Spree
 
     validates :month, :year, numericality: { only_integer: true }, unless: :has_payment_profile?
     validates :number, presence: true, unless: :has_payment_profile?, on: :create
+    validates :name, presence: true
     validates :verification_value, presence: true, unless: :has_payment_profile?, on: :create
     validate :expiry_not_in_the_past
 
@@ -26,19 +27,12 @@ module Spree
     }
 
     def expiry=(expiry)
-      return unless expiry.present?
-
-      self[:month], self[:year] =
-      if expiry.match(/\d\s?\/\s?\d/) # will match mm/yy and mm / yyyy
-        expiry.delete(' ').split('/')
-      elsif match = expiry.match(/(\d{2})(\d{2,4})/) # will match mmyy and mmyyyy
-        [match[1], match[2]]
-      end
-      if self[:year]
+      if expiry.present?
+        self[:month], self[:year] = expiry.delete(' ').split('/')
         self[:year] = "20" + self[:year] if self[:year].length == 2
         self[:year] = self[:year].to_i
+        self[:month] = self[:month].to_i
       end
-      self[:month] = self[:month].to_i
     end
 
     def number=(num)
@@ -68,14 +62,6 @@ module Spree
       CARD_TYPES.find{|type, pattern| return type.to_s if numbers =~ pattern}.to_s
     end
 
-    def name?
-      first_name? && last_name?
-    end
-
-    def name
-      "#{first_name} #{last_name}"
-    end
-
     def verification_value?
       verification_value.present?
     end
@@ -126,13 +112,9 @@ module Spree
 
     def expiry_not_in_the_past
       if year.present? && month.present?
-        if month.to_i < 1 || month.to_i > 12
-          errors.add(:base, :expiry_invalid)
-        else
-          current = Time.current
-          if year.to_i < current.year or (year.to_i == current.year and month.to_i < current.month)
-            errors.add(:base, :card_expired)
-          end
+        time = "#{year}-#{month}-1".to_time
+        if time < Time.zone.now.to_time.beginning_of_month
+          errors.add(:base, :card_expired)
         end
       end
     end

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

@@ -26,7 +26,7 @@ module Spree
     def authorize(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
-        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 => 'D' })
       else
         ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
       end
@@ -35,7 +35,7 @@ module Spree
     def purchase(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
-        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 => 'M' })
       else
         ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
       end
@@ -45,9 +45,9 @@ module Spree
       ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
     end
 
-    def capture(authorization, credit_card, gateway_options)
-      if authorization.response_code == '12345'
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '67890')
+    def capture(money, authorization, gateway_options)
+      if authorization == '12345'
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true)
       else
         ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
       end

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

@@ -6,14 +6,6 @@ module Spree
       false
     end
 
-    def capture(money, response_code, options = {})
-      if response_code == '12345'
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '67890')
-      else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
-      end
-    end
-
     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' })

data/app/models/spree/image.rb

@@ -14,15 +14,6 @@ module Spree
     # we need to look at the write-queue for images which have not been saved yet
     after_post_process :find_dimensions
 
-    include Spree::Core::S3Support
-    supports_s3 :attachment
-
-    Spree::Image.attachment_definitions[:attachment][:styles] = ActiveSupport::JSON.decode(Spree::Config[:attachment_styles]).symbolize_keys!
-    Spree::Image.attachment_definitions[:attachment][:path] = Spree::Config[:attachment_path]
-    Spree::Image.attachment_definitions[:attachment][:url] = Spree::Config[:attachment_url]
-    Spree::Image.attachment_definitions[:attachment][:default_url] = Spree::Config[:attachment_default_url]
-    Spree::Image.attachment_definitions[:attachment][:default_style] = Spree::Config[:attachment_default_style]
-
     #used by admin products autocomplete
     def mini_url
       attachment.url(:mini, false)

data/app/models/spree/inventory_unit.rb

@@ -1,9 +1,10 @@
 module Spree
   class InventoryUnit < ActiveRecord::Base
-    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 :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"
+    belongs_to :line_item, class_name: "Spree::LineItem", inverse_of: :inventory_units
 
     scope :backordered, -> { where state: 'backordered' }
     scope :shipped, -> { where state: 'shipped' }
@@ -44,7 +45,12 @@ module Spree
     end
 
     def self.finalize_units!(inventory_units)
-      inventory_units.map { |iu| iu.update_column(:pending, false) }
+      inventory_units.map do |iu|
+        iu.update_columns(
+          pending: false,
+          updated_at: Time.now,
+        )
+      end
     end
 
     def find_stock_item

data/app/models/spree/item_adjustments.rb

@@ -0,0 +1,65 @@
+module Spree
+  # Manage (recalculate) item (LineItem or Shipment) adjustments
+  class ItemAdjustments
+    attr_reader :item
+
+    delegate :adjustments, :order, to: :item
+
+    def initialize(item)
+      @item = item
+    end
+
+    def update
+      update_adjustments if item.persisted?
+      item
+    end
+
+    # TODO this should be probably the place to calculate proper item taxes
+    # values after promotions are applied
+    def update_adjustments
+      # 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/
+      # 
+      # 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 effect the eventual total price.
+      #
+      # Additional tax adjustments are the opposite; effecting the final total. 
+      promotion_total = adjustments.promotion.reload.map(&:update!).compact.sum
+      unless promotion_total == 0
+        choose_best_promotion_adjustment
+      end
+      promo_total = best_promotion_adjustment.try(:amount).to_f
+      included_tax_total = adjustments.tax.included.reload.map(&:update!).compact.sum
+      additional_tax_total = adjustments.tax.additional.reload.map(&:update!).compact.sum
+
+      item.update_columns(
+        :promo_total => promo_total,
+        :included_tax_total => included_tax_total,
+        :additional_tax_total => additional_tax_total,
+        :adjustment_total => promo_total + additional_tax_total,
+        :updated_at => Time.now,
+      )
+    end
+
+    # Picks one (and only one) promotion to be eligible for this order
+    # This promotion provides the most discount, and if two promotions
+    # have the same amount, then it will pick the latest one.
+    def choose_best_promotion_adjustment
+      if best_promotion_adjustment
+        other_promotions = self.adjustments.promotion.where("id NOT IN (?)", best_promotion_adjustment.id)
+        other_promotions.update_all(:eligible => false)
+      end
+    end
+
+    def best_promotion_adjustment
+      @best_promotion_adjustment ||= adjustments.promotion.eligible.reorder("amount ASC, created_at DESC").first
+    end
+  end
+end

data/app/models/spree/legacy_user.rb

@@ -4,6 +4,7 @@ module Spree
     include Core::UserAddress
 
     self.table_name = 'spree_users'
+
     has_many :orders, foreign_key: :user_id
 
     before_destroy :check_completed_orders

data/app/models/spree/line_item.rb

@@ -1,12 +1,14 @@
 module Spree
   class LineItem < ActiveRecord::Base
     before_validation :adjust_quantity
-    belongs_to :order, class_name: "Spree::Order", touch: true
-    belongs_to :variant, class_name: "Spree::Variant"
+    belongs_to :order, class_name: "Spree::Order", inverse_of: :line_items
+    belongs_to :variant, class_name: "Spree::Variant", inverse_of: :line_items
     belongs_to :tax_category, class_name: "Spree::TaxCategory"
 
     has_one :product, through: :variant
+
     has_many :adjustments, as: :adjustable, dependent: :destroy
+    has_many :inventory_units, inverse_of: :line_item
 
     before_validation :copy_price
     before_validation :copy_tax_category
@@ -20,9 +22,12 @@ module Spree
     validates :price, numericality: true
     validates_with Stock::AvailabilityValidator
 
+    before_destroy :update_inventory
+
     after_save :update_inventory
-    after_save :update_order
-    after_destroy :update_order
+    after_save :update_adjustments
+
+    after_create :create_tax_charge
 
     delegate :name, :description, :should_track_inventory?, to: :variant
 
@@ -38,14 +43,23 @@ module Spree
 
     def copy_tax_category
       if variant
-        self.tax_category = variant.product.tax_category
+        self.tax_category = variant.tax_category
       end
     end
 
     def amount
       price * quantity
     end
-    alias total amount
+    alias subtotal amount
+
+    def discounted_amount
+      amount + promo_total
+    end
+
+    def final_amount
+      amount + adjustment_total.to_f
+    end
+    alias total final_amount
 
     def single_money
       Spree::Money.new(price, { currency: currency })
@@ -63,7 +77,7 @@ module Spree
     end
 
     def sufficient_stock?
-      Stock::Quantifier.new(variant).can_supply? quantity
+      Stock::Quantifier.new(variant_id).can_supply? quantity
     end
 
     def insufficient_stock?
@@ -87,17 +101,23 @@ module Spree
     private
       def update_inventory
         if changed?
-          Spree::OrderInventory.new(self.order).verify(self, target_shipment)
+          Spree::OrderInventory.new(self.order, self).verify(target_shipment)
         end
       end
 
-      def update_order
-        if changed? || destroyed?
-          # update the order totals, etc.
-          order.create_tax_charge!
-          order.update!
+      def update_adjustments
+        if quantity_changed?
+          recalculate_adjustments
         end
       end
+
+      def recalculate_adjustments
+        Spree::ItemAdjustments.new(self).update
+      end
+
+      def create_tax_charge
+        Spree::TaxRate.adjust(order, [self])
+      end
   end
 end
 

data/app/models/spree/option_type.rb

@@ -1,7 +1,7 @@
 module Spree
   class OptionType < ActiveRecord::Base
-    has_many :option_values, -> { order(:position) }, dependent: :destroy
-    has_many :product_option_types, dependent: :destroy
+    has_many :option_values, -> { order(:position) }, dependent: :destroy, inverse_of: :option_type
+    has_many :product_option_types, dependent: :destroy, inverse_of: :option_type
     has_many :products, through: :product_option_types
     has_and_belongs_to_many :prototypes, join_table: 'spree_option_types_prototypes'
 

data/app/models/spree/option_value.rb

@@ -1,6 +1,6 @@
 module Spree
   class OptionValue < ActiveRecord::Base
-    belongs_to :option_type, :class_name => 'Spree::OptionType', :touch => true
+    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"
 

data/app/models/spree/order.rb

@@ -9,7 +9,6 @@ module Spree
       go_to_state :address
       go_to_state :delivery
       go_to_state :payment, if: ->(order) {
-        order.update_totals
         order.payment_required?
       }
       go_to_state :confirm, if: ->(order) { order.confirmation_required? }
@@ -24,9 +23,11 @@ module Spree
     if Spree.user_class
       belongs_to :user, class_name: Spree.user_class.to_s
       belongs_to :created_by, class_name: Spree.user_class.to_s
+      belongs_to :approver, class_name: Spree.user_class.to_s
     else
       belongs_to :user
       belongs_to :created_by
+      belongs_to :approver
     end
 
     belongs_to :bill_address, foreign_key: :bill_address_id, class_name: 'Spree::Address'
@@ -35,16 +36,20 @@ module Spree
     belongs_to :ship_address, foreign_key: :ship_address_id, class_name: 'Spree::Address'
     alias_attribute :shipping_address, :ship_address
 
+    alias_attribute :ship_total, :shipment_total
+
     has_many :state_changes, as: :stateful
-    has_many :line_items, -> { order('created_at ASC') }, dependent: :destroy
+    has_many :line_items, -> { order('created_at ASC') }, dependent: :destroy, inverse_of: :order
     has_many :payments, dependent: :destroy
     has_many :return_authorizations, dependent: :destroy
     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 :all_adjustments, class_name: 'Spree::Adjustment'
-    has_many :inventory_units
+    has_many :shipment_adjustments, through: :shipments, source: :adjustments
+    has_many :inventory_units, inverse_of: :order
+
+    has_and_belongs_to_many :promotions, join_table: 'spree_orders_promotions'
 
-    has_many :shipments, dependent: :destroy do
+    has_many :shipments, dependent: :destroy, inverse_of: :order do
       def states
         pluck(:state).uniq
       end
@@ -63,16 +68,15 @@ module Spree
     attr_accessor :use_billing
 
     before_create :link_by_email
-    after_create :create_tax_charge!
 
     validates :email, presence: true, if: :require_email
     validates :email, email: true, if: :require_email, allow_blank: true
-    validates :number, uniqueness: true
     validate :has_available_shipment
-    validate :has_available_payment
 
     make_permalink field: :number
 
+    delegate :update_totals, :persist_totals, :to => :updater
+
     class_attribute :update_hooks
     self.update_hooks = Set.new
 
@@ -80,12 +84,8 @@ module Spree
       where(number: number)
     end
 
-    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) }
-
     def self.between(start_date, end_date)
-      ActiveSupport::Deprecation.warn("Order#between will be deprecated in Spree 2.3, please use either Order#created_between or Order#completed_between instead.")
-      self.created_between(start_date, end_date)
+      where(created_at: start_date..end_date)
     end
 
     def self.by_customer(customer)
@@ -110,6 +110,10 @@ module Spree
       self.update_hooks.add(hook)
     end
 
+    def all_adjustments
+      Adjustment.where("order_id = :order_id OR adjustable_id = :order_id", :order_id => self.id)
+    end
+
     # For compatiblity with Calculator::PriceSack
     def amount
       line_items.inject(0.0) { |sum, li| sum + li.amount }
@@ -131,24 +135,33 @@ module Spree
       Spree::Money.new(adjustment_total, { currency: currency })
     end
 
-    def display_tax_total
-      Spree::Money.new(tax_total, { currency: currency })
+    def display_included_tax_total
+      Spree::Money.new(included_tax_total, { currency: currency })
+    end
+
+    def display_additional_tax_total
+      Spree::Money.new(additional_tax_total, { currency: currency })
     end
 
-    def display_ship_total
-      Spree::Money.new(ship_total, { currency: currency })
+    def display_shipment_total
+      Spree::Money.new(shipment_total, { currency: currency })
     end
+    alias :display_ship_total :display_shipment_total
 
     def display_total
       Spree::Money.new(total, { currency: currency })
     end
 
+    def shipping_discount
+      shipment_adjustments.eligible.sum(:amount) * - 1
+    end
+
     def to_param
       number.to_s.to_url.upcase
     end
 
     def completed?
-      completed_at.present? || complete?
+      completed_at.present?
     end
 
     # Indicates whether or not the user is allowed to proceed to checkout.
@@ -174,11 +187,6 @@ module Spree
         state == 'confirm'
     end
 
-    # Indicates the number of items in the order
-    def item_count
-      line_items.inject(0) { |sum, li| sum + li.quantity }
-    end
-
     def backordered?
       shipments.any?(&:backordered?)
     end
@@ -202,16 +210,6 @@ module Spree
       Spree::Config[:tax_using_ship_address] ? ship_address : bill_address
     end
 
-    # Array of totals grouped by Adjustment#label. Useful for displaying line item
-    # adjustments on an invoice. For example, you can display tax breakout for
-    # cases where tax is included in price.
-    def line_item_adjustment_totals
-      Hash[self.line_item_adjustments.eligible.group_by(&:label).map do |label, adjustments|
-        total = adjustments.sum(&:amount)
-        [label, Spree::Money.new(total, { currency: currency })]
-      end]
-    end
-
     def updater
       @updater ||= OrderUpdater.new(self)
     end
@@ -220,10 +218,6 @@ module Spree
       updater.update
     end
 
-    def update_totals
-      updater.update_totals
-    end
-
     def clone_billing_address
       if bill_address and self.ship_address.nil?
         self.ship_address = bill_address.clone
@@ -258,11 +252,15 @@ module Spree
       end
     end
 
+    # FIXME refactor this method and implement validation using validates_* utilities
     def generate_order_number
-      self.number ||= loop do
+      record = true
+      while record
         random = "R#{Array.new(9){rand(9)}.join}"
-        break random unless self.class.exists?(number: random)
+        record = self.class.where(number: random).first
       end
+      self.number = random if self.number.blank?
+      self.number
     end
 
     def shipped_shipments
@@ -282,14 +280,11 @@ module Spree
       line_items.detect { |line_item| line_item.variant_id == variant.id }
     end
 
-    def ship_total
-      adjustments.shipping.sum(:amount)
-    end
-
     # Creates new tax charges if there are any applicable rates. If prices already
     # include taxes then price adjustments are created instead.
     def create_tax_charge!
-      Spree::TaxRate.adjust(self)
+      Spree::TaxRate.adjust(self, line_items)
+      Spree::TaxRate.adjust(self, shipments) if shipments.any?
     end
 
     def outstanding_balance
@@ -318,10 +313,8 @@ module Spree
     # Finalizes an in progress order after checkout is complete.
     # Called after transition to complete state when payments will have been processed
     def finalize!
-      touch :completed_at
-
       # lock all adjustments (coupon promotions, etc.)
-      adjustments.update_all state: 'closed'
+      all_adjustments.each{|a| a.close}
 
       # update payment and shipment(s) states, and save
       updater.update_payment_state
@@ -334,16 +327,16 @@ module Spree
       save
       updater.run_hooks
 
-      deliver_order_confirmation_email
+      touch :completed_at
+
+      deliver_order_confirmation_email unless confirmation_delivered?
+
+      consider_risk
     end
 
     def deliver_order_confirmation_email
-      begin
-        OrderMailer.confirm_email(self.id).deliver
-      rescue Exception => e
-        logger.error("#{e.class.name}: #{e.message}")
-        logger.error(e.backtrace * "\n")
-      end
+      OrderMailer.confirm_email(self.id).deliver
+      update_column(:confirmation_delivered, true)
     end
 
     # Helper methods for checkout steps
@@ -356,7 +349,7 @@ module Spree
     end
 
     def pending_payments
-      payments.select(&:checkout?)
+      payments.select { |payment| payment.checkout? || payment.pending? }
     end
 
     # processes any pending payments and must return a boolean as it's
@@ -408,7 +401,7 @@ module Spree
     end
 
     def insufficient_stock_lines
-      line_items.select &:insufficient_stock?
+     @insufficient_stock_lines ||= line_items.select(&:insufficient_stock?)
     end
 
     def merge!(order, user = nil)
@@ -432,13 +425,10 @@ module Spree
     end
 
     def empty!
-      adjustments.destroy_all
       line_items.destroy_all
-    end
-
-    def clear_adjustments!
-      self.adjustments.destroy_all
-      self.line_item_adjustments.destroy_all
+      adjustments.destroy_all
+      update_totals
+      persist_totals
     end
 
     def has_step?(step)
@@ -465,27 +455,10 @@ module Spree
       @coupon_code = code.strip.downcase rescue nil
     end
 
-    # Tells us if there if the specified promotion is already associated with the order
-    # regardless of whether or not its currently eligible. Useful because generally
-    # you would only want a promotion action to apply to order no more than once.
-    #
-    # Receives an adjustment +originator+ (here a PromotionAction object) and tells
-    # if the order has adjustments from that already
-    def promotion_credit_exists?(originator)
-      !! adjustments.includes(:originator).promotion.reload.detect { |credit| credit.originator.id == originator.id }
-    end
-
-    def promo_total
-      adjustments.eligible.promotion.sum(:amount)
+    def can_add_coupon?
+      Spree::Promotion.order_activatable?(self)
     end
 
-    def manual_adjustment_total
-      adjustments.eligible.manual.sum(:amount)
-    end
-
-    def discount_total
-      promo_total + manual_adjustment_total
-    end
 
     def shipped?
       %w(partial shipped).include?(shipment_state)
@@ -503,20 +476,31 @@ module Spree
       shipments
     end
 
+    def apply_free_shipping_promotions
+      Spree::PromotionHandler::FreeShipping.new(self).activate
+      shipments.each { |shipment| ItemAdjustments.new(shipment).update }
+      updater.update_shipment_total
+      persist_totals
+    end
+
     # Clean shipments and make order back to address state
     #
     # At some point the might need to force the order to transition from address
     # to delivery again so that proper updated shipments are created.
     # e.g. customer goes back from payment step and changes order items
     def ensure_updated_shipments
-      if shipments.any? && !self.completed?
+      if shipments.any?
         self.shipments.destroy_all
+        self.update_column(:shipment_total, 0)
         restart_checkout_flow
       end
     end
 
     def restart_checkout_flow
-      self.update_column(:state, checkout_steps.first)
+      self.update_columns(
+        state: checkout_steps.first,
+        updated_at: Time.now,
+      )
     end
 
     def refresh_shipment_rates
@@ -527,6 +511,12 @@ module Spree
       (bill_address.empty? && ship_address.empty?) || bill_address.same_as?(ship_address)
     end
 
+    def set_shipments_cost
+      shipments.each(&:update_amounts)
+      updater.update_shipment_total
+      persist_totals
+    end
+
     def is_risky?
       self.payments.where(%{
         (avs_response IS NOT NULL and avs_response != '' and avs_response != 'D' and avs_response != 'M') or
@@ -536,6 +526,39 @@ module Spree
       }.squish!).uniq.count > 0
     end
 
+    def approved_by(user)
+      self.transaction do
+        approve!
+        self.update_columns(
+          approver_id: user.id,
+          approved_at: Time.now,
+          considered_risky: false,
+        )
+      end
+    end
+
+    def approved?
+      !!self.approved_at
+    end
+
+    def can_approve?
+      !approved?
+    end
+
+    def consider_risk
+      if is_risky? && !approved?
+        considered_risky!
+      end
+    end
+
+    def considered_risky!
+      update_column(:considered_risky, true)
+    end
+
+    def approve!
+      update_column(:considered_risky, false)
+    end
+
     private
 
       def link_by_email
@@ -566,14 +589,9 @@ module Spree
         end
       end
 
-      def has_available_payment
-        return unless has_step?("delivery") && delivery?
-        # errors.add(:base, :no_payment_methods_available) if available_payment_methods.empty?
-      end
-
       def after_cancel
         shipments.each { |shipment| shipment.cancel! }
-        payments.completed.each { |payment| payment.cancel! }
+        payments.completed.each { |payment| payment.credit! }
 
         send_cancel_email
         self.update_column(:payment_state, 'credit_owed') unless shipped?
@@ -585,6 +603,7 @@ module Spree
 
       def after_resume
         shipments.each { |shipment| shipment.resume! }
+        consider_risk
       end
 
       def use_billing?
@@ -594,5 +613,6 @@ module Spree
       def set_currency
         self.currency = Spree::Config[:currency] if self[:currency].nil?
       end
+
   end
 end