kylekthompson-shoppe 1.0.7

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

@@ -0,0 +1,20 @@
+module Shoppe
+  class Product < ActiveRecord::Base
+  
+    # Product attributes for this product
+    has_many :product_attributes, -> { order(:position) }, :class_name => 'Shoppe::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/shoppe/product/variants.rb

@@ -0,0 +1,51 @@
+module Shoppe
+  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 => 'Shoppe::Product', :foreign_key => 'parent_id', :dependent => :destroy
+
+    # The parent product (only applies to variants)
+    belongs_to :parent, :class_name => 'Shoppe::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 [Shoppe::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/shoppe/product_attribute.rb

@@ -0,0 +1,66 @@
+module Shoppe
+  class ProductAttribute < ActiveRecord::Base
+  
+    self.table_name = 'shoppe_product_attributes'  
+    
+    # Validations
+    validates :key, :presence => true
+  
+    # The associated product
+    #
+    # @return [Shoppe::Product]
+    belongs_to :product, :class_name => 'Shoppe::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 Shoppe::ProductAttribute.public is deprecated. use Shoppe::ProductAttribute.publicly_accessible.")
+      self.publicly_accessible
+    end
+  
+  end
+end

data/app/models/shoppe/product_categorization.rb

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

data/app/models/shoppe/product_category.rb

@@ -0,0 +1,75 @@
+require 'awesome_nested_set'
+
+module Shoppe
+  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 = '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: 'Shoppe::ProductCategorization', inverse_of: :product_category
+    has_many :products, class_name: 'Shoppe::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/shoppe/setting.rb

@@ -0,0 +1,68 @@
+require 'ostruct'
+
+module Shoppe
+  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("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

data/app/models/shoppe/stock_level_adjustment.rb

@@ -0,0 +1,19 @@
+module Shoppe
+  class StockLevelAdjustment < ActiveRecord::Base
+
+    # The orderable item which the stock level adjustment belongs to
+    belongs_to :item, :polymorphic => true
+
+    # The parent (OrderItem) which the stock level adjustment belongs to
+    belongs_to :parent, :polymorphic => true
+
+    # Validations
+    validates :description, :presence => true
+    validates :adjustment, :numericality => true
+    validate { errors.add(:adjustment, I18n.t('shoppe.activerecord.attributes.stock_level_adjustment.must_be_greater_or_equal_zero')) if adjustment == 0 }
+
+    # All stock level adjustments ordered by their created date desending
+    scope :ordered, -> { order(:id => :desc) }
+
+  end
+end

data/app/models/shoppe/tax_rate.rb

@@ -0,0 +1,46 @@
+module Shoppe
+  class TaxRate < ActiveRecord::Base
+    
+    self.table_name = 'shoppe_tax_rates'
+    
+    include Shoppe::AssociatedCountries
+    
+    # The order address types which may be used when choosing how to apply the tax rate
+    ADDRESS_TYPES = ['billing', 'delivery']
+    
+    # Validations
+    validates :name, :presence => true
+    validates :address_type, :inclusion => {:in => ADDRESS_TYPES}
+    validates :rate, :numericality => true
+    
+    # All products which are assigned to this tax rate
+    has_many :products, :dependent => :restrict_with_exception, :class_name => 'Shoppe::Product'
+    
+    # All delivery service prices which are assigned to this tax rate
+    has_many :delivery_service_prices, :dependent => :restrict_with_exception, :class_name => 'Shoppe::DeliveryServicePrice'
+    
+    # All tax rates ordered by their ID
+    scope :ordered, -> { order(:id)}
+    
+    # Set the address type if appropriate
+    before_validation { self.address_type = ADDRESS_TYPES.first if self.address_type.blank? }
+    
+    # A description of the tax rate including its name & percentage
+    #
+    # @return [String]
+    def description
+      "#{name} (#{rate}%)"
+    end
+    
+    # The rate for a given order based on the rules on the tax rate
+    #
+    # @return [BigDecimal]
+    def rate_for(order)
+      return rate if countries.empty?
+      return rate if address_type == 'billing'  && (order.billing_country.nil?   || country?(order.billing_country))
+      return rate if address_type == 'delivery' && (order.delivery_country.nil?  || country?(order.delivery_country))
+      BigDecimal(0)
+    end
+    
+  end
+end

data/app/models/shoppe/user.rb

@@ -0,0 +1,49 @@
+module Shoppe
+  class User < ActiveRecord::Base
+
+    self.table_name = 'shoppe_users'
+  
+    has_secure_password
+  
+    # Validations
+    validates :first_name, :presence => true
+    validates :last_name, :presence => true
+    validates :email_address, :presence => true
+  
+    # The user's first name & last name concatenated
+    #
+    # @return [String]
+    def full_name
+      "#{first_name} #{last_name}"
+    end
+  
+    # The user's first name & initial of last name concatenated
+    #
+    # @return [String]
+    def short_name
+      "#{first_name} #{last_name[0,1]}"
+    end
+  
+    # Reset the user's password to something random and e-mail it to them
+    def reset_password!
+      self.password = SecureRandom.hex(8)
+      self.password_confirmation = self.password
+      self.save!
+      Shoppe::UserMailer.new_password(self).deliver_now
+    end
+  
+    # Attempt to authenticate a user based on email & password. Returns the 
+    # user if successful otherwise returns false.
+    #
+    # @param email_address [String]
+    # @param paassword [String]
+    # @return [Shoppe::User]
+    def self.authenticate(email_address, password)
+      user = self.where(:email_address => email_address).first
+      return false if user.nil?
+      return false unless user.authenticate(password)
+      user
+    end
+  
+  end
+end

data/app/validators/permalink_validator.rb

@@ -0,0 +1,7 @@
+class PermalinkValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    unless value =~ /\A[A-z0-9\-_]+\Z/
+      record.errors.add(attribute, :wrong_format)
+    end
+  end
+end

data/app/views/layouts/shoppe/application.html.haml

@@ -0,0 +1,34 @@
+!!!
+%html
+  %head
+    %title #{@page_title} - Shoppe
+    = stylesheet_link_tag 'shoppe/application'
+    = javascript_include_tag 'shoppe/application'
+    = csrf_meta_tags
+    :javascript
+      window.Shoppe = {}
+      window.Shoppe.currencyUnit = "#{h Shoppe.settings.currency_unit}";
+  %body
+    %nav.sidebar
+      %header.logo
+        %h1= link_to "Shoppe", root_path
+        %p v#{Shoppe::VERSION}
+      %p.logged= t('.logged_in_as', user_name: current_user.full_name)
+
+      %ul
+        - for item in Shoppe::NavigationManager.find(:admin_primary).items
+          %li= navigation_manager_link item
+
+        %li= link_to t('.logout'), [:logout], :method => :delete
+
+    %header.main
+      = yield :header
+
+    #content
+      = display_flash
+      %section.main
+        = yield
+
+    %footer
+      %p.store= link_to "← #{t('.goto')} #{Shoppe.settings.store_name}".html_safe, '/'
+