caboose-store 0.0.10 → 0.0.11

data/app/models/caboose_store/search_filter.rb

@@ -2,51 +2,41 @@ require 'json'
 
 module CabooseStore
   class SearchFilter < ActiveRecord::Base
-        
-    self.table_name = "store_search_filters"  
-    attr_accessible :id, 
+    self.table_name = 'store_search_filters'
+    
+    attr_accessible :id,
       :url,
       :title_like,
+      :search_like,
       :category_id,
       :category,
-      :vendors, 
+      :vendors,
       :option1,
       :option2,
       :option3,
       :prices
-
+      
     before_save :json_encode
     after_initialize :json_decode
-
+    
     def json_encode
-      self.category = self.category.to_json if !self.category.nil?
-      self.vendors  = self.vendors.to_json  if !self.vendors.nil?        
-      self.option1  = self.option1.to_json  if !self.option1.nil? 
-      self.option2  = self.option2.to_json  if !self.option2.nil? 
-      self.option3  = self.option3.to_json  if !self.option3.nil? 
-      self.prices   = self.prices.to_json   if !self.prices.nil?
+      self.category = self.category.to_json if not self.category.nil?
+      self.vendors  = self.vendors.to_json  if not self.vendors.nil?
+      self.option1  = self.option1.to_json  if not self.option1.nil?
+      self.option2  = self.option2.to_json  if not self.option2.nil?
+      self.option3  = self.option3.to_json  if not self.option3.nil?
+      self.prices   = self.prices.to_json   if not self.prices.nil?
     end
     
     def json_decode
-      if !self.category.nil?
-        cat = JSON.parse(self.category)
-        self.category = Caboose::StdClass.new({
-          'id' => cat['id'],
-          'name' => cat['name'],
-          'children' => cat['children'].collect { |cat2| Caboose::StdClass.new(cat2) }
-        })
-      end
-         
-      #self.category = JSON.parse(self.category).collect{ |hash| Caboose::StdClass.new(hash) } if !self.category.nil?
-      self.vendors  = JSON.parse(self.vendors ).collect{ |hash| Caboose::StdClass.new(hash) } if !self.vendors.nil?
-      self.option1  = JSON.parse(self.option1 ) if !self.option1.nil? 
-      self.option2  = JSON.parse(self.option2 ) if !self.option2.nil? 
-      self.option3  = JSON.parse(self.option3 ) if !self.option3.nil? 
-      self.prices   = JSON.parse self.prices    if !self.prices.nil?
-
-      Caboose.log(self.option1)      
+      self.category = JSON.parse(self.category) if not self.category.nil?
+      self.vendors  = JSON.parse(self.vendors)  if not self.vendors.nil?
+      self.option1  = JSON.parse(self.option1)  if not self.option1.nil?
+      self.option2  = JSON.parse(self.option2)  if not self.option2.nil?
+      self.option3  = JSON.parse(self.option3)  if not self.option3.nil?
+      self.prices   = JSON.parse(self.prices)   if not self.prices.nil?
     end
-      
+    
     def self.exclude_params_from_url(url, exclude_params = nil)
       return url if exclude_params.nil? || exclude_params.count == 0
       
@@ -73,65 +63,54 @@ module CabooseStore
       return url2
     end
     
-    def self.find_from_url(url, pager, exclude_params = nil)
+    def self.find_from_url(url, pager, exclude_params=nil)
       
-      url2 = self.exclude_params_from_url(url, exclude_params)
-      Caboose.log("url2 = #{url2}")
+      # Filter any specified parameters from the url
+      filtered_url = self.exclude_params_from_url(url, exclude_params)
       
-      if SearchFilter.exists?(:url => url2)
-        return SearchFilter.where(:url => url2).first
-      end
-
-      f = SearchFilter.new
-      f.url = url2
-      
-      url2 = url2.split("?")[0] if url2.include?('?')     
-      parent = nil
-      selected_cat_id = nil
-      
-      if Category.exists?(:url => url2)
-        parent = Category.where(:url => url2).first
-        f.category_id = parent.id if parent
-        parent = Category.find(parent.parent_id) if parent && parent.children && parent.children.count == 0
-      elsif pager.params['category_id'] && pager.params['category_id'] != ''
-        cat_id = pager.params['category_id'].kind_of?(Array) ? pager.params['category_id'][0] : pager.params['category_id'] 
-        cat = Category.find(cat_id)
-        parent = cat.parent
-        f.category_id = cat.id if !pager.params['category_id'].kind_of?(Array)
-      elsif pager.params['category_slug'] && pager.params['category_slug'] != ''
-        slug = pager.params['category_slug'].kind_of?(Array) ? pager.params['category_slug'][0] : pager.params['category_slug'] 
-        cat = Category.where(:slug => slug).first
-        parent = cat.parent
-        f.category_id = cat.id if !pager.params['category_slug'].kind_of?(Array)
+      # If the search filter already exists pass it back
+      # return SearchFilter.where(url: pager.options['base_url']) if SearchFilter.exists?(url: pager.options['base_url'])
+      
+      # Create a new search filter
+      search_filter     = SearchFilter.new
+      search_filter.url = filtered_url
+      
+      search_filter.category_id = if pager.params['category_id'].kind_of?(Array)
+        pager.params['category_id'].first
+      else
+        pager.params['category_id']
       end
-      f.category = nil
-      if parent && parent.children && parent.children.count > 0
-        f.category = { 
-          'id'        => parent.id,
-          'name'      => parent.name,
-          'selected'  => parent.id == f.category_id,
-          'children'  => parent.children.collect { |cat| { 
-              'id'       => cat.id, 
-              'name'     => cat.name, 
-              'url'      => cat.url, 
-              'selected' => cat.id == f.category_id 
-            }
-          }
-        }
+      
+      # Grab the category NOTE: A category id is required
+      category = Category.find(search_filter.category_id)
+      
+      # Define the category info
+      search_filter.category         = Hash.new
+      search_filter.category['id']   = category.id
+      search_filter.category['name'] = category.name
+      
+      # Define children categories info
+      search_filter.category['children'] = category.children.collect do |child_category|
+        child         = Hash.new
+        child['id']   = child_category.id
+        child['name'] = child_category.name
+        child['url']  = child_category.url
+        
+        child
       end
-      pager.params['category_id'] = f.category_id if pager.params['category_id'].nil? || pager.params['category_id'] == ''
       
-      f.title_like = pager.params['title_like'] if pager.params['title_like']
-            
-      vendor_ids = []
-      option1 = Caboose::StdClass.new({ 'name' => [], 'values' => [] })
-      option2 = Caboose::StdClass.new({ 'name' => [], 'values' => [] })
-      option3 = Caboose::StdClass.new({ 'name' => [], 'values' => [] })      
+      # Initialize option hashes
+      option1 = { 'name' => [], 'values' => [] }
+      option2 = { 'name' => [], 'values' => [] }
+      option3 = { 'name' => [], 'values' => [] }
+      
+      # Default min an max values
       min = 0.0
       max = 1000000.0
       
-      prices = [
-        [    0,    10],
+      # Set price ranges
+      price_ranges = [
+        [    1,    10],
         [   10,    25],
         [   25,    50],
         [   50,    75],
@@ -148,49 +127,65 @@ module CabooseStore
         [ 4000,  5000],
         [ 7000,  7500],
         [ 7500, 10000],
-        [10000, 50000]                
-      ]      
-      price_counts = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
-      
-      pager.all_items.each do |p|
-        vendor_ids   << p.vendor_id
-        option1.name << p.option1
-        option2.name << p.option2
-        option3.name << p.option3                
-        p.variants.each do |v|
-          option1.values << v.option1
-          option2.values << v.option2
-          option3.values << v.option3          
-          min = v.price if v.price < min
-          max = v.price if v.price > max
-          prices.each_index do |i|
-            minmax = prices[i]
-            price_counts[i] = price_counts[i] + 1 if v.price > minmax[0] && v.price < minmax[1]
+        [10000, 50000]
+      ]
+      
+      # Create an array of the same length as the price ranges to hold a match count
+      price_range_matches = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
+      
+      # Array to hold all relevant vendor IDs
+      vendor_ids = []
+      
+      # Iterate over pager results for product and variant info
+      pager.all_items.each do |product|
+        option1['name'] << product.option1
+        option2['name'] << product.option2
+        option3['name'] << product.option3
+        
+        product.variants.each do |variant|
+          option1['values'] << variant.option1.strip if !variant.option1.nil?
+          option2['values'] << variant.option2.strip if !variant.option2.nil?
+          option3['values'] << variant.option3.strip if !variant.option3.nil?
+          
+          # Iterate over price ranges
+          price_ranges.each_with_index do |price_range, index|
+            min = price_range.first
+            max = price_range.last
+            
+            # Skip to next variant if the price isnt defined or is less than $1
+            next if variant.price.nil? || variant.price < 1
+            
+            # Increment price count at index if the varaint is within the price range
+            if variant.price > min and variant.price < max
+              price_range_matches[index] += 1
+              vendor_ids << product.vendor_id
+            end
           end
         end
       end
       
-      vendor_ids = vendor_ids ? vendor_ids.compact.uniq : nil       
-      f.vendors = vendor_ids && vendor_ids.count > 0 ? vendor_ids.collect { |vid| Vendor.find(vid) } : nil
+      # Grab all active vendors
+      search_filter.vendors = Vendor.where('id IN (?) AND status = ?', vendor_ids.uniq, 'Active')
       
-      option1.name = option1.name ? option1.name.compact.uniq : nil
-      option2.name = option2.name ? option2.name.compact.uniq : nil
-      option3.name = option3.name ? option3.name.compact.uniq : nil
+      # Remove nil and duplicate values from option name arrays
+      option1['name'] = option1['name'].compact.uniq
+      option2['name'] = option2['name'].compact.uniq
+      option3['name'] = option3['name'].compact.uniq
       
-      f.option1 = option1.name && option1.name.count == 1 ? Caboose::StdClass.new({ 'name' => option1.name[0], 'values' => option1.values.compact.uniq.sort }) : nil 
-      f.option2 = option2.name && option2.name.count == 1 ? Caboose::StdClass.new({ 'name' => option2.name[0], 'values' => option2.values.compact.uniq.sort }) : nil 
-      f.option3 = option3.name && option3.name.count == 1 ? Caboose::StdClass.new({ 'name' => option3.name[0], 'values' => option3.values.compact.uniq.sort }) : nil       
+      # ?? If option name array have exactly 1 value then set the search filter's option values
+      search_filter.option1 = if option1['name'].count == 1 then { 'name' => option1['name'][0], 'values' => option1['values'].compact.uniq.sort } else nil end
+      search_filter.option2 = if option2['name'].count == 1 then { 'name' => option2['name'][0], 'values' => option2['values'].compact.uniq.sort } else nil end
+      search_filter.option3 = if option3['name'].count == 1 then { 'name' => option3['name'][0], 'values' => option3['values'].compact.uniq.sort } else nil end
       
-      f.prices = []
-      price_counts.each_index do |i| 
-        f.prices << prices[i] if price_counts[i] > 0
-      end
-      f.prices = nil if f.prices.count == 0
+      # Get all price ranges that have matches
+      search_filter.prices = price_range_matches.collect.with_index { |matches, index| price_ranges[index] if matches > 0 }.compact
       
-      f.save
-      return SearchFilter.find(f.id)
+      # Inject the search filter into the database
+      # search_filter.save
       
+      # Finally, return the filter; NOTE: find out of the database so the hashes get serialized correctly
+      # SearchFilter.find(search_filter.id)
+      return search_filter
     end
-    
   end
 end

data/app/models/caboose_store/shipping_calculator.rb

@@ -3,77 +3,79 @@ include ActiveMerchant::Shipping
 
 module CabooseStore
   class ShippingCalculator
-    
-    # Calculates the total cost of shipping
-    # Providers can be ups, fedex, or usps
-    #
-    # padded envelope,  5 lbs, 90210 =>  $7.62
-    # padded envelope, 20 lbs, 90210 => $13.99
-    # box1           , 20 lbs, 90210 => $20.00
-    # box2           , 30 lbs, 90210 => $25.00
-    def self.rates(order, service_code = nil)
+    def self.rates(order)
+      return [] if CabooseStore::shipping.nil?
       
-      total = 0.0
+      total  = 0.0
       weight = 0.0
+      
       order.line_items.each do |li|
-        total = total + (li.variant.shipping_unit_value.nil? ? 0 : li.variant.shipping_unit_value)
-        weight = weight + li.variant.weight
+        total  = total + (li.variant.shipping_unit_value.nil? ? 0 : li.variant.shipping_unit_value)
+        weight = weight + (li.variant.weight || 0)
       end
-        
+      
       length = 0
       width  = 0
       height = 0
-          
-      if total <= 5 # padded envelope
+      
+      if total <= 5
         length = 15.5
         width  = 9.5
         height = 6
-      elsif total <= 10 # box1
+      elsif total <= 10
         length = 12
         width  = 8
         height = 5
-      else # box2
+      else
         length = 20
         width  = 16
-        height = 14      
+        height = 14
       end
-  
-      origin = Location.new(:country => 'US', :state => 'AL', :city => 'Tuscaloosa', :zip => '35405')
-      destination = Location.new(:country => 'US', :state => order.shipping_address.state, :city => order.shipping_address.city, :postal_code => order.shipping_address.zip)
+      
+      origin = Location.new(
+        :country => CabooseStore::shipping[:origin][:country],
+        :state   => CabooseStore::shipping[:origin][:state],
+        :city    => CabooseStore::shipping[:origin][:city],
+        :zip     => CabooseStore::shipping[:origin][:zip]
+      )
+      
+      destination = Location.new(
+        :country     => CabooseStore::shipping[:origin][:country],
+        :state       => order.shipping_address.state,
+        :city        => order.shipping_address.city,
+        :postal_code => order.shipping_address.zip
+      )
+      
       packages = [Package.new(weight, [length, width, height], :units => :imperial)]
-        
+      
       ups = UPS.new(
-        :key => '7CBEA07A8AA3279A',
-        :login => 'ABBE FINE',
-        :password => '*TuskWear10*',    
-        :origin_account => 'A102Y2'
-        #:login    => Tuskwear::Application.config.shipping[:ups][:login], 
-        #:password => Tuskwear::Application.config.shipping[:ups][:password], 
-        #:key      => Tuskwear::Application.config.shipping[:ups][:key]
+        :key            => CabooseStore::shipping[:ups][:key],
+        :login          => CabooseStore::shipping[:ups][:username],
+        :password       => CabooseStore::shipping[:ups][:password],
+        :origin_account => CabooseStore::shipping[:ups][:origin_account]
       )
-      response = ups.find_rates(origin, destination, packages)
       
-      rates = []	
-  	  response.rates.each do |r|
-  	    next if r.service_code != '03' && r.service_code !='02'
-  	    rates << {
-  	      'service_code'    => r.service_code,
-  	      'service_name'    => r.service_name,
-  	      'total_price'     => r.total_price,
-  	      'negotiated_rate' => r.negotiated_rate # - 300
-  	    }	    
-  	  end
-  	  return rates    
-    end
-    
-    # Return the rate for the given service code
-    def self.rate(order, service_code)
-      self.rates(order).each do |r|
-        next if r['service_code'] != service_code
-        return r
+      ups_response = ups.find_rates(origin, destination, packages)
+      
+      rates = ups_response.rates.collect do |rate|
+        next if CabooseStore::allowed_shipping_codes && !CabooseStore::allowed_shipping_codes.index(rate.service_code)
+        
+        {
+          :service_code    => rate.service_code,
+          :service_name    => rate.service_name,
+          :total_price     => rate.total_price.to_d / 100,
+          :negotiated_rate => rate.negotiated_rate
+        }
       end
-      return nil	            
+      
+      return rates.compact
     end
     
+    def self.rate(order)
+      return nil if !order.shipping_code
+      self.rates(order).each { |rate| return rate if rate[:service_code] == order.shipping_code }
+      return nil
+    end
   end
 end
+

data/app/models/caboose_store/tax_calculator.rb

@@ -1,10 +1,7 @@
-
 module CabooseStore
   class TaxCalculator
-    
-    # Calculates the total cost of shipping
-    # Providers can be ups, fedex, or usps
     def self.tax_rate(address)
+      return 0 if address.state.downcase != 'al'
       city = address.city.downcase
       rate = 0.00
       rate = rate + 0.05 if city == 'brookwood'  
@@ -19,8 +16,7 @@ module CabooseStore
       rate = rate + 0.05 if city == 'vance'      
       rate = rate + 0.05 if city == 'woodstock'  
       rate = rate + 0.04 if address.state.downcase == 'al' || address.state.downcase == 'alabama'        
-      return rate
+      return rate.round(2)
     end
-  
   end
 end

data/app/models/caboose_store/tax_line.rb

@@ -1,12 +1,9 @@
-
 module CabooseStore
-  class TaxLine < ActiveRecord::Base    
-  
+  class TaxLine < ActiveRecord::Base
     attr_accessible :id,
       :title,           # The name of the tax, eg. QST or VAT
       :price,           # The amount
       :rate,            # The rate. It will return 0.175 if it is 17.5%
       :rate_percentage  # The tax rate in human readable form. It will return 17.5 if the rate is 0.175
-      
   end
 end

data/app/models/caboose_store/variant.rb

@@ -1,31 +1,88 @@
+#
+# Variant
+#
+# :: Class Methods
+# :: Instance Methods
 
 module CabooseStore
   class Variant < ActiveRecord::Base
-    self.table_name = "store_variants"
+    self.table_name = 'store_variants'
     
     belongs_to :product
     has_many :product_image_variants
-    has_many :product_images, :through => :product_image_variants    
+    has_many :product_images, :through => :product_image_variants
     
-    attr_accessible :id,      # Variant’s unique id.
+    attr_accessible :id,
+      :alternate_id,
       :product_id,
-      :sku,                   # The variant's SKU.
-      :barcode,               # Returns the barcode value of the variant.
-      :price,                 # Variant’s price.
-      :quantity_in_stock,     # How many of this variants are in stock for this shop.
-      :allow_backorder,       # Whether to allow items with no inventory to be added to the cart    
-      :status,                # Current status: active, inactive, deleted
-      :weight,                # The weight of the variant. This will always be in metric grams.
-      :length,                # Length of variant in inches
-      :width,                 # Width of variant in inches
-      :height,                # Height of variant in inches
-      :option1,               # Returns the value of option1 for given variant
-      :option2,               # If a product has a second option defined, then returns the value of this variant's option2.
-      :option3,               # If a product has a third option defined, then returns the value of this variant's option3.  
-      :requires_shipping,     # Returns true if the variant is shippable or false if it is a service or a digital good.    
-      :taxable                # Returns true if the variant is taxable or false if it is not.
-  
-    # Concatenation of all the variant's option values, joined by " / "
+      :barcode,            # Returns the barcode value of the variant.
+      :price,              # Variant’s price.
+      :ignore_quantity,
+      :quantity,
+      :allow_backorder,    # Whether to allow items with no inventory to be added to the cart    
+      :status,             # Current status: active, inactive, deleted
+      :weight,             # The weight of the variant. This will always be in metric grams.
+      :length,             # Length of variant in inches
+      :width,              # Width of variant in inches
+      :height,             # Height of variant in inches
+      :option1,            # Returns the value of option1 for given variant
+      :option2,            # If a product has a second option defined, then returns the value of this variant's option2.
+      :option3,            # If a product has a third option defined, then returns the value of this variant's option3.  
+      :requires_shipping,  # Returns true if the variant is shippable or false if it is a service or a digital good.    
+      :taxable,            # Returns true if the variant is taxable or false if it is not.
+      :sku,
+      :available,
+      :cylinder,
+      :shipping_unit_value
+    
+    #
+    # Class Methods
+    #
+    
+    def self.find_by_options(product_id, option1=nil, option2=nil, option3=nil)
+      
+      # Create the vars that will become the full conditions statement
+      where  = ['product_id=?']
+      values = [product_id.to_i]
+      
+      # Append option values if they exist
+      
+      if option1
+        where  << 'option1=?'
+        values << option1
+      end
+      
+      if option2
+        where  << 'option2=?'
+        values << option2
+      end
+      
+      if option3
+        where  << 'option3=?'
+        values << option3
+      end
+      
+      # Combine all the options into a single conditions statement
+      conditions = [ where.join(' AND ') ].concat(values)
+      
+      # Return whatever is found
+      return Variant.where(conditions).first
+    end
+    
+    #
+    # Instance Methods
+    #
+    
+    def as_json(options={})
+      self.attributes.merge({
+        :images => if self.product_images.any?
+          self.product_images
+        else
+          [self.product.product_images.first]
+        end
+      })
+    end
+    
     def title
       return self.options.join(' / ')
     end
@@ -37,6 +94,5 @@ module CabooseStore
       arr << self.option3 if self.option3 && self.option3.strip.length > 0
       return arr
     end
-          
   end
 end

data/app/models/caboose_store/vendor.rb

@@ -1,7 +1,22 @@
 
 module CabooseStore
   class Vendor < ActiveRecord::Base
-    self.table_name = "store_vendors"  
-    attr_accessible :id, :name  
+    self.table_name = 'store_vendors'
+    
+    has_many :products
+    attr_accessible :id, :name, :status, :sort_order
+    after_save :clear_filters
+    
+    def self.active
+      where(:status => 'Active')
+    end
+    
+    def update_products
+      self.products.each { |product| product.update_attribute(:vendor_status, self.status) }
+    end
+    
+    def clear_filters
+      SearchFilter.delete_all
+    end
   end
 end

data/app/views/caboose_store/cart/index.html.erb

@@ -1,19 +1,4 @@
+<div class="wrapper">
+  <div id="cart"></div>
+</div>
 
-<div id='cart'></div>
-<%= content_for :caboose_js do %>
-<%= javascript_include_tag 'cart' %>
-<script type='text/javascript'>
-
-var modal = false;
-$(window).load(function() {
-  var line_items = <%= raw Caboose.json(line_items(@order)) %>;
-  var c = new Cart(line_items);
-  c.print();
-  if (c.line_items.length > 0)
-    modal = new CabooseModal(600);
-  else
-    modal = new CabooseModal(400, 50);
-});
-
-</script>
-<% end %>