spree_core 0.30.0.beta1 → 0.30.0

data/app/models/adjustment.rb

@@ -22,6 +22,7 @@ class Adjustment < ActiveRecord::Base
 
   scope :tax, lambda { where(:label => I18n.t(:tax)) }
   scope :shipping, lambda { where(:label => I18n.t(:shipping)) }
+  scope :optional, where(:mandatory => false)
 
   # update the order totals, etc.
   after_save {order.update!}
@@ -35,12 +36,12 @@ class Adjustment < ActiveRecord::Base
   end
 
   # Tells the adjustment that its time to update itself.  Adjustments will delegate this request to their Originator
-  # when present, but only if +frozen+ is false.  Adjustments that are +frozen+ will never change their amount.
+  # when present, but only if +locked+ is false.  Adjustments that are +locked+ will never change their amount.
   # The new adjustment amount will be set by by the +originator+ and is not automatically saved.  This makes it save
   # to use this method in an after_save hook for other models without causing an infinite recursion problem.  If there
   # is no +originator+ then this method will have no effect.
   def update!
-    return if frozen? or originator.nil?
+    return if locked? or originator.nil?
     originator.update_adjustment(self, source)
   end
 end

data/app/models/app_configuration.rb

@@ -1,22 +1,7 @@
 class AppConfiguration < Configuration
 
-  MAIL_AUTH = ['none', 'plain', 'login', 'cram_md5']
-  SECURE_CONNECTION_TYPES = ['None','SSL','TLS']
-
   preference :site_name, :string, :default => 'Spree Demo Site'
   preference :site_url, :string, :default => 'demo.spreecommerce.com'
-  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 => MAIL_AUTH[0]
-  preference :smtp_username, :string
-  preference :smtp_password, :string
-  preference :secure_connection_type, :string, :default => SECURE_CONNECTION_TYPES[0]
-  preference :mails_from, :string
-  preference :mail_bcc, :string
-  preference :order_from, :string, :default => "orders@example.com"
-  preference :order_bcc, :string
   preference :store_cc, :boolean, :default => false
   preference :store_cvv, :boolean, :default => false
   preference :default_locale, :string, :default => 'en'
@@ -24,7 +9,8 @@ class AppConfiguration < Configuration
   preference :default_country_id, :integer, :default => 214
   preference :allow_backorders, :boolean, :default => true
   preference :allow_backorder_shipping, :boolean, :default => false # should only be true if you don't need to track inventory
-  preference :track_inventory_levels, :boolean, :default => true #
+  preference :track_inventory_levels, :boolean, :default => true # will not track on_hand values for variants /products
+  preference :create_inventory_units, :boolean, :default => true # should only be false when track_inventory_levels is false, also disables RMA's
   preference :show_descendents, :boolean, :default => true
   preference :show_zero_stock_products, :boolean, :default => true
   preference :orders_per_page, :integer, :default => 15
@@ -48,6 +34,7 @@ class AppConfiguration < Configuration
   preference :always_put_site_name_in_title, :boolean, :default => true
   preference :cache_static_content, :boolean, :default => true
   preference :use_content_controller, :boolean, :default => true
+  preference :allow_checkout_on_gateway_error, :boolean, :default => false
 
   validates :name, :presence => true, :uniqueness => true
 

data/app/models/creditcard.rb

@@ -3,6 +3,8 @@ class Creditcard < ActiveRecord::Base
 
   before_save :set_last_digits
 
+  attr_accessor :number, :verification_value
+
   validates :month, :year, :numericality => { :only_integer => true }
   validates :number, :presence => true, :unless => :has_payment_profile?, :on => :create
   validates :verification_value, :presence => true, :unless => :has_payment_profile?, :on => :create
@@ -57,15 +59,13 @@ class Creditcard < ActiveRecord::Base
     cc_type
   end
 
-
-
-
-  #RAILS3 TODO
-  # scope :with_payment_profile, where("gateway_customer_profile_id IS NOT NULL")
+  scope :with_payment_profile, where("gateway_customer_profile_id IS NOT NULL")
 
   def authorize(amount, payment)
     # ActiveMerchant is configured to use cents so we need to multiply order total by 100
     response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))
+    record_log payment, response
+
     if response.success?
       payment.response_code = response.authorization
       payment.avs_response = response.avs_result['code']
@@ -81,6 +81,8 @@ class Creditcard < ActiveRecord::Base
   def purchase(amount, payment)
     #combined Authorize and Capture that gets processed by the ActiveMerchant gateway as one single transaction.
     response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment))
+    record_log payment, response
+
     if response.success?
       payment.response_code = response.authorization
       payment.avs_response = response.avs_result['code']
@@ -103,6 +105,9 @@ class Creditcard < ActiveRecord::Base
       # Standard ActiveMerchant capture usage
       response = payment_gateway.capture((payment.amount * 100).round, payment.response_code, minimal_gateway_options(payment))
     end
+
+    record_log payment, response
+
     if response.success?
       payment.response_code = response.authorization
       payment.complete
@@ -116,6 +121,8 @@ class Creditcard < ActiveRecord::Base
 
   def void(payment)
     response = payment_gateway.void(payment.response_code, self, minimal_gateway_options(payment))
+    record_log payment, response
+
     if response.success?
       payment.response_code = response.authorization
       payment.void
@@ -126,14 +133,24 @@ class Creditcard < ActiveRecord::Base
     gateway_error I18n.t(:unable_to_connect_to_gateway)
   end
 
-  def credit(payment, amount)
+  def credit(payment)
+    amount = payment.credit_allowed >= payment.order.outstanding_balance.abs ? payment.order.outstanding_balance : payment.credit_allowed
+
     if payment_gateway.payment_profiles_supported?
       response = payment_gateway.credit((amount * 100).round, self, payment.response_code, minimal_gateway_options(payment))
     else
       response = payment_gateway.credit((amount * 100).round, payment.response_code, minimal_gateway_options(payment))
     end
+
+    record_log payment, response
+
     if response.success?
-      Payment.create(:source => payment, :amount => amount.abs * -1, :response_code => response.authorization, :state => 'completed')
+      Payment.create(:order => payment.order,
+                    :source => payment,
+                    :payment_method => payment.payment_method,
+                    :amount => amount.abs * -1,
+                    :response_code => response.authorization,
+                    :state => 'completed')
     else
       gateway_error(response)
     end
@@ -142,30 +159,44 @@ class Creditcard < ActiveRecord::Base
   end
 
 
+
+
   def actions
     %w{capture void credit}
   end
 
-  # def can_capture?(payment)
-  #   authorization(payment).present? &&
-  #   has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE, CreditcardTxn::TxnType::VOID)
-  # end
+  # Indicates whether its possible to capture the payment
+  def can_capture?(payment)
+    payment.state == "pending"
+  end
 
-  # def can_void?(payment)
-  #   has_transaction_of_types?(payment, CreditcardTxn::TxnType::AUTHORIZE, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) &&
-  #   has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID)
-  # end
+  # Indicates whether its possible to void the payment.  Most gateways require that the payment has not been
+  # settled yet when performing a void (which generally happens within 12-24 hours of the transaction.)  For
+  # this reason, the default behavior of Spree is to only allow void operations within the first 12 hours of
+  # the payment creation time.
+  def can_void?(payment)
+    return false unless (Time.now - 12.hours) < payment.created_at
+    %w{completed pending}.include? payment.state
+  end
 
-  # # Can only refund a captured transaction but if transaction hasn't been cleared by merchant, refund may still fail
-  # def can_credit?(payment)
-  #   has_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) &&
-  #   has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID) and payment.order.outstanding_credit?
-  # end
+  # Indicates whether its possible to credit the payment.  Most gateways require that the payment be settled
+  # first which generally happens within 12-24 hours of the transaction.  For this reason, the default
+  # behavior of Spree is to disallow credit operations until the payment is at least 12 hours old.
+  def can_credit?(payment)
+    return false unless (Time.now - 12.hours) > payment.created_at
+    return false unless payment.state == "completed"
+    return false unless payment.order.payment_state == "credit_owed"
+    payment.credit_allowed > 0
+  end
 
   def has_payment_profile?
     gateway_customer_profile_id.present?
   end
 
+  def record_log(payment, response)
+    payment.log_entries.create(:details => response.to_yaml)
+  end
+
   def gateway_error(error)
     if error.is_a? ActiveMerchant::Billing::Response
       text = error.params['message'] || error.params['response_reason_text'] || error.message
@@ -212,29 +243,4 @@ class Creditcard < ActiveRecord::Base
     @payment_gateway ||= Gateway.current
   end
 
-  private
-
-    def has_transaction_of_types?(payment, *types)
-      (payment.txns.map(&:txn_type) & types).any?
-    end
-
-    def has_no_transaction_of_types?(payment, *types)
-      (payment.txns.map(&:txn_type) & types).none?
-    end
-
-    #RAILS 3 TODO
-    # # 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 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/inventory_unit.rb

@@ -5,7 +5,6 @@ class InventoryUnit < ActiveRecord::Base
   belongs_to :return_authorization
 
   scope :backorder, where(:state => 'backordered')
-  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
@@ -13,72 +12,74 @@ class InventoryUnit < ActiveRecord::Base
       transition :to => 'sold', :from => 'backordered'
     end
     event :ship do
-      transition :to => 'shipped', :if => :allow_ship? #, :from => 'sold'
+      transition :to => 'shipped', :if => :allow_ship?
     end
-    # TODO: add backorder state and relevant transitions
-  end
-
-  # 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
+    event :return do
+      transition :to => 'returned', :from => 'shipped'
     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
+    after_transition :on => :fill_backorder, :do => :update_order
+    after_transition :to => 'returned', :do => :restock_variant
   end
 
-  # grab the appropriate units from inventory, mark as sold and associate with the order
+  # method deprecated in favour of adjust_units (which creates & destroys units as needed).
   def self.sell_units(order)
-    return if order.complete?
-    order.line_items.map do |line_item|
-      create_units(order, line_item, line_item.quantity)
-    end.flatten
+    warn "[DEPRECATION] `InventoryUnits#sell_units` is deprecated.  Please use `InventoryUnits#assign_opening_inventory` instead. (called from #{caller[0]})"
+    self.adjust_units(order)
   end
 
-  def self.adjust_units(order)
-    units_by_variant = order.inventory_units.group_by(&:variant_id)
+  # 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?
+
     out_of_stock_items = []
 
-    #check line items quantities match
+    #increase inventory to meet initial requirements
     order.line_items.each do |line_item|
-      variant = line_item.variant
-      quantity = line_item.quantity
-      unit_count = units_by_variant.key?(variant.id) ? units_by_variant[variant.id].size : 0
-
-      if unit_count < quantity
-        out_of_stock_items.concat create_units(order, line_item, (quantity - unit_count))
-      elsif  unit_count > quantity
-        (unit_count - quantity).times do
-          inventory_unit = units_by_variant[variant.id].pop
-          inventory_unit.restock!
-        end
-      end
-
-      #remove it from hash as it's up-to-date
-      units_by_variant.delete(variant.id)
+      out_of_stock_items.concat increase(order, line_item.variant, line_item.quantity)
     end
 
-    #check for deleted line items (if theres anything left in units_by_variant its' extra)
-    units_by_variant.each do |variant_id, units|
-      units.each {|unit| unit.restock!}
+    out_of_stock_items
+  end
+
+  # manages both variant.count_on_hand and inventory unit creation
+  #
+  def self.increase(order, variant, quantity)
+    # calculate number of sold vs. backordered units
+    if variant.count_on_hand == 0
+      back_order = quantity
+      sold = 0
+    elsif variant.count_on_hand < quantity
+      back_order = quantity - (variant.count_on_hand < 0 ? 0 : variant.count_on_hand)
+      sold = quantity - back_order
+    else
+      back_order = 0
+      sold = quantity
+    end
+
+    #set on_hand if configured
+    if Spree::Config[:track_inventory_levels]
+      variant.decrement!(:count_on_hand, quantity)
     end
 
+    #create units if configured, returning any backorderd variants with count
+    out_of_stock_items = []
+    if Spree::Config[:create_inventory_units]
+      out_of_stock_items = create_units(order, variant, sold, back_order)
+    end
     out_of_stock_items
   end
 
-  def can_restock?
-    %w(sold shipped backordered).include?(state)
-  end
+  def self.decrease(order, variant, quantity)
+    if Spree::Config[:track_inventory_levels]
+       variant.increment!(:count_on_hand, quantity)
+    end
 
-  def restock!
-    variant.update_attribute(:count_on_hand, variant.count_on_hand + 1) if Spree::Config[:track_inventory_levels] && !backordered?
-    delete
+    if Spree::Config[:create_inventory_units]
+      destroy_units(order, variant, quantity)
+    end
   end
 
   # find the specified quantity of units with the specified status
@@ -90,43 +91,39 @@ class InventoryUnit < ActiveRecord::Base
 
   private
   def allow_ship?
-    Spree::Config[:allow_backorder_shipping] || (state == 'ready_to_ship')
+    Spree::Config[:allow_backorder_shipping] || self.sold?
   end
 
-  def self.create_units(order, line_item, quantity)
-    variant = line_item.variant
+  def self.destroy_units(order, variant, quantity)
+    variant_units = order.inventory_units.group_by(&:variant_id)[variant.id].sort_by(&:state)
 
-    out_of_stock_items = []
+    quantity.times do
+      inventory_unit = variant_units.shift
+      inventory_unit.destroy
+    end
+  end
 
-    if Spree::Config[:track_inventory_levels]
-      # 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
-    else
-      # not tracking stock levels, so just create all inventory_units as sold (for shipping purposes)
-      quantity.times do
-        order.inventory_units.create(:variant => variant, :state => "sold")
-      end
+  def self.create_units(order, variant, sold, back_order)
+    shipment = order.shipments.detect {|shipment| !shipment.shipped? }
+
+    sold.times do
+      order.inventory_units.create(:variant => variant, :state => "sold", :shipment => shipment)
     end
-    out_of_stock_items
+
+    if Spree::Config[:allow_backorders]
+      back_order.times { order.inventory_units.create(:variant => variant, :state => "backordered", :shipment => shipment) }
+    end
+
+    back_order == 0 ? [] : [{:variant => variant, :count => back_order}]
+  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

@@ -13,10 +13,13 @@ class LineItem < ActiveRecord::Base
   validates :price, :numericality => true
   # validate :meta_validation_of_quantities
 
-  attr_accessible :quantity, :variant_id, :order_id
+  attr_accessible :quantity
 
-  # update the order totals, etc.
-  after_save {order.update!}
+  before_save :update_inventory
+  before_destroy :remove_inventory
+
+  after_save :update_order
+  after_destroy :update_order
 
   def copy_price
     self.price = variant.price if variant && self.price.nil?
@@ -56,7 +59,33 @@ class LineItem < ActiveRecord::Base
     self.quantity = 0 if self.quantity.nil? || self.quantity < 0
   end
 
-  # private
+  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 shipped_count = order.shipped_units.nil? ? nil : order.shipped_units[variant]
   #     errors.add_to_base I18n.t("cannot_destory_line_item_as_inventory_units_have_shipped")