gemgento 2.8.0

data/app/models/gemgento/order_status.rb

@@ -0,0 +1,7 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class OrderStatus < ActiveRecord::Base
+    belongs_to :order
+  end
+end

data/app/models/gemgento/payment.rb

@@ -0,0 +1,50 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class Payment < ActiveRecord::Base
+    belongs_to :payable, polymorphic: true
+
+    attr_accessor :cc_number, :cc_cid, :save_card, :payment_id
+
+    before_save :set_cc_last4, if: Proc.new { |payment| payment.cc_number.present? || payment.payment_id.present? }
+
+    validates :method, :payable, presence: true
+
+    REDIRECTING_PAYMENT_METHODS = {
+        paypal_standard: %w[confirm_after],
+        paypal_express: %w[payment_after confirm_before]
+    }
+
+    def is_redirecting_payment_method?(step = nil)
+      if REDIRECTING_PAYMENT_METHODS.has_key?(self.method.to_sym)
+        if step.blank?
+          return true
+        else
+          return REDIRECTING_PAYMENT_METHODS[self.method.to_sym].include? step
+        end
+      else
+        return false
+      end
+    end
+
+    # Set cc_last4 to the last 4 numbers of cc_number.
+    #
+    # @return [void]
+    def set_cc_last4
+      if self.cc_number.present?
+        self.cc_last4 = cc_number[-4..-1]
+
+      elsif saved_cc = Gemgento::SavedCreditCard.find_by(user: self.payable.user, token: self.payment_id)
+        self.cc_last4 = saved_cc.cc_number.to_s[-4..-1]
+      end
+    end
+
+    def is_new_credit_card_payment?
+      payable_type == 'Gemgento::Quote' &&
+          payable.converted_at.nil? &&
+          !is_redirecting_payment_method? &&
+          method != 'free' && payment_id.nil?
+    end
+
+  end
+end

data/app/models/gemgento/price_rule.rb

@@ -0,0 +1,258 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class PriceRule < ActiveRecord::Base
+    serialize :conditions, Hash
+
+    has_and_belongs_to_many :stores, join_table: 'gemgento_price_rules_stores', class_name: 'Store'
+    has_and_belongs_to_many :user_groups, join_table: 'gemgento_price_rules_user_groups', class_name: 'UserGroup'
+
+    after_save :apply, if: -> { changed? }
+
+    default_scope ->{ order(sort_order: :asc) }
+    scope :active, -> { where(is_active: true) }
+
+    # Calculate a product price based on PriceRules.
+    #
+    # @param product [Gemgento::Product]
+    # @param user_group [Gemgento::UserGroup]
+    # @param store [Gemgento::Store]
+    # @return [Float]
+    def self.calculate_price(product, user_group = nil, store = nil)
+      store ||= Store.current
+      price = product.attribute_value('price', store).to_f
+      user_group ||= UserGroup.find_by(magento_id: 0)
+
+      PriceRule.active.each do |price_rule|
+        if price_rule.is_valid?(product, user_group, store)
+          price = price_rule.calculate(price)
+          return price if price_rule.stop_rules_processing?
+        end
+      end
+
+      return price
+    end
+
+    # Determines if the rule is valid for a product.
+    #
+    # @param product [Gemgento::Product]
+    # @param user_group [Gemgento::UserGroup]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def is_valid?(product, user_group, store)
+      if !self.is_active?
+        return false
+      elsif !self.stores.include?(store)
+        return false
+      elsif !self.user_groups.include?(user_group)
+        return false
+      elsif !self.from_date.nil? && Date.today < from_date
+        return false
+      elsif !self.to_date.nil? && Date.today > to_date
+        return false
+      else
+        return PriceRule.meets_condition?(self.conditions, product, store)
+      end
+    end
+
+    # Calculate the discount based on rule actions.
+    #
+    # @param price [Float]
+    # @return Float
+    def calculate(price)
+      case self.simple_action
+      when 'to_fixed'
+        return [self.discount_amount.to_f, price].min
+      when 'to_percent'
+        return price * self.discount_amount.to_f / 100
+      when 'by_fixed'
+        return [0, price - self.discount_amount.to_f].max
+      when 'by_percent'
+        return price * (1 - self.discount_amount.to_f / 100)
+      else
+        return price
+      end
+    end
+
+    # Determines if the condition is met.
+    #
+    # @param condition [Hash]
+    # @param product [Gemgento::Product]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def self.meets_condition?(condition, product, store)
+      if condition['type'] == 'catalogrule/rule_condition_combine'
+        return meets_condition_combine?(condition, product, store)
+      elsif condition['type'] == 'catalogrule/rule_condition_product'
+        return meets_condition_product?(condition, product, store)
+      else
+        return false # non-determinable condition type
+      end
+    end
+
+    # Determines if the combined child conditions are met.
+    #
+    # @param condition [Hash]
+    # @param product [Gemgento::Product]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def self.meets_condition_combine?(condition, product, store)
+      return true if condition['conditions'].nil?
+
+      condition['conditions'].each do |child_condition|
+
+        if meets_condition?(child_condition, product, store) # the condition has been met
+          if condition['aggregator'] == 'all' && condition['value'] == '0' # all conditions not met
+            return false
+          elsif condition['aggregator'] == 'any' && condition['value'] == '1' # any condition met
+            return true
+          end
+
+        else # the condition has not be met
+          if condition['aggregator'] == 'all' && condition['value'] == '1' # all conditions met
+            return false
+          elsif condition['aggregator'] == 'any' && condition['value'] == '0' # any condition not be met
+            return true
+          end
+        end
+      end
+
+      if condition['aggregator'] == 'all' # all conditions evaluated and all met
+        return true
+      else # all conditions evaluated and none met
+        return false
+      end
+    end
+
+    # Determines if the product conditions are met.
+    #
+    # @param condition [Hash]
+    # @param product [Gemgento::Product]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def self.meets_condition_product?(condition, product, store)
+      if condition['attribute'] == 'category_ids'
+        return meets_category_condition?(condition, product, store)
+      elsif condition['attribute'] == 'attribute_set_id'
+        return meets_attribute_set_condition?(condition, product)
+      else
+        return meets_attribute_condition?(condition, product, store)
+      end
+    end
+
+    # Determines if a product meets a category based condition.
+    #
+    # @param condition [Hash]
+    # @param product [Gemgento::Product]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def self.meets_category_condition?(condition, product, store)
+      magento_category_ids = ProductCategory.where(product: product, store: store).includes(:category).map{ |pc| pc.category.magento_id unless pc.category.nil? }.uniq
+      condition_category_ids = condition['value'].split(',').map(&:to_i)
+
+      case condition['operator']
+        when *%w[== {} ()]
+          return (magento_category_ids & condition_category_ids).any?
+        when *%w[!= !{} !()]
+          return (magento_category_ids & condition_category_ids).empty?
+        else
+          return false
+      end
+    end
+
+    # Determines if a product meets an attribute set based condition.
+    #
+    # @param condition [Hash]
+    # @param product [Gemgento::Product]
+    # @return [Boolean]
+    def self.meets_attribute_set_condition?(condition, product)
+      magento_attribute_set_id = product.product_attribute_set.magento_id
+      condition_attribute_set_id = condition['value'].to_i
+
+      case condition['operator']
+        when *%w[== {} ()]
+          return magento_attribute_set_id == condition_attribute_set_id
+        when *%w[!= !{} !()]
+          return magento_attribute_set_id != condition_attribute_set_id
+        else
+          return false
+      end
+    end
+
+    # Determines if a product meets an attribute based condition.
+    #
+    # @param condition [Hash]
+    # @param product [Gemgento::Product]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def self.meets_attribute_condition?(condition, product, store)
+      return false unless attribute = ProductAttribute.find_by(code: condition['attribute'])
+
+      product_value = product.attribute_value(attribute.code, store).to_s.downcase
+
+      if attribute.frontend_input == 'select'
+        return false unless option = attribute.product_attribute_options.find_by(value: condition['value'], store: store)
+        condition_value = option.label.downcase
+      else
+        condition_value = condition['value'].downcase
+      end
+
+      case condition['operator']
+        when '==' # is
+          return product_value == condition_value
+        when '!=' # is not
+          return product_value != condition_value
+        when '>=' # equals or greater than
+          return product_value >= condition_value
+        when '<=' # equals or less than
+          return product_value <= condition_value
+        when '>' # greater than
+          return product_value > condition_value
+        when '<' # less than
+          return product_value < condition_value
+        when '{}' # contains
+          return product_value.include?(condition_value)
+        when '!{}' # does not contain
+          return !product_value.include?(condition_value)
+        when '()' # is one of
+          return condition_value.split(',').map(&:strip).include?(product_value)
+        when '!()' # is not one of
+          return !condition_value.split(',').map(&:strip).include?(product_value)
+        else
+          return false
+      end
+    end
+
+    # Get the earliest date and time that a price rule will expire for a given product.
+    #
+    # @param product [Gemgento::Product]
+    # @param user_group [Gemgento::UserGroup]
+    # @param store [Gemgento::Store]
+    # @return [DateTime, nil]
+    def self.first_to_expire(product, user_group, store)
+      expires_at = nil
+
+      PriceRule.active.each do |price_rule|
+        next if price_rule.to_date.nil?
+
+        if price_rule.is_valid?(product, user_group, store)
+          if expires_at.nil? || price_rule.to_date.end_of_day < expires_at
+            expires_at = price_rule.to_date.end_of_day
+          end
+        end
+      end
+
+      return expires_at
+    end
+
+    private
+
+    # Touch products affected by the PriceRule
+    #
+    # @return [Void]
+    def apply
+      ApplyPriceRule.perform_async(self.id)
+    end
+
+  end
+end

data/app/models/gemgento/price_tier.rb

@@ -0,0 +1,36 @@
+module Gemgento
+  class PriceTier < ActiveRecord::Base
+    include Gemgento::ProductTouches
+
+    belongs_to :store, class_name: 'Gemgento::Store'
+    belongs_to :product, class_name: 'Gemgento::Product'
+    belongs_to :user_group, class_name: 'Gemgento::UserGroup'
+
+    validates :store, :product, :quantity, :price, presence: true
+
+    # Check if PriceTier is valid for the given quantity and user.
+    #
+    # @param quantity [Float]
+    # @param user_group [Gemgento::UserGroup]
+    def is_valid?(quantity, user_group)
+      return quantity >= self.quantity && (self.user_group.nil? || user_group == self.user_group)
+    end
+
+    # @param product [Gemgento::Product]
+    # @param quantity [Float]
+    # @param user_group [Gemgento::UserGroup]
+    def self.calculate_price(product, quantity = 1.0, user_group = nil, store = nil)
+      store ||= Gemgento::Store.current
+      price = product.attribute_value('price', store).to_f
+      user_group ||= UserGroup.find_by(magento_id: 0)
+
+      product.price_tiers.where(store: store).where('quantity <= ?', quantity).each do |price_tier|
+        next unless price_tier.is_valid? quantity, user_group
+        price = price_tier.price if price_tier.price < price
+      end
+
+      return price
+    end
+
+  end
+end

data/app/models/gemgento/product.rb

@@ -0,0 +1,607 @@
+module Gemgento
+
+  # @author Gemgento LLC
+  class Product < ActiveRecord::Base
+
+    belongs_to :product_attribute_set
+
+    has_many :assets, dependent: :destroy
+    has_many :bundle_items, class_name: 'Gemgento::Bundle::Item', dependent: :destroy
+    has_many :bundle_options, class_name: 'Gemgento::Bundle::Option', dependent: :destroy
+    has_many :categories, -> { uniq }, through: :product_categories, class_name: 'Gemgento::Category'
+    has_many :inventories, class_name: 'Gemgento::Inventory'
+    has_many :line_items, class_name: 'Gemgento::LineItem'
+    has_many :orders, through: :line_items, source: :itemizable, source_type: 'Gemgento::Order', class_name: 'Gemgento::Order'
+    has_many :price_tiers, class_name: 'Gemgento::PriceTier'
+    has_many :product_attribute_values, class_name: 'Gemgento::ProductAttributeValue', dependent: :destroy
+    has_many :product_attributes, through: :product_attribute_values, class_name: 'Gemgento::ProductAttribute'
+    has_many :product_attribute_options, through: :product_attribute_values, class_name: 'Gemgento::ProductAttributeOption'
+    has_many :product_categories, class_name: '::Gemgento::ProductCategory', dependent: :destroy
+    has_many :quotes, through: :line_items, source: :itemizable, source_type: 'Gemgento::Quote', class_name: 'Gemgento::Quote'
+    has_many :relations, as: :relatable, class_name: 'Relation', dependent: :destroy
+    has_many :shipment_items
+    has_many :wishlist_items
+    has_many :users, through: :wishlist_items
+
+    has_one :shopify_adapter, class_name: 'Adapter::ShopifyAdapter', as: :gemgento_model
+
+    has_and_belongs_to_many :stores, -> { distinct }, join_table: 'gemgento_stores_products', class_name: 'Store'
+    has_and_belongs_to_many :tags, class_name: 'Tag', join_table: 'gemgento_products_tags'
+    has_and_belongs_to_many :configurable_attributes, -> { distinct }, join_table: 'gemgento_configurable_attributes', class_name: 'ProductAttribute'
+    has_and_belongs_to_many :configurable_products, -> { distinct },
+                            join_table: 'gemgento_configurable_simple_relations',
+                            foreign_key: 'simple_product_id',
+                            association_foreign_key: 'configurable_product_id',
+                            class_name: 'Product'
+    has_and_belongs_to_many :simple_products, -> { distinct },
+                            join_table: 'gemgento_configurable_simple_relations',
+                            foreign_key: 'configurable_product_id',
+                            association_foreign_key: 'simple_product_id',
+                            class_name: 'Product'
+
+    scope :eager, -> { includes([{product_attribute_values: :product_attribute}, {assets: [:asset_file, :asset_types]}, :inventories]) }
+    scope :configurable, -> { where(magento_type: 'configurable') }
+    scope :simple, -> { where(magento_type: 'simple') }
+    scope :enabled, -> { where(status: true) }
+    scope :disabled, -> { where(status: false) }
+    scope :catalog_visible, -> { where(visibility: [2, 4]) }
+    scope :search_visible, -> { where(visibility: [3, 4]) }
+    scope :visible, -> { where(visibility: [2, 3, 4]) }
+    scope :not_deleted, -> { where(deleted_at: nil) }
+    scope :active, -> { where(deleted_at: nil, status: true) }
+
+    touch :categories, after_touch: :after_touch
+    touch :configurable_products, after_touch: :after_touch
+    touch :bundle_items, after_touch: :after_touch
+
+    after_find :manage_cache_expires_at
+
+    before_save :create_magento_product, if: -> { sync_needed? && magento_id.nil? }
+    before_save :update_magento_product, if: -> { sync_needed? && !magento_id.nil? }
+
+    before_destroy :delete_associations
+
+    after_commit :remove_from_active_quotes, unless: Proc.new { |product| product.status && product.deleted_at.nil?  }
+
+    validates :sku, uniqueness: { scope: :deleted_at }
+    validates :magento_id, uniqueness: true
+
+    attr_accessor :configurable_attribute_ordering, :attribute_values, :sync_needed
+
+    def sync_needed?
+      self.sync_needed.to_bool
+    end
+
+    # Set an attribute value.
+    #
+    # @param code [String] attribute code
+    # @param value [String, Boolean, Integer, Float, BigDecimal]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def set_attribute_value(code, value, store = nil)
+      store = Store.current if store.nil?
+
+      product_attribute = ProductAttribute.find_by(code: code)
+
+      if product_attribute.nil?
+        return false
+      else
+        # enforce a single attribute value per attribute per store per product
+        product_attribute_values = ProductAttributeValue.where(product_id: self.id, product_attribute_id: product_attribute.id, store: store)
+
+        if product_attribute_values.size > 1
+          ProductAttributeValue.where(product_id: self.id, product_attribute_id: product_attribute.id, store: store).where('id != ?', product_attribute_values.first.id).destroy_all
+        end
+
+        # set the attribute value
+        product_attribute_value = ProductAttributeValue.where(product_id: self.id, product_attribute_id: product_attribute.id, store: store).first_or_initialize
+        product_attribute_value.product = self
+        product_attribute_value.product_attribute = product_attribute
+        product_attribute_value.value = value
+        product_attribute_value.store = store
+        product_attribute_value.save!
+
+        self.product_attribute_values << product_attribute_value unless self.product_attribute_values.include?(product_attribute_value)
+        self.attribute_values = nil # reload cached attributes values
+
+        return true
+      end
+    end
+
+    # Get an attribute value.
+    #
+    # @param code [String] attribute code
+    # @param store [Gemgento::Store]
+    # @return [String, Boolean, nil]
+    def attribute_value(code, store = nil)
+      store = Gemgento::Store.current if store.nil?
+      product_attribute_value = self.attribute_values.select { |value| !value.product_attribute.nil? && value.product_attribute.code == code.to_s && value.store_id == store.id }.first
+
+      ## if the attribute is not currently associated with the product, check if it exists
+      if product_attribute_value.nil?
+        product_attribute = Gemgento::ProductAttribute.find_by(code: code)
+
+        if product_attribute.nil? # throw an error if the code is not recognized
+          raise "Unknown product attribute code - #{code}"
+        end
+      else
+        product_attribute = product_attribute_value.product_attribute
+      end
+
+      value = product_attribute_value.nil? ? product_attribute.default_value : product_attribute_value.value
+      return nil if value.nil?
+
+      if product_attribute.frontend_input == 'boolean' || product_attribute.code == 'is_recurring'
+        if value == 'Yes' || value == '1' || value == '1.0'
+          value = true
+        else
+          value = false
+        end
+      elsif product_attribute.frontend_input == 'select'
+        option = product_attribute.product_attribute_options.find_by(value: value, store: store)
+        value = option.nil? ? nil : option.label
+      end
+
+      return value
+    end
+
+    def attribute_values
+      @attribute_values ||= self.product_attribute_values.joins(:product_attribute).includes(:product_attribute)
+    end
+
+    # Attempts to return attribute_value before error.
+    def method_missing(method, *args)
+      begin
+        return self.attribute_value(method)
+      rescue
+        super
+      end
+    end
+
+    # Determine if product has a specific inventory level.
+    #
+    # @param quantity [Integer, BigDecimal, Float]
+    # @param store [Gemgento::Store]
+    # @return [Boolean]
+    def in_stock?(quantity = 1, store = nil)
+      store = Store.current if store.nil?
+
+      if self.magento_type == 'configurable'
+        inventories = Inventory.where(product_id: self.simple_products.active.select(:id), store: store)
+
+        if inventories.empty? # no inventories means inventory is not tracked
+          return true
+        else
+          inventories.each do |inventory|
+            return true if inventory.in_stock?(quantity)
+          end
+
+          return false
+        end
+
+      else
+        if inventory = self.inventories.find_by(store: store)
+          return inventory.in_stock?(quantity)
+        else
+          return true
+        end
+      end
+    end
+
+    # Mark a product deleted.
+    #
+    # @return [Void]
+    def mark_deleted
+      self.deleted_at = Time.now
+      self.shopify_adapter.destroy if self.shopify_adapter
+    end
+
+    # Mark a product deleted and save.
+    #
+    # @return [Void]
+    def mark_deleted!
+      mark_deleted
+      self.save
+    end
+
+    # Filter products based on attribute values.
+    #
+    #   filter example:
+    #     {attribute: Gemgento::ProductAttribute.find_by(code: 'size'), value: 'large'})
+    #     or
+    #     {attribute: Gemgento::ProductAttribute.find_by(code: 'size'), value: %w[large small]})
+    #     or
+    #     {attribute: [Gemgento::ProductAttribute.find_by(code: 'size'), Gemgento::ProductAttribute.find_by(code: 'dimension')], value: 'large'})
+    #     or
+    #     {attribute: [Gemgento::ProductAttribute.find_by(code: 'size'), Gemgento::ProductAttribute.find_by(code: 'dimension')], value: %w[large small]})
+    #     or
+    #     [{attribute: Gemgento::ProductAttribute.find_by(code: 'size'), value: 'large'}), {attribute: Gemgento::ProductAttribute.find_by(code: 'color'), value: 'red'})]
+    #
+    #   Filters can also take an optional operand, the default operand is '=' or 'IN' for an array
+    #
+    # @param filters [Hash, Array(Hash)]
+    # @param store [Gemgento::Store]
+    # @return [ActiveRecord::Result]
+    def self.filter(filters, store = nil)
+      store = Store.current if store.nil?
+
+      filters = [filters] unless filters.is_a? Array
+      products = self
+
+      filters.each_with_index do |filter, index|
+        filter[:attribute] = [filter[:attribute]] unless filter[:attribute].is_a? Array
+        operand = filter[:value].is_a?(Array) ? 'IN' : ( filter.has_key?(:operand) ? filter[:operand] : '=' )
+        value_placeholder = filter[:value].is_a?(Array) ? '(?)' : '?'
+
+        unless filter[:attribute][0].frontend_input == 'select'
+          products = products.joins(ActiveRecord::Base.escape_sql(
+                                        "INNER JOIN gemgento_product_attribute_values AS value#{index} ON value#{index}.product_id = gemgento_products.id AND value#{index}.value #{operand} #{value_placeholder} AND value#{index}.store_id = ?
+                    INNER JOIN gemgento_product_attributes AS attribute#{index} ON attribute#{index}.id = value#{index}.product_attribute_id AND attribute#{index}.id IN (?)",
+                                        filter[:value],
+                                        store.id,
+                                        filter[:attribute].map { |a| a.id }
+                                    )).distinct.readonly(false)
+        else
+          products = products.joins(ActiveRecord::Base.escape_sql(
+                                        "INNER JOIN gemgento_product_attribute_values AS value#{index} ON value#{index}.product_id = gemgento_products.id
+                    INNER JOIN gemgento_product_attributes AS attribute#{index} ON attribute#{index}.id = value#{index}.product_attribute_id
+                      AND attribute#{index}.id IN (?)
+                    INNER JOIN gemgento_product_attribute_options AS option#{index} ON option#{index}.product_attribute_id = attribute#{index}.id
+                      AND value#{index}.value = option#{index}.value
+                      AND option#{index}.label #{operand} #{value_placeholder}",
+                                        filter[:attribute].map { |a| a.id },
+                                        filter[:value]
+                                    )).distinct.readonly(false) # does not compare against values
+        end
+      end
+
+      return products
+    end
+
+    # Order ActiveRecord result by attribute values.
+    #
+    # @param attribute [Gemgento::ProductAttribute]
+    # @param direction ['ASC', 'DESC']
+    # @param is_numeric [Boolean]
+    # @param store [Gemgento::Store]
+    # @return [ActiveRecord::Result]
+    def self.order_by_attribute(attribute, direction = 'ASC', is_numeric = false, store = nil)
+      store = Store.current if store.nil?
+      raise 'Direction must be equivalent to ASC or DESC' if direction != 'ASC' and direction != 'DESC'
+
+      products = self
+
+      unless attribute.frontend_input == 'select'
+        products = products.joins(
+            ActiveRecord::Base.escape_sql(
+                'INNER JOIN gemgento_product_attribute_values ON gemgento_product_attribute_values.product_id = gemgento_products.id AND gemgento_product_attribute_values.product_attribute_id = ? AND gemgento_product_attribute_values.store_id = ? ' +
+                    'INNER JOIN gemgento_product_attributes ON gemgento_product_attributes.id = gemgento_product_attribute_values.product_attribute_id ',
+                attribute.id,
+                store.id
+            ))
+
+        if is_numeric
+          products = products.reorder("CAST(gemgento_product_attribute_values.value AS SIGNED) #{direction}")
+        else
+          products = products.reorder("gemgento_product_attribute_values.value #{direction}")
+        end
+      else
+        products = products.joins(
+            ActiveRecord::Base.escape_sql(
+                'INNER JOIN gemgento_product_attribute_values ON gemgento_product_attribute_values.product_id = gemgento_products.id AND gemgento_product_attribute_values.product_attribute_id = ? ' +
+                    'INNER JOIN gemgento_product_attributes ON gemgento_product_attributes.id = gemgento_product_attribute_values.product_attribute_id ' +
+                    'INNER JOIN gemgento_product_attribute_options ON gemgento_product_attribute_options.product_attribute_id = gemgento_product_attributes.id AND gemgento_product_attribute_options.value = gemgento_product_attribute_values.value ' +
+                    'AND gemgento_product_attribute_options.store_id = ?',
+                attribute.id,
+                store.id
+            ))
+
+        if is_numeric
+          products = products.reorder("CAST(gemgento_product_attribute_options.order AS SIGNED) #{direction}")
+        else
+          products = products.reorder("gemgento_product_attribute_options.order #{direction}")
+        end
+      end
+
+      products = products.readonly(false)
+
+      return products
+    end
+
+    # Get the product price.
+    #
+    # @param user_group [Gemgento::UserGroup]
+    # @param store [Store]
+    # @param quantity [Float]
+    # @return Float
+    def price(user_group = nil, store = nil, quantity = 1.0)
+      Gemgento::Price.new(self, user_group, store, quantity).calculate
+    end
+
+    # Determine if product is on sale.
+    #
+    # @param user_group [Gemgento::UserGroup]
+    # @param store [Store]
+    # @param quantity [Float]
+    # @return Boolean
+    def on_sale?(user_group = nil, store = nil, quantity = 1.0)
+      return self.attribute_value('price', store).to_f != self.price(user_group, store, quantity)
+    end
+
+    # Get the original, non sale, price for a product.
+    #
+    # @param [Store, nil] store
+    # @return [Float]
+    def original_price(store = nil)
+      return self.attribute_value('price', store).to_f
+    end
+
+    # Return the ordering of configurable attribute values.
+    #
+    # @param [Store, nil] store
+    # @param [Boolean] active_only
+    # @param [Hash(Hash(Array(Integer)))]
+    def configurable_attribute_order(store = nil, active_only = true)
+      self.configurable_attribute_ordering ||= self.get_configurable_attribute_ordering(store, active_only)
+    end
+
+    # Calculate the ordering of configurable attribute values
+    #
+    # @param [Store, nil] store
+    # @param [Boolean] active_only
+    # @return [Hash(Hash(Array(Integer)))]
+    def get_configurable_attribute_ordering(store, active_only)
+      store = Store.current if store.nil?
+      order = {}
+
+      if self.magento_type != 'configurable' && !self.configurable_products.empty?
+        configurable_product = self.configurable_products.first
+      else
+        configurable_product = self
+      end
+
+      if active_only
+        simple_products = configurable_product.simple_products.active.eager
+      else
+        simple_products = self.simple_products.eager
+      end
+
+      configurable_attributes = self.product_attribute_set.product_attributes.
+          where(is_configurable: true, frontend_input: 'select', scope: 'global')
+
+      configurable_attributes.each do |attribute|
+        order[attribute.code] = []
+
+        simple_products = simple_products.sort_by do |simple_product|
+          if o = simple_product.product_attribute_options.find_by(product_attribute: attribute, store: store)
+            o.order
+          else
+            0
+          end
+        end
+
+        mapping = {}
+        simple_products.each do |simple_product|
+          value = simple_product.attribute_value(attribute.code, store)
+          mapping[value] = [] if mapping[value].nil?
+          mapping[value] << simple_product.id unless mapping[value].include? simple_product.id
+        end
+
+        order[attribute.code] = []
+        mapping.each do |k, value|
+          order[attribute.code] << { value: k, simple_product_ids: value }
+        end
+      end
+
+      return order
+    end
+
+    # Determine if the product is catalog visible.
+    #
+    # @return [Boolean]
+    def is_catalog_visible?
+      return [2, 4].include?(self.visibility)
+    end
+
+    # Set the associated simple products, using an array of Magento product IDs.
+    #
+    # @param magento_ids [Array(Integer)] Magento IDs of the associated simple products
+    # @return [void]
+    def set_simple_products_by_magento_ids(magento_ids)
+      simple_product_ids = []
+
+      magento_ids.each do |magento_id|
+        simple_product = Product.active.find_by(magento_id: magento_id)
+        next if simple_product.nil?
+
+        self.simple_products << simple_product unless self.simple_products.include? simple_product
+        simple_product_ids << simple_product.id
+      end
+
+      self.simple_products.delete(self.simple_products.where('simple_product_id NOT IN (?)', simple_product_ids))
+    end
+
+    # Set the associated configurable products, using an array of Magento product IDs.
+    #
+    # @param magento_ids [Array(Integer)] Magento IDs of the associated configurable products
+    # @return [void]
+    def set_configurable_products_by_magento_ids(magento_ids)
+      configurable_product_ids = []
+
+      magento_ids.each do |magento_id|
+        configurable_product = Product.active.find_by(magento_id: magento_id)
+        next if configurable_product.nil?
+
+        self.configurable_products << configurable_product unless self.configurable_products.include? configurable_product
+        configurable_product_ids << configurable_product.id
+      end
+
+      self.configurable_products.delete(self.configurable_products.where('configurable_product_id NOT IN (?)', configurable_product_ids))
+    end
+
+    # If the product has a cache_expires_at date set, make sure it hasn't expired.  If it has, set it again.
+    #
+    # @return [DateTime, nil]
+    def manage_cache_expires_at
+      self.set_cache_expires_at if self.cache_expires_at && self.cache_expires_at < Time.now
+    end
+
+    # Calculate the datetime that the product cache should expire.
+    #
+    # @return [Void]
+    def set_cache_expires_at
+      self.cache_expires_at = nil
+
+      Store.all.each do |store|
+        UserGroup.all.each do |user_group|
+          if Price.new(self, user_group, store).has_special?
+            date =  self.attribute_value('special_to_date', store)
+          else
+            date =  PriceRule.first_to_expire(self, user_group, store)
+          end
+
+          next if date.nil?
+          self.cache_expires_at = date if self.cache_expires_at.nil? || date < self.cache_expires_at
+        end
+      end
+
+      self.sync_needed = false
+      self.save
+    end
+
+    def to_param
+      "#{self.id}-#{self.url_key}"
+    end
+
+    # Determine the current category of a product based on the active navigation categories related to the product.
+    # A preferred category id can be specified, if this category is not found in the products navigation categories,
+    # then the lowest level navigation category is returned.
+    #
+    # @param category_id [Integer] id of a preferred category to return
+    # @param store [Gemgento::Store]
+    # @return [Gemgento::Category]
+    def current_category(category_id = nil, store = nil)
+      @current_category ||= begin
+        self.categories(store || Gemgento::Store.current).active.navigation.find(category_id)
+      rescue ActiveRecord::RecordNotFound
+        self.categories(store || Gemgento::Store.current).active.navigation.bottom_level.first!
+      end
+    end
+
+    # Check if the product is configurable.
+    #
+    # @return [Boolean]
+    def configurable?
+      magento_type == 'configurable'
+    end
+
+    # Check if the product is simple.
+    #
+    # @return [Boolean]
+    def simple?
+      magento_type == 'simple'
+    end
+
+    # Categories related to the product.
+    #
+    # @param store [Gemgento::Store]
+    # @return []
+    def categories(store = nil)
+      return super if store.nil?
+      Gemgento::Category.where(id: self.product_categories.where(store: store).pluck(:category_id))
+    end
+
+    def remove_from_active_quotes
+      self.line_items
+          .joins('INNER JOIN gemgento_quotes ON gemgento_line_items.itemizable_id = gemgento_quotes.id')
+          .joins('LEFT JOIN gemgento_orders ON gemgento_quotes.id = gemgento_orders.quote_id')
+          .where(gemgento_line_items: { itemizable_type: 'Gemgento::Quote' })
+          .where(gemgento_orders: { id: nil }).where('gemgento_quotes.created_at >= ?', 30.days.ago)
+          .destroy_all
+    end
+
+    def after_touch
+      # do nothing
+    end
+
+    private
+
+    # Create an attribute option in Magento.
+    #
+    # @param product_attribute [ProductAttribute]
+    # @param option_label [String]
+    # @param store [Store]
+    # @return [ProductAttributeOption]
+    def create_attribute_option(product_attribute, option_label, store)
+      attribute_option = ProductAttributeOption.new
+      attribute_option.product_attribute = product_attribute
+      attribute_option.label = option_label
+      attribute_option.store = store
+      attribute_option.sync_needed = false
+      attribute_option.save
+
+      attribute_option.sync_local_to_magento
+      attribute_option.destroy
+
+      return ProductAttributeOption.find_by(product_attribute: product_attribute, label: option_label, store: store)
+    end
+
+    # Create an associated magento Product.
+    #
+    # @return [Boolean]
+    def create_magento_product
+      response = API::SOAP::Catalog::Product.create(self, self.stores.first)
+
+      if response.success?
+        self.magento_id = response.body[:result]
+        self.sync_needed = false
+
+        stores.each_with_index do |store, index|
+          next if index == 0
+          response = API::SOAP::Catalog::Product.update(self, store)
+
+          # If there was a problem updating on of the stores, then make sure the product will be synced on next save.
+          # The product needs to be saved regardless, since a Magento product was created and the id must be set.  So,
+          # this will not return false.
+          self.sync_needed = true unless response.success?
+        end
+
+        return true
+      else
+        errors.add(:base, response.body[:faultstring])
+        return false
+      end
+    end
+
+    # Update associated Magento Product.
+    #
+    # @return [Boolean]
+    def update_magento_product
+      self.stores.each do |store|
+        response = API::SOAP::Catalog::Product.update(self, store)
+
+        unless response.success?
+          errors.add(:base, response.body[:faultstring])
+          return false
+        end
+      end
+
+      self.sync_needed = false
+      return true
+    end
+
+    # Delete associations.
+    #
+    # @return [Void]
+    def delete_associations
+      self.configurable_attributes.destroy_all
+    end
+
+    def to_ary
+      nil
+    end
+
+    alias :to_a :to_ary
+
+  end
+end