spree_core 0.30.0.beta1 → 0.30.0

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/order.rb

@@ -1,24 +1,20 @@
 class Order < ActiveRecord::Base
-  # module Totaling
-  #   def total
-  #     map(&:amount).sum
-  #   end
-  # end
 
-  attr_accessible :line_items, :bill_address, :ship_address
-  #attr_protected :charge_total, :item_total, :total, :user, :user_id, :number, :token
+  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#, :extend => Totaling
+  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
@@ -26,19 +22,15 @@ class Order < ActiveRecord::Base
   accepts_nested_attributes_for :payments
   accepts_nested_attributes_for :shipments
 
-  has_many :adjustments
-
   before_create :create_user
   before_create :generate_order_number
 
-  delegate :email, :to => :user
+  validates_presence_of :email, :if => :require_email
+
   #delegate :ip_address, :to => :checkout
   def ip_address
     '192.168.1.100'
   end
-  #delegate :special_instructions, :to => :checkout
-
-  #validates :item_total, :total, :numericality => true
 
   scope :by_number, lambda {|number| where("orders.number = ?", number)}
   scope :between, lambda {|*dates| where("orders.created_at between :start and :stop").where(:start, dates.first.to_date).where(:stop, dates.last.to_date)}
@@ -49,16 +41,21 @@ class Order < ActiveRecord::Base
 
   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, :user_id, :number, :token #,:state
-
   attr_accessor :out_of_stock_items
 
+  class_inheritable_accessor :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 complete?
+  def completed?
     !! completed_at
   end
 
@@ -78,6 +75,7 @@ class Order < ActiveRecord::Base
   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 => 'payment', :to => 'confirm'
@@ -98,15 +96,28 @@ class Order < ActiveRecord::Base
       transition :to => 'awaiting_return'
     end
 
-    before_transition :to => 'complete', :do => :process_payments!
+    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_and_shipping_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
 
@@ -116,11 +127,15 @@ class Order < ActiveRecord::Base
   # 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_shipment_state
     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,
@@ -129,6 +144,8 @@ class Order < ActiveRecord::Base
       :payment_total => payment_total,
       :total => total
     })
+
+    update_hooks.each { |hook| self.send hook }
   end
 
   def restore_state
@@ -137,9 +154,10 @@ class Order < ActiveRecord::Base
     update_attribute("state", state_events.last.previous_state)
 
     if paid?
-      InventoryUnit.sell_units(self) if inventory_units.empty?
-      shipment.inventory_units = inventory_units
-      shipment.ready!
+      raise "do something with inventory"
+      #InventoryUnit.assign_opening_inventory(self) if inventory_units.empty?
+      #shipment.inventory_units = inventory_units
+      #shipment.ready!
     end
 
   end
@@ -158,54 +176,9 @@ class Order < ActiveRecord::Base
 
 
 
-  # 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.concat(shipment.shipped? ? shipment.inventory_units : []) }
-  #   return nil if shipped_units.empty?
-  #
-  #   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'
+    return false unless completed? and state != 'canceled'
+    %w{ready backorder pending}.include? shipment_state
   end
 
   def allow_resume?
@@ -260,31 +233,12 @@ class Order < ActiveRecord::Base
     line_items.detect{|line_item| line_item.variant_id == variant.id}
   end
 
-  # def mark_shipped
-  #   inventory_units.each do |inventory_unit|
-  #     inventory_unit.ship!
-  #   end
-  # end
-
-  # TODO: Re-implement these 4 methods
   def ship_total
-    # shipping_charges.reload.map(&:amount).sum
-    0
+    adjustments.shipping.map(&:amount).sum
   end
 
   def tax_total
-    # tax_charges.reload.map(&:amount).sum
-    0
-  end
-
-  def credit_total
-    # credits.reload.map(&:amount).sum.abs
-    0
-  end
-
-  def charge_total
-    # charges.reload.map(&:amount).sum
-    0
+    adjustments.tax.map(&:amount).sum
   end
 
   # Creates a new tax charge if applicable.  Uses the highest possible matching rate and destroys any previous
@@ -298,26 +252,25 @@ class Order < ActiveRecord::Base
     rate.create_adjustment(I18n.t(:tax), self, self, true)
   end
 
-  def create_shipment_and_shipping_charge!
+  # Creates a new shipment (adjustment is created by shipment model)
+  def create_shipment!
     shipping_method.reload
     if shipment.present?
       shipment.update_attributes(:shipping_method => shipping_method)
     else
-      self.shipments << Shipment.create(:order => self, :shipping_method => shipping_method)
-    end
-    if shipping_charge = adjustments.shipping.first
-      # shipping_charge.update_attributes(:originator_id => shipping_method.id)
-      shipping_charge.originator = shipping_method
-      shipping_charge.save
-    else
-      shipping_method.create_adjustment(I18n.t(:shipping), self, shipment, true)
+      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?
@@ -328,46 +281,23 @@ class Order < ActiveRecord::Base
     "#{address.firstname} #{address.lastname}" if address
   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
-
-  # Indicates whether order has a real user associated with it or just a placeholder anonymous user
-  def anonymous?
-    user && user.anonymous?
-  end
-
-  # Associates the order with a registered user (replacing the previously associated guest user)
-  #
-  # throws an Exception if there is already a registered user associated with the order
-  def register!(user)
-    raise "Already registred" if user and not user.anonymous?
-    self.user = user and save!
+  def creditcards
+    creditcard_ids = payments.from_creditcard.map(&:source_id).uniq
+    Creditcard.scoped(:conditions => {:id => creditcard_ids})
   end
 
   def process_payments!
-    payments.each(&:process!)
+    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!
-    self.out_of_stock_items = InventoryUnit.sell_units(self)
-    shipments.create(:inventory_units => inventory_units.reload)
     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
   end
 
 
@@ -418,49 +348,9 @@ class Order < ActiveRecord::Base
   end
 
 
-
-
   private
-  # def complete_order
-  #   self.adjustments.each(&:update_amount)
-  #   update_attribute(:completed_at, Time.now)
-  #
-  #   if email
-  #     OrderMailer.confirm(self).deliver
-  #   end
-  #
-  #   begin
-  #     @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}"
-  #     logger.error self.to_yaml
-  #   end
-  # end
-  #
-  # def cancel_order
-  #   make_shipments_pending
-  #   restock_inventory
-  #   OrderMailer.cancel(self).deliver
-  # end
-  #
-  # def restock_inventory
-  #   inventory_units.each do |inventory_unit|
-  #     inventory_unit.restock! if inventory_unit.can_restock?
-  #   end
-  #
-  #   inventory_units.reload
-  # 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 create_user
+    self.email = user.email if self.user and user.email !~ /example.net/
     self.user ||= User.anonymous!
   end
 
@@ -471,6 +361,7 @@ class Order < ActiveRecord::Base
   #           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
@@ -482,6 +373,8 @@ class Order < ActiveRecord::Base
       "shipped"
     when shipments.ready.count
       "ready"
+    when shipments.pending.count
+      "pending"
     else
       "partial"
     end
@@ -493,11 +386,13 @@ class Order < ActiveRecord::Base
   # 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
@@ -529,8 +424,15 @@ class Order < ActiveRecord::Base
     self.adjustments.reload.each(&:update!)
   end
 
-  # def create_shipment
-  #   self.shipments << Shipment.create(:order => self)
-  # 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 after_cancel
+    # TODO: make_shipments_pending
+    # TODO: restock_inventory
+    OrderMailer.cancel_email(self).deliver
+  end
 
 end