piggybak 0.1.0

data/app/models/piggybak/order.rb

@@ -0,0 +1,141 @@
+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
+    belongs_to :billing_address, :class_name => "Piggybak::Address"
+    belongs_to :shipping_address, :class_name => "Piggybak::Address"
+    belongs_to :user
+  
+    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
+
+    validates_presence_of :status  
+    validates_presence_of :email
+    validates_presence_of :phone
+    validates_presence_of :total
+    validates_presence_of :total_due
+    validates_presence_of :tax_charge
+    validates_presence_of :created_at
+
+    before_validation :set_defaults
+    after_validation :update_totals
+    before_save :process_payments, :update_status
+
+    def process_payments
+      has_errors = false
+      self.payments.each do |payment|
+        if(!payment.process)
+          has_errors = true
+        end
+      end
+
+      self.total_due = self.total
+      payments.each do |payment|
+        self.total_due -= payment.total
+      end
+      !has_errors
+    end
+
+    def details
+      if !self.new_record? 
+        subtotal = self.line_items.inject(0) { |subtotal, li| subtotal + li.total }
+        shipping = self.shipments.inject(0) { |shipping, shipment| shipping + shipment.total }
+        return "Status: #{self.status}<br />" +
+          "Subtotal: $#{"%.2f" % subtotal}<br />" + 
+          "Shipping: $#{"%.2f" % shipping}<br />" + 
+          "Tax: $#{"%.2f" % self.tax_charge}<br />" + 
+          "Due: $#{"%.2f" % self.total_due}<br />" + 
+          "Created at: #{self.created_at.strftime("%m-%d-%Y")}<br />" #details here"
+      else
+        return "New Order"
+      end
+    end
+
+    def add_line_items(cart)
+      cart.update_quantities
+      cart.items.each do |item|
+        line_item = Piggybak::LineItem.new({ :product_id => item[:product].id,
+          :total => item[:product].price*item[:quantity],
+          :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.line_items.each do |line_item|
+        line_item.total = line_item.product.price * line_item.quantity
+      end
+    end
+
+    def update_totals
+      self.total = 0
+
+      self.line_items.each do |line_item|
+        self.total += line_item.total
+      end
+
+      self.tax_charge = TaxMethod.calculate_tax(self)
+      self.total += self.tax_charge
+
+      shipments.each do |shipment|
+        if shipment.new_record? 
+          calculator = shipment.shipping_method.klass.constantize
+          shipment.total = calculator.rate(shipment.shipping_method, self)
+        end
+logger.warn "steph shipment total is #{shipment.total}"
+        self.total += shipment.total
+      end
+logger.warn "steph: total is #{self.total}"
+      self.total = self.total.to_c
+
+      self.total_due = self.total
+      payments.each do |payment|
+        self.total_due -= payment.total
+      end
+    end
+
+    def update_status
+      if self.total_due > 0.00
+        self.status = "payment owed"
+      elsif self.total_due < 0.00
+        self.status = "credit_owed" 
+      else
+        if self.total == 0.00
+          self.status = "new"
+        elsif self.shipments.all? { |s| s.status == "shipped" }
+          self.status = "shipped"
+        else
+          self.status = "paid"
+        end
+      end
+    end
+
+    def status_enum
+      ["incomplete", "paid", "shipped"]
+    end
+      
+    def avs_address
+      {
+      :address1 => self.billing_address.address1,
+      :city     => self.billing_address.city,
+      :state    => self.billing_address.state,
+      :zip      => self.billing_address.zip,
+      :country  => "US" 
+      }
+    end
+
+    def admin_label
+      "Order ##{self.id}"    
+    end
+  end
+end

data/app/models/piggybak/payment.rb

@@ -0,0 +1,80 @@
+module Piggybak
+  class Payment < ActiveRecord::Base
+    belongs_to :order
+    belongs_to :payment_method
+
+    validates_presence_of :status
+    validates_presence_of :total
+    validates_presence_of :payment_method_id
+    validates_presence_of :month
+    validates_presence_of :year
+
+    def status_enum
+      ["paid"]
+    end
+
+    def month_enum
+      1.upto(12)
+    end
+
+    def year_enum
+      Time.now.year.upto(Time.now.year + 10)
+    end
+
+    def credit_card
+      { "number" => self.number,
+        "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 }
+    end
+
+    def process
+      if self.new_record?
+        payment_gateway = self.payment_method.klass.constantize
+        gateway = payment_gateway::KLASS.new(self.payment_method.key_values)
+  	    credit_card = ActiveMerchant::Billing::CreditCard.new(self.credit_card)
+        gateway_response = gateway.authorize(self.order.total_due*100, credit_card, :address => self.order.avs_address)
+        if gateway_response.success?
+          self.attributes = { :total => self.order.total_due, 
+                              :number => 'hidden',
+                              :verification_value => 'hidden' }
+          gateway.capture(1000, gateway_response.authorization)
+          return true
+  	    else
+  	      self.errors.add :payment_method_id, gateway_response.message
+          return false
+  	    end
+      else
+        return true
+      end
+    end
+
+    def admin_label
+      if !self.new_record? 
+        return "Payment ##{self.id} (#{self.created_at.strftime("%m-%d-%Y")})<br />" + 
+          "Payment Method: #{self.payment_method.description}<br />" +
+          "Status: #{self.status}<br />" +
+          "$#{"%.2f" % self.total}"
+      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)
+  	 
+        if !credit_card.valid?
+          credit_card.errors.each do |key, value|
+            if value.any? && !["first_name", "last_name", "type"].include?(key)
+              record.errors.add key, value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/piggybak/payment_calculator.rb

@@ -0,0 +1,7 @@
+module Piggybak
+  class PaymentCalculator
+    def self.authorize(*args)
+      self::KLASS.authorize(*args)
+    end
+  end
+end

data/app/models/piggybak/payment_calculator/authorize_net.rb

@@ -0,0 +1,6 @@
+module Piggybak
+  class PaymentCalculator::AuthorizeNet < PaymentCalculator
+    KEYS = ["login", "password"]
+    KLASS = ::ActiveMerchant::Billing::AuthorizeNetGateway
+  end
+end

data/app/models/piggybak/payment_calculator/fake.rb

@@ -0,0 +1,24 @@
+module Piggybak
+  class PaymentCalculator::Fake < PaymentCalculator
+    KEYS = []
+    KLASS = ::Piggybak::PaymentCalculator::Fake
+
+    def self.new(*args)
+      return self
+    end
+
+    def self.authorize(*args)
+      self
+    end
+
+    def self.success?
+      true
+    end
+
+    def self.authorization
+    end
+
+    def self.capture(*args)
+    end
+  end
+end

data/app/models/piggybak/payment_method.rb

@@ -0,0 +1,40 @@
+module Piggybak 
+  class PaymentMethod < ActiveRecord::Base
+    has_many :payment_method_values, :dependent => :destroy
+    alias :metadata :payment_method_values
+
+    accepts_nested_attributes_for :payment_method_values, :allow_destroy => true
+
+    validates_presence_of :klass
+    validates_presence_of :description
+
+    def klass_enum 
+      #TODO: Troubleshoot use of subclasses here instead
+      [Piggybak::PaymentCalculator::AuthorizeNet,
+       Piggybak::PaymentCalculator::Fake]
+    end
+
+    validates_each :payment_method_values do |record, attr, value|
+      if record.klass
+        payment_method = record.klass.constantize
+        metadata_keys = value.collect { |v| v.key }.sort
+        if payment_method::KEYS.sort != metadata_keys
+          record.errors.add attr, "You must define key values for #{payment_method::KEYS.join(', ')} for this payment method."
+        end
+      end
+    end
+    validates_each :active do |record, attr, value|
+      if value && PaymentMethod.find_all_by_active(true).select { |p| p != record }.size > 0
+        record.errors.add attr, "You may only have one active payment method."
+      end
+    end
+
+    def key_values
+      self.metadata.inject({}) { |h, k| h[k.key.to_sym] = k.value; h }
+    end
+
+    def admin_label
+      "#{self.description}"
+    end
+  end
+end

data/app/models/piggybak/payment_method_value.rb

@@ -0,0 +1,11 @@
+module Piggybak
+  class PaymentMethodValue < ActiveRecord::Base
+    belongs_to :payment_method
+    validates_presence_of :key
+    validates_presence_of :value
+        
+    def admin_label
+      "#{self.key} - #{self.value}"
+    end
+  end
+end

data/app/models/piggybak/product.rb

@@ -0,0 +1,19 @@
+class Piggybak::Product < ActiveRecord::Base
+  belongs_to :item, :polymorphic => true, :inverse_of => :piggybak_product
+  attr_accessible :sku, :description, :price, :quantity, :active, :unlimited_inventory, :item_id, :item_type
+
+  validates_presence_of :sku
+  validates_uniqueness_of :sku
+  validates_presence_of :description
+  validates_presence_of :price
+  validates_presence_of :item_type
+  validates_numericality_of :quantity, :only_integer => true, :greater_than_or_equal_to => 0
+    
+  def admin_label
+    "Product: #{self.description}"
+  end
+
+  def update_inventory(purchased)
+    self.update_attribute(:quantity, self.quantity + purchased)
+  end
+end

data/app/models/piggybak/shipment.rb

@@ -0,0 +1,21 @@
+module Piggybak
+  class Shipment < ActiveRecord::Base
+    belongs_to :order
+    belongs_to :shipping_method
+
+    validates_presence_of :status
+    validates_presence_of :total
+    validates_presence_of :shipping_method_id
+
+    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

data/app/models/piggybak/shipping_calculator.rb

@@ -0,0 +1,12 @@
+module Piggybak
+  class ShippingCalculator
+    def self.available?(*args)
+      false
+    end
+
+    def self.lookup(*args)
+      { :available => false,
+        :rate => 0.00 }
+    end
+  end
+end

data/app/models/piggybak/shipping_calculator/flat_rate.rb

@@ -0,0 +1,13 @@
+module Piggybak
+  class ShippingCalculator::FlatRate < ShippingCalculator
+    KEYS = ["rate"]
+
+    def self.available?(*args)
+      true
+    end
+
+    def self.rate(method, object)
+      method.metadata.detect { |m| m.key == "rate" }.value.to_f.to_c
+    end
+  end
+end

data/app/models/piggybak/shipping_calculator/pickup.rb

@@ -0,0 +1,23 @@
+module Piggybak
+  class ShippingCalculator::Pickup < ShippingCalculator
+    KEYS = ["state_abbr", "rate"]
+
+    def self.available?(method, object)
+      abbr = method.metadata.detect { |t| t.key == "state_abbr" }.value
+
+      if object.is_a?(Cart)
+        state = State.find(object.extra_data["state_id"])
+        return true if state.abbr == abbr
+      else
+        if object.billing_address && object.billing_address.state 
+          return object.billing_address.state.abbr == abbr
+        end
+      end
+      return false
+    end
+
+    def self.rate(method, object)
+      method.metadata.detect { |m| m.key == "rate" }.value.to_f.to_c
+    end
+  end
+end

data/app/models/piggybak/shipping_calculator/range.rb

@@ -0,0 +1,16 @@
+module Piggybak
+  class ShipppingCalculator::Range < ShippingCalculator
+    KEYS = ["cost", "upper", "lower"]
+
+    def self.available?(method, object)
+      low_end = method.metadata.detect { |m| m.key == "lower" }.value
+      high_end = method.metadata.detect { |m| m.key == "upper" }.value
+
+      object.total >= low_end.to_f && object.total <= high_end.to_f
+    end
+
+    def self.rate(method, object)
+      method.metadata.detect { |m| m.key == "cost" }.value.to_f.to_c
+    end
+  end
+end

data/app/models/piggybak/shipping_method.rb

@@ -0,0 +1,55 @@
+module Piggybak
+  class ShippingMethod < ActiveRecord::Base
+    has_many :shipping_method_values, :dependent => :destroy
+    alias :metadata :shipping_method_values
+
+    validates_presence_of :description
+    validates_presence_of :klass
+
+    accepts_nested_attributes_for :shipping_method_values, :allow_destroy => true
+
+    validates_each :shipping_method_values do |record, attr, value|
+      if record.klass
+        calculator = record.klass.constantize
+        metadata_keys = value.collect { |v| v.key }.sort
+        if calculator::KEYS.sort != metadata_keys
+          record.errors.add attr, "You must define key values for #{calculator::KEYS.join(', ')} for this shipping method."
+        end
+      end
+    end
+
+    def klass_enum 
+      #TODO: Troubleshoot use of subclasses here instead
+      [Piggybak::ShippingCalculator::FlatRate,
+       Piggybak::ShippingCalculator::Range,
+       Piggybak::ShippingCalculator::Pickup]
+    end
+
+    def self.available_methods(cart)
+      active_methods = ShippingMethod.find_all_by_active(true)
+
+      active_methods.select { |method| method.klass.constantize.available?(method, cart) }
+    end
+
+    def self.lookup_methods(cart)
+      active_methods = ShippingMethod.find_all_by_active(true)
+
+      active_methods.inject([]) do |arr, method|
+        klass = method.klass.constantize
+logger.warn "steph: inside here!! #{method.inspect}"
+        if klass.available?(method, cart)
+          rate = klass.rate(method, cart)
+logger.warn "steph rate is #{rate.inspect}"
+          arr << {
+            :label => "#{method.description} $#{"%.2f" % rate}",
+			:id => method.id,
+            :rate => rate }
+		end
+        arr
+      end
+    end
+    def admin_label
+      self.description
+    end
+  end
+end