kkt_shoppe 1.1.0

data/app/models/kkt_shoppe/order_item.rb

@@ -0,0 +1,239 @@
+module KktShoppe
+  class OrderItem < ActiveRecord::Base
+
+    self.table_name = 'kkt_shoppe_order_items'
+
+    # The associated order
+    #
+    # @return [KktShoppe::Order]
+    belongs_to :order, :class_name => 'KktShoppe::Order', :touch => true, :inverse_of => :order_items
+
+    # The item which has been ordered
+    belongs_to :ordered_item, :polymorphic => true
+
+    # Any stock level adjustments which have been made for this order item
+    has_many :stock_level_adjustments, :as => :parent, :dependent => :nullify, :class_name => 'KktShoppe::StockLevelAdjustment'
+
+    # Validations
+    validates :quantity, :numericality => true
+    validates :ordered_item, :presence => true
+
+    validate do
+      unless in_stock?
+        errors.add :quantity, :too_high_quantity
+      end
+    end
+
+    # Before saving an order item which belongs to a received order, cache the pricing again if appropriate.
+    before_save do
+      if order.received? && (unit_price_changed? || unit_cost_price_changed? || tax_rate_changed? || tax_amount_changed?)
+        cache_pricing
+      end
+    end
+
+    # After saving, if the order has been shipped, reallocate stock appropriate
+    after_save do
+      if order.shipped?
+        allocate_unallocated_stock!
+      end
+    end
+
+    # This allows you to add a product to the scoped order. For example Order.first.order_items.add_product(...).
+    # This will either increase the quantity of the value in the order or create a new item if one does not
+    # exist already.
+    #
+    # @param ordered_item [Object] an object which implements the KktShoppe::OrderableItem protocol
+    # @param quantity [Fixnum] the number of items to order
+    # @return [KktShoppe::OrderItem]
+    def self.add_item(ordered_item, quantity = 1)
+      raise Errors::UnorderableItem, :ordered_item => ordered_item unless ordered_item.orderable?
+      transaction do
+        if existing = self.where(:ordered_item_id => ordered_item.id, :ordered_item_type => ordered_item.class.to_s).first
+          existing.increase!(quantity)
+          existing
+        else
+          new_item = self.create(:ordered_item => ordered_item, :quantity => 0)
+          new_item.increase!(quantity)
+          new_item
+        end
+      end
+    end
+
+    # Remove a product from an order. It will also ensure that the order's custom delivery
+    # service is updated if appropriate.
+    #
+    # @return [KktShoppe::OrderItem]
+    def remove
+      transaction do
+        self.destroy!
+        self.order.remove_delivery_service_if_invalid
+        self
+      end
+    end
+
+    # Increases the quantity of items in the order by the number provided. Will raise an error if we don't have
+    # the stock to do this.
+    #
+    # @param quantity [Fixnum]
+    def increase!(amount = 1)
+      transaction do
+        self.quantity += amount
+        unless self.in_stock?
+          raise KktShoppe::Errors::NotEnoughStock, :ordered_item => self.ordered_item, :requested_stock => self.quantity
+        end
+        self.save!
+        self.order.remove_delivery_service_if_invalid
+      end
+    end
+
+    # Decreases the quantity of items in the order by the number provided.
+    #
+    # @param amount [Fixnum]
+    def decrease!(amount = 1)
+      transaction do
+        self.quantity -= amount
+        self.quantity == 0 ? self.destroy : self.save!
+        self.order.remove_delivery_service_if_invalid
+      end
+    end
+
+    # The total weight of the item
+    #
+    # @return [BigDecimal]
+    def weight
+      read_attribute(:weight) || ordered_item.try(:weight) || BigDecimal(0)
+    end
+
+    # Return the total weight of the item
+    #
+    # @return [BigDecimal]
+    def total_weight
+      quantity * weight
+    end
+
+    # The unit price for the item
+    #
+    # @return [BigDecimal]
+    def unit_price
+      read_attribute(:unit_price) || ordered_item.try(:price) || BigDecimal(0)
+    end
+
+    # The cost price for the item
+    #
+    # @return [BigDecimal]
+    def unit_cost_price
+      read_attribute(:unit_cost_price) || ordered_item.try(:cost_price) || BigDecimal(0)
+    end
+
+    # The tax rate for the item
+    #
+    # @return [BigDecimal]
+    def tax_rate
+      read_attribute(:tax_rate) || ordered_item.try(:tax_rate).try(:rate_for, self.order) || BigDecimal(0)
+    end
+
+    # The total tax for the item
+    #
+    # @return [BigDecimal]
+    def tax_amount
+      read_attribute(:tax_amount) || (self.sub_total / BigDecimal(100)) * self.tax_rate
+    end
+
+    # The total cost for the product
+    #
+    # @return [BigDecimal]
+    def total_cost
+      quantity * unit_cost_price
+    end
+
+    # The sub total for the product
+    #
+    # @return [BigDecimal]
+    def sub_total
+      quantity * unit_price
+    end
+
+    # The total price including tax for the order line
+    #
+    # @return [BigDecimal]
+    def total
+      tax_amount + sub_total
+    end
+
+    # Cache the pricing for this order item
+    def cache_pricing
+      write_attribute :weight, self.weight
+      write_attribute :unit_price, self.unit_price
+      write_attribute :unit_cost_price, self.unit_cost_price
+      write_attribute :tax_rate, self.tax_rate
+    end
+
+    # Cache the pricing for this order item and save
+    def cache_pricing!
+      cache_pricing
+      save!
+    end
+
+    # Trigger when the associated order is confirmed. It handles caching the values
+    # of the monetary items and allocating stock as appropriate.
+    def confirm!
+      cache_pricing!
+      allocate_unallocated_stock!
+    end
+
+    # Trigger when the associated order is accepted
+    def accept!
+    end
+
+    # Trigged when the associated order is rejected..
+    def reject!
+      self.stock_level_adjustments.destroy_all
+    end
+
+    # Do we have the stock needed to fulfil this order?
+    #
+    # @return [Boolean]
+    def in_stock?
+      if self.ordered_item && self.ordered_item.stock_control?
+        self.ordered_item.stock >= unallocated_stock
+      else
+        true
+      end
+    end
+
+    # How much stock remains to be allocated for this order?
+    #
+    # @return [Fixnum]
+    def unallocated_stock
+      self.quantity - allocated_stock
+    end
+
+    # How much stock has been allocated to this item?
+    #
+    # @return [Fixnum]
+    def allocated_stock
+      0 - self.stock_level_adjustments.sum(:adjustment)
+    end
+
+    # Validate the stock level against the product and update as appropriate. This method will be executed
+    # before an order is completed. If we have run out of this product, we will update the quantity to an
+    # appropriate level (or remove the order item) and return the object.
+    def validate_stock_levels
+      if in_stock?
+        false
+      else
+        self.quantity = self.ordered_item.stock
+        self.quantity == 0 ? self.destroy : self.save!
+        self
+      end
+    end
+
+    # Allocate any unallocated stock for this order item. There is no return value.
+    def allocate_unallocated_stock!
+      if self.ordered_item.stock_control? && self.unallocated_stock != 0
+        self.ordered_item.stock_level_adjustments.create!(:parent => self, :adjustment => 0 - self.unallocated_stock, :description => "Order ##{self.order.number}")
+      end
+    end
+
+  end
+end

data/app/models/kkt_shoppe/payment.rb

@@ -0,0 +1,86 @@
+module KktShoppe
+  class Payment < ActiveRecord::Base
+
+    # Additional callbacks
+    extend ActiveModel::Callbacks
+    define_model_callbacks :refund
+
+    # The associated order
+    #
+    # @return [KktShoppe::Order]
+    belongs_to :order, :class_name => 'KktShoppe::Order'
+
+    # An associated payment (only applies to refunds)
+    #
+    # @return [KktShoppe::Payment]
+    belongs_to :parent, :class_name => "KktShoppe::Payment", :foreign_key => "parent_payment_id"
+
+    # Validations
+    validates :amount, :numericality => true
+    validates :reference, :presence => true
+    validates :method, :presence => true
+
+    # Payments can have associated properties
+    key_value_store :properties
+
+    # Callbacks
+    after_create :cache_amount_paid
+    after_destroy :cache_amount_paid
+    before_destroy { self.parent.update_attribute(:amount_refunded, self.parent.amount_refunded + amount) if self.parent }
+
+    # Is this payment a refund?
+    #
+    # @return [Boolean]
+    def refund?
+      self.amount < BigDecimal(0)
+    end
+
+    # Has this payment had any refunds taken from it?
+    #
+    # @return [Boolean]
+    def refunded?
+      self.amount_refunded > BigDecimal(0)
+    end
+
+    # How much of the payment can be refunded
+    #
+    # @return [BigDecimal]
+    def refundable_amount
+      refundable? ? (self.amount - self.amount_refunded) : BigDecimal(0)
+    end
+
+    # Process a refund from this payment.
+    #
+    # @param amount [String] the amount which should be refunded
+    # @return [Boolean]
+    def refund!(amount)
+      run_callbacks :refund do
+        amount = BigDecimal(amount)
+        if refundable_amount >= amount
+          transaction do
+            self.class.create(:parent => self, :order_id => self.order_id, :amount => 0-amount, :method => self.method, :reference => reference)
+            self.update_attribute(:amount_refunded, self.amount_refunded + amount)
+            true
+          end
+        else
+          raise KktShoppe::Errors::RefundFailed, :message => I18n.t('.refund_failed', refundable_amount: refundable_amount)
+        end
+      end
+    end
+
+    # Return a transaction URL for viewing further information about this
+    # payment.
+    #
+    # @return [String]
+    def transaction_url
+      nil
+    end
+
+    private
+
+    def cache_amount_paid
+      self.order.update_attribute(:amount_paid, self.order.payments.sum(:amount))
+    end
+
+  end
+end

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

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

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

@@ -0,0 +1,189 @@
+require "roo"
+require "globalize"
+
+module KktShoppe
+  class Product < ActiveRecord::Base
+
+    self.table_name = 'kkt_shoppe_products'
+
+    # Add dependencies for products
+    require_dependency 'kkt_shoppe/product/product_attributes'
+    require_dependency 'kkt_shoppe/product/variants'
+
+    # Products have a default_image and a data_sheet
+    attachment :default_image
+    attachment :data_sheet
+
+    # The product's categorizations
+    #
+    # @return [KktShoppe::ProductCategorization]
+    has_many :product_categorizations, dependent: :destroy, class_name: 'KktShoppe::ProductCategorization', inverse_of: :product
+    # The product's categories
+    #
+    # @return [KktShoppe::ProductCategory]
+    has_many :product_categories, class_name: 'KktShoppe::ProductCategory', through: :product_categorizations
+
+    # The product's tax rate
+    #
+    # @return [KktShoppe::TaxRate]
+    belongs_to :tax_rate, :class_name => "KktShoppe::TaxRate"
+
+    # Ordered items which are associated with this product
+    has_many :order_items, :dependent => :restrict_with_exception, :class_name => 'KktShoppe::OrderItem', :as => :ordered_item
+
+    # Orders which have ordered this product
+    has_many :orders, :through => :order_items, :class_name => 'KktShoppe::Order'
+
+    # Stock level adjustments for this product
+    has_many :stock_level_adjustments, :dependent => :destroy, :class_name => 'KktShoppe::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 [KktShoppe::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:
+    #
+    #   KktShoppe::Product.active.with_attribute('Manufacturer', 'Apple').with_attribute('Model', ['Macbook', 'iPhone'])
+    #
+    # @return [Enumerable]
+    def self.with_attributes(key, values)
+      product_ids = KktShoppe::ProductAttribute.searchable.where(:key => key, :value => values).pluck(:product_id).uniq
+      where(:id => product_ids)
+    end
+
+    # Imports products from a spreadsheet file
+    # Example:
+    #
+    #   KktShoppe: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('kkt_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 KktShoppe::ProductCategory.find_by(name: row["category_name"]).present?
+                KktShoppe::ProductCategory.find_by(name: row["category_name"])
+              else
+                KktShoppe::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('kkt_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('kkt_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/kkt_shoppe/product_attribute.rb

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

data/app/models/kkt_shoppe/product_categorization.rb

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