piggybak 0.5.5 → 0.6.0

data/app/models/piggybak/order.rb

@@ -1,9 +1,6 @@
 module Piggybak
   class Order < ActiveRecord::Base
     has_many :line_items, :inverse_of => :order
-    has_many :payments, :inverse_of => :order
-    has_many :shipments, :inverse_of => :order
-    has_many :adjustments, :inverse_of => :order
     has_many :order_notes, :inverse_of => :order
 
     belongs_to :billing_address, :class_name => "Piggybak::Address"
@@ -12,42 +9,38 @@ module Piggybak
   
     accepts_nested_attributes_for :billing_address, :allow_destroy => true
     accepts_nested_attributes_for :shipping_address, :allow_destroy => true
-    accepts_nested_attributes_for :shipments, :allow_destroy => true
     accepts_nested_attributes_for :line_items, :allow_destroy => true
-    accepts_nested_attributes_for :payments
-    accepts_nested_attributes_for :adjustments, :allow_destroy => true
     accepts_nested_attributes_for :order_notes
 
-    attr_accessor :recorded_changes
-    attr_accessor :recorded_changer
-    attr_accessor :was_new_record
-    attr_accessor :disable_order_notes
+    attr_accessor :recorded_changes, :recorded_changer,
+                  :was_new_record, :disable_order_notes 
 
-    validates_presence_of :status, :email, :phone, :total, :total_due, :tax_charge, :created_at, :ip_address, :user_agent
+    validates_presence_of :status, :email, :phone, :total, :total_due, :created_at, :ip_address, :user_agent
 
-    after_initialize :initialize_nested, :initialize_request
-    before_validation :set_defaults, :prepare_for_destruction
-    after_validation :update_totals
-    before_save :process_payments, :update_status, :set_new_record
+    after_initialize :initialize_defaults
+    before_save :postprocess_order, :update_status, :set_new_record
     after_save :record_order_note
 
     default_scope :order => 'created_at DESC'
 
-    def initialize_nested
+    attr_accessible :user_id, :email, :phone, :billing_address_attributes, 
+                    :shipping_address_attributes, :line_items_attributes,
+                    :order_notes_attributes, :details, :recorded_changer, :ip_address
+                    
+    def initialize_defaults
       self.recorded_changes ||= []
 
       self.billing_address ||= Piggybak::Address.new
       self.shipping_address ||= Piggybak::Address.new
-      self.shipments ||= [Piggybak::Shipment.new] 
-      self.payments ||= [Piggybak::Payment.new]
-      if self.payments.any?
-        self.payments.first.payment_method_id = Piggybak::PaymentMethod.find_by_active(true).id
-      end
-    end
 
-    def initialize_request
       self.ip_address ||= 'admin'
       self.user_agent ||= 'admin'
+
+      self.created_at ||= Time.now
+      self.status ||= "new"
+      self.total ||= 0
+      self.total_due ||= 0
+      self.disable_order_notes = false
     end
 
     def initialize_user(user, on_post)
@@ -57,26 +50,62 @@ module Piggybak
       end
     end
 
-    def process_payments
-      has_errors = false
-
-      self.payments.each do |payment|
-        if(!payment.process)
-          has_errors = true
+    def postprocess_order
+      # Mark line items for destruction if quantity == 0
+      self.line_items.each do |line_item|
+        if line_item.quantity == 0
+          line_item.mark_for_destruction
         end
       end
 
-      payments_total = self.payments.inject(0) { |s, payment| s + payment.total }
+      # Recalculate and create line item for tax
+      # If a tax line item already exists, reset price
+      # If a tax line item doesn't, create
+      # If tax is 0, destroy tax line item
+      tax = TaxMethod.calculate_tax(self)
+      tax_line_item = self.line_items.detect { |line_item| line_item.line_item_type == "tax" }
+      if tax > 0
+        if tax_line_item
+          tax_line_item.price = tax
+        else
+          self.line_items << LineItem.new({ :line_item_type => "tax", :description => "Tax Charge", :price => tax })
+        end
+      elsif tax_line_item
+        tax_line_item.mark_for_destruction
+      end
 
-      adjustments.each do |adjustment|
-        if !adjustment._destroy
-          payments_total += adjustment.total.round(2)
+      # Postprocess everything but payments first
+      self.line_items.each do |line_item|
+        next if line_item.line_item_type == "payment"
+        method = "postprocess_#{line_item.line_item_type}"
+        if line_item.respond_to?(method)
+          if !line_item.send(method)
+            return false
+          end
         end
       end
+      
+      # Recalculating total and total due, in case post process changed totals
+      self.total = 0
+      self.line_items.each do |line_item|
+        if !line_item._destroy
+          self.total += line_item.price
+        end
+      end
+      self.total_due = self.total
 
-      self.total_due = (self.total - payments_total).round(2)
+      # Postprocess payment last
+      self.line_items.each do |line_item|
+        next if line_item.line_item_type != "payment"
+        method = "postprocess_#{line_item.line_item_type}"
+        if line_item.respond_to?(method)
+          if !line_item.send(method)
+            return false
+          end
+        end
+      end
 
-      !has_errors
+      true
     end
 
     def record_order_note
@@ -89,82 +118,38 @@ module Piggybak
       end
     end
 
-    def add_line_items(cart)
-      cart.update_quantities
-      cart.items.each do |item|
-        line_item = Piggybak::LineItem.new({ :variant_id => item[:variant].id,
-          :price => item[:variant].price,
-          :total => item[:variant].price*item[:quantity],
-          :description => item[:variant].description,
-          :quantity => item[:quantity] })
-        self.line_items << line_item
-      end
-    end
-
-    def set_defaults
-      self.created_at ||= Time.now
-      self.status ||= "new"
-      self.total = 0
-      self.total_due = 0
-      self.tax_charge = 0
-      self.disable_order_notes = false
-
-      return if self.to_be_cancelled
+    def create_payment_shipment
+      shipment_line_item = self.line_items.detect { |li| li.line_item_type == "shipment" }
 
-      self.line_items.each do |line_item|
-        if self.status != "shipped"
-          line_item.description = line_item.variant.description
-          line_item.price = line_item.variant.price
-        end
-        if line_item.variant
-          line_item.total = line_item.price * line_item.quantity.to_i
-        else
-          line_item.total = 0
-        end
+      if shipment_line_item.nil?
+        new_shipment_line_item = Piggybak::LineItem.new({ :line_item_type => "shipment" })
+        new_shipment_line_item.build_shipment
+        self.line_items << new_shipment_line_item
+      elsif shipment_line_item.shipment.nil?
+        shipment_line_item.build_shipment
+      else
+        previous_method = shipment_line_item.shipment.shipping_method_id
+        shipment_line_item.build_shipment
+        shipment_line_item.shipment.shipping_method_id = previous_method
       end
-    end
 
-    def prepare_for_destruction
-      self.line_items.each do |line_item|
-        if line_item.quantity == 0
-          line_item.mark_for_destruction
-        end
+      if !self.line_items.detect { |li| li.line_item_type == "payment" }
+        payment_line_item = Piggybak::LineItem.new({ :line_item_type => "payment" })
+        payment_line_item.build_payment 
+        self.line_items << payment_line_item
       end
     end
 
-    def update_totals
-      self.total = 0
-
-      self.line_items.each do |line_item|
-        if !line_item._destroy
-          self.total += line_item.total 
-        end
-      end
-
-      self.tax_charge = TaxMethod.calculate_tax(self)
-      self.total += self.tax_charge
-
-      shipments.each do |shipment|
-        if !shipment._destroy
-          if (shipment.new_record? || shipment.status != 'shipped') && shipment.shipping_method
-            calculator = shipment.shipping_method.klass.constantize
-            shipment.total = calculator.rate(shipment.shipping_method, self)
-          end
-
-          shipping_cast = ((shipment.total*100).to_i).to_f/100
-          self.total += shipping_cast
-        end
-      end
-
-      payments_total = self.payments.inject(0) { |s, payment| s + payment.total }
+    def add_line_items(cart)
+      cart.update_quantities
 
-      adjustments.each do |adjustment|
-        if !adjustment._destroy
-          payments_total += adjustment.total.round(2)
-        end
+      cart.items.each do |item|
+        self.line_items << Piggybak::LineItem.new({ :sellable_id => item[:sellable].id,
+          :unit_price => item[:sellable].price,
+          :price => item[:sellable].price*item[:quantity],
+          :description => item[:sellable].description,
+          :quantity => item[:quantity] })
       end
-
-      self.total_due = (self.total - payments_total).round(2)
     end
 
     def update_status
@@ -175,18 +160,19 @@ module Piggybak
       else
         if self.to_be_cancelled
           self.status = "cancelled"
-        elsif self.shipments.any? && self.shipments.all? { |s| s.status == "shipped" }
+        # TODO: line items scope doesn't work here, maybe on new items? Fix if possible.
+        elsif line_items.select { |li| li.line_item_type == "shipment" }.any? && line_items.select { |li| li.line_item_type == "shipment" }.all? { |s| s.shipment.status == "shipped" }
           self.status = "shipped"
-        elsif self.shipments.any? && self.shipments.all? { |s| s.status == "processing" }
+        elsif line_items.select { |li| li.line_item_type == "shipment" }.any? && line_items.select { |li| li.line_item_type == "shipment" }.all? { |s| s.shipment.status == "processing" }
           self.status = "processing"
         else
           self.status = "new"
         end
       end
     end
+
     def set_new_record
       self.was_new_record = self.new_record?
-
       true
     end
 
@@ -211,9 +197,9 @@ module Piggybak
     def subtotal
       v = 0
 
-      self.line_items.each do |line_item|
+      self.line_items.select { |li| li.line_item_type == "sellable" }.each do |line_item|
         if !line_item._destroy
-          v += line_item.total 
+          v += line_item.price
         end
       end
 

data/app/models/piggybak/payment.rb

@@ -1,11 +1,10 @@
 module Piggybak
   class Payment < ActiveRecord::Base
     belongs_to :order
-    acts_as_changer
     belongs_to :payment_method
+    belongs_to :line_item
 
     validates_presence_of :status
-    validates_presence_of :total
     validates_presence_of :payment_method_id
     validates_presence_of :month
     validates_presence_of :year
@@ -13,6 +12,9 @@ module Piggybak
     attr_accessor :number
     attr_accessor :verification_value
 
+    attr_accessible :number, :verification_value, :month, :year,
+                    :transaction_id, :masked_number, :payment_method_id
+    
     def status_enum
       ["paid"]
     end
@@ -30,30 +32,27 @@ module Piggybak
         "month" => self.month,
         "year" => self.year,
         "verification_value" => self.verification_value,
-        "first_name" => self.order.billing_address.firstname,
-        "last_name" => self.order.billing_address.lastname }
+        "first_name" => self.line_item ? self.line_item.order.billing_address.firstname : nil,
+        "last_name" => self.line_item ? self.line_item.order.billing_address.lastname : nil }
     end
 
-    def process
+    def process(order)
+      return true if !self.new_record?
+
       ActiveMerchant::Billing::Base.mode = Piggybak.config.activemerchant_mode
 
-      if self.new_record?
-        payment_gateway = self.payment_method.klass.constantize
-        gateway = payment_gateway::KLASS.new(self.payment_method.key_values)
-        p_credit_card = ActiveMerchant::Billing::CreditCard.new(self.credit_card)
-        gateway_response = gateway.authorize(self.order.total_due*100, p_credit_card, :address => self.order.avs_address)
-        if gateway_response.success?
-          self.attributes = { :total => self.order.total_due, 
-                              :transaction_id => payment_gateway.transaction_id(gateway_response),
-                              :masked_number => self.number.mask_cc_number }
-          gateway.capture(self.order.total_due*100, gateway_response.authorization, { :credit_card => p_credit_card } )
-          return true
-  	    else
-  	      self.errors.add :payment_method_id, gateway_response.message
-          return false
-  	    end
-      else
+      payment_gateway = self.payment_method.klass.constantize
+      gateway = payment_gateway::KLASS.new(self.payment_method.key_values)
+      p_credit_card = ActiveMerchant::Billing::CreditCard.new(self.credit_card)
+      gateway_response = gateway.authorize(order.total_due*100, p_credit_card, :address => order.avs_address)
+      if gateway_response.success?
+        self.attributes = { :transaction_id => payment_gateway.transaction_id(gateway_response),
+                            :masked_number => self.number.mask_cc_number }
+        gateway.capture(order.total_due*100, gateway_response.authorization, { :credit_card => p_credit_card } )
         return true
+      else
+        self.errors.add :payment_method_id, gateway_response.message
+        return false
       end
     end
 
@@ -66,20 +65,19 @@ module Piggybak
       return
     end
 
-    def admin_label
+    def details
       if !self.new_record? 
-        return "Payment ##{self.id} (#{self.created_at.strftime("%m-%d-%Y")}): " + 
-          "$#{"%.2f" % self.total}"
+        return "Payment ##{self.id} (#{self.created_at.strftime("%m-%d-%Y")}): " #+ 
+          #"$#{"%.2f" % self.total}" reference line item total here instead
       else
         return ""
       end
     end
-    alias :details :admin_label
 
     validates_each :payment_method_id do |record, attr, value|
       if record.new_record?
-  	    credit_card = ActiveMerchant::Billing::CreditCard.new(record.credit_card)
-  	 
+        credit_card = ActiveMerchant::Billing::CreditCard.new(record.credit_card)
+     
         if !credit_card.valid?
           credit_card.errors.each do |key, value|
             if value.any? && !["first_name", "last_name", "type"].include?(key)

data/app/models/piggybak/payment_method.rb

@@ -7,7 +7,9 @@ module Piggybak
 
     validates_presence_of :klass
     validates_presence_of :description
-
+    
+    attr_accessible :active, :payment_method_values_attributes, :description,
+                    :klass
     def klass_enum 
       Piggybak.config.payment_calculators
     end

data/app/models/piggybak/payment_method_value.rb

@@ -3,7 +3,9 @@ module Piggybak
     belongs_to :payment_method
     validates_presence_of :key
     validates_presence_of :value
-        
+    
+    attr_accessible :key, :value
+      
     def admin_label
       "#{self.key} - #{self.value}"
     end

data/app/models/piggybak/{variant.rb → sellable.rb}

@@ -1,5 +1,5 @@
-class Piggybak::Variant < ActiveRecord::Base
-  belongs_to :item, :polymorphic => true, :inverse_of => :piggybak_variant
+class Piggybak::Sellable < ActiveRecord::Base
+  belongs_to :item, :polymorphic => true, :inverse_of => :piggybak_sellable
   attr_accessible :sku, :description, :price, :quantity, :active, :unlimited_inventory, :item_id, :item_type 
   attr_accessible :item # to allow direct assignment from code or console
 
@@ -9,9 +9,11 @@ class Piggybak::Variant < ActiveRecord::Base
   validates_presence_of :price
   validates_presence_of :item_type
   validates_numericality_of :quantity, :only_integer => true, :greater_than_or_equal_to => 0
-    
+
+  has_many :line_items, :as => :reference, :inverse_of => :reference
+
   def admin_label
-    "Variant: #{self.description}"
+    "Sellable: #{self.description}"
   end
 
   def update_inventory(purchased)

data/app/models/piggybak/shipment.rb

@@ -1,22 +1,16 @@
 module Piggybak
   class Shipment < ActiveRecord::Base
     belongs_to :order
-    acts_as_changer
     belongs_to :shipping_method
+    belongs_to :line_item
 
     validates_presence_of :status
-    validates_presence_of :total
     validates_presence_of :shipping_method_id
-
+    
+    attr_accessible :shipping_method_id, :status
+    
     def status_enum
       ["new", "processing", "shipped"]
     end
-
-    def admin_label
-      "Shipment ##{self.id}<br />" +
-      "#{self.shipping_method.description}<br />" +
-      "Status: #{self.status}<br />" +
-      "$#{"%.2f" % self.total}"
-    end
   end
 end