rfcommerce_core 0.0.3

data/app/models/gateway/braintree.rb

@@ -0,0 +1,88 @@
+class Gateway::Braintree < Gateway
+	preference :merchant_id, :string
+	preference :public_key, :string
+	preference :private_key, :string
+
+  def provider_class
+    ActiveMerchant::Billing::BraintreeGateway
+  end
+
+  def authorize(money, creditcard, options = {})
+    adjust_options_for_braintree(creditcard, options)
+    payment_method = creditcard.gateway_customer_profile_id || creditcard
+    provider.authorize(money, payment_method, options)
+  end
+
+  def capture(authorization, ignored_creditcard, ignored_options)
+    amount = (authorization.amount * 100).to_i
+    provider.capture(amount, authorization.response_code)
+  end
+
+  def create_profile(payment)
+    if payment.source.gateway_customer_profile_id.nil?
+      response = provider.store(payment.source)
+      if response.success?
+        payment.source.update_attributes!(:gateway_customer_profile_id => response.params["customer_vault_id"])
+      else
+        payment.source.gateway_error response.message
+      end
+    end
+  end
+
+  def credit(*args)
+    if args.size == 4
+      credit_with_payment_profiles(*args)
+    elsif args.size == 3
+      credit_without_payment_profiles(*args)
+    else
+      raise ArgumentError, "Expected 3 or 4 arguments, received #{args.size}"
+    end
+  end
+
+  def credit_with_payment_profiles(amount, payment, response_code, option)
+    provider.credit(amount, payment)
+  end
+
+  def credit_without_payment_profiles(amount, response_code, options)
+    transaction = ::Braintree::Transaction.find(response_code)
+    if BigDecimal.new(amount.to_s) == (transaction.amount * 100)
+      provider.refund(response_code)
+    else
+      raise NotImplementedError
+    end
+  end
+
+  def payment_profiles_supported?
+    true
+  end
+
+  def purchase(money, creditcard, options = {})
+    authorize(money, creditcard, options.merge(:submit_for_settlement => true))
+  end
+
+  def void(response_code, ignored_options)
+    provider.void(response_code)
+  end
+
+  protected
+
+  def adjust_country_name(options)
+    [:billing_address, :shipping_address].each do |address|
+      if options[address] && options[address][:country] == "US"
+        options[address][:country] = "United States of America"
+      end
+    end
+  end
+
+  def adjust_billing_address(creditcard, options)
+    if creditcard.gateway_customer_profile_id
+      options.delete(:billing_address)
+    end
+  end
+
+  def adjust_options_for_braintree(creditcard, options)
+    adjust_country_name(options)
+    adjust_billing_address(creditcard, options)
+  end
+end
+

data/app/models/gateway/eway.rb

@@ -0,0 +1,11 @@
+class Gateway::Eway < Gateway
+  preference :login, :string
+
+  # Note: EWay supports purchase method only (no authorize method).
+  # Ensure Spree::Config[:auto_capture] is set to true
+
+  def provider_class
+    ActiveMerchant::Billing::EwayGateway
+  end
+
+end

data/app/models/gateway/linkpoint.rb

@@ -0,0 +1,8 @@
+class Gateway::Linkpoint < Gateway
+	preference :login, :string
+	preference :pem, :text
+
+  def provider_class
+    ActiveMerchant::Billing::LinkpointGateway
+  end
+end

data/app/models/gateway/pay_pal.rb

@@ -0,0 +1,11 @@
+class Gateway::PayPal < Gateway
+	preference :login, :string
+	preference :password, :string
+	preference :signature, :string
+	preference :currency_code, :string
+
+  def provider_class
+		ActiveMerchant::Billing::PaypalGateway
+  end	
+
+end

data/app/models/gateway/sage_pay.rb

@@ -0,0 +1,9 @@
+class Gateway::SagePay < Gateway
+  preference :login, :string
+  preference :password, :string
+  preference :account, :string
+
+  def provider_class
+    ActiveMerchant::Billing::SagePayGateway
+  end	
+end

data/app/models/image.rb

@@ -0,0 +1,31 @@
+class Image < Asset
+  validate :no_attachement_errors
+  has_attached_file :attachment,
+                    :styles => { :mini => '48x48>', :small => '100x100>', :product => '240x240>', :large => '600x600>' },
+                    :default_style => :product,
+                    :url => "/assets/products/:id/:style/:basename.:extension",
+                    :path => ":rails_root/public/assets/products/:id/:style/:basename.:extension"
+
+  # 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
+
+  def find_dimensions
+    temporary = attachment.queued_for_write[:original]
+    filename = temporary.path unless temporary.nil?
+    filename = attachment.path if filename.blank?
+    geometry = Paperclip::Geometry.from_file(filename)
+    self.attachment_width  = geometry.width
+    self.attachment_height = geometry.height
+  end
+
+  # if there are errors from the plugin, then add a more meaningful message
+  def no_attachement_errors
+    unless attachment.errors.empty?
+      # uncomment this to get rid of the less-than-useful interrim messages
+      # errors.clear
+      errors.add :attachment, "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
+      false
+    end
+  end
+end

data/app/models/inventory_unit.rb

@@ -0,0 +1,119 @@
+class InventoryUnit < ActiveRecord::Base
+  belongs_to :variant
+  belongs_to :order
+  belongs_to :shipment
+  belongs_to :return_authorization
+
+  scope :backorder, where(:state => 'backordered')
+
+  # state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+  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?
+    end
+    event :return do
+      transition :to => 'returned', :from => 'shipped'
+    end
+
+    after_transition :on => :fill_backorder, :do => :update_order
+    after_transition :to => 'returned', :do => :restock_variant
+  end
+
+  # method deprecated in favour of adjust_units (which creates & destroys units as needed).
+  def self.sell_units(order)
+    warn "[DEPRECATION] `InventoryUnits#sell_units` is deprecated.  Please use `InventoryUnits#assign_opening_inventory` instead. (called from #{caller[0]})"
+    self.adjust_units(order)
+  end
+
+  # Assigns inventory to a newly completed order.
+  # Should only be called once during the life-cycle of an order, on transition to completed.
+  #
+  def self.assign_opening_inventory(order)
+    return [] unless order.completed?
+
+    #increase inventory to meet initial requirements
+    order.line_items.each do |line_item|
+      increase(order, line_item.variant, line_item.quantity)
+    end
+  end
+
+  # manages both variant.count_on_hand and inventory unit creation
+  #
+  def self.increase(order, variant, quantity)
+    back_order = determine_backorder(order, variant, quantity)
+    sold = quantity - back_order
+
+    #set on_hand if configured
+    if Spree::Config[:track_inventory_levels]
+      variant.decrement!(:count_on_hand, quantity)
+    end
+
+    #create units if configured
+    if Spree::Config[:create_inventory_units]
+      create_units(order, variant, sold, back_order)
+    end
+  end
+
+  def self.decrease(order, variant, quantity)
+    if Spree::Config[:track_inventory_levels]
+       variant.increment!(:count_on_hand, quantity)
+    end
+
+    if Spree::Config[:create_inventory_units]
+      destroy_units(order, variant, quantity)
+    end
+  end
+
+  # find the specified quantity of units with the specified status
+  def self.find_by_status(variant, quantity, status)
+    variant.inventory_units.where(:status => status).limit(quantity)
+  end
+
+  private
+  def allow_ship?
+    Spree::Config[:allow_backorder_shipping] || self.sold?
+  end
+
+  def self.determine_backorder(order, variant, quantity)
+    if variant.on_hand == 0
+      quantity
+    elsif variant.on_hand.present? and variant.on_hand < quantity
+      quantity - (variant.on_hand < 0 ? 0 : variant.on_hand)
+    else
+      0
+    end
+  end
+
+  def self.destroy_units(order, variant, quantity)
+    variant_units = order.inventory_units.group_by(&:variant_id)[variant.id].sort_by(&:state)
+
+    quantity.times do
+      inventory_unit = variant_units.shift
+      inventory_unit.destroy
+    end
+  end
+
+  def self.create_units(order, variant, sold, back_order)
+    if back_order > 0 && !Spree::Config[:allow_backorders]
+      raise "Cannot request back orders when backordering is disabled"
+    end
+
+    shipment = order.shipments.detect {|shipment| !shipment.shipped? }
+
+    sold.times { order.inventory_units.create(:variant => variant, :state => "sold", :shipment => shipment) }
+    back_order.times { order.inventory_units.create(:variant => variant, :state => "backordered", :shipment => shipment) }
+  end
+
+  def update_order
+    self.order.update!
+  end
+
+  def restock_variant
+    self.variant.on_hand = (self.variant.on_hand + 1)
+    self.variant.save
+  end
+
+end

data/app/models/line_item.rb

@@ -0,0 +1,95 @@
+class LineItem < ActiveRecord::Base
+  before_validation :adjust_quantity
+  belongs_to :order
+  belongs_to :variant
+
+  has_one :product, :through => :variant
+
+  before_validation :copy_price
+
+  validates :variant, :presence => true
+  validates :quantity, :numericality => { :only_integer => true, :message => I18n.t("validation.must_be_int") }
+  validates :price, :numericality => true
+  # validate :meta_validation_of_quantities
+
+  attr_accessible :quantity
+
+  before_save :update_inventory
+  before_destroy :ensure_not_shipped, :remove_inventory
+
+  after_save :update_order
+  after_destroy :update_order
+
+  def copy_price
+    self.price = variant.price if variant && self.price.nil?
+  end
+
+  # def meta_validation_of_quantities
+  #   unless quantity && quantity >= 0
+  #     errors.add(:quantity, I18n.t("validation.must_be_non_negative"))
+  #   end
+  #   # avoid reload of order.inventory_units by using direct lookup
+  #   unless !Spree::Config[:track_inventory_levels]                        ||
+  #          Spree::Config[:allow_backorders]                               ||
+  #          order   && InventoryUnit.order_id_equals(order).first.present? ||
+  #          variant && quantity <= variant.on_hand
+  #     errors.add(:quantity, I18n.t("validation.is_too_large") + " (#{self.variant.name})")
+  #   end
+  #
+  #   if shipped_count = order.shipped_units.nil? ? nil : order.shipped_units[variant]
+  #     errors.add(:quantity, I18n.t("validation.cannot_be_less_than_shipped_units") ) if quantity < shipped_count
+  #   end
+  # end
+
+  def increment_quantity
+    self.quantity += 1
+  end
+
+  def decrement_quantity
+    self.quantity -= 1
+  end
+
+  def amount
+    self.price * self.quantity
+  end
+  alias total amount
+
+  def adjust_quantity
+    self.quantity = 0 if self.quantity.nil? || self.quantity < 0
+  end
+
+  private
+    def update_inventory
+      return true unless self.order.completed?
+
+      if self.new_record?
+        InventoryUnit.increase(self.order, self.variant, self.quantity)
+      elsif old_quantity = self.changed_attributes["quantity"]
+        if old_quantity < self.quantity
+          InventoryUnit.increase(self.order, self.variant, (self.quantity - old_quantity))
+        elsif old_quantity > self.quantity
+          InventoryUnit.decrease(self.order, self.variant, (old_quantity - self.quantity))
+        end
+      end
+
+    end
+
+    def remove_inventory
+      return true unless self.order.completed?
+
+      InventoryUnit.decrease(self.order, self.variant, self.quantity)
+    end
+
+    def update_order
+      # update the order totals, etc.
+      order.update!
+    end
+
+    def ensure_not_shipped
+      if order.try(:inventory_units).to_a.any?{|unit| unit.variant_id == variant_id && unit.shipped?}
+        errors.add :base, I18n.t("cannot_destory_line_item_as_inventory_units_have_shipped")
+        return false
+     end
+  end
+end
+

data/app/models/log_entry.rb

@@ -0,0 +1,3 @@
+class LogEntry < ActiveRecord::Base
+  belongs_to :source, :polymorphic => true
+end

data/app/models/mail_method.rb

@@ -0,0 +1,23 @@
+class MailMethod < ActiveRecord::Base
+
+  MAIL_AUTH = ['none', 'plain', 'login', 'cram_md5']
+  SECURE_CONNECTION_TYPES = ['None','SSL','TLS']
+
+  preference :enable_mail_delivery, :boolean, :default => false
+  preference :mail_host, :string, :default => 'localhost'
+  preference :mail_domain, :string, :default => 'localhost'
+  preference :mail_port, :integer, :default => 25
+  preference :mail_auth_type, :string, :default => MailMethod::MAIL_AUTH[0]
+  preference :smtp_username, :string
+  preference :smtp_password, :string
+  preference :secure_connection_type, :string, :default => MailMethod::SECURE_CONNECTION_TYPES[0]
+  preference :mails_from, :string, :default => "no-reply@example.com"
+  preference :mail_bcc, :string, :default => "spree@example.com"
+  preference :intercept_email, :string, :default => nil
+
+  validates :environment, :presence => true
+
+  def self.current
+    MailMethod.where(:environment => Rails.env).first
+  end
+end

data/app/models/option_type.rb

@@ -0,0 +1,9 @@
+class OptionType < ActiveRecord::Base
+  has_many :option_values, :order => :position, :dependent => :destroy
+  has_many :product_option_types, :dependent => :destroy
+  has_and_belongs_to_many :prototypes
+  validates :name, :presentation, :presence => true
+  default_scope :order => "option_types.position"
+
+  accepts_nested_attributes_for :option_values, :reject_if => lambda { |ov| ov[:name].blank? || ov[:presentation].blank? }, :allow_destroy => true
+end

data/app/models/option_value.rb

@@ -0,0 +1,5 @@
+class OptionValue < ActiveRecord::Base
+  belongs_to :option_type
+  acts_as_list :scope => :option_type
+  has_and_belongs_to_many :variants
+end

data/app/models/order.rb

@@ -0,0 +1,484 @@
+class Order < ActiveRecord::Base
+
+  attr_accessible :line_items, :bill_address_attributes, :ship_address_attributes, :payments_attributes,
+                  :ship_address, :line_items_attributes,
+                  :shipping_method_id, :email, :use_billing, :special_instructions
+
+  belongs_to :user
+  belongs_to :bill_address, :foreign_key => "bill_address_id", :class_name => "Address"
+  belongs_to :ship_address, :foreign_key => "ship_address_id", :class_name => "Address"
+  belongs_to :shipping_method
+
+  has_many :state_events, :as => :stateful
+  has_many :line_items, :dependent => :destroy
+  has_many :inventory_units
+  has_many :payments, :dependent => :destroy
+  has_many :shipments, :dependent => :destroy
+  has_many :return_authorizations, :dependent => :destroy
+  has_many :adjustments, :dependent => :destroy
+
+  accepts_nested_attributes_for :line_items
+  accepts_nested_attributes_for :bill_address
+  accepts_nested_attributes_for :ship_address
+  accepts_nested_attributes_for :payments
+  accepts_nested_attributes_for :shipments
+
+  before_create :create_user
+  before_create :generate_order_number
+  before_update:create_shipment!
+  # TODO: validate the format of the email as well (but we can't rely on authlogic anymore to help with validation)
+  validates :email, :presence => true, :format => /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i, :if => :require_email
+  validate :has_available_shipment
+
+  #delegate :ip_address, :to => :checkout
+  def ip_address
+    '192.168.1.100'
+  end
+
+  scope :by_number, lambda {|number| where("orders.number = ?", number)}
+  scope :between, lambda {|*dates| where("orders.created_at between ? and ?", dates.first.to_date, dates.last.to_date)}
+  scope :by_customer, lambda {|customer| joins(:user).where("users.email =?", customer)}
+  scope :by_state, lambda {|state| where("state = ?", state)}
+  scope :complete, where("orders.completed_at IS NOT NULL")
+  scope :incomplete, where("orders.completed_at IS NULL")
+
+  make_permalink :field => :number
+
+  attr_accessor :out_of_stock_items
+
+  class_attribute :update_hooks
+  self.update_hooks = Set.new
+
+  # Use this method in other gems that wish to register their own custom logic that should be called after Order#updat
+  def self.register_update_hook(hook)
+    self.update_hooks.add(hook)
+  end
+
+  def to_param
+    number.to_s.parameterize.upcase
+  end
+
+  def completed?
+    !! completed_at
+  end
+
+  # Indicates whether or not the user is allowed to proceed to checkout.  Currently this is implemented as a
+  # check for whether or not there is at least one LineItem in the Order.  Feel free to override this logic
+  # in your own application if you require additional steps before allowing a checkout.
+  def checkout_allowed?
+    line_items.count > 0
+  end
+
+  # Indicates the number of items in the order
+  def item_count
+    line_items.map(&:quantity).sum
+  end
+
+  # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+  state_machine :initial => 'cart', :use_transactions => false do
+
+    event :next do
+      transition :from => 'cart',     :to => 'address'
+      transition :from => 'address',  :to => 'delivery'
+      transition :from => 'delivery', :to => 'payment'
+      transition :from => 'confirm',  :to => 'complete'
+
+      # note: some payment methods will not support a confirm step
+      transition :from => 'payment',  :to => 'confirm',
+                                      :if => Proc.new { Gateway.current && Gateway.current.payment_profiles_supported? }
+
+      transition :from => 'payment', :to => 'complete'
+    end
+
+    event :cancel do
+      transition :to => 'canceled', :if => :allow_cancel?
+    end
+    event :return do
+      transition :to => 'returned', :from => 'awaiting_return'
+    end
+    event :resume do
+      transition :to => 'resumed', :from => 'canceled', :if => :allow_resume?
+    end
+    event :authorize_return do
+      transition :to => 'awaiting_return'
+    end
+
+    before_transition :to => 'complete' do |order|
+      begin
+        order.process_payments!
+      rescue Spree::GatewayError
+        if Spree::Config[:allow_checkout_on_gateway_error]
+          true
+        else
+          false
+        end
+      end
+    end
+
+    after_transition :to => 'complete', :do => :finalize!
+    after_transition :to => 'delivery', :do => :create_tax_charge!
+    after_transition :to => 'payment', :do => :create_shipment!
+    after_transition :to => 'canceled', :do => :after_cancel
+
+  end
+
+  # Indicates whether there are any backordered InventoryUnits associated with the Order.
+  def backordered?
+    return false unless Spree::Config[:track_inventory_levels]
+    inventory_units.backorder.present?
+  end
+
+  # This is a multi-purpose method for processing logic related to changes in the Order.  It is meant to be called from
+  # various observers so that the Order is aware of changes that affect totals and other values stored in the Order.
+  # This method should never do anything to the Order that results in a save call on the object (otherwise you will end
+  # up in an infinite recursion as the associations try to save and then in turn try to call +update!+ again.)
+  def update!
+    update_totals
+    update_payment_state
+    
+    # give each of the shipments a chance to update themselves
+    shipments.each { |shipment| shipment.update!(self) }#(&:update!)
+   update_shipment_state
+    update_adjustments
+    # update totals a second time in case updated adjustments have an effect on the total
+     update_totals
+
+    update_attributes_without_callbacks({
+      :payment_state => payment_state,
+      :shipment_state => shipment_state,
+      :item_total => item_total,
+      :adjustment_total => adjustment_total,
+      :payment_total => payment_total,
+      :total => total
+    })
+    puts "ensure checkout payment"
+    #ensure checkout payment always matches order total
+    if payment and payment.checkout? and payment.amount != total
+      puts "payment update"
+      payment.update_attributes_without_callbacks(:amount => total)
+    end
+    puts  "update hook"
+    update_hooks.each { |hook| self.send hook }
+  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)
+
+    if paid?
+      raise "do something with inventory"
+      #InventoryUnit.assign_opening_inventory(self) if inventory_units.empty?
+      #shipment.inventory_units = inventory_units
+      #shipment.ready!
+    end
+
+  end
+
+  before_validation :clone_billing_address, :if => "@use_billing"
+  attr_accessor :use_billing
+
+  def clone_billing_address
+    if bill_address and self.ship_address.nil?
+      self.ship_address = bill_address.clone
+    else
+      self.ship_address.attributes = bill_address.attributes.except("id", "updated_at", "created_at")
+    end
+    true
+  end
+
+
+
+  def allow_cancel?
+    return false unless completed? and state != 'canceled'
+    %w{ready backorder pending}.include? shipment_state
+  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 add_variant(variant, quantity = 1)
+    current_item = contains?(variant)
+    if current_item
+      current_item.quantity += quantity
+      current_item.save
+    else
+      current_item = LineItem.new(:quantity => quantity)
+      current_item.variant = variant
+      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|
+      value = ""
+
+      if field[:only].nil? || field[:only].include?(:variant)
+        value = variant.send(field[:name].gsub(" ", "_").downcase)
+      elsif field[:only].include?(:product)
+        value = variant.product.send(field[:name].gsub(" ", "_").downcase)
+      end
+      current_item.update_attribute(field[:name].gsub(" ", "_").downcase, value)
+    end
+
+    current_item
+  end
+
+  # FIXME refactor this method and implement validation using validates_* utilities
+  def generate_order_number
+    record = true
+    while record
+      random = "R#{Array.new(9){rand(9)}.join}"
+      record = self.class.find(:first, :conditions => ["number = ?", random])
+    end
+    self.number = random if self.number.blank?
+    self.number
+  end
+
+  # convenience method since many stores will not allow user to create multiple shipments
+  def shipment
+    @shipment ||= shipments.last
+  end
+
+  def contains?(variant)
+    line_items.detect{|line_item| line_item.variant_id == variant.id}
+  end
+
+  def ship_total
+    adjustments.shipping.map(&:amount).sum
+  end
+
+  def tax_total
+    adjustments.tax.map(&:amount).sum
+  end
+
+  # Creates a new tax charge if applicable.  Uses the highest possible matching rate and destroys any previous
+  # tax charges if they were created by rates that no longer apply.
+  def create_tax_charge!
+    adjustments.tax.each {|e| e.destroy }
+    TaxRate.match(ship_address).each {|r| r.create_adjustment(I18n.t(:tax), self, self, true) }
+  end
+
+  # Creates a new shipment (adjustment is created by shipment model)
+  def create_shipment!
+    shipping_method(true)
+    if shipment.present?
+      shipment.update_attributes(:shipping_method => shipping_method)
+    else
+      self.shipments << Shipment.create(:order => self,
+                                        :shipping_method => shipping_method,
+                                        :address => self.ship_address)
+    end
+
+  end
+
+  def outstanding_balance
+    total - payment_total
+  end
+
+  def outstanding_balance?
+   self.outstanding_balance != 0
+  end
+
+  def destroy_inapplicable_adjustments
+    destroyed = adjustments.reject(&:applicable?).map(&:destroy)
+    adjustments.reload if destroyed.any?
+  end
+
+  def name
+    if (address = bill_address || ship_address)
+      "#{address.firstname} #{address.lastname}"
+    end
+  end
+
+  def creditcards
+    creditcard_ids = payments.from_creditcard.map(&:source_id).uniq
+    Creditcard.scoped(:conditions => {:id => creditcard_ids})
+  end
+
+  def process_payments!
+    ret = payments.each(&:process!)
+  end
+
+  # Finalizes an in progress order after checkout is complete.
+  # Called after transition to complete state when payments will have been processed
+  def finalize!
+    update_attribute(:completed_at, Time.now)
+    self.out_of_stock_items = InventoryUnit.assign_opening_inventory(self)
+    # lock any optional adjustments (coupon promotions, etc.)
+    adjustments.optional.each { |adjustment| adjustment.update_attribute("locked", true) }
+    OrderMailer.confirm_email(self).deliver
+
+    self.state_events.create({
+      :previous_state => "cart",
+      :next_state     => "complete",
+      :name           => "order" ,
+      :user_id        => (User.respond_to?(:current) && User.current.try(:id)) || self.user_id
+    })
+  end
+
+
+  # Helper methods for checkout steps
+
+  def available_shipping_methods(display_on = nil)
+    return [] unless ship_address
+    ShippingMethod.all_available(self, display_on)
+  end
+
+  def rate_hash
+    @rate_hash ||= available_shipping_methods(:front_end).collect do |ship_method|
+      next unless cost = ship_method.calculator.compute(self)
+      { :id => ship_method.id,
+        :shipping_method => ship_method,
+        :name => ship_method.name,
+        :cost => cost
+      }
+    end.compact.sort_by{|r| r[:cost]}
+  end
+
+  def payment
+    payments.first
+  end
+
+  def available_payment_methods
+    @available_payment_methods ||= PaymentMethod.available(:front_end)
+  end
+
+  def payment_method
+    if payment and payment.payment_method
+      payment.payment_method
+    else
+      available_payment_methods.first
+    end
+  end
+
+  def billing_firstname
+    bill_address.try(:firstname)
+  end
+
+  def billing_lastname
+    bill_address.try(:lastname)
+  end
+
+  def products
+    line_items.map{|li| li.variant.product}
+  end
+
+  private
+  def create_user
+    self.email = user.email if self.user and not user.anonymous?
+    self.user ||= User.anonymous!
+  end
+
+  # Updates the +shipment_state+ attribute according to the following logic:
+  #
+  # shipped   when all Shipments are in the "shipped" state
+  # partial   when at least one Shipment has a state of "shipped" and there is another Shipment with a state other than "shipped"
+  #           or there are InventoryUnits associated with the order that have a state of "sold" but are not associated with a Shipment.
+  # ready     when all Shipments are in the "ready" state
+  # backorder when there is backordered inventory associated with an order
+  # pending   when all Shipments are in the "pending" state
+  #
+  # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+  def update_shipment_state
+    
+    self.shipment_state =
+    case shipments.count
+    when 0
+      nil
+    when shipments.shipped.count
+      "shipped"
+    when shipments.ready.count
+      "ready"
+    when shipments.pending.count
+      "pending"
+    else
+      "partial"
+    end
+    self.shipment_state = "backorder" if backordered?
+
+    if old_shipment_state = self.changed_attributes["shipment_state"]
+      self.state_events.create({
+        :previous_state => old_shipment_state,
+        :next_state     => self.shipment_state,
+        :name           => "shipment" ,
+        :user_id        => (User.respond_to?(:current) && User.current && User.current.id) || self.user_id
+      })
+    end
+
+  end
+
+  # Updates the +payment_state+ attribute according to the following logic:
+  #
+  # paid          when +payment_total+ is equal to +total+
+  # balance_due   when +payment_total+ is less than +total+
+  # credit_owed   when +payment_total+ is greater than +total+
+  # failed        when most recent payment is in the failed state
+  #
+  # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+  def update_payment_state
+    if payment_total < total
+      self.payment_state = "balance_due"
+      self.payment_state = "failed" if payments.present? and payments.last.state == "failed"
+    elsif payment_total > total
+      self.payment_state = "credit_owed"
+    else
+      self.payment_state = "paid"
+    end
+
+    if old_payment_state = self.changed_attributes["payment_state"]
+      self.state_events.create({
+        :previous_state => old_payment_state,
+        :next_state     => self.payment_state,
+        :name           => "payment" ,
+        :user_id        =>  (User.respond_to?(:current) && User.current && User.current.id) || self.user_id
+      })
+    end
+  end
+
+  # Updates the following Order total values:
+  #
+  # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
+  # +item_total+         The total value of all LineItems
+  # +adjustment_total+   The total value of all adjustments (promotions, credits, etc.)
+  # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +adjustment_total+.
+  def update_totals
+    # update_adjustments
+    self.payment_total = payments.completed.map(&:amount).sum
+    self.item_total = line_items.map(&:amount).sum
+    self.adjustment_total = adjustments.map(&:amount).sum
+    self.total = item_total + adjustment_total
+  end
+
+  # Updates each of the Order adjustments.  This is intended to be called from an Observer so that the Order can
+  # respond to external changes to LineItem, Shipment, other Adjustments, etc.  Adjustments that are no longer
+  # applicable will be removed from the association and destroyed.
+  def update_adjustments
+    # separate into adjustments to keep and adjustements to toss
+    obsolete_adjustments = adjustments.select{|adjustment| !adjustment.applicable?}
+    obsolete_adjustments.each(&:destroy)
+    self.adjustments.reload.each(&:update!)
+  end
+
+  # Determine if email is required (we don't want validation errors before we hit the checkout)
+  def require_email
+    return true unless new_record? or state == 'cart'
+  end
+
+  def has_available_shipment
+    return unless :address == state_name.to_sym
+    return unless ship_address && ship_address.valid?
+    errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
+  end
+
+  def after_cancel
+    # TODO: make_shipments_pending
+    # TODO: restock_inventory
+    OrderMailer.cancel_email(self).deliver
+  end
+
+end