caboose-cms 0.4.151 → 0.5.1

data/app/models/caboose/product_image_variant.rb

@@ -0,0 +1,10 @@
+module Caboose
+  class ProductImageVariant < ActiveRecord::Base
+    self.table_name = 'store_product_image_variants'
+    
+    belongs_to :product_image
+    belongs_to :variant
+    
+    attr_accessible :product_image_id, :variant_id
+  end
+end

data/app/models/caboose/review.rb

@@ -0,0 +1,13 @@
+module Caboose
+  class Review < ActiveRecord::Base
+    self.table_name = 'store_reviews'
+    
+    belongs_to :product
+    
+    attr_accessible :id,
+      :product_id,
+      :name,
+      :rating,
+      :content
+  end
+end

data/app/models/caboose/schema.rb

@@ -84,6 +84,23 @@ class Caboose::Schema < Caboose::Utilities::Schema
         [ :ab_variant_id , :integer ],
         [ :ab_option_id  , :integer ]
       ],
+      Caboose::Address => [
+        [ :name          , :string  ],
+        [ :first_name    , :string  ],
+        [ :last_name     , :string  ],
+        [ :street        , :string  ],
+        [ :address1      , :string  ],
+        [ :address2      , :string  ],
+        [ :company       , :string  ],
+        [ :city          , :string  ],
+        [ :state         , :string  ],
+        [ :province      , :string  ],
+        [ :province_code , :string  ],
+        [ :zip           , :string  ],
+        [ :country       , :string  ],
+        [ :country_code  , :string  ],
+        [ :phone         , :string  ]
+      ],
       Caboose::Asset => [
         [ :page_id        , :integer    ],
         [ :user_id        , :integer    ],
@@ -177,18 +194,65 @@ class Caboose::Schema < Caboose::Utilities::Schema
         [ :repeat_count , :integer  ],
         [ :date_end     , :date     ]
       ],
+      Caboose::Category => [        
+        [ :parent_id             , :integer   ],
+        [ :name                  , :string    ],
+        [ :url                   , :string    ],
+        [ :slug                  , :string    ],
+        [ :status                , :string    ],
+        [ :image_file_name       , :string    ],
+        [ :image_content_type    , :string    ],
+        [ :image_file_size       , :integer   ],
+        [ :image_updated_at      , :datetime  ],
+        [ :square_offset_x       , :integer   ],
+        [ :square_offset_y       , :integer   ],
+        [ :square_scale_factor   , :numeric   ],
+        [ :sort_order            , :integer   ]
+      ],
+      Caboose::CategoryMembership => [        
+        [ :category_id           , :integer ],
+        [ :product_id            , :integer ]      
+      ],
+      Caboose::CustomizationMembership => [
+        [ :product_id       , :integer ],
+        [ :customization_id , :integer ]
+      ],
       Caboose::DatabaseSession => [
         [ :session_id  , :string   , :null => false ],
         [ :data        , :text                      ],
         [ :created_at  , :datetime , :null => true  ],
         [ :updated_at  , :datetime , :null => true  ]
       ],
+      Caboose::Discount => [
+        [ :name                  , :string   ],
+        [ :code                  , :string   ],
+        [ :amount_current        , :numeric  ],
+        [ :amount_total          , :numeric  ],
+        [ :amount_flat           , :numeric  ],
+        [ :amount_percentage     , :numeric  ],
+        [ :no_shipping           , :boolean  ],
+        [ :no_tax                , :boolean  ]
+      ],
       Caboose::Domain => [
         [ :site_id            , :integer ],
         [ :domain             , :string  ],
         [ :primary            , :boolean, { :default => false }],
         [ :under_construction , :boolean, { :default => false }]
       ],
+      Caboose::LineItem => [
+        [ :order_id              , :integer  ],
+        [ :variant_id            , :integer  ],
+        [ :parent_id             , :integer  ],
+        [ :quantity              , :integer   , :default => 0 ],
+        [ :status                , :string   ],
+        [ :tracking_number       , :string   ],
+        #[ :unit_price            , :numeric  ],
+        [ :price                 , :numeric   , :default => 0 ],
+        [ :notes                 , :text     ],
+        [ :custom1               , :string   ],
+        [ :custom2               , :string   ],
+        [ :custom3               , :string   ]
+      ],
       Caboose::MediaCategory => [
         [ :parent_id         , :integer ],
         [ :site_id           , :integer ],
@@ -206,6 +270,46 @@ class Caboose::Schema < Caboose::Utilities::Schema
         [ :description       , :text       ],
         [ :file              , :attachment ]
       ],
+      Caboose::Order => [
+        [ :email                 , :string   ],
+        [ :order_number          , :string   ],
+        [ :subtotal              , :numeric   , :default => 0 ],
+        [ :tax                   , :numeric   , :default => 0 ],
+        [ :shipping              , :numeric   , :default => 0 ],
+        [ :handling              , :numeric   , :default => 0 ],
+        [ :discount              , :numeric   , :default => 0 ],
+        [ :total                 , :numeric   , :default => 0 ],
+        [ :customer_id           , :integer  ],
+        [ :payment_id            , :integer  ],
+        [ :gateway_id            , :integer  ],
+        [ :financial_status      , :string   ],
+        [ :shipping_address_id   , :integer  ],
+        [ :billing_address_id    , :integer  ],
+        [ :notes                 , :text     ],
+        [ :status                , :string   ],
+        [ :date_created          , :datetime ],
+        [ :date_authorized       , :datetime ],
+        [ :date_captured         , :datetime ],
+        [ :date_cancelled        , :datetime ],
+        [ :referring_site        , :text     ],
+        [ :landing_page          , :string   ],
+        [ :landing_page_ref      , :string   ],
+        [ :shipping_method       , :string   ],
+        [ :shipping_method_code  , :string   ],
+        [ :transaction_id        , :string   ],
+        [ :auth_code             , :string   ],
+        [ :alternate_id          , :integer  ],
+        [ :auth_amount           , :numeric  ],
+        [ :date_shipped          , :datetime ],
+        [ :transaction_id        , :string   ],
+        [ :transaction_service   , :string   ],
+        [ :amount_discounted     , :numeric  ],
+        [ :decremented           , :boolean  ]
+      ],
+      Caboose::OrderDiscount => [
+        [ :order_id              , :integer ],
+        [ :discount_id           , :integer ]
+      ],
       Caboose::Page => [
         [ :site_id               , :integer ],
         [ :parent_id             , :integer ],
@@ -270,6 +374,51 @@ class Caboose::Schema < Caboose::Utilities::Schema
         [ :post_id          , :integer ],
         [ :post_category_id , :integer ]
       ],
+      Caboose::Product => [
+        [ :alternate_id          , :string    ],
+        [ :title                 , :string    ],
+        [ :caption               , :string    ],
+        [ :description           , :text      ],
+        [ :handle                , :string    ],
+        [ :vendor_id             , :integer   ],
+        [ :option1               , :string    ],
+        [ :option2               , :string    ],
+        [ :option3               , :string    ],
+        [ :category_id           , :integer   ],
+        [ :status                , :string    ],
+        [ :default1              , :string    ],
+        [ :default2              , :string    ],
+        [ :default3              , :string    ],
+        [ :seo_title             , :string    ],
+        [ :seo_description       , :string    ],
+        [ :alternate_id          , :string    ],
+        [ :date_available        , :datetime  ],
+        [ :custom_input          , :text      ],
+        [ :sort_order            , :integer   ],
+        [ :featured              , :boolean   , :default => false ]
+      ],
+      Caboose::ProductImage => [
+        [ :product_id            , :integer  ],
+        [ :title                 , :string   ],
+        [ :position              , :integer  ],
+        [ :image_file_name       , :string   ],
+        [ :image_content_type    , :string   ],
+        [ :image_file_size       , :integer  ],
+        [ :image_updated_at      , :datetime ],
+        [ :square_offset_x       , :integer  ],
+        [ :square_offset_y       , :integer  ],
+        [ :square_scale_factor   , :numeric  ]
+      ],
+      Caboose::ProductImageVariant => [
+        [ :product_image_id      , :integer ],
+        [ :variant_id            , :integer ]
+      ],
+      Caboose::Review => [
+        [ :product_id            , :integer   ],
+        [ :content               , :string    ],
+        [ :name                  , :string    ],
+        [ :rating                , :decimal   ] 
+      ],
       Caboose::Role => [
         [ :parent_id            , :integer  ],
         [ :name                 , :string   ],
@@ -283,6 +432,18 @@ class Caboose::Schema < Caboose::Utilities::Schema
 	    	[ :role_id        , :integer ],
 	    	[ :permission_id  , :integer ]
 	    ],
+	    Caboose::SearchFilter => [
+        [ :url                   , :string   ],
+        [ :title_like            , :string   ],
+        [ :search_like           , :string   ],
+        [ :category_id           , :integer  ],
+        [ :category              , :text     ],
+        [ :vendors               , :text     ],
+        [ :option1               , :text     ],
+        [ :option2               , :text     ],
+        [ :option3               , :text     ],        
+        [ :prices                , :text     ] 
+      ],
       Caboose::Setting => [
         [ :name  , :string ],
         [ :value , :text   ]
@@ -325,7 +486,40 @@ class Caboose::Schema < Caboose::Utilities::Schema
         [ :password_reset_sent  , :datetime   ],
         [ :token                , :string     ],
         [ :date_created         , :datetime   ],
-        [ :image                , :attachment ]
+        [ :image                , :attachment ],
+        [ :is_guest             , :boolean    , { :default => false }]
+      ],
+      Caboose::Variant => [
+        [ :sku                   , :string   ],
+        [ :barcode               , :string   ],
+        [ :price                 , :numeric   , :default => 0 ],
+        [ :available             , :boolean  ],
+        #[ :quantity_in_stock     , :integer  ],
+        [ :quantity              , :integer   , :default => 0 ],
+        [ :ignore_quantity       , :boolean  ],
+        [ :allow_backorder       , :boolean  ],
+        [ :weight                , :decimal  ],
+        [ :length                , :decimal  ],
+        [ :width                 , :decimal  ],
+        [ :height                , :decimal  ],
+        [ :cylinder              , :boolean  ],
+        [ :option1               , :string   ],
+        [ :option2               , :string   ],
+        [ :option3               , :string   ],
+        [ :requires_shipping     , :boolean  ],
+        [ :taxable               , :boolean  ],
+        [ :product_id            , :integer  ],
+        [ :shipping_unit_value   , :numeric  ],
+        [ :alternate_id          , :string   ],
+        [ :status                , :string   ],
+        [ :option1_sort_order    , :integer  , { :defult => 0 }],
+        [ :option2_sort_order    , :integer  , { :defult => 0 }],
+        [ :option3_sort_order    , :integer  , { :defult => 0 }],
+        [ :sort_order            , :integer  , { :defult => 0 }]
+      ],
+      Caboose::Vendor => [
+        [ :name   , :string ],
+        [ :status , :string, { default: 'Active' } ]
       ]
     }
 
@@ -483,6 +677,16 @@ class Caboose::Schema < Caboose::Utilities::Schema
       cat = Caboose::MediaCategory.where("parent_id is null and site_id = ? and name = ?", site.id, 'Files').first
       Caboose::MediaCategory.create(:site_id => site.id, :name => 'Files') if cat.nil?
     end
+    
+    # Make sure a default category exists for all products
+    if !Caboose::Category.exists?(1)
+      Caboose::Category.create({
+        :id   => 1,
+        :name => 'All Products',
+        :url  => '/products',
+        :slug => 'products'
+      })
+    end
 
   end
 end

data/app/models/caboose/search_filter.rb

@@ -0,0 +1,191 @@
+require 'json'
+
+module Caboose
+  class SearchFilter < ActiveRecord::Base
+    self.table_name = 'store_search_filters'
+    
+    attr_accessible :id,
+      :url,
+      :title_like,
+      :search_like,
+      :category_id,
+      :category,
+      :vendors,
+      :option1,
+      :option2,
+      :option3,
+      :prices
+      
+    before_save :json_encode
+    after_initialize :json_decode
+    
+    def json_encode
+      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
+      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
+      
+      url2 = "#{url}"
+      url2[0] = '' if url2.starts_with?('/')
+      
+      if Caboose.use_url_params
+        arr = url2.split('/')
+        arr2 = []
+        i = arr.count - 1
+        while i >= 1 do
+          k = arr[i-1]
+          v = arr[i]
+          arr2 << "#{k}/#{v}" if !exclude_params.include?(k)
+          i = i - 2
+        end
+        arr2 << arr[0] if i == 0
+        url2 = arr2.reverse.join('/')
+      else
+        # TODO: Handle removing parameters from the querystring
+      end        
+      
+      url2 = "/#{url2}" if !url2.starts_with?('/')
+      return url2
+    end
+    
+    def self.find_from_url(url, pager, exclude_params=nil)
+      
+      # Filter any specified parameters from the url
+      filtered_url = self.exclude_params_from_url(url, exclude_params)
+      
+      # 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
+      
+      # 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
+      
+      # Initialize option hashes
+      option1 = { 'name' => [], 'values' => [] }
+      option2 = { 'name' => [], 'values' => [] }
+      option3 = { 'name' => [], 'values' => [] }
+      
+      # Default min an max values
+      min = 0.0
+      max = 1000000.0
+      
+      # Set price ranges
+      price_ranges = [
+        [    1,    10],
+        [   10,    25],
+        [   25,    50],
+        [   50,    75],
+        [   75,   100],
+        [  100,   150],
+        [  150,   200],
+        [  200,   250],
+        [  250,   300],
+        [  300,   400],
+        [  400,   500],
+        [  500,  1000],
+        [ 1000,  2000],
+        [ 2000,  3000],
+        [ 4000,  5000],
+        [ 7000,  7500],
+        [ 7500, 10000],
+        [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
+      
+      # Grab all active vendors
+      search_filter.vendors = Vendor.where('id IN (?) AND status = ?', vendor_ids.uniq, 'Active')
+      
+      # 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
+      
+      # ?? 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
+      
+      # 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
+      
+      # 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