spree 0.9.4 → 0.10.0.beta

data/app/models/coupon_credit.rb

@@ -0,0 +1,25 @@
+class CouponCredit < Credit
+  named_scope :with_order, :conditions => "order_id IS NOT NULL"
+
+  def calculate_adjustment
+    adjustment_source && calculate_coupon_credit
+  end
+
+  # Checks if credit is still applicable to order
+  # If source of adjustment is credit, it checks if it's still valid
+  def applicable?
+    adjustment_source && adjustment_source.eligible?(order) && super
+  end
+
+  # Calculates credit for the coupon.
+  #
+  # If coupon amount exceeds the order item_total, credit is adjusted.
+  #
+  # Always returns negative non positive.
+  def calculate_coupon_credit
+    return 0 if order.line_items.empty?
+    amount = adjustment_source.calculator.compute(order.line_items).abs
+    amount = order.item_total if amount > order.item_total
+    -1 * amount
+  end
+end

data/app/models/credit.rb

@@ -1,27 +1,19 @@
 class Credit < Adjustment
-   before_save :inverse_amount
+  before_save :ensure_negative_amount
 
-  def calculate_adjustment
-    if adjustment_source
-      case adjustment_source_type
-      when "Coupon"
-       calculate_coupon_credit
-      else
-        super
-      end
+  private
+  # Ensures Charge always has negative amount.
+  #
+  # Amount shold be modified ONLY when it's going to be saved to the database
+  # (read_attribute returns value)
+  #
+  # WARNING! It does not protect from Credits getting positive amounts while
+  # amount is autocalculated! Descending classes should ensure amount is always
+  # negative in their calculate_adjustment methods
+  # This method should be threated as a last resort for keeping integrity of adjustments
+  def ensure_negative_amount
+    if (db_amount = read_attribute(:amount)) && db_amount > 0
+      self.amount *= -1
     end
   end
-   
-  def inverse_amount
-    x = self.amount > 0 ? -1 : 1
-    self.amount = self.amount * x
-  end
-  
-  private 
-  def calculate_coupon_credit
-    return 0 if order.line_items.empty?
-    amount = adjustment_source.calculator.compute(order)
-    amount = order.item_total if amount > order.item_total
-    amount
-  end
 end

data/app/models/creditcard.rb

@@ -1,59 +1,43 @@
-class Creditcard < ActiveRecord::Base 
-  before_save :filter_sensitive
-  belongs_to :checkout
-  belongs_to :address
-  has_many :creditcard_payments
-  before_validation :prepare
+class Creditcard < ActiveRecord::Base         
+  has_many :payments, :as => :source
 
-  accepts_nested_attributes_for :address
-      
-  include ActiveMerchant::Billing::CreditCardMethods
-
-  class ExpiryDate #:nodoc:
-    attr_reader :month, :year
-    def initialize(month, year)
-      @month = month
-      @year = year
-    end
-    
-    def expired? #:nodoc:
-      Time.now > expiration rescue true
-    end
-    
-    def expiration #:nodoc:
-      Time.parse("#{month}/#{month_days}/#{year} 23:59:59") rescue Time.at(0)
-    end
-    
-    private
-    def month_days
-      mdays = [nil,31,28,31,30,31,30,31,31,30,31,30,31]
-      mdays[2] = 29 if Date.leap?(year)
-      mdays[month]
+  before_save :set_last_digits
+  
+  validates_numericality_of :month, :integer => true
+  validates_numericality_of :year, :integer => true   
+  validates_presence_of :number, :unless => :has_payment_profile?, :on => :create
+  validates_presence_of :verification_value, :unless => :has_payment_profile?, :on => :create
+  
+  
+  def process!(payment)
+    begin
+      if Spree::Config[:auto_capture]
+        purchase(payment.amount.to_f, payment)
+        payment.finalize!
+      else
+        authorize(payment.amount.to_f, payment)
+      end
     end
   end
   
-  def expiry_date
-    ExpiryDate.new(Time.now.month, Time.now.year)
-  end
-
-  def expired?
-    expiry_date.expired?
+  def set_last_digits
+    self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1) 
   end
-  
+    
   def name?
     first_name? && last_name?
   end
   
   def first_name?
-    !@first_name.blank?
+    !self.first_name.blank?
   end
   
   def last_name?
-    !@last_name.blank?
+    !self.last_name.blank?
   end
         
   def name
-    "#{@first_name} #{@last_name}"
+    "#{self.first_name} #{self.last_name}"
   end
         
   def verification_value?
@@ -61,86 +45,30 @@ class Creditcard < ActiveRecord::Base
   end
 
   # Show the card number, with all but last 4 numbers replace with "X". (XXXX-XXXX-XXXX-4338)
-  #def display_number
-  #  self.class.mask(number)
-  #end
-  
-  def last_digits
-    self.class.last_digits(number)
-  end
-
-  # needed for some of the ActiveMerchant gateways (eg. Protx)
-  def brand
-    cc_type
-  end 
-
-  def validate 
-    validate_essential_attributes
-    validate_card_type
-    #validate_card_number
-    #validate_verification_value 
-    #validate_switch_or_solo_attributes
+  def display_number
+   "XXXX-XXXX-XXXX-#{last_digits}"
   end
   
-  def self.requires_verification_value?
-    true
-    #require_verification_value
-  end
+  alias :attributes_with_quotes_default :attributes_with_quotes
   
-  private
-  # Validation logic ripped from ActiveMerchant's Creditcard model
-  # http://github.com/Shopify/active_merchant/tree/master/lib/active_merchant/billing/credit_card.rb
-  def filter_sensitive
-    self.display_number = ActiveMerchant::Billing::CreditCard.mask(number) if self.display_number.blank?
-    self.number = nil unless Spree::Config[:store_cc]
-    self.verification_value = nil unless Spree::Config[:store_cvv]
-  end
 
-  def prepare #:nodoc:
-    self.month = month.to_i
-    self.year = year.to_i
-    self.number = number.to_s.gsub(/[^\d]/, "")
-    self.cc_type.downcase! if cc_type.respond_to?(:downcase)
-    self.cc_type = spree_cc_type if cc_type.blank?    
-    self.first_name = address.firstname if address
-    self.last_name = address.lastname if address
-  end
   
-  def validate_card_number #:nodoc:
-    errors.add :number, "is not a valid credit card number" unless Creditcard.valid_number?(number)
-    unless errors.on(:number) || errors.on(:cc_type)
-      errors.add :cc_type, "is not the correct card type" unless Creditcard.matching_type?(number, cc_type)
-    end
-  end
   
-  def validate_card_type #:nodoc:
-    #errors.add :cc_type, "is required" if cc_type.blank?
-    errors.add :cc_type, "is invalid" unless Creditcard.card_companies.keys.include?(cc_type)
-  end
+  private
   
-  def validate_essential_attributes #:nodoc:
-    errors.add :first_name, "cannot be empty" if first_name.blank?
-    errors.add :last_name, "cannot be empty" if last_name.blank?
-    errors.add :month, "is not a valid month" unless valid_month?(month)
-    errors.add :year, "expired" if expired?
-    errors.add :year, "is not a valid year" unless valid_expiry_year?(year)
-  end
   
-  def validate_switch_or_solo_attributes #:nodoc:
-    if %w[switch solo].include?(cc_type)
-      unless valid_month?(@start_month) && valid_start_year?(@start_year) || valid_issue_number?(@issue_number)
-        errors.add :start_month, "is invalid" unless valid_month?(@start_month)
-        errors.add :start_year, "is invalid" unless valid_start_year?(@start_year)
-        errors.add :issue_number, "cannot be empty" unless valid_issue_number?(@issue_number)
-      end
-    end
+  # Override default behavior of Rails attr_readonly so that its never written to the database (not even on create)
+  def attributes_with_quotes(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
+    attributes_with_quotes_default(include_primary_key, false, attribute_names)
   end
-  
-  def validate_verification_value #:nodoc:
-    if Creditcard.requires_verification_value?
-      errors.add :verification_value, "is required" unless verification_value?
+
+  def remove_readonly_attributes(attributes)
+    if self.class.readonly_attributes.present?
+      attributes.delete_if { |key, value| self.class.readonly_attributes.include?(key.gsub(/\(.+/,"")) }
     end
+    # extra logic for sanitizing the number and verification value based on preferences
+    attributes.delete_if { |key, value| key == "number" and !Spree::Config[:store_cc] } 
+    attributes.delete_if { |key, value| key == "verification_value" and !Spree::Config[:store_cvv] } 
   end
-
 end
 

data/app/models/creditcard_txn.rb

@@ -1,6 +1,9 @@
-class CreditcardTxn < ActiveRecord::Base
-  belongs_to :creditcard_payment
-  validates_numericality_of :amount
-  
+class CreditcardTxn < Transaction
+
   enumerable_constant :txn_type, :constants => [:authorize, :capture, :purchase, :void, :credit]
+  
+  def txn_type_name
+    TxnType.from_value(txn_type)
+  end
+
 end

data/app/models/inventory_unit.rb

@@ -1,71 +1,88 @@
 class InventoryUnit < ActiveRecord::Base
   belongs_to :variant
   belongs_to :order
-  
+  belongs_to :shipment
+  belongs_to :return_authorization
+
   named_scope :retrieve_on_hand, lambda {|variant, quantity| {:conditions => ["state = 'on_hand' AND variant_id = ?", variant], :limit => quantity}}
 
   # state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-  state_machine :initial => 'on_hand' do    
-    event :sell do
-      transition :to => 'sold', :from => 'on_hand'
-    end
+  state_machine :initial => 'on_hand' do
     event :fill_backorder do
       transition :to => 'sold', :from => 'backordered'
     end
     event :ship do
       transition :to => 'shipped', :if => :allow_ship? #, :from => 'sold'
     end
-    event :restock do
-      transition :to => 'on_hand', :from => %w(sold shipped)
-    end
     # TODO: add backorder state and relevant transitions
   end
-  
-  # destroy the specified number of on hand inventory units 
+
+  # destroy the specified number of on hand inventory units
   def self.destroy_on_hand(variant, quantity)
     inventory = self.retrieve_on_hand(variant, quantity)
     inventory.each do |unit|
       unit.destroy
-    end                                          
+    end
   end
-  
+
   # create the specified number of on hand inventory units
   def self.create_on_hand(variant, quantity)
     quantity.times do
       self.create(:variant => variant, :state => 'on_hand')
     end
   end
-  
-  # grab the appropriate units from inventory, mark as sold and associate with the order 
+
+  # grab the appropriate units from inventory, mark as sold and associate with the order
   def self.sell_units(order)
+    out_of_stock_items = []
     order.line_items.each do |line_item|
       variant = line_item.variant
       quantity = line_item.quantity
-      # retrieve the requested number of on hand units (or as many as possible) - note: optimistic locking used here
-      on_hand = self.retrieve_on_hand(variant, quantity)
-      # mark all of these units as sold and associate them with this order 
-      on_hand.each do |unit|          
-        unit.order = order
-        unit.sell!
-      end
-      # right now we always allow back ordering
-      backorder = quantity - on_hand.size
-      backorder.times do 
-        order.inventory_units.create(:variant => variant, :state => "backordered")
+
+      # mark all of these units as sold and associate them with this order
+      remaining_quantity = variant.count_on_hand - quantity
+      if (remaining_quantity >= 0)
+        quantity.times do
+          order.inventory_units.create(:variant => variant, :state => "sold")
+        end
+        variant.update_attribute(:count_on_hand, remaining_quantity)
+      else
+        (quantity + remaining_quantity).times do
+          order.inventory_units.create(:variant => variant, :state => "sold")
+        end
+        if Spree::Config[:allow_backorders]
+          (-remaining_quantity).times do
+            order.inventory_units.create(:variant => variant, :state => "backordered")
+          end
+        else
+          line_item.update_attribute(:quantity, quantity + remaining_quantity)
+          out_of_stock_items << {:line_item => line_item, :count => -remaining_quantity}
+        end
+        variant.update_attribute(:count_on_hand, 0)
       end
     end
+    out_of_stock_items
   end
-  
+
+  def can_restock?
+    %w(sold shipped).include?(state)
+  end
+
+  def restock!
+    variant.update_attribute(:count_on_hand, variant.count_on_hand + 1)
+    delete
+  end
+
   # find the specified quantity of units with the specified status
   def self.find_by_status(variant, quantity, status)
-    variant.inventory_units.find(:all, 
-                                 :conditions => ['status = ? ', status], 
+    variant.inventory_units.find(:all,
+                                 :conditions => ['status = ? ', status],
                                  :limit => quantity)
-  end 
-  
+  end
+
   private
   def allow_ship?
-    state == 'ready_to_ship' || Spree::Config[:allow_backorder_shipping]
+    Spree::Config[:allow_backorder_shipping] || (state == 'ready_to_ship')
   end
-  
-end
+
+end

data/app/models/line_item.rb

@@ -5,21 +5,27 @@ class LineItem < ActiveRecord::Base
   
   has_one :product, :through => :variant
 
-  validates_presence_of :variant
-  validates_numericality_of :quantity, :only_integer => true, :message => "must be an integer"
+  before_validation :copy_price
+
+  validates_presence_of :variant, :order
+  validates_numericality_of :quantity, :only_integer => true, :message => I18n.t("validation.must_be_int")
   validates_numericality_of :price
 
-  attr_accessible :quantity
+  attr_accessible :quantity, :variant_id, :order_id
+
+  def copy_price
+    self.price = variant.price if variant && self.price.nil?
+  end
   
   def validate
     unless quantity && quantity >= 0
-      errors.add(:quantity, "must be a non-negative value")
+      errors.add(:quantity, I18n.t("validation.must_be_non_negative"))
     end
     # avoid reload of order.inventory_units by using direct lookup
     unless Spree::Config[:allow_backorders]                               ||
            order   && InventoryUnit.order_id_equals(order).first.present? || 
            variant && quantity <= variant.on_hand                         
-      errors.add(:quantity, " is too large-- stock on hand cannot cover requested quantity!")
+      errors.add(:quantity, I18n.t("validation.is_too_large"))
     end
   end
   

data/app/models/option_type.rb

@@ -1,5 +1,6 @@
 class OptionType < ActiveRecord::Base
   has_many :option_values, :order => :position, :dependent => :destroy, :attributes => true
+  has_many :product_option_types, :dependent => :destroy
   has_and_belongs_to_many :prototypes
   validates_presence_of [:name, :presentation]
-end
+end

data/app/models/order.rb

@@ -7,41 +7,40 @@ class Order < ActiveRecord::Base
 
   before_create :generate_token
   before_save :update_line_items, :update_totals
-  after_create :create_checkout_and_shippment, :create_tax_charge
+  after_create :create_checkout, :create_shipment, :create_tax_charge
 
   belongs_to :user
-  has_many :state_events
+  has_many :state_events, :as => :stateful
 
   has_many :line_items, :extend => Totaling, :dependent => :destroy
   has_many :inventory_units
 
-  has_many :payments,            :extend => Totaling
-  has_many :creditcard_payments, :extend => Totaling
+  has_many :payments, :as => :payable, :extend => Totaling
 
   has_one :checkout
   has_one :bill_address, :through => :checkout
+  has_one :ship_address, :through => :checkout
   has_many :shipments, :dependent => :destroy
+  has_many :return_authorizations, :dependent => :destroy
 
   has_many :adjustments,      :extend => Totaling, :order => :position
   has_many :charges,          :extend => Totaling, :order => :position
-  has_many :shipping_charges, :extend => Totaling, :order => :position,
-    :class_name => "Charge", :conditions => {:secondary_type => "ShippingCharge"}
-  has_many :tax_charges,      :extend => Totaling, :order => :position,
-    :class_name => "Charge", :conditions => {:secondary_type => "TaxCharge"}
   has_many :credits,          :extend => Totaling, :order => :position
-  has_many :coupon_credits, :class_name => "Credit", :extend => Totaling, :conditions => {:adjustment_source_type => "Coupon"}, :order => :position
-  has_many :non_zero_charges, :class_name => "Charge", :conditions => ["amount > 0"]
+  has_many :shipping_charges, :extend => Totaling, :order => :position
+  has_many :tax_charges,      :extend => Totaling, :order => :position
+  has_many :coupon_credits,   :extend => Totaling, :order => :position
+  has_many :non_zero_charges, :extend => Totaling, :order => :position,
+           :class_name => "Charge", :conditions => ["amount != 0"]
 
-  accepts_nested_attributes_for :checkout  
+  accepts_nested_attributes_for :checkout
   accepts_nested_attributes_for :line_items
-  
-  def ship_address; shipment.address; end
-  delegate :shipping_method, :to =>:shipment
+  accepts_nested_attributes_for :shipments
+
+  delegate :shipping_method, :to => :checkout
   delegate :email, :to => :checkout
   delegate :ip_address, :to => :checkout
-  delegate :special_instructions, :to => :checkout 
-  
-  validates_associated :line_items, :message => "are not valid"
+  delegate :special_instructions, :to => :checkout
+
   validates_numericality_of :item_total
   validates_numericality_of :total
 
@@ -49,28 +48,30 @@ class Order < ActiveRecord::Base
   named_scope :between, lambda {|*dates| {:conditions => ["orders.created_at between :start and :stop", {:start => dates.first.to_date, :stop => dates.last.to_date}]}}
   named_scope :by_customer, lambda {|customer| {:include => :user, :conditions => ["users.email = ?", customer]}}
   named_scope :by_state, lambda {|state| {:conditions => ["state = ?", state]}}
-  named_scope :checkout_complete, {:include => :checkout, :conditions => ["checkouts.completed_at IS NOT NULL"]}
+  named_scope :checkout_complete, {:include => :checkout, :conditions => ["orders.completed_at IS NOT NULL"]}
   make_permalink :field => :number
-  
+
   # attr_accessible is a nightmare with attachment_fu, so use attr_protected instead.
   attr_protected :charge_total, :item_total, :total, :user, :number, :state, :token
 
-  def to_param  
+  def checkout_complete; !!completed_at; end
+
+  def to_param
     self.number if self.number
     generate_order_number unless self.number
     self.number.parameterize.to_s.upcase
   end
 
-  def checkout_complete
-    checkout.completed_at
-  end
   # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-  state_machine :initial => 'in_progress' do    
+  state_machine :initial => 'in_progress' do
     after_transition :to => 'in_progress', :do => lambda {|order| order.update_attribute(:checkout_complete, false)}
     after_transition :to => 'new', :do => :complete_order
     after_transition :to => 'canceled', :do => :cancel_order
     after_transition :to => 'returned', :do => :restock_inventory
-    after_transition :to => 'resumed', :do => :restore_state 
+    after_transition :to => 'resumed', :do => :restore_state
+    after_transition :to => 'paid', :do => :make_shipments_ready
+    after_transition :to => 'shipped', :do => :make_shipments_shipped
+    after_transition :to => 'balance_due', :do => :make_shipments_pending
 
     event :complete do
       transition :to => 'new', :from => 'in_progress'
@@ -79,39 +80,99 @@ class Order < ActiveRecord::Base
       transition :to => 'canceled', :if => :allow_cancel?
     end
     event :return do
-      transition :to => 'returned', :from => 'shipped'
+      transition :to => 'returned', :from => 'credit_owed'
     end
-    event :resume do 
+    event :resume do
       transition :to => 'resumed', :from => 'canceled', :if => :allow_resume?
-    end    
+    end
     event :pay do
       transition :to => 'paid', :if => :allow_pay?
     end
+    event :under_paid do
+      transition :to => 'balance_due', :from => ['paid', 'new', 'credit_owed', 'shipped', 'awaiting_return']
+    end
+    event :over_paid do
+      transition :to => 'credit_owed', :from => ['paid', 'new', 'balance_due', 'shipped', 'awaiting_return']
+    end
     event :ship do
       transition :to => 'shipped', :from  => 'paid'
     end
+    event :return_authorized do
+      transition :to => 'awaiting_return', :from => 'shipped'
+    end
   end
-  
+
   def restore_state
     # pop the resume event so we can see what the event before that was
     state_events.pop if state_events.last.name == "resume"
     update_attribute("state", state_events.last.previous_state)
   end
 
+  def make_shipments_shipped
+    shipments.reject(&:shipped?).each do |shipment|
+      shipment.update_attributes(:state => 'shipped', :shipped_at => Time.now)
+    end
+  end
+
+  def make_shipments_ready
+    shipments.each(&:ready)
+  end
+
+  def make_shipments_pending
+    shipments.each(&:pend)
+  end
+
+  def shipped_units
+    shipped_units = shipments.inject([]) { |units, shipment| units << shipment.inventory_units if shipment.shipped? }
+
+    if shipped_units.nil?
+      return nil
+    else
+      shipped_units.flatten!
+    end
+
+    shipped = {}
+    shipped_units.group_by(&:variant_id).each do |variant_id, ship_units|
+      shipped[Variant.find(variant_id)] = ship_units.size
+    end
+    shipped
+  end
+
+  def returnable_units
+    returned_units = return_authorizations.inject([]) { |units, return_auth| units << return_auth.inventory_units}
+    returned_units.flatten! unless returned_units.nil?
+
+    returnable = shipped_units
+    return if returnable.nil?
+
+    returned_units.group_by(&:variant_id).each do |variant_id, returned_units|
+      variant = returnable.detect { |ru| ru.first.id == variant_id }[0]
+
+      count = returnable[variant] - returned_units.size
+      if count > 0
+        returnable[variant] = returnable[variant] - returned_units.size
+      else
+        returnable.delete variant
+      end
+    end
+
+    returnable.empty? ? nil : returnable
+  end
+
   def allow_cancel?
     self.state != 'canceled'
   end
-  
+
   def allow_resume?
     # we shouldn't allow resume for legacy orders b/c we lack the information necessary to restore to a previous state
     return false if state_events.empty? || state_events.last.previous_state.nil?
     true
   end
-  
+
   def allow_pay?
     checkout_complete
   end
-  
+
   def add_variant(variant, quantity=1)
     current_item = contains?(variant)
     if current_item
@@ -124,12 +185,12 @@ class Order < ActiveRecord::Base
       current_item.price   = variant.price
       self.line_items << current_item
     end
-    
+
     # populate line_items attributes for additional_fields entries
     # that have populate => [:line_item]
-    Variant.additional_fields.select{|f| !f[:populate].nil? && f[:populate].include?(:line_item) }.each do |field| 
+    Variant.additional_fields.select{|f| !f[:populate].nil? && f[:populate].include?(:line_item) }.each do |field|
       value = ""
-      
+
       if field[:only].nil? || field[:only].include?(:variant)
         value = variant.send(field[:name].gsub(" ", "_").downcase)
       elsif field[:only].include?(:product)
@@ -137,29 +198,31 @@ class Order < ActiveRecord::Base
       end
       current_item.update_attribute(field[:name].gsub(" ", "_").downcase, value)
     end
+
+    current_item
   end
 
-  def generate_order_number                
+  def generate_order_number
     record = true
     while record
-      random = "R#{Array.new(9){rand(9)}.join}"                                        
+      random = "R#{Array.new(9){rand(9)}.join}"
       record = Order.find(:first, :conditions => ["number = ?", random])
-    end          
+    end
     self.number = random
-  end          
-    
+  end
+
   # convenience method since many stores will not allow user to create multiple shipments
   def shipment
-    shipments.last
+    @shipment ||= shipments.last
   end
-  
+
   def contains?(variant)
     line_items.select { |line_item| line_item.variant == variant }.first
   end
 
   def grant_access?(token=nil)
     return true if token && token == self.token
-    return false unless current_user_session = UserSession.find   
+    return false unless current_user_session = UserSession.find
     return current_user_session.user == self.user
   end
   def mark_shipped
@@ -167,17 +230,18 @@ class Order < ActiveRecord::Base
       inventory_unit.ship!
     end
   end
-      
+
   # collection of available shipping countries
   def shipping_countries
+    return [] unless ShippingMethod.count > 0
     ShippingMethod.all.collect { |method| method.zone.country_list }.flatten.uniq.sort_by {|item| item.send 'name'}
   end
-  
+
   def shipping_methods
-    return [] unless ship_address
-    ShippingMethod.all.select { |method| method.zone.include?(ship_address) && method.available?(self) }
+    return [] unless ship_address and ShippingMethod.count > 0
+    ShippingMethod.all_available_to_address(ship_address)
   end
-   
+
   def payment_total
     payments.reload.total
   end
@@ -203,19 +267,24 @@ class Order < ActiveRecord::Base
       tax_charges.create({
           :order => self,
           :description => I18n.t(:tax),
-          :adjustment_source => self,
-        })
+          :adjustment_source => self
+      })
     end
   end
 
-  def update_totals
+  def update_totals(force_adjustment_recalculation=false)
     self.item_total       = self.line_items.total
 
     # save the items which might be changed by an order update, so that
     # charges can be recalculated accurately.
     self.line_items.map(&:save)
 
-    adjustments.reload.each(&:update_amount)
+    if !self.checkout_complete || force_adjustment_recalculation
+      applicable_adjustments, adjustments_to_destroy = adjustments.partition{|a| a.applicable?}
+      self.adjustments = applicable_adjustments
+      adjustments_to_destroy.each(&:destroy)
+    end
+
     self.adjustment_total = self.charge_total - self.credit_total
 
     self.total            = self.item_total   + self.adjustment_total
@@ -223,18 +292,71 @@ class Order < ActiveRecord::Base
 
   def update_totals!
     update_totals
+
+    payments_total = self.payments.total
+    if payments_total < self.total
+      #Total is higher so balance_due
+      self.under_paid
+    elsif payments_total > self.total
+      #Total is lower so credit_owed
+      self.over_paid
+    end
+
     save!
   end
 
+  def update_adjustments
+    self.adjustments.each(&:update_amount)
+    update_totals(:force_adjustment_update)
+    self
+  end
+
+  def name
+    address = bill_address || ship_address
+    "#{address.firstname} #{address.lastname}" if address
+  end
+
+
+  def out_of_stock_items
+    @out_of_stock_items
+  end
+
+  def outstanding_balance
+    [0, total - payments.total].max
+  end
+
+  def outstanding_balance?
+    outstanding_balance > 0
+  end
+
+  def outstanding_credit
+    [0, payments.total - total].max
+  end
+
+  def outstanding_credit?
+    outstanding_credit > 0
+  end
+
+
+  def creditcards
+    creditcard_ids = (payments.from_creditcard + checkout.payments.from_creditcard).map(&:source_id).uniq
+    Creditcard.scoped(:conditions => {:id => creditcard_ids})
+  end
+
   private
- 
+
   def complete_order
-    checkout.update_attribute(:completed_at, Time.now)
+    self.adjustments.each(&:update_amount)
+    update_attribute(:completed_at, Time.now)
+
     if email
       OrderMailer.deliver_confirm(self)
     end
+
     begin
-      InventoryUnit.sell_units(self)
+      @out_of_stock_items = InventoryUnit.sell_units(self)
+      update_totals unless @out_of_stock_items.empty?
+      shipment.inventory_units = inventory_units
       save!
     rescue Exception => e
       logger.error "Problem saving authorized order: #{e.message}"
@@ -246,28 +368,31 @@ class Order < ActiveRecord::Base
     restock_inventory
     OrderMailer.deliver_cancel(self)
   end
-  
+
   def restock_inventory
     inventory_units.each do |inventory_unit|
       inventory_unit.restock! if inventory_unit.can_restock?
     end
   end
- 
+
   def update_line_items
     to_wipe = self.line_items.select {|li| 0 == li.quantity || li.quantity.nil? }
     LineItem.destroy(to_wipe)
     self.line_items -= to_wipe      # important: remove defunct items, avoid a reload
   end
-  
+
   def generate_token
     self.token = Authlogic::Random.friendly_token
   end
-  
-  def create_checkout_and_shippment
+
+  def create_checkout
+    self.checkout ||= Checkout.new(:order => self)
+    self.checkout.enable_validation_group(:address)
+    self.checkout.save!
+  end
+
+  def create_shipment
     self.shipments << Shipment.create(:order => self)
-    self.checkout ||= Checkout.create(:order => self)
   end
-end
 
-# please don't remove it, it's needed to activite observer if user doesn't update environment.rb
-OrderObserver.instance
+end