caboose-cms 0.7.85 → 0.8.1

data/app/models/caboose/comment_routes.rb

@@ -6,59 +6,80 @@ module Caboose
     end
       
     def CommentRoutes.controller_routes(controller = nil)
+      
+      controller = controller[1] if controller && controller.is_a?(Array)            
+      controller_paths = []
+      Gem.loaded_specs.each do |name, s|
+        controller_paths << s.full_gem_path        
+      end
+      Rails.application.config.paths['app/controllers'].each do |controller_path|                
+        controller_paths << Rails.root.join(controller_path)
+      end
           
-      classes = {'zzz_all_domains' => []}            
-      Rails.application.config.paths['app/controllers'].each do |controller_path|
+      classes = {'zzz_all_domains' => []}       
+      controller_paths.each do |controller_path|                
         #files = Dir.glob(Rails.root.join(controller_path, '*.rb'))        
         #files = controller ? Dir.glob(Rails.root.join(controller_path, "#{controller}_controller.rb")) : Dir.glob(Rails.root.join(controller_path, '**/*.rb'))
-        files = controller ? Dir.glob(Rails.root.join(controller_path, "#{controller}_controller.rb")) : Dir.glob(Rails.root.join(controller_path, '*.rb'))        
-        for file in files    
-          f = Rails.root.join('app', 'controllers', file)
-          f2 = File.open(f, "r")
+        #files = controller ? Dir.glob(Rails.root.join(controller_path, "#{controller}_controller.rb")) : Dir.glob(Rails.root.join(controller_path, '*.rb'))        
+        #files = controller ? Dir.glob("#{controller_path}/#{controller}_controller.rb") : Dir.glob("#{controller_path}/*.rb")                          
+        files = controller ? Dir.glob("#{controller_path}/**/#{controller.gsub(/(.*?)::(.*?)/, '\2')}_controller.rb") : Dir.glob("#{controller_path}/**/*_controller.rb")
+        #files = Dir.glob("#{controller_path}/**/*_controller.rb")        
+        for file in files
+          f2 = File.open(file, "r")
                   
           domains = []
+          module_name = nil
           class_name = nil
           class_priority = 20
           route_priority = 20
+          custom_route_priority = false          
           uris = []
           actions = []
           f2.each_line do |line|      
             line = line.strip        
-            if line =~ /^(.*?)class (.*?)Controller(.*?)$/
+            if line =~ /^module (.*?)$/
+              module_name = line.gsub(/^module (.*?)$/, '\1').gsub(/([A-Z])/, '_\1').downcase
+              module_name[0] = '' if module_name[0] == '_'
+            elsif line =~ /^(.*?)class (.*?)Controller(.*?)$/
               class_name = line.gsub(/^(.*?)class (.*?)Controller(.*?)$/, '\2').gsub(/([A-Z])/, '_\1').downcase
               class_name[0] = '' if class_name[0] == '_'
+              class_name = "#{module_name}::#{class_name}" if module_name
             elsif line =~ /# @route_domain (.*?)$/            
               domain = line.gsub(/# @route_domain (.*?)$/, '\1')
-              domains << domain if !domains.include?(domain)                        
+              domains << domain if !domains.include?(domain)
+            elsif line =~ /# @route_constraints (.*?)$/            
+              constraints = line.gsub(/# @route_constraints (.*?)$/, '\1')
+              uris.last[1] = constraints if uris.length > 0
+              constraints = nil
             elsif line =~ /# @class_route_priority \d/
               class_priority = line.gsub(/# @class_route_priority (\d*?)$/, '\1').to_i
             elsif line =~ /# @route_priority \d/
-              route_priority = line.gsub(/# @route_priority (\d*?)$/, '\1').to_i
-            elsif line.starts_with?('def ')
-              actions << [line.gsub('def ', ''), uris, route_priority]              
+              custom_route_priority = line.gsub(/# @route_priority (\d*?)$/, '\1').to_i              
+            elsif line.starts_with?('def ')                                           
+              actions << [line.gsub('def ', ''), uris, custom_route_priority ? custom_route_priority : route_priority]                            
               uris = []
-              route_priority = 20
-            elsif line =~ /# @route GET (.*?)/       then uris << "get    \"#{line.gsub(/# @route GET (.*?)/       , '\1')}\""          
-            elsif line =~ /# @route POST (.*?)/      then uris << "post   \"#{line.gsub(/# @route POST (.*?)/      , '\1')}\""          
-            elsif line =~ /# @route PUT (.*?)/       then uris << "put    \"#{line.gsub(/# @route PUT (.*?)/       , '\1')}\""          
-            elsif line =~ /# @route DELETE (.*?)/    then uris << "delete \"#{line.gsub(/# @route DELETE (.*?)/    , '\1')}\""
-            end
-          end
-          if domains.count > 0
-            domains.each do |domain|
-              classes[domain] = [] if classes[domain].nil?
-              classes[domain] << [class_name, actions, class_priority]
+              route_priority = route_priority + 1 if !custom_route_priority
+              custom_route_priority = false
+              constraints = nil
+            elsif line =~ /# @route GET (.*?)/       then uris << ["get    \"#{line.gsub(/# @route GET (.*?)/       , '\1').strip}\"", nil]              
+            elsif line =~ /# @route POST (.*?)/      then uris << ["post   \"#{line.gsub(/# @route POST (.*?)/      , '\1').strip}\"", nil]              
+            elsif line =~ /# @route PUT (.*?)/       then uris << ["put    \"#{line.gsub(/# @route PUT (.*?)/       , '\1').strip}\"", nil]              
+            elsif line =~ /# @route DELETE (.*?)/    then uris << ["delete \"#{line.gsub(/# @route DELETE (.*?)/    , '\1').strip}\"", nil]              
             end
-          else                      
-            classes['zzz_all_domains'] << [class_name, actions, class_priority]
           end
+          ds = domains.count > 0 ? domains.sort.join(' ') : 'zzz_all_domains' 
+          classes[ds] = [] if classes[ds].nil?
+          classes[ds] << [class_name, actions, class_priority]
         end
       end
            
       routes = []
       classes.sort_by{ |domain, domain_classes| domain }.to_h.each do |domain, domain_classes|
-                
-        routes << "constraints Caboose::DomainConstraint.new('#{domain}') do" if domain != 'zzz_all_domains'                
+                        
+        if domain != 'zzz_all_domains'
+          domains = domain.split(' ').collect{ |d| "'#{d}'" }.join(', ')
+          routes << "constraints Caboose::DomainConstraint.new([#{domains}]) do"
+        end
         domain_classes.sort_by{ |arr| arr[2] }.each do |carr|
         
           class_name = carr[0]
@@ -66,16 +87,20 @@ module Caboose
           
           # Get the longest URI so we can make routes that line up vertically
           longest = ''
-          actions.each{ |action, uris| uris.each{ |uri| longest = uri if uri.length > longest.length }}
+          actions.each{ |action, uris| uris.each{ |uri_arr| longest = uri_arr[0] if uri_arr[0].length > longest.length }}
           length = longest.length + 1
           
-          # Make the route line
+          # Make the route line         
           actions.sort_by{ |arr| arr[2] }.each do |arr|
             action = arr[0]
             uris = arr[1]
-            uris.each do |uri|              
-              # puts "#{uri.ljust(length, ' ')} => \"#{class_name}\##{action}\""              
-              routes << "#{uri.ljust(length, ' ')} => \"#{class_name}\##{action}\""              
+            uris.each do |uri_arr|
+              uri = uri_arr[0]
+              constraints = uri_arr[1]
+              # puts "#{uri.ljust(length, ' ')} => \"#{class_name}\##{action}\""
+              route = "#{uri.ljust(length, ' ')} => \"#{class_name}\##{action}\""
+              route = "#{route}, :constraints => #{constraints}" if constraints
+              routes << route              
             end
           end
           #puts ""
@@ -117,17 +142,19 @@ module Caboose
       return false
     end
     
-    def CommentRoutes.compare_routes                              
-        
+    def CommentRoutes.compare_routes(controller, route_file)
+      
+      controller = controller[1] if controller && controller.is_a?(Array)        
       routes_in_routes_file = []
-      file = File.open(Rails.root.join('config', 'routes.rb'), "r")
+      file = File.open(route_file ? route_file : Rails.root.join('config', 'routes.rb'), "r")      
       file.each_line do |line|        
         line = line.strip
-        routes_in_routes_file << self.split_route(line)        
+        arr = self.split_route(line)
+        routes_in_routes_file << arr if arr && arr[2].starts_with?("#{controller}#")                  
       end
-      
+            
       routes_in_controllers = []
-      self.controller_routes.split("\n").each do |route|
+      self.controller_routes(controller).split("\n").each do |route|
         route = route.strip
         next if route.length == 0
         routes_in_controllers << self.split_route(route)
@@ -138,8 +165,8 @@ module Caboose
       # See what routes are in the controller routes but not in routes file
       routes_not_in_routes_file = []
       routes_in_controllers.each do |route|
-        next if route.nil? || route.count != 3
-        all_routes << [route[0], route[1], route[2], 'Y', self.in_routes_array(route, routes_in_routes_file) ? 'Y' : '']
+        next if route.nil? || route.count != 3        
+        all_routes << [route[0], route[1], route[2], 'Yes', self.in_routes_array(route, routes_in_routes_file) ? 'Yes' : 'No']
       end
       
       # See what routes are in the routes file but not in the controllers
@@ -147,7 +174,7 @@ module Caboose
       routes_in_routes_file.each do |route|
         next if route.nil? || route.count != 3
         if !self.in_routes_array(route, all_routes)
-          all_routes << [route[0], route[1], route[2], '', 'Y']
+          all_routes << [route[0], route[1], route[2], 'No', 'Yes']
         end        
       end
       
@@ -161,7 +188,7 @@ module Caboose
       puts "#{"Verb".ljust(lengths[0], ' ')} #{"URI".ljust(lengths[1], ' ')} #{"Action".ljust(lengths[2], ' ')} #{"In Controller".ljust(14, ' ')} #{"In Routes File".ljust(14, ' ')}"
       puts "#{"".ljust(lengths[0], '-')} #{"".ljust(lengths[1], '-')} #{"".ljust(lengths[2], '-')} #{"".ljust(14, '-')} #{"".ljust(14, '-')}"
       all_routes.each do |route|          
-        next if route[3] == 'Y' && route[4] == 'Y'        
+        #next if route[3] == 'Y' && route[4] == 'Y'        
         puts "#{route[0].ljust(lengths[0], ' ')} #{route[1].ljust(lengths[1], ' ')} #{route[2].ljust(lengths[2], ' ')} #{route[3].ljust(14, ' ')} #{route[4].ljust(14, ' ')}"
       end              
       puts "\n"

data/app/models/caboose/core_plugin.rb

@@ -35,7 +35,7 @@ class Caboose::CorePlugin < Caboose::CaboosePlugin
       item = { 'id' => 'store', 'text' => 'Store', 'children' => [] }
       item['children'] << { 'id' => 'categories'       , 'href' => '/admin/categories'        , 'text' => 'Categories'        , 'modal' => false } if user.is_allowed('categories'       , 'view')
       item['children'] << { 'id' => 'giftcards'        , 'href' => '/admin/gift-cards'        , 'text' => 'Gift Cards'        , 'modal' => false } if user.is_allowed('giftcards'        , 'view')
-      item['children'] << { 'id' => 'orders'           , 'href' => '/admin/orders'            , 'text' => 'Orders'            , 'modal' => false } if user.is_allowed('orders'           , 'view')
+      item['children'] << { 'id' => 'invoices'         , 'href' => '/admin/invoices'          , 'text' => 'Invoices'          , 'modal' => false } if user.is_allowed('invoices'         , 'view')
       item['children'] << { 'id' => 'products'         , 'href' => '/admin/products'          , 'text' => 'Products'          , 'modal' => false } if user.is_allowed('products'         , 'view')
       item['children'] << { 'id' => 'shippingpackages' , 'href' => '/admin/shipping-packages' , 'text' => 'Shipping Packages' , 'modal' => false } if user.is_allowed('shippingpackages' , 'view')
       item['children'] << { 'id' => 'vendors'          , 'href' => '/admin/vendors'           , 'text' => 'Vendors'           , 'modal' => false } if user.is_allowed('vendors'          , 'view')    

data/app/models/caboose/discount.rb

@@ -1,18 +1,29 @@
 module Caboose
   class Discount < ActiveRecord::Base
-    self.table_name  = 'store_order_discounts'
+    self.table_name  = 'store_invoice_discounts'
     self.primary_key = 'id'
             
     belongs_to :gift_card
-    belongs_to :order
+    belongs_to :invoice
     attr_accessible :id,
       :gift_card_id,
-      :order_id,
+      :invoice_id,
       :amount
 
     after_find do |d|
       d.amount = 0.00 if d.amount.nil?                        
     end
+    
+    def calculate_amount                                
+      gc = self.gift_card      
+      self.amount = case self.gift_card.card_type
+        when GiftCard::CARD_TYPE_AMOUNT      then (self.order.total >= gc.balance ? gc.balance : self.order.total)
+        when GiftCard::CARD_TYPE_PERCENTAGE  then self.order.subtotal * gc.total
+        when GiftCard::CARD_TYPE_NO_SHIPPING then self.order.shipping
+        when GiftCard::CARD_TYPE_NO_TAX      then self.order.tax
+      end
+      self.save
+    end
       
   end
 end

data/app/models/caboose/domain_constraint.rb

@@ -1,9 +1,17 @@
 class Caboose::DomainConstraint
-  def initialize(domain)
-    @domains = [domain].flatten
+  def initialize(domains)    
+    @domains = domains.is_a?(Array) ? domains.flatten : [domains].flatten
   end
 
   def matches?(request)
-    return @domains.include?(request.host)        
+    m = false
+    @domains.each do |d|
+      if request.host =~ /#{d.gsub("\\","\\\\")}/
+        m = true
+        break
+      end
+    end
+    return m              
+    #return @domains.include?(request.host)     
   end
 end

data/app/models/caboose/gift_card.rb

@@ -5,7 +5,7 @@ module Caboose
         
     belongs_to :site    
     has_many :discounts
-    has_many :orders, :through => :discounts    
+    has_many :invoices, :through => :discounts    
     attr_accessible :id,
       :site_id,      
       :name,  # The name of this discount            
@@ -13,7 +13,7 @@ module Caboose
       :card_type,
       :total,
       :balance,
-      :min_order_total, # The minimum order total required to be able to use the card
+      :min_invoice_total, # The minimum invoice total required to be able to use the card
       :date_available,
       :date_expires,
       :status            
@@ -30,20 +30,20 @@ module Caboose
     after_initialize :check_nil_fields
     
     def check_nil_fields
-      self.total           = 0.00 if self.total.nil?
-      self.balance         = 0.00 if self.balance.nil?          
-      self.min_order_total = 0.00 if self.min_order_total.nil?  
+      self.total             = 0.00 if self.total.nil?
+      self.balance           = 0.00 if self.balance.nil?          
+      self.min_invoice_total = 0.00 if self.min_invoice_total.nil?  
     end
 
-    def valid_for_order?(order)
+    def valid_for_invoice?(invoice)
       return false if self.status != GiftCard::STATUS_ACTIVE
       return false if self.date_available && DateTime.now.utc < self.date_available
       return false if self.date_expires && DateTime.now.utc > self.date_expires
       return false if self.card_type == GiftCard::CARD_TYPE_AMOUNT && self.balance <= 0      
-      return false if self.min_order_total && order.total < self.min_order_total
+      return false if self.min_invoice_total && invoice.total < self.min_invoice_total
       return true
     end
-    
+
   end
 end
 

data/app/models/caboose/invoice.rb

@@ -0,0 +1,706 @@
+#
+# Invoice
+#
+
+module Caboose        
+  class Invoice < ActiveRecord::Base
+    self.table_name  = 'store_invoices'
+    self.primary_key = 'id'
+
+    belongs_to :site    
+    belongs_to :customer, :class_name => 'Caboose::User'
+    belongs_to :shipping_address, :class_name => 'Caboose::Address'
+    belongs_to :billing_address, :class_name => 'Caboose::Address'
+    has_many :discounts    
+    has_many :line_items, :order => :id
+    has_many :invoice_packages, :class_name => 'Caboose::InvoicePackage'
+    has_many :invoice_transactions
+    
+    attr_accessible :id,
+      :site_id               ,
+      :invoice_number        ,
+      :alternate_id          ,
+      :subtotal              ,
+      :tax                   ,
+      :tax_rate              ,
+      :shipping              ,
+      :handling              ,
+      :gift_wrap             ,
+      :custom_discount       ,
+      :discount              ,
+      :total                 ,
+      :cost                  ,
+      :profit                ,
+      :customer_id           ,
+      :financial_status      ,
+      :shipping_address_id   ,
+      :billing_address_id    ,
+      :notes                 ,
+      :status                ,
+      :payment_terms         ,
+      :date_created          ,
+      :date_authorized       ,
+      :date_captured         ,
+      :date_shipped          ,
+      :date_due              ,
+      :referring_site        ,
+      :landing_page          ,
+      :landing_page_ref      ,
+      :auth_amount           ,
+      :gift_message          ,
+      :include_receipt               
+          
+    STATUS_CART          = 'cart'
+    STATUS_PENDING       = 'pending'    
+    STATUS_CANCELED      = 'canceled'
+    STATUS_READY_TO_SHIP = 'ready to ship'
+    STATUS_SHIPPED       = 'shipped'    
+    STATUS_TESTING       = 'testing'
+    
+    # New
+    #STATUS_PENDING        = 'Pending'
+    #STATUS_OVERDUE        = 'Overdue'
+    #STATUS_UNDER_REVIEW   = 'Under Review'
+    #STATUS_PAID           = 'Paid'
+    #STATUS_PAID_BY_CHECK  = 'Paid By Check'
+    #STATUS_CANCELED       = 'Canceled'
+    #STATUS_WAIVED         = 'Waived'
+
+    FINANCIAL_STATUS_PENDING    = 'pending'
+    FINANCIAL_STATUS_AUTHORIZED = 'authorized'
+    FINANCIAL_STATUS_CAPTURED   = 'captured'
+    FINANCIAL_STATUS_REFUNDED   = 'refunded'
+    FINANCIAL_STATUS_VOIDED     = 'voided'
+    
+    PAYMENT_TERMS_PIA   = 'pia'
+    PAYMENT_TERMS_NET7  = 'net7'
+    PAYMENT_TERMS_NET10 = 'net10'
+    PAYMENT_TERMS_NET30 = 'net30'
+    PAYMENT_TERMS_NET60 = 'net60'
+    PAYMENT_TERMS_NET90 = 'net90'
+    PAYMENT_TERMS_EOM   = 'eom'
+        
+    #
+    # Scopes
+    #    
+    scope :cart       , where('status = ?', 'cart')
+    scope :pending    , where('status = ?', 'pending')    
+    scope :canceled   , where('status = ?', 'canceled')
+    scope :shipped    , where('status = ?', 'shipped')
+    scope :test       , where('status = ?', 'testing')
+    
+    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', 'canceled', 'ready to ship', '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'"
+    }
+    
+    after_initialize :check_nil_fields
+    
+    def check_nil_fields
+      self.subtotal        = 0.00 if self.subtotal.nil?       
+      self.tax             = 0.00 if self.tax.nil?
+      self.shipping        = 0.00 if self.shipping.nil?
+      self.handling        = 0.00 if self.handling.nil?
+      self.custom_discount = 0.00 if self.custom_discount.nil?
+      self.discount        = 0.00 if self.discount.nil?
+      self.total           = 0.00 if self.total.nil?
+    end
+           
+    def decrement_quantities            
+      self.line_items.each do |line_item|
+        line_item.variant.update_attribute(:quantity_in_stock, line_item.variant.quantity_in_stock - line_item.quantity)
+      end            
+    end
+    
+    def increment_quantities            
+      self.line_items.each do |line_item|
+        line_item.variant.update_attribute(:quantity_in_stock, line_item.variant.quantity_in_stock - line_item.quantity)
+      end            
+    end
+    
+    def resend_confirmation
+      InvoicesMailer.configure_for_site(self.site_id).customer_new_invoice(self).deliver
+    end
+    
+    def test?
+      self.status == 'testing'
+    end
+    
+    def authorized?
+      self.financial_status == 'authorized'
+    end
+    
+    #def refund
+    #  PaymentProcessor.refund(self)
+    #end
+    #
+    #def void
+    #  PaymentProcessor.void(self)
+    #end
+    
+    def calculate        
+      self.update_column(:subtotal  , self.calculate_subtotal  )
+      self.update_column(:tax       , self.calculate_tax       )
+      self.update_column(:shipping  , self.calculate_shipping  )
+      self.update_column(:handling  , self.calculate_handling  )
+      self.update_column(:gift_wrap , self.calculate_gift_wrap )
+      
+      # Calculate the total without the discounts first       
+      self.discounts.each{ |d| d.update_column(:amount, 0.0) } if self.discounts      
+      self.update_column(:total     , self.calculate_total     )
+      
+      self.update_column(:discount  , self.calculate_discount  )
+      self.update_column(:total     , self.calculate_total     )      
+      self.update_column(:cost      , self.calculate_cost      )
+      self.update_column(:profit    , self.calculate_profit    )              
+    end
+    
+    def calculate_subtotal
+      return 0.0 if self.line_items.empty?
+      self.line_items.each{ |li| li.verify_unit_price } # Make sure the unit prices are populated        
+      x = 0.0      
+      self.line_items.each{ |li| x = x + (li.unit_price * li.quantity) } # Fixed issue with quantity 
+      return x
+    end
+    
+    def calculate_tax      
+      return TaxCalculator.tax(self)
+    end
+    
+    def calculate_shipping      
+      return 0.0 if self.invoice_packages.nil? || self.invoice_packages.count == 0
+      x = 0.0
+      self.invoice_packages.all.each{ |op| x = x + op.total }
+      return x
+    end
+    
+    def calculate_handling
+      return 0.0 if self.site.nil? || self.site.store_config.nil?      
+      self.subtotal * self.site.store_config.handling_percentage.to_f
+    end
+    
+    def calculate_gift_wrap      
+      x = 0.0
+      self.line_items.each do |li|
+        next if !li.gift_wrap
+        next if !li.variant.product.allow_gift_wrap
+        x = x + li.variant.product.gift_wrap_price * li.quantity
+      end
+      return x
+    end
+    
+    def calculate_discount              
+      x = 0.0
+      if self.discounts && self.discounts.count > 0                              
+        self.discounts.each do |d|
+          d.calculate_amount                    
+          x = x + d.amount
+        end
+      end
+      x = x + self.custom_discount if self.custom_discount
+      return x
+    end
+    
+    def calculate_total
+      return (self.subtotal + self.tax + self.shipping + self.handling + self.gift_wrap) - self.discount
+    end
+    
+    def calculate_cost      
+      x = 0.0
+      invalid_cost = false
+      self.line_items.each do |li|
+        invalid_cost = true if li.variant.nil? || li.variant.cost.nil?
+        x = x + (li.variant.cost * li.quantity)
+      end
+      return 0.00 if invalid_cost
+      return x            
+    end
+    
+    def calculate_profit
+      return 0.00 if self.cost.nil?
+      return (self.total - (self.tax ? self.tax : 0.00) - (self.shipping ? self.shipping : 0.00) - (self.handling ? self.handling : 0.00) - (self.gift_wrap ? self.gift_wrap : 0.00)) - self.cost
+    end
+    
+    def shipping_and_handling
+      (self.shipping ? self.shipping : 0.0) + (self.handling ? self.handling : 0.0)      
+    end
+    
+    def item_count
+      count = 0
+      self.line_items.each{ |li| count = count + li.quantity } if self.line_items
+      return count
+    end
+    
+    def take_gift_card_funds
+      return if self.discounts.nil? || self.discounts.count == 0
+      self.discounts.each do |d|        
+        gc = d.gift_card
+        gc.balance = gc.balance - d.amount
+        gc.save
+      end
+    end
+    
+    def has_empty_shipping_methods?
+      return true if self.invoice_packages.nil?
+      return true if self.invoice_packages.count == 0
+      self.invoice_packages.all.each do |op|
+        return true if op.shipping_method_id.nil?
+      end
+      return false
+    end
+    
+    def has_downloadable_items?
+      self.line_items.each do |li|
+        return true if li.variant.downloadable
+      end
+      return false
+    end
+    
+    def has_shippable_items?
+      self.line_items.each do |li|
+        return true if !li.variant.downloadable
+      end
+      return false
+    end
+    
+    def has_taxable_items?
+      self.line_items.each do |li|
+        return true if li.variant.taxable && li.variant.taxable == true
+      end
+      return false
+    end        
+
+    # Capture funds from a previously authorized transaction
+    def capture_funds
+      
+      resp = StdClass.new      
+      it = InvoiceTransaction.where(:invoice_id => self.id, :success => true).first
+            
+      if self.financial_status == Invoice::FINANCIAL_STATUS_CAPTURED
+        resp.error = "Funds for this invoice have already been captured."    
+      elsif self.total > it.amount
+        resp.error = "The invoice total exceeds the authorized amount."
+      elsif it.nil?
+        resp.error = "This invoice doesn't seem to be authorized."
+      else
+                        
+        sc = self.site.store_config                
+        case sc.pp_name
+          
+          #when 'authorize.net'
+          #  transaction = AuthorizeNet::AIM::Transaction.new(sc.authnet_api_login_id, sc.authnet_api_transaction_key)
+          #  response = transaction.prior_auth_capture(t.transaction_id, self.total)
+          #  
+          #  ot = Caboose::InvoiceTransaction.create(
+          #    :invoice_id       => self.id,
+          #    :date_processed   => DateTime.now.utc,
+          #    :transaction_type => InvoiceTransaction::TYPE_CAPTURE,
+          #    :amount           => self.total,        
+          #    :success          => response.response_code && response.response_code == '1',            
+          #    :transaction_id   => response.transaction_id,
+          #    :auth_code        => response.authorization_code,
+          #    :response_code    => response.response_code
+          #  )
+          #  if ot.success
+          #    self.date_captured = DateTime.now.utc
+          #    self.save              
+          #  end                                    
+          #  self.update_attribute(:financial_status, Invoice::FINANCIAL_STATUS_CAPTURED)
+          #  resp.success = 'Captured funds successfully'
+                                    
+          when StoreConfig::PAYMENT_PROCESSOR_STRIPE
+                                          
+            it = Caboose::InvoiceTransaction.where(:invoice_id => self.id, :success => true).first
+            if it.nil?
+              resp.error = "Error capturing funds for invoice #{self.id}. No previous successful authorization for this invoice exists."
+              return false
+            else                        
+              Stripe.api_key = sc.stripe_secret_key.strip
+              bt = nil
+              begin
+                c = Stripe::Charge.retrieve(it.transaction_id)
+                c = c.capture
+                bt = Stripe::BalanceTransaction.retrieve(c.balance_transaction)
+              rescue Exception => ex
+                resp.error = "Error during capture process\n#{ex.message}"                
+              end
+              
+              if resp.error.nil?
+                InvoiceTransaction.create(
+                  :invoice_id => self.id,
+                  :transaction_id => bt.id,
+                  :transaction_type => InvoiceTransaction::TYPE_CAPTURE, 
+                  :amount => bt.amount / 100,                
+                  :date_processed => DateTime.strptime(bt.created.to_s, '%s'),
+                  :success => bt.status == 'succeeded' || bt.status == 'pending'
+                )
+                if bt.status == 'succeeded' || bt.status == 'pending'
+                  self.financial_status = Invoice::FINANCIAL_STATUS_CAPTURED
+                  self.save
+                  resp.success = true
+                else
+                  resp.error = "Error capturing funds."
+                end
+              end
+            end
+          
+        end        
+      end      
+      return resp
+    end
+        
+    # Void an authorized invoice
+    def void
+            
+      resp = StdClass.new
+      t = InvoiceTransaction.where(:invoice_id => self.id, :transaction_type => InvoiceTransaction::TYPE_AUTHORIZE, :success => true).first
+      
+      if self.financial_status == Invoice::FINANCIAL_STATUS_CAPTURED
+        resp.error = "This invoice has already been captured, you will need to refund instead"
+      elsif t.nil?
+        resp.error = "This invoice doesn't seem to be authorized."
+      else
+                
+        sc = self.site.store_config
+        ot = Caboose::InvoiceTransaction.new(
+          :invoice_id => self.id,
+          :date_processed => DateTime.now.utc,
+          :transaction_type => InvoiceTransaction::TYPE_VOID,
+          :amount => self.total
+        )
+        
+        case sc.pp_name
+          when 'authorize.net'            
+            response = AuthorizeNet::SIM::Transaction.new(
+              sc.authnet_api_login_id, 
+              sc.authnet_api_transaction_key,                      
+              self.total,
+              :transaction_type => InvoiceTransaction::TYPE_VOID,
+              :transaction_id => t.transaction_id,
+              :test => sc.pp_testing
+            )                    
+            self.update_attributes(
+              :financial_status => Invoice::FINANCIAL_STATUS_VOIDED,
+              :status => Invoice::STATUS_CANCELED
+            )
+            self.save          
+            # TODO: Add the variant quantities invoiceed back        
+            resp.success = "Invoice voided successfully"
+                        
+            ot.success        = response.response_code && response.response_code == '1'            
+            ot.transaction_id = response.transaction_id
+            #ot.auth_code      = response.authorization_code
+            ot.response_code  = response.response_code            
+            ot.save
+          
+          when 'stripe'
+            # TODO: Implement void invoice for strip
+            
+          when 'payscape'
+            # TODO: Implement void invoice for payscape
+            
+        end
+        
+      end
+      return resp      
+    end        
+      
+    # Refund an order
+    def refund(amount = nil)
+      
+      resp = StdClass.new      
+      it = InvoiceTransaction.where(:invoice_id => self.id, :success => true).first
+      amount = self.total - self.amount_refunded if amount.nil?
+            
+      if self.financial_status == Invoice::FINANCIAL_STATUS_REFUNDED
+        resp.error = "Funds for this invoice have already been refunded."    
+      elsif amount > self.amount_refunded
+        resp.error = "The amount to refund exceeds the amount available to refund."
+      elsif it.nil?
+        resp.error = "This invoice doesn't seem to be authorized."
+      else
+                        
+        sc = self.site.store_config                
+        case sc.pp_name
+                                    
+          when StoreConfig::PAYMENT_PROCESSOR_STRIPE
+                                          
+            it = Caboose::InvoiceTransaction.where(:invoice_id => self.id, :success => true).first
+            if it.nil?
+              resp.error = "Error capturing funds for invoice #{self.id}. No previous successful authorization for this invoice exists."
+              return false
+            else                        
+              Stripe.api_key = sc.stripe_secret_key.strip
+              bt = nil
+              begin
+                c = Stripe::Charge.retrieve(it.transaction_id)
+                c = c.capture
+                bt = Stripe::BalanceTransaction.retrieve(c.balance_transaction)
+              rescue Exception => ex
+                resp.error = "Error during capture process\n#{ex.message}"                
+              end
+              
+              if resp.error.nil?
+                InvoiceTransaction.create(
+                  :invoice_id => self.id,
+                  :transaction_id => bt.id,
+                  :transaction_type => InvoiceTransaction::TYPE_CAPTURE, 
+                  :amount => bt.amount / 100,                
+                  :date_processed => DateTime.strptime(bt.created.to_s, '%s'),
+                  :success => bt.status == 'succeeded' || bt.status == 'pending'
+                )
+                if bt.status == 'succeeded' || bt.status == 'pending'
+                  self.financial_status = Invoice::FINANCIAL_STATUS_CAPTURED
+                  self.save
+                  resp.success = true
+                else
+                  resp.error = "Error capturing funds."
+                end
+              end
+            end
+          
+        end        
+      end      
+      return resp
+    end
+    
+    def send_payment_authorization_email
+      InvoicesMailer.configure_for_site(self.site_id).customer_payment_authorization(self).deliver
+    end
+    
+    def determine_statuses
+      
+      auth    = false
+      capture = false
+      void    = false
+      refund  = false
+      
+      self.invoice_transactions.each do |it|
+        auth    = true if it.transaction_type == InvoiceTransaction::TYPE_AUTHORIZE && it.success == true
+        capture = true if it.transaction_type == InvoiceTransaction::TYPE_CAPTURE   && it.success == true
+        void    = true if it.transaction_type == InvoiceTransaction::TYPE_VOID      && it.success == true
+        refund  = true if it.transaction_type == InvoiceTransaction::TYPE_REFUND    && it.success == true
+      end
+      
+      if    refund  then self.financial_status = Invoice::FINANCIAL_STATUS_REFUNDED
+      elsif void    then self.financial_status = Invoice::FINANCIAL_STATUS_VOIDED
+      elsif capture then self.financial_status = Invoice::FINANCIAL_STATUS_CAPTURED
+      elsif auth    then self.financial_status = Invoice::FINANCIAL_STATUS_AUTHORIZED
+      else               self.financial_status = Invoice::FINANCIAL_STATUS_PENDING
+      end
+    
+      self.status = Invoice::STATUS_PENDING if self.status == Invoice::STATUS_CART && (refund || void || capture || auth) 
+      
+      self.save
+
+    end
+    
+    def hide_prices_for_any_line_item?
+      self.line_items.each do |li|
+        return true if li.hide_prices
+      end
+      return false
+    end  
+    
+    def amount_not_paid
+      amount = self.vendor_transactions.where(:success => true).all.collect{ |vt| vt.amount }.sum
+      return self.total - amount
+    end
+    
+    #===========================================================================
+    
+    def verify_invoice_packages
+      
+      Caboose.log("Verifying invoice packages....")
+      
+      # See if any there are any empty invoice packages          
+      self.invoice_packages.each do |ip|
+        count = 0
+        self.line_items.each do |li|
+          count = count + 1 if li.invoice_package_id == ip.id
+        end
+        ip.destroy if count == 0
+      end
+      
+      # See if any line items aren't associated with an invoice package
+      line_items_attached = true      
+      self.line_items.each do |li|
+        line_items_attached = false if li.invoice_package_id.nil?
+      end
+      shipping_packages_attached = true
+      self.invoice_packages.each do |ip|    
+        shipping_packages_attached = false if ip.shipping_package_id.nil?                          
+      end
+      ips = self.invoice_packages
+      if ips.count == 0 || !line_items_attached || !shipping_packages_attached        
+        self.calculate
+        LineItem.where(:invoice_id => self.id).update_all(:invoice_package_id => nil)
+        InvoicePackage.where(:invoice_id => self.id).destroy_all          
+        self.create_invoice_packages
+      end
+                  
+    end
+    
+    # Calculates the shipping packages required for all the items in the invoice
+    def create_invoice_packages
+      
+      Caboose.log("Creating invoice packages...")
+      
+      store_config = self.site.store_config            
+      if !store_config.auto_calculate_packages                        
+        InvoicePackage.custom_invoice_packages(store_config, self)
+        return
+      end
+                  
+      # Make sure all the line items in the invoice have a quantity of 1
+      extra_line_items = []
+      self.line_items.each do |li|        
+        if li.quantity > 1          
+          (1..li.quantity).each{ |i|            
+            extra_line_items << li.copy 
+          }
+          li.quantity = 1
+          li.save
+        end        
+      end
+      extra_line_items.each do |li|         
+        li.quantity = 1                        
+        li.save 
+      end 
+      
+      # Make sure all the items in the invoice have attributes set
+      self.line_items.each do |li|              
+        v = li.variant
+        next if v.downloadable
+        Caboose.log("Error: variant #{v.id} has a zero weight") and return false if v.weight.nil? || v.weight == 0
+        next if v.volume && v.volume > 0
+        Caboose.log("Error: variant #{v.id} has a zero length") and return false if v.length.nil? || v.length == 0
+        Caboose.log("Error: variant #{v.id} has a zero width" ) and return false if v.width.nil?  || v.width  == 0
+        Caboose.log("Error: variant #{v.id} has a zero height") and return false if v.height.nil? || v.height == 0        
+        v.volume = v.length * v.width * v.height
+        v.save
+      end
+            
+      # Reorder the items in the invoice by volume
+      line_items = self.line_items.sort_by{ |li| li.quantity * (li.variant.volume ? li.variant.volume : 0.00) * -1 }
+                      
+      # Get all the packages we're going to use      
+      all_packages = ShippingPackage.where(:site_id => self.site_id).reorder(:flat_rate_price).all      
+      
+      # Now go through each variant and fit it in a new or existing package            
+      line_items.each do |li|        
+        next if li.variant.downloadable
+        
+        # See if the item will fit in any of the existing packages
+        it_fits = false
+        self.invoice_packages.all.each do |op|
+          it_fits = op.fits(li)
+          if it_fits            
+            li.invoice_package_id = op.id
+            li.save            
+            break
+          end
+        end        
+        next if it_fits
+        
+        # Otherwise find the cheapest package the item will fit into
+        it_fits = false
+        all_packages.each do |sp|
+          it_fits = sp.fits(li.variant)          
+          if it_fits            
+            op = InvoicePackage.create(:invoice_id => self.id, :shipping_package_id => sp.id)
+            li.invoice_package_id = op.id
+            li.save                          
+            break
+          end
+        end
+        next if it_fits
+        
+        Caboose.log("Error: line item #{li.id} (#{li.variant.product.title}) does not fit into any package.")               
+      end      
+    end
+    
+    def refresh_transactions  
+      InvoiceTransaction.where(:invoice_id => self.id).destroy_all        
+      sc = self.site.store_config
+      case sc.pp_name          
+        when StoreConfig::PAYMENT_PROCESSOR_STRIPE
+          
+          Stripe.api_key = sc.stripe_secret_key.strip
+          charges = Stripe::Charge.list(:limit => 100, :customer => self.customer.stripe_customer_id)
+          
+          self.financial_status = Invoice::FINANCIAL_STATUS_PENDING                      
+          charges.each do |c|            
+            invoice_id = c.metadata && c.metadata['invoice_id'] ? c.metadata['invoice_id'].to_i : nil            
+            next if invoice_id.nil? || invoice_id != self.id
+            
+            if c.refunded                               then self.financial_status = Invoice::FINANCIAL_STATUS_REFUNDED
+            elsif c.status == 'succeeded' && c.captured then self.financial_status = Invoice::FINANCIAL_STATUS_CAPTURED
+            elsif c.status == 'succeeded'               then self.financial_status = Invoice::FINANCIAL_STATUS_AUTHORIZED            
+            end                                    
+                        
+            auth_trans = InvoiceTransaction.create(
+              :invoice_id => self.id,
+              :transaction_id => c.id,
+              :transaction_type => c.captured ? InvoiceTransaction::TYPE_AUTHCAP : InvoiceTransaction::TYPE_AUTHORIZE, 
+              :amount => c.amount / 100.0,
+              :amount_refunded => c.amount_refunded,
+              :date_processed => DateTime.strptime(c.created.to_s, '%s'),              
+              :success => c.status == 'succeeded',
+              :captured => c.captured,
+              :refunded => c.refunded              
+            )
+            if c.balance_transaction
+              bt = Stripe::BalanceTransaction.retrieve(c.balance_transaction)
+              capture_trans = InvoiceTransaction.create(
+                :invoice_id => self.id,
+                :parent_id => auth_trans.id, 
+                :transaction_id => bt.id,
+                :transaction_type => InvoiceTransaction::TYPE_CAPTURE, 
+                :amount => bt.amount / 100.0,                
+                :date_processed => DateTime.strptime(bt.created.to_s, '%s'),
+                :success => bt.status == 'succeeded' || bt.status == 'pending'
+              )                            
+            end
+            if c.refunds && c.refunds['total_count'] > 0
+              total = 0
+              c.refunds['data'].each do |r|
+                total = total + r.amount
+                InvoiceTransaction.create(
+                  :invoice_id => self.id,
+                  :parent_id => auth_trans.id,
+                  :transaction_id => r.id,
+                  :transaction_type => InvoiceTransaction::TYPE_REFUND, 
+                  :amount => r.amount / 100.0,                
+                  :date_processed => DateTime.strptime(r.created.to_s, '%s'),
+                  :success => r.status == 'succeeded' || r.status == 'pending'
+                )
+              end
+              total = total.to_f / 100
+              if total >= auth_trans.amount
+                auth_trans.refunded = true
+                auth_trans.save
+              end
+            end
+          end
+          self.save
+      end
+    end
+    
+  end
+end
+