caboose-store 0.0.10 → 0.0.11

data/app/models/caboose_store/line_item.rb

@@ -0,0 +1,77 @@
+module CabooseStore
+  class LineItem < ActiveRecord::Base
+    self.table_name = 'store_line_items'
+    
+    belongs_to :variant
+    belongs_to :order, :dependent => :destroy
+    belongs_to :parent, :class_name => 'LineItem', :foreign_key => 'parent_id'
+    has_many :children, :class_name => 'LineItem', :foreign_key => 'parent_id'
+    
+    attr_accessible :id,
+      :variant_id,
+      :quantity,
+      :price,
+      :notes,
+      :order_id,
+      :status,
+      :tracking_number,
+      :custom1,
+      :custom2,
+      :custom3
+    
+    #
+    # Scopes
+    #
+    
+    scope :pending, where('status = ?', 'pending')
+    scope :fulfilled, where('status = ?', 'shipped')
+    scope :unfulfilled, where('status != ?', 'shipped')
+    #
+    # Validations
+    #
+    
+    validates :status, :inclusion => {
+      :in      => ['pending', 'shipped'],
+      :message => "%{value} is not a valid status. Must be either 'pending' or 'shipped'"
+    }
+    
+    validates :quantity, :numericality => { :greater_than_or_equal_to => 0 }
+    
+    validate :quantity_in_stock
+    def quantity_in_stock
+      errors.add(:base, "There #{self.variant.quantity > 1 ? 'are' : 'is'} only #{self.variant.quantity} left in stock.") if self.variant.quantity - self.quantity < 0
+    end
+    
+    #
+    # Callbacks
+    #
+    
+    before_save :update_price
+    after_save { self.order.calculate }
+    
+    #
+    # Methods
+    #
+    
+    def update_price
+      self.price = self.variant.price * self.quantity
+    end
+    
+    def title
+      if self.variant.product.variants.count > 1
+        "#{self.variant.product.title} - #{self.variant.title}"
+      else
+        self.variant.product.title
+      end
+    end
+    
+    def as_json(options={})
+      self.attributes.merge({
+        :variant => self.variant,
+        :title => self.title,
+        :product => { :images => self.variant.product.product_images }
+      })
+    end
+  end
+end
+

data/app/models/caboose_store/message.rb

@@ -7,12 +7,10 @@ module CabooseStore
     attr_accessor :name, :email, :body
     
     validates :name, :email, :body, presence: true
-    validates :email, format: { with: %r{.+@.+\..+} }, allow_blank: false
+    validates :email, format: { :with => %r{.+@.+\..+} }, allow_blank: false
     
-    def initialize(attributes = {})
-      attributes.each do |name, value|
-        send("#{name}=", value)
-      end
+    def initialize(attributes={})
+      attributes.each { |name, value| send("#{name}=", value) }
     end
     
     def persisted?

data/app/models/caboose_store/order.rb

@@ -1,97 +1,187 @@
+#
+# Order
+#
+
 module CabooseStore        
   class Order < ActiveRecord::Base
-    self.table_name = "store_orders"
+    self.table_name  = 'store_orders'
+    self.primary_key = 'id'
     
     belongs_to :customer, :class_name => 'Caboose::User'
     belongs_to :shipping_address, :class_name => 'Address'
     belongs_to :billing_address, :class_name => 'Address'
     has_many :discounts, :through => :order_discounts
     has_many :order_discounts
-    has_many :order_line_items
+    has_many :line_items, :after_add => :line_item_added, :after_remove => :line_item_removed
     
     attr_accessible :id,
-      :order_number,      # Customer-set unique number of the order    
-      :subtotal,              
+      :order_number,
+      :subtotal,
       :tax,
+      :shipping_code,
       :shipping_method,
-      :shipping_method_code,
       :shipping,
+      :handling,
       :discount,
-      :total,    
-      :status,            # The current order status. One of: cart, pending, backordered, fulfilled
-      :payment_status,    # The current payment status. One of: nil, 'pending', 'authorized', 'paid', 'voided', 'refunded'        
-      :notes,             # The note which is attached to the order.
-      :referring_site,    # Contains the url of the referrer that brought the customer to your store
-      :landing_site,      # Contains the path of the landing site the customer used. The first page that the customer saw when he/she reached the store.
-      :landing_site_ref,  # Looks at the landing site and extracts a reference parameter from it.
-      :cancel_reason,     # The reason selected when cancelling the order. One of: 'inventory', 'customer', 'fraud', 'other'
+      :amount_discounted,
+      :total,
+      :status,
+      :payment_status,
+      :notes,
+      :referring_site,
+      :landing_site,
+      :landing_site_ref,
+      :cancel_reason,
       :date_created,
       :date_authorized,
       :date_captured,
-      :date_cancelled    
-  
-    def line_items
-      return self.order_line_items
+      :date_cancelled,
+      :email,
+      :customer_id,
+      :payment_id,
+      :gateway_id,
+      :financial_status,
+      :shipping_address_id,
+      :billing_address_id,
+      :landing_page,
+      :landing_page_ref,
+      :transaction_d,
+      :auth_code,
+      :alternate_id,
+      :auth_amount,
+      :date_shipped,
+      :transaction_service,
+      :transaction_id
+    
+    #
+    # Scopes
+    #
+    
+    scope :test, where('status = ?', 'testing')
+    scope :cancelled, where('status = ?', 'cancelled')
+    scope :pending, where('status = ?', 'pending')
+    #TODO scope :fulfilled
+    #TODO scope :unfulfilled
+    scope :authorized, where('financial_status = ?', 'authorized')
+    scope :captured, where('financial_status = ?', 'captured')
+    scope :refunded, where('financial_status = ?', 'refunded')
+    scope :voided, where('financial_status = ?', 'voided')
+    
+    #
+    # Validations
+    #
+    
+    validates :status, :inclusion => {
+      :in      => ['cart', 'pending', 'cancelled', 'shipped', 'testing'],
+      :message => "%{value} is not a valid status. Must be either 'pending' or 'shipped'"
+    }
+    
+    validates :financial_status, :inclusion => {
+      :in      => ['pending', 'authorized', 'captured', 'refunded', 'voided'],
+      :message => "%{value} is not a valid financial status. Must be 'authorized', 'captured', 'refunded' or 'voided'"
+    }
+    
+    #
+    # Callbacks
+    #
+    
+    after_update :calculate
+    
+    #
+    # Methods
+    #
+    
+    def as_json(options={})
+      self.attributes.merge({
+        :line_items => self.line_items,
+        :shipping_address => self.shipping_address,
+        :billing_address => self.billing_address
+      })
     end
     
-    def subtotal
-      return self.order_line_items.inject(0.0){ |sum,li| sum + li.subtotal }
+    def decrement_quantities
+      return false if self.decremented
+      
+      self.line_items.each do |line_item|
+        line_item.variant.update_attribute(:quantit, line_item.variant.quantity - line_item.quantity)
+      end
+      
+      self.update_attribute(:decremented, true)
     end
     
-    # Array of any Line Items which have been fulfilled (marked as shipped on the order screen).
-    def fulfilled_line_items
-      return self.order_line_items.where(:status => 'shipped').all
+    def increment_quantities
+      return false if !self.decremented
+      
+      self.line_items.each do |line_item|
+        line_item.variant.update_attribute(:quantity, line_item.variant.quantity - line_item.quantity)
+      end
+      
+      self.update_attribute(:decremented, false)
     end
     
-    # Array of those Line Items which have not yet been fulfilled (marked as shipped on the order screen).
-    def unfulfilled_line_items
-      return self.order_line_items.where('status != ?', 'shipped').all
+    def resend_confirmation
+      OrdersMailer.customer_new_order(self).deliver
     end
     
-    def cancelled
-      return self.status == 'cancelled'
+    def test?
+      self.status == 'testing'
     end
     
-    # Returns true if there is at least one item in the order that requires shipping, and returns false otherwise
-    def requires_shipping
-      requires = false
-      self.order_line_items.each do |li|
-        if li.variant.requires_shipping
-          requires = true
-          break
-        end
-      end
-      return requires
+    def authorized?
+      self.financial_status == 'authorized'
     end
     
-    def calculate_total
-      self.calculate_discount
-      self.total = self.subtotal + self.tax + self.shipping + self.handling - self.discount
-      return self.total
+    def capture
+      PaymentProcessor.capture(self)
     end
     
-    def calculate_discount        
-      
-      percentage_off = 0.0
-      amount_off = 0.0
-      no_shipping = false
-      no_tax = false
-      
-      self.discounts.each do |d|
-        percentage_off = percentage_off + d.amount_percentage
-        amount_off = amount_off + d.amount_flat
-        no_shipping = true if d.no_shipping
-        no_tax = true if d.no_tax
-      end
-      
-      x = 0.0
-      x = x + self.subtotal * percentage_off if percentage_off > 0
-      x = x + amount_off if amount_off > 0
-      x = x + self.shipping if no_shipping
-      x = x + self.tax if no_tax
-  
-      self.discount = x
-      return self.discount      
+    def refuned
+      PaymentProcessor.refund(self)
+    end
+    
+    def void
+      PaymentProcessor.void(self)
+    end
+    
+    def line_item_added(line_item)
+      self.calculate
+    end
+    
+    def line_item_removed(line_item)
+      self.calculate
+    end
+    
+    def calculate
+      self.update_column(:subtotal, (self.calculate_subtotal * 100).ceil / 100.00)
+      self.update_column(:tax, (self.calculate_tax * 100).ceil / 100.00)
+      self.update_column(:shipping, (self.calculate_shipping * 100).ceil / 100.00)
+      self.update_column(:handling, (self.calculate_handling * 100).ceil / 100.00)
+      self.update_column(:total, (self.calculate_total * 100).ceil / 100.00)
+    end
+    
+    def calculate_subtotal
+      return 0 if self.line_items.empty?
+      self.line_items.collect { |line_item| line_item.price }.inject { |sum, price| sum + price }
+    end
+    
+    def calculate_tax
+      return 0 if !self.shipping_address
+      TaxCalculator.tax_rate(self.shipping_address)
+    end
+    
+    def calculate_shipping
+      return 0 if !self.shipping_address || !self.shipping_code
+      ShippingCalculator.rate(self)[:total_price]
+    end
+    
+    def calculate_handling
+      return 0 if !CabooseStore::handling_percentage
+      self.shipping * CabooseStore::handling_percentage
+    end
+    
+    def calculate_total
+      [self.subtotal, self.tax, self.shipping, self.handling].compact.inject { |sum, price| sum + price }
     end
   end
 end
+

data/app/models/caboose_store/order_discount.rb

@@ -1,11 +1,10 @@
 module CabooseStore        
   class OrderDiscount < ActiveRecord::Base
-    self.table_name = "store_order_discounts"
+    self.table_name = 'store_order_discounts'
     
     belongs_to :order
     belongs_to :discount
     
     attr_accessible :order_id, :discount_id
-  
   end
 end

data/app/models/caboose_store/order_pdf.rb

@@ -4,7 +4,7 @@ module CabooseStore
   class OrderPdf < Prawn::Document
     
     attr_accessor :order
-  
+    
     def to_pdf
       image open("https://dmwwflw4i3miv.cloudfront.net/logo.png"), :position => :center
       text " "
@@ -73,10 +73,8 @@ module CabooseStore
       tbl << [{ :content => "#{order.shipping_method} Shipping & Handling"  , :colspan => 5, :align => :right }, { :content => sprintf("%.2f", order.shipping + order.handling) , :align => :right }]    
       tbl << [{ :content => "Discount"                                      , :colspan => 5, :align => :right }, { :content => sprintf("%.2f", order.discount )                 , :align => :right }]
       tbl << [{ :content => "Total"                                         , :colspan => 5, :align => :right }, { :content => sprintf("%.2f", order.total    )                 , :align => :right }]
-  
-      table tbl
       
+      table tbl
     end
-    
   end
 end

data/app/models/caboose_store/payment_processors/authorizenet.rb

@@ -1,3 +1,21 @@
-
-class CabooseStore::PaymentProcessors::Authorizenet > CabooseStore::PaymentProcessors::Base
+class CabooseStore::PaymentProcessors::Authorizenet < CabooseStore::PaymentProcessors::Base
+  def self.api(root, body, test=false)
+  end
+  
+  def self.form_url(order)
+    #'https://secure.authorize.net/gateway/transact.dll'
+    'https://test.authorize.net/gateway/transact.dll'
+  end
+  
+  def self.authorize(order, params)
+  end
+  
+  def self.void(order)
+  end
+  
+  def self.capture(order)
+  end
+  
+  def self.refund(order)
+  end
 end

data/app/models/caboose_store/payment_processors/base.rb

@@ -1,4 +1,3 @@
-
 class CabooseStore::PaymentProcessors::Base
   
   # Gets a transaction object that obfuscates transaction info.  
@@ -38,4 +37,3 @@ class CabooseStore::PaymentProcessors::Base
     return false
   end
 end
-   

data/app/models/caboose_store/payment_processors/payscape.rb

@@ -1,3 +1,93 @@
+require "rexml/document"
 
-class CabooseStore::PaymentProcessors::Payscape > CabooseStore::PaymentProcessors::Base
+class CabooseStore::PaymentProcessors::Payscape < CabooseStore::PaymentProcessors::Base
+  def self.api(root, body, test=false)
+    
+    # Determine if transaction should be a test
+    body['api-key'] = if test or Rails.env == 'development'
+      '2F822Rw39fx762MaV7Yy86jXGTC7sCDy'
+    else
+      CabooseStore::api_key
+    end
+    
+    ap "API key used: #{body['api-key']}"
+    # ap "AUTH USERNAME: #{CabooseStore::payscape_username}"
+    # ap "AUTH PASSWORD: #{CabooseStore::payscape_password}"
+    
+    uri                  = URI.parse('https://secure.payscapegateway.com/api/v2/three-step')
+    http                 = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl         = true
+    request              = Net::HTTP::Post.new(uri.path)
+    request.content_type = 'text/xml'
+    request.body         = body.to_xml({:root => root})
+    xml_response         = http.request(request)
+    document             = REXML::Document.new(xml_response.body.to_s)
+    response             = Hash.new
+    
+    document.root.elements.each { |element| response[element.name] = element.text }
+    
+    ap response
+    
+    return response
+  end
+  
+  def self.form_url(order)
+    response = self.api 'auth', {
+      'redirect-url' => "#{CabooseStore::root_url}/checkout/relay/#{order.id}",
+      'amount'       => order.total.to_s,
+      'billing'      => {
+        'first-name' => order.billing_address.first_name,
+        'last-name'  => order.billing_address.last_name,
+        'address1'   => order.billing_address.address1,
+        'address2'   => order.billing_address.address2,
+        'city'       => order.billing_address.city,
+        'state'      => order.billing_address.state,
+        'postal'     => order.billing_address.zip
+      }
+    }, order.test?
+    
+    order.transaction_id = response['transaction-id']
+    order.transaction_service = 'payscape'
+    order.save
+    
+    return response['form-url']
+  end
+  
+  def self.authorized?(order)
+    uri              = URI.parse("https://secure.payscapegateway.com/api/query.php?username=#{CabooseStore::payscape_username}&password=#{CabooseStore::payscape_password}&transaction_id=#{order.transaction_id}")
+    http             = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl     = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    request          = Net::HTTP::Get.new(uri.request_uri)
+    response         = http.request(request)
+    document         = Nokogiri::XML response.body
+    actions          = Hash.new
+    
+    document.xpath('//action').each { |action| actions[action.xpath('action_type').text] = action.xpath('success').text == '1' }
+    return actions['auth']
+  end
+  
+  def self.authorize(order, params)
+    response = self.api 'complete-action', { 'token-id' => params['token-id'] }, order.test?
+    return response['result-code'].to_i == 100
+  end
+  
+  def self.void(order)
+    response = self.api 'void', { 'transaction-id' => order.transaction_id }, order.test?
+    return response['result-code'].to_i == 100
+  end
+  
+  def self.capture(order)
+    response = self.api 'capture', { 'transaction-id' => order.transaction_id }, order.test?
+    return response['result-code'].to_i == 100
+  end
+  
+  def self.refund(order)
+    response = self.api 'refund', {
+      'transaction-id' => order.transaction_id,
+      'amount'         => order.total.to_s
+    }, order.test?
+    
+    return response['result-code'].to_i == 100
+  end
 end

data/app/models/caboose_store/product.rb

@@ -1,21 +1,29 @@
-module CabooseStore        
+module CabooseStore
   class Product < ActiveRecord::Base
-    self.table_name = "store_products"
+    self.table_name = 'store_products'
+    self.primary_key = 'id'
     
     belongs_to :vendor, :class_name => 'CabooseStore::Vendor'
-    has_many :categories, :through => :category_memberships, :class_name => 'CabooseStore::Category'
-    has_many :category_memberships , :class_name => 'CabooseStore::CategoryMembership'
-    has_many :variants             , :class_name => 'CabooseStore::Variant'
-    has_many :product_images       , :class_name => 'CabooseStore::ProductImage'
-    has_many :reviews              , :class_name => 'CabooseStore::Review'
-  
+    has_many :customizations, :class_name => 'CabooseStore::Product', :through => :customization_memberships
+    has_many :customization_memberships, :class_name => 'CabooseStore::CustomizationMembership'
+    has_many :categories, :class_name => 'CabooseStore::Category', :through => :category_memberships
+    has_many :category_memberships, :class_name => 'CabooseStore::CategoryMembership'
+    has_many :variants, :class_name => 'CabooseStore::Variant'
+    has_many :product_images, :class_name => 'CabooseStore::ProductImage'
+    has_many :proudct_inputs, :class_name => 'CabooseStore::ProductInput'
+    has_many :reviews, :class_name => 'CabooseStore::Review'
+    
+    default_scope order('store_products.sort_order')
+    
     attr_accessible :id,
+      :alternate_id,
       :title,
       :description,
-      :vendor_id,    
+      :vendor_id,
       :handle,
+      :date_available,
       :seo_title,
-      :seo_description,    
+      :seo_description,
       :option1,
       :option2,
       :option3,
@@ -23,20 +31,58 @@ module CabooseStore
       :default2,
       :default3,
       :status,
-      :alternate_id
+      :custom_input,
+      :featured,
+      :sort_order
+    
+    
+    #
+    # Scopes
+    #
+    
+    scope :featured, -> { where(:featured => true) }
+      
+    #
+    # Class Methods
+    #
+    
+    def self.with_images
+      joins(:product_images)
+    end
+    
+    def self.active
+      where(:status => 'Active')
+    end
+    
+    def self.by_title
+      order('title')
+    end
+    
+    #
+    # Instance Methods
+    #
+    
+    def as_json(options={})
+      self.attributes.merge({
+        :variants => self.variants,
+        :images => self.product_images
+      })
+    end
     
     def options
-      arr = []
-      arr << self.option1 if !self.option1.nil? && self.option1.strip.length > 0
-      arr << self.option2 if !self.option2.nil? && self.option2.strip.length > 0
-      arr << self.option3 if !self.option3.nil? && self.option3.strip.length > 0
-      return arr
+      options = []
+      
+      options << self.option1 if !self.option1.nil? && self.option1.strip.length > 0
+      options << self.option2 if !self.option2.nil? && self.option2.strip.length > 0
+      options << self.option3 if !self.option3.nil? && self.option3.strip.length > 0
+      
+      return options
     end
-  
+    
     def most_popular_variant
-    	self.variants.order('price DESC').first
+      self.variants.where('price > ? AND status != ?', 0, 'Deleted').order('price ASC').first
     end
-  
+    
     def featured_image
     	self.product_images.reject{|p| p.nil?}.first
     end
@@ -49,30 +95,40 @@ module CabooseStore
     def price_range
       min = 100000
       max = 0
-      variants.each do |v|
-        next if v.nil? || v.price.nil?
-        min = v.price if v.price < min
-        max = v.price if v.price > max
+      
+      variants.each do |variant|
+        next if variant.nil? or variant.price.nil? or variant.price < 0
+        min = variant.price if variant.price < min
+        max = variant.price if variant.price > max
       end
+      
       return [min, max]
     end
     
     def url
-      return "/products/#{self.id}"
+      "/products/#{self.id}"
     end
     
     def related_items
-      return []
+      Array.new # TODO should be obvious
     end
     
     def in_stock
-      return Variant.where(:product_id => self.id).where("quantity_in_stock > 0").count > 0    
+      Variant.where(:product_id => self.id).where('quantity > 0').count > 0
     end
     
-    # Returns non deleted variants
-    def live_variants
-      return self.variants.where(:status => ['Active', 'Inactive'])
+    def input_required?
+      !self.custom_input.nil?
+    end
+    
+    def active_customizations
+      self.customizations.where(:status => 'Active')
     end
+    
+    def live_variants
       
+      # Return variants that haven't been "deleted"
+      self.variants.where(:status => ['Active', 'Inactive'])
+    end
   end
-end
+end