kylekthompson_shoppe 1.0.7

data/app/models/kylekthompson_shoppe/product/product_attributes.rb

@@ -0,0 +1,20 @@
+module KylekthompsonShoppe
+  class Product < ActiveRecord::Base
+  
+    # Product attributes for this product
+    has_many :product_attributes, -> { order(:position) }, :class_name => 'KylekthompsonShoppe::ProductAttribute'
+  
+    # Used for setting an array of product attributes which will be updated. Usually
+    # received from a web browser.
+    attr_accessor :product_attributes_array
+    
+    # After saving automatically try to update the product attributes based on the
+    # the contents of the product_attributes_array array.
+    after_save do
+      if product_attributes_array.is_a?(Array)
+        self.product_attributes.update_from_array(product_attributes_array)
+      end
+    end
+  
+  end
+end

data/app/models/kylekthompson_shoppe/product/variants.rb

@@ -0,0 +1,51 @@
+module KylekthompsonShoppe
+  class Product < ActiveRecord::Base
+
+    # Validations
+    validate { errors.add :base, :can_belong_to_root if self.parent && self.parent.parent }
+
+    # Variants of the product
+    has_many :variants, :class_name => 'KylekthompsonShoppe::Product', :foreign_key => 'parent_id', :dependent => :destroy
+
+    # The parent product (only applies to variants)
+    belongs_to :parent, :class_name => 'KylekthompsonShoppe::Product', :foreign_key => 'parent_id'
+
+    # All products which are not variants
+    scope :root, -> { where(:parent_id => nil) }
+
+    # If a variant is created, the base product should be updated so that it doesn't have stock control enabled
+    after_save do
+      if self.parent
+        self.parent.price = 0
+        self.parent.cost_price = 0
+        self.parent.tax_rate = nil
+        self.parent.weight = 0
+        self.parent.stock_control = false
+        self.parent.save if self.parent.changed?
+      end
+    end
+
+    # Does this product have any variants?
+    #
+    # @return [Boolean]
+    def has_variants?
+      !variants.empty?
+    end
+
+    # Returns the default variant for the product or nil if none exists.
+    #
+    # @return [KylekthompsonShoppe::Product]
+    def default_variant
+      return nil if self.parent
+      @default_variant ||= self.variants.select { |v| v.default? }.first
+    end
+
+    # Is this product a variant of another?
+    #
+    # @return [Boolean]
+    def variant?
+      !self.parent_id.blank?
+    end
+
+  end
+end

data/app/models/kylekthompson_shoppe/product.rb

@@ -0,0 +1,189 @@
+require "roo"
+require "globalize"
+
+module KylekthompsonShoppe
+  class Product < ActiveRecord::Base
+
+    self.table_name = 'kylekthompson_shoppe_products'
+
+    # Add dependencies for products
+    require_dependency 'kylekthompson_shoppe/product/product_attributes'
+    require_dependency 'kylekthompson_shoppe/product/variants'
+
+    # Products have a default_image and a data_sheet
+    attachment :default_image
+    attachment :data_sheet
+
+    # The product's categorizations
+    #
+    # @return [KylekthompsonShoppe::ProductCategorization]
+    has_many :product_categorizations, dependent: :destroy, class_name: 'KylekthompsonShoppe::ProductCategorization', inverse_of: :product
+    # The product's categories
+    #
+    # @return [KylekthompsonShoppe::ProductCategory]
+    has_many :product_categories, class_name: 'KylekthompsonShoppe::ProductCategory', through: :product_categorizations
+
+    # The product's tax rate
+    #
+    # @return [KylekthompsonShoppe::TaxRate]
+    belongs_to :tax_rate, :class_name => "KylekthompsonShoppe::TaxRate"
+
+    # Ordered items which are associated with this product
+    has_many :order_items, :dependent => :restrict_with_exception, :class_name => 'KylekthompsonShoppe::OrderItem', :as => :ordered_item
+
+    # Orders which have ordered this product
+    has_many :orders, :through => :order_items, :class_name => 'KylekthompsonShoppe::Order'
+
+    # Stock level adjustments for this product
+    has_many :stock_level_adjustments, :dependent => :destroy, :class_name => 'KylekthompsonShoppe::StockLevelAdjustment', :as => :item
+
+    # Validations
+    with_options :if => Proc.new { |p| p.parent.nil? } do |product|
+      product.validate :has_at_least_one_product_category
+      product.validates :description, :presence => true
+      product.validates :short_description, :presence => true
+    end
+    validates :name, :presence => true
+    validates :permalink, :presence => true, :uniqueness => true, :permalink => true
+    validates :sku, :presence => true
+    validates :weight, :numericality => true
+    validates :price, :numericality => true
+    validates :cost_price, :numericality => true, :allow_blank => true
+
+    # Before validation, set the permalink if we don't already have one
+    before_validation { self.permalink = self.name.parameterize if self.permalink.blank? && self.name.is_a?(String) }
+
+    # All active products
+    scope :active, -> { where(:active => true) }
+
+    # All featured products
+    scope :featured, -> {where(:featured => true)}
+
+    # Localisations
+    translates :name, :permalink, :description, :short_description
+    scope :ordered, -> { includes(:translations).order(:name) }
+
+    # Return the name of the product
+    #
+    # @return [String]
+    def full_name
+      self.parent ? "#{self.parent.name} (#{name})" : name
+    end
+
+    # Is this product orderable?
+    #
+    # @return [Boolean]
+    def orderable?
+      return false unless self.active?
+      return false if self.has_variants?
+      true
+    end
+
+    # The price for the product
+    #
+    # @return [BigDecimal]
+    def price
+      # self.default_variant ? self.default_variant.price : read_attribute(:price)
+      self.default_variant ? self.default_variant.price : read_attribute(:price)
+    end
+
+    # Is this product currently in stock?
+    #
+    # @return [Boolean]
+    def in_stock?
+      self.default_variant ? self.default_variant.in_stock? : (stock_control? ? stock > 0 : true)
+    end
+
+    # Return the total number of items currently in stock
+    #
+    # @return [Fixnum]
+    def stock
+      self.stock_level_adjustments.sum(:adjustment)
+    end
+
+    # Return the first product category
+    #
+    # @return [KylekthompsonShoppe::ProductCategory]
+    def product_category
+      self.product_categories.first rescue nil
+    end
+
+    # Search for products which include the given attributes and return an active record
+    # scope of these products. Chainable with other scopes and with_attributes methods.
+    # For example:
+    #
+    #   KylekthompsonShoppe::Product.active.with_attribute('Manufacturer', 'Apple').with_attribute('Model', ['Macbook', 'iPhone'])
+    #
+    # @return [Enumerable]
+    def self.with_attributes(key, values)
+      product_ids = KylekthompsonShoppe::ProductAttribute.searchable.where(:key => key, :value => values).pluck(:product_id).uniq
+      where(:id => product_ids)
+    end
+
+    # Imports products from a spreadsheet file
+    # Example:
+    #
+    #   KylekthompsonShoppe:Product.import("path/to/file.csv")
+    def self.import(file)
+      spreadsheet = open_spreadsheet(file)
+      spreadsheet.default_sheet = spreadsheet.sheets.first
+      header = spreadsheet.row(1)
+      (2..spreadsheet.last_row).each do |i|
+        row = Hash[[header, spreadsheet.row(i)].transpose]
+
+        # Don't import products where the name is blank
+        unless row["name"].nil?
+          if product = find_by(name: row["name"])
+            # Dont import products with the same name but update quantities if they're not the same
+            qty = row["qty"].to_i
+            if qty > 0 && qty != product.stock
+              product.stock_level_adjustments.create!(description: I18n.t('kylekthompson_shoppe.import'), adjustment: qty)
+            end
+          else
+            product = new
+            product.name = row["name"]
+            product.sku = row["sku"]
+            product.description = row["description"]
+            product.short_description = row["short_description"]
+            product.weight = row["weight"]
+            product.price = row["price"].nil? ? 0 : row["price"]
+            product.permalink  = row["permalink"]
+
+            product.product_categories << begin
+              if KylekthompsonShoppe::ProductCategory.find_by(name: row["category_name"]).present?
+                KylekthompsonShoppe::ProductCategory.find_by(name: row["category_name"])
+              else
+                KylekthompsonShoppe::ProductCategory.create(name: row["category_name"])
+              end
+            end
+
+            product.save!
+
+            qty = row["qty"].to_i
+            if qty > 0
+              product.stock_level_adjustments.create!(description: I18n.t('kylekthompson_shoppe.import'), adjustment: qty)
+            end
+          end
+        end
+      end
+    end
+
+    def self.open_spreadsheet(file)
+      case File.extname(file.original_filename)
+      when ".csv" then Roo::CSV.new(file.path)
+      when ".xls" then Roo::Excel.new(file.path)
+      when ".xlsx" then Roo::Excelx.new(file.path)
+      else raise I18n.t('kylekthompson_shoppe.imports.errors.unknown_format', filename: File.original_filename)
+      end
+    end
+
+    private
+
+    # Validates
+
+    def has_at_least_one_product_category
+      errors.add(:base, 'must add at least one product category') if self.product_categories.blank?
+    end
+
+  end
+end

data/app/models/kylekthompson_shoppe/product_attribute.rb

@@ -0,0 +1,66 @@
+module KylekthompsonShoppe
+  class ProductAttribute < ActiveRecord::Base
+  
+    self.table_name = 'kylekthompson_shoppe_product_attributes'  
+    
+    # Validations
+    validates :key, :presence => true
+  
+    # The associated product
+    #
+    # @return [KylekthompsonShoppe::Product]
+    belongs_to :product, :class_name => 'KylekthompsonShoppe::Product'
+  
+    # All attributes which are searchable
+    scope :searchable, -> { where(:searchable => true) }
+    
+    # All attributes which are public
+    scope :publicly_accessible, -> { where(:public => true) }
+  
+    # Return the the available options as a hash
+    #
+    # @return [Hash]
+    def self.grouped_hash
+      all.group_by(&:key).inject(Hash.new) do |h, (key, attributes)|
+        h[key] = attributes.map(&:value).uniq
+        h
+      end
+    end
+  
+    # Create/update attributes for a product based on the provided hash of
+    # keys & values.
+    #
+    # @param array [Array]
+    def self.update_from_array(array)
+      existing_keys = self.pluck(:key)
+      index = 0
+      array.each do |hash|
+        next if hash['key'].blank?
+        index += 1
+        params = hash.merge({
+          :searchable => hash['searchable'].to_s == '1',
+          :public => hash['public'].to_s == '1',
+          :position => index
+        })
+        if existing_attr = self.where(:key => hash['key']).first
+          if hash['value'].blank?
+            existing_attr.destroy
+            index -= 1
+          else
+            existing_attr.update_attributes(params)
+          end
+        else
+          attribute = self.create(params)
+        end
+      end
+      self.where(:key => existing_keys - array.map { |h| h['key']}).delete_all
+      true
+    end
+    
+    def self.public
+      ActiveSupport::Deprecation.warn("The use of KylekthompsonShoppe::ProductAttribute.public is deprecated. use KylekthompsonShoppe::ProductAttribute.publicly_accessible.")
+      self.publicly_accessible
+    end
+  
+  end
+end

data/app/models/kylekthompson_shoppe/product_categorization.rb

@@ -0,0 +1,14 @@
+module KylekthompsonShoppe
+  class ProductCategorization < ActiveRecord::Base
+  
+    self.table_name = 'kylekthompson_shoppe_product_categorizations'
+
+    # Links back 
+    belongs_to :product, class_name: 'KylekthompsonShoppe::Product'
+    belongs_to :product_category, class_name: 'KylekthompsonShoppe::ProductCategory'
+    
+    # Validations
+    validates_presence_of :product, :product_category
+
+  end
+end

data/app/models/kylekthompson_shoppe/product_category.rb

@@ -0,0 +1,75 @@
+require 'awesome_nested_set'
+
+module KylekthompsonShoppe
+  class ProductCategory < ActiveRecord::Base
+
+    # Allow the nesting of product categories
+    # :restrict_with_exception relies on a fix to the awesome_nested_set gem
+    # which has been referenced in the Gemfile as we can't add a dependency
+    # to a branch in the .gemspec
+    acts_as_nested_set  dependent: :restrict_with_exception,
+                        after_move: :set_ancestral_permalink
+
+    self.table_name = 'kylekthompson_shoppe_product_categories'
+
+    # Categories have an image attachment
+    attachment :image
+
+    # All products within this category
+    has_many :product_categorizations, dependent: :restrict_with_exception, class_name: 'KylekthompsonShoppe::ProductCategorization', inverse_of: :product_category
+    has_many :products, class_name: 'KylekthompsonShoppe::Product', through: :product_categorizations
+
+    # Validations
+    validates :name, :presence => true
+    validates :permalink, :presence => true, :uniqueness => {scope: :parent_id}, :permalink => true
+
+    # Root (no parent) product categories only
+    scope :without_parent, -> { where(parent_id: nil) }
+
+    # No descendents
+    scope :except_descendants, ->(record) { where.not(id: (Array.new(record.descendants) << record).flatten) }
+
+    translates :name, :permalink, :description, :short_description
+    scope :ordered, -> { includes(:translations).order(:name) }
+    
+    # Set the permalink on callback
+    before_validation :set_permalink, :set_ancestral_permalink
+    after_save :set_child_permalinks
+
+    def combined_permalink
+      if self.permalink_includes_ancestors && self.ancestral_permalink.present?
+        "#{self.ancestral_permalink}/#{self.permalink}"
+      else
+        self.permalink
+      end
+    end
+
+    # Return array with all the product category parents hierarchy
+    # in descending order
+    def hierarchy_array
+      return [self] unless parent
+      parent.hierarchy_array.concat [self]
+    end
+
+    private
+
+    def set_permalink
+      self.permalink = self.name.parameterize if self.permalink.blank? && self.name.is_a?(String)
+    end
+
+    def set_ancestral_permalink
+      permalinks = Array.new
+      self.ancestors.each do |category|
+        permalinks << category.permalink
+      end
+      self.ancestral_permalink = permalinks.join '/'
+    end
+
+    def set_child_permalinks
+      self.children.each do |category|
+        category.save!  # save forces children to update their ancestral_permalink
+      end
+    end
+
+  end
+end

data/app/models/kylekthompson_shoppe/setting.rb

@@ -0,0 +1,68 @@
+require 'ostruct'
+
+module KylekthompsonShoppe
+  class Setting < ActiveRecord::Base
+    
+    # Validations
+    validates :key, :presence => true, :uniqueness => true
+    validates :value, :presence => true
+    validates :value_type, :presence => true
+    
+    before_validation do
+      self.value_type = I18n.t("kylekthompson_shoppe.settings.types")[self.key.to_sym].try(:capitalize) || self.value.class.to_s
+      self.value      = encoded_value
+    end
+    
+    # The encoded value for saving in the backend (as a string)
+    #
+    # @return [String]
+    def encoded_value
+      case value_type
+      when 'Array', 'Hash'  then  value.to_json
+      when 'Boolean'        then  value.to_s == 'true' ? 'true' : 'false'
+      else                        value.to_s
+      end
+    end
+    
+    # The decoded value for the setting attribute (in it's native type)
+    #
+    # @return [Object]
+    def decoded_value
+      case value_type
+      when 'Fixnum'         then  value.to_i
+      when 'Float'          then  value.to_f
+      when 'Array', 'Hash'  then  JSON.parse(value)
+      when 'Boolean'        then  value == 'true' ? true : false
+      else                        value.to_s
+      end
+    end
+    
+    # A full hash of all settings available in the current scope
+    #
+    # @return [Hash]
+    def self.to_hash
+      all.inject({}) do |h, setting|
+        h[setting.key.to_s] = setting.decoded_value
+        h
+      end
+    end
+    
+    # Update settings from a given hash and persist them. Accepts a 
+    # hash of keys (which should be strings).
+    #
+    # @return [Hash]
+    def self.update_from_hash(hash)
+      existing_settings = self.all.to_a
+      hash.each do |key, value|
+        existing = existing_settings.select { |s| s.key.to_s == key.to_s }.first
+        if existing
+          value.blank? ? existing.destroy! : existing.update!(:value => value)
+        else
+          value.blank? ? nil : self.create!(:key => key, :value => value)
+        end
+      end
+      hash
+    end
+    
+  end
+end