My-Commerce_core 1.0.0

data/app/models/payment_method.rb

@@ -0,0 +1,56 @@
+class PaymentMethod < ActiveRecord::Base
+  DISPLAY =  [:both, :front_end, :back_end]
+  default_scope where(:deleted_at => nil)
+
+  @provider = nil
+  @@providers = Set.new
+  def self.register
+    @@providers.add(self)
+  end
+
+  def self.providers
+    @@providers.to_a
+  end
+
+  def provider_class
+    raise "You must implement provider_class method for this gateway."
+  end
+
+  # The class that will process payments for this payment type, used for @payment.source
+  # e.g. Creditcard in the case of a the Gateway payment type
+  # nil means the payment method doesn't require a source e.g. check
+  def payment_source_class
+    raise "You must implement payment_source_class method for this gateway."
+  end
+
+  def self.available(display_on='both')
+    PaymentMethod.all.select { |p| p.active && (p.display_on == display_on.to_s || p.display_on.blank?) &&  (p.environment == Rails.env || p.environment.blank?) }
+  end
+
+  def self.active?
+    self.count(:conditions => {:type => self.to_s, :environment => Rails.env, :active => true}) > 0
+  end
+
+  def self.current
+    PaymentMethod.find(:first, :conditions => {:active => true, :environment => Rails.env})
+  end
+
+  def method_type
+    type.demodulize.downcase
+  end
+
+  def destroy
+    self.update_attribute(:deleted_at, Time.now.utc)
+  end
+
+  def self.find_with_destroyed *args
+    self.with_exclusive_scope { find(*args) }
+  end
+
+  def payment_profiles_supported?
+    false
+  end
+  def source_required?
+   true
+  end
+end

data/app/models/preference.rb

@@ -0,0 +1,51 @@
+# Represents a preferred value for a particular preference on a model.
+#
+# == Targeted preferences
+#
+# In addition to simple named preferences, preferences can also be targeted for
+# a particular record.  For example, a User may have a preferred color for a
+# particular Car.  In this case, the +owner+ is the User, the +preference+ is
+# the color, and the +target+ is the Car.  This allows preferences to have a sort
+# of context around them.
+class Preference < ActiveRecord::Base
+  belongs_to  :owner, :polymorphic => true
+  belongs_to  :group, :polymorphic => true
+
+  validates :name, :owner_id, :owner_type, :presence => true
+  validates :group_type, :presence => true, :if => :group_id?
+
+  class << self
+    # Splits the given group into its corresponding id and type
+    def split_group(group = nil)
+      if group.is_a?(ActiveRecord::Base)
+        group_id, group_type = group.id, group.class.base_class.name.to_s
+      else
+        group_id, group_type = nil, group
+      end
+      return group_id, group_type
+    end
+  end
+
+  # The definition for the attribute
+  def definition
+    owner.preference_definitions[name] unless owner_type.blank?
+  end
+
+  # Typecasts the value depending on the preference definition's declared type
+  def value
+    value = read_attribute(:value)
+    value = definition.type_cast(value) if definition
+    value
+  end
+
+  # Only searches for the group record if the group id is specified
+  def group_with_optional_lookup
+    group_id ? group_without_optional_lookup : group_type
+  end
+  alias_method_chain :group, :optional_lookup
+end
+
+
+# Most of this code is taken from the preferences plugin available
+# at http://github.com/pluginaweek/preferences/tree/master
+

data/app/models/product.rb

@@ -0,0 +1,258 @@
+# PRODUCTS
+# Products represent an entity for sale in a store.
+# Products can have variations, called variants
+# Products properties include description, permalink, availability,
+#   shipping category, etc. that do not change by variant.
+#
+# MASTER VARIANT
+# Every product has one master variant, which stores master price and sku, size and weight, etc.
+# The master variant does not have option values associated with it.
+# Price, SKU, size, weight, etc. are all delegated to the master variant.
+# Contains on_hand inventory levels only when there are no variants for the product.
+#
+# VARIANTS
+# All variants can access the product properties directly (via reverse delegation).
+# Inventory units are tied to Variant.
+# The master variant can have inventory units, but not option values.
+# All other variants have option values and may have inventory units.
+# Sum of on_hand each variant's inventory level determine "on_hand" level for the product.
+#
+class Product < ActiveRecord::Base
+  has_many :product_option_types, :dependent => :destroy
+  has_many :option_types, :through => :product_option_types
+  has_many :product_properties, :dependent => :destroy
+  has_many :properties, :through => :product_properties
+  has_many :images, :as => :viewable, :order => :position, :dependent => :destroy
+  has_and_belongs_to_many :product_groups
+  belongs_to :tax_category
+  has_and_belongs_to_many :taxons
+  belongs_to :shipping_category
+
+  has_one :master,
+    :class_name => 'Variant',
+    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", true]
+
+  delegate_belongs_to :master, :sku, :price, :weight, :height, :width, :depth, :is_master
+  delegate_belongs_to :master, :cost_price if Variant.table_exists? && Variant.column_names.include?("cost_price")
+
+  after_create :set_master_variant_defaults
+  after_create :add_properties_and_option_types_from_prototype
+  before_save :recalculate_count_on_hand
+  before_update :sanitize_permalink
+  after_save :update_memberships if ProductGroup.table_exists?
+  after_save :set_master_on_hand_to_zero_when_product_has_variants
+  after_save :save_master
+
+  has_many :variants,
+    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", false],
+    :order => 'variants.position ASC'
+
+
+  has_many :variants_including_master,
+    :class_name => 'Variant',
+    :conditions => ["variants.deleted_at IS NULL"],
+    :dependent => :destroy
+
+  has_many :variants_with_only_master,
+    :class_name => 'Variant',
+    :conditions => ["variants.deleted_at IS NULL AND variants.is_master = ?", true],
+    :dependent => :destroy
+
+
+  validates :name, :price, :permalink,:available_on, :presence => true
+  
+  accepts_nested_attributes_for :product_properties, :allow_destroy => true, :reject_if => lambda { |pp| pp[:property_name].blank? }
+
+  make_permalink
+
+  alias :options :product_option_types
+
+  include ::Scopes::Product
+
+  #RAILS3 TODO -  scopes are duplicated here and in scopres/product.rb - can we DRY it up?
+  # default product scope only lists available and non-deleted products
+  scope :not_deleted,     where("products.deleted_at is NULL")
+
+  scope :available,       lambda { |*on| where("products.available_on <= ?", on.first || Time.zone.now ) }
+
+  #RAILS 3 TODO - this scope doesn't match the original 2.3.x version, needs attention (but it works)
+  scope :active,          lambda{ not_deleted.available }
+
+  scope :on_hand,         where("products.count_on_hand > 0")
+
+  if (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL')
+    if ActiveRecord::Base.connection.tables.include?("products")
+      scope :group_by_products_id, { :group => "products." + Product.column_names.join(", products.") }
+    end
+  else
+    scope :group_by_products_id, { :group => "products.id" }
+  end
+  search_methods :group_by_products_id
+
+  scope :id_equals, lambda { |input_id| where("products.id = ?", input_id) }
+
+  scope :taxons_name_eq, lambda { |name| joins(:taxons).where("taxons.name = ?", name) }
+
+  # ----------------------------------------------------------------------------------------------------------
+  #
+  # The following methods are deprecated and will be removed in a future version of Spree
+  #
+  # ----------------------------------------------------------------------------------------------------------
+
+  def master_price
+    warn "[DEPRECATION] `Product.master_price` is deprecated.  Please use `Product.price` instead. (called from #{caller[0]})"
+    self.price
+  end
+
+  def master_price=(value)
+    warn "[DEPRECATION] `Product.master_price=` is deprecated.  Please use `Product.price=` instead. (called from #{caller[0]})"
+    self.price = value
+  end
+
+  def variants?
+    warn "[DEPRECATION] `Product.variants?` is deprecated.  Please use `Product.has_variants?` instead. (called from #{caller[0]})"
+    self.has_variants?
+  end
+
+  def variant
+    warn "[DEPRECATION] `Product.variant` is deprecated.  Please use `Product.master` instead. (called from #{caller[0]})"
+    self.master
+  end
+
+  # ----------------------------------------------------------------------------------------------------------
+  # end deprecation region
+  # ----------------------------------------------------------------------------------------------------------
+
+  def to_param
+    return permalink if permalink.present?
+    name.to_url
+  end
+
+  # returns true if the product has any variants (the master variant is not a member of the variants array)
+  def has_variants?
+    !variants.empty?
+  end
+
+  # returns the number of inventory units "on_hand" for this product
+  def on_hand
+    has_variants? ? variants.inject(0){|sum, v| sum + v.on_hand} : master.on_hand
+  end
+
+  # adjusts the "on_hand" inventory level for the product up or down to match the given new_level
+  def on_hand=(new_level)
+    raise "cannot set on_hand of product with variants" if has_variants? && Spree::Config[:track_inventory_levels]
+    master.on_hand = new_level
+  end
+
+  # Returns true if there are inventory units (any variant) with "on_hand" state for this product
+  def has_stock?
+    master.in_stock? || !!variants.detect{|v| v.in_stock?}
+  end
+
+  def tax_category
+    if self[:tax_category_id].nil?
+      TaxCategory.first(:conditions => {:is_default => true})
+    else
+      TaxCategory.find(self[:tax_category_id])
+    end
+  end
+
+  # Adding properties and option types on creation based on a chosen prototype
+  attr_reader :prototype_id
+  def prototype_id=(value)
+    @prototype_id = value.to_i
+  end
+
+  def add_properties_and_option_types_from_prototype
+    if prototype_id && prototype = Prototype.find_by_id(prototype_id)
+      prototype.properties.each do |property|
+        product_properties.create(:property => property)
+      end
+      self.option_types = prototype.option_types
+    end
+  end
+
+  # for adding products which are closely related to existing ones
+  # define "duplicate_extra" for site-specific actions, eg for additional fields
+  def duplicate
+    p = self.clone
+    p.name = 'COPY OF ' + self.name
+    p.deleted_at = nil
+    p.created_at = p.updated_at = nil
+    p.taxons = self.taxons
+
+    p.product_properties = self.product_properties.map {|q| r = q.clone; r.created_at = r.updated_at = nil; r}
+
+    image_clone = lambda {|i| j = i.clone; j.attachment = i.attachment.clone; j}
+    p.images = self.images.map {|i| image_clone.call i}
+
+    variant = self.master.clone
+    variant.sku = 'COPY OF ' + self.master.sku
+    variant.deleted_at = nil
+    variant.images = self.master.images.map {|i| image_clone.call i}
+    p.master = variant
+
+    if self.has_variants?
+      # don't clone the actual variants, just the characterising types
+      p.option_types = self.option_types
+    else
+    end
+    # allow site to do some customization
+    p.send(:duplicate_extra) if p.respond_to?(:duplicate_extra)
+    p.save!
+    p
+  end
+
+  # use deleted? rather than checking the attribute directly. this
+  # allows extensions to override deleted? if they want to provide
+  # their own definition.
+  def deleted?
+    !!deleted_at
+  end
+
+  # split variants list into hash which shows mapping of opt value onto matching variants
+  # eg categorise_variants_from_option(color) => {"red" -> [...], "blue" -> [...]}
+  def categorise_variants_from_option(opt_type)
+    return {} unless option_types.include?(opt_type)
+    variants.active.group_by {|v| v.option_values.detect {|o| o.option_type == opt_type} }
+  end
+
+  def self.like_any(fields, values)
+    where_str = fields.map{|field| Array.new(values.size, "products.#{field} #{LIKE} ?").join(' OR ') }.join(' OR ')
+    self.where([where_str, values.map{|value| "%#{value}%"} * fields.size].flatten)
+  end
+
+  private
+  
+  def sanitize_permalink
+    self.permalink = self.permalink.to_url
+  end
+
+  def recalculate_count_on_hand
+    product_count_on_hand = has_variants? ?
+        variants.inject(0) {|acc, v| acc + v.count_on_hand} :
+        (master ? master.count_on_hand : 0)
+    self.count_on_hand = product_count_on_hand
+  end
+
+  # the master on_hand is meaningless once a product has variants as the inventory
+  # units are now "contained" within the product variants
+  def set_master_on_hand_to_zero_when_product_has_variants
+    master.on_hand = 0 if has_variants? && Spree::Config[:track_inventory_levels]
+  end
+
+  # ensures the master variant is flagged as such
+  def set_master_variant_defaults
+    master.is_master = true
+  end
+
+  # there's a weird quirk with the delegate stuff that does not automatically save the delegate object
+  # when saving so we force a save using a hook.
+  def save_master
+    master.save if master && (master.changed? || master.new_record?)
+  end
+
+  def update_memberships
+    self.product_groups = ProductGroup.all.select{|pg| pg.include?(self)}
+  end
+end

data/app/models/product_group.rb

@@ -0,0 +1,216 @@
+# *ProductGroups* are used for creating and managing sets of products.
+# Product group can be either anonymous(adhoc) or named.
+#
+# Anonymous Product groups are created by combining product scopes generated from url
+# in 2 formats:
+#
+#   /t/*taxons/s/name_of_scope/comma_separated_arguments/name_of_scope_that_doesn_take_any//order
+#   */s/name_of_scope/comma_separated_arguments/name_of_scope_that_doesn_take_any//order
+#
+# Named product groups can be created from anonymous ones, lub from another named scope
+# (using ProductGroup.from_url method).
+# Named product groups have pernament urls, that don't change even after changes
+# to scopes are made, and come in two types.
+#
+#   /t/*taxons/pg/named_product_group
+#   */pg/named_product_group
+#
+# first one is used for combining named scope with taxons, named product group can
+# have #in_taxon or #taxons_name_eq scope defined, result should combine both
+# and return products that exist in both taxons.
+#
+# ProductGroup#dynamic_products returns chain of named scopes generated from order and
+# product scopes. So you can do counting, calculations etc, on resulted set of products,
+# without retriving all records.
+#
+# ProductGroup operates on named scopes defined for product in Scopes::Product,
+# or generated automatically by meta_search
+#
+class ProductGroup < ActiveRecord::Base
+  validates :name, :presence => true # TODO ensure that this field is defined as not_null
+  validates_associated :product_scopes
+
+  before_save :set_permalink
+  after_save :update_memberships
+
+  has_and_belongs_to_many :cached_products, :class_name => "Product"
+  # name
+  has_many :product_scopes
+  accepts_nested_attributes_for :product_scopes
+
+  # Testing utility: creates new *ProductGroup* from search permalink url.
+  # Follows conventions for accessing PGs from URLs, as decoded in routes
+  def self.from_url(url)
+    pg = nil;
+    case url
+    when /\/t\/(.+?)\/s\/(.+)/  then taxons = $1; attrs = $2;
+    when /\/t\/(.+?)\/pg\/(.+)/ then taxons = $1; pg_name = $2;
+    when /(.*?)\/s\/(.+)/       then attrs = $2;
+    when /(.*?)\/pg\/(.+)/      then pg_name = $2;
+    else                        return(nil)
+    end
+
+    if pg_name && opg = ProductGroup.find_by_permalink(pg_name)
+      pg = new.from_product_group(opg)
+    elsif attrs
+      attrs = url.split("/")
+      pg = new.from_route(attrs)
+    end
+    taxon = taxons && taxons.split("/").last
+    pg.add_scope("in_taxon", taxon) if taxon
+
+    pg
+  end
+
+  def from_product_group(opg)
+    self.product_scopes = opg.product_scopes.map{|ps|
+      ps = ps.clone;
+      ps.product_group_id = nil;
+      ps.product_group = self;
+      ps
+    }
+    self
+  end
+
+  def from_route(attrs)
+    self.order_scope = attrs.pop if attrs.length % 2 == 1
+    attrs.each_slice(2) do |scope|
+      next unless Product.respond_to?(scope.first)
+      add_scope(scope.first, scope.last.split(","))
+    end
+    self
+  end
+
+  def from_search(search_hash)
+    search_hash.each_pair do |scope_name, scope_attribute|
+      add_scope(scope_name, scope_attribute)
+    end
+
+    self
+  end
+
+  def add_scope(scope_name, arguments=[])
+    if scope_name.to_s !~ /eval|send|system|[^a-z0-9_!?]/
+      self.product_scopes << ProductScope.new({
+          :name => scope_name.to_s,
+          :arguments => [*arguments]
+        })
+    else
+      raise ArgumentError.new("'#{scope_name}` can't be used as scope")
+    end
+    self
+  end
+
+  def apply_on(scopish, use_order = true)
+    # There's bug in AR, it doesn't merge :order, instead it takes order
+    # from first nested_scope so we have to apply ordering FIRST.
+    # see #2253 on rails LH
+    base_product_scope = scopish
+    if use_order && !self.order_scope.blank? && Product.respond_to?(self.order_scope.intern)
+      base_product_scope = base_product_scope.send(self.order_scope)
+    end
+
+    return self.product_scopes.reject {|s| s.is_ordering? }.inject(base_product_scope) do |result, scope|
+      scope.apply_on(result)
+    end
+
+  end
+
+  # returns chain of named scopes generated from order scope and product scopes.
+  def dynamic_products(use_order = true)
+    apply_on(Product.group_by_products_id, use_order)
+  end
+
+  # Does the final ordering if requested
+  # TODO: move the order stuff out of the above - is superfluous now
+  def products(use_order = true)
+    cached_group = Product.in_cached_group(self)
+    if cached_group.limit(1).blank?
+      dynamic_products(use_order)
+    elsif !use_order
+      cached_group
+    else
+      product_scopes.select {|s|
+        s.is_ordering?
+      }.inject(cached_group) {|res,order|
+        order.apply_on(res)
+      }
+    end
+  end
+
+  def include?(product)
+    res = apply_on(Product.id_equals(product.id), false)
+    res.count > 0
+  end
+
+  def scopes_to_hash
+    result = {}
+    self.product_scopes.each do |scope|
+      result[scope.name] = scope.arguments
+    end
+    result
+  end
+
+  # generates ProductGroup url
+  def to_url
+    if (new_record? || name.blank?)
+      result = ""
+      result+= self.product_scopes.map{|ps|
+        [ps.name, ps.arguments.join(",")]
+      }.flatten.join('/')
+      result+= self.order_scope if self.order_scope
+
+      result
+    else
+      name.to_url
+    end
+  end
+
+  def set_permalink
+    self.permalink = self.name.to_url
+  end
+
+  def update_memberships
+    # wipe everything directly to avoid expensive in-rails sorting
+    ActiveRecord::Base.connection.execute "DELETE FROM product_groups_products WHERE product_group_id = #{self.id}"
+
+    # and generate the new group entirely in SQL
+    ActiveRecord::Base.connection.execute "INSERT INTO product_groups_products #{dynamic_products(false).scoped(:select => "products.id, #{self.id}").to_sql}"
+  end
+
+  def generate_preview(size = Spree::Config[:admin_pgroup_preview_size])
+    count = self.class.count_by_sql ["SELECT COUNT(*) FROM product_groups_products WHERE product_groups_products.product_group_id = ?", self]
+
+    return count, products.limit(size)
+  end
+
+  def to_s
+    "<ProductGroup" + (id && "[#{id}]").to_s + ":'#{to_url}'>"
+  end
+  
+  def to_param
+    self.permalink
+  end
+
+  def order_scope
+    if scope = product_scopes.detect {|s| s.is_ordering?}
+      scope.name
+    end
+  end
+
+  def order_scope=(scope_name)
+    if scope = product_scopes.detect {|s| s.is_ordering?}
+      scope.update_attribute(:name, scope_name)
+    else
+      self.product_scopes.build(:name => scope_name, :arguments => [])
+    end
+  end
+
+  # Build a new product group with a scope to filter by specified products
+  def self.new_from_products(products, attrs = {})
+    pg = new(attrs)
+    pg.product_scopes.build(:name => 'with_ids', :arguments => [products.map(&:id).join(',')])
+    pg
+  end
+
+end

data/app/models/product_option_type.rb

@@ -0,0 +1,5 @@
+class ProductOptionType < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :option_type
+  acts_as_list :scope => :product
+end

data/app/models/product_property.rb

@@ -0,0 +1,15 @@
+class ProductProperty < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :property
+
+  validates :property, :presence => true
+
+  # virtual attributes for use with AJAX completion stuff
+  def property_name
+    property.name if property
+  end
+
+  def property_name=(name)
+    self.property = Property.find_by_name(name) unless name.blank?
+  end
+end

data/app/models/product_scope.rb

@@ -0,0 +1,78 @@
+# *ProductScope* is model for storing named scopes with their arguments,
+# to be used with ProductGroups.
+#
+# Each product Scope can be applied to Product (or product scope) with #apply_on method
+# which returns new combined named scope
+#
+class ProductScope < ActiveRecord::Base
+  # name
+  # arguments
+  belongs_to :product_group
+  serialize :arguments
+
+  validate :check_validity_of_scope
+
+  extend ::Scopes::Dynamic
+
+  # Get all products with this scope
+  def products
+    if Product.respond_to?(name)
+      Product.send(name, *arguments)
+    end
+  end
+
+  # Applies product scope on Product model or another named scope
+  def apply_on(another_scope)
+    array = *self.arguments
+    if Product.respond_to?(self.name.intern)
+      relation2 = if (array.blank? || array.size < 2)
+                      Product.send(self.name.intern, array.try(:first))
+                  else
+                      Product.send(self.name.intern, *array)
+                  end
+    else
+      relation2 = Product.metasearch({self.name.intern => array}).relation
+    end
+    unless another_scope.class == ActiveRecord::Relation
+      another_scope = another_scope.send(:relation)
+    end
+    another_scope.merge(relation2)
+  end
+
+  before_validation(:on => :create) {
+    # Add default empty arguments so scope validates and errors aren't caused when previewing it
+     if name && args = Scopes::Product.arguments_for_scope_name(name)
+      self.arguments ||= ['']*args.length
+    end
+  }
+
+  # checks validity of the named scope (if its safe and can be applied on Product)
+  def check_validity_of_scope
+    errors.add(:name, "is not a valid scope name") unless Product.respond_to?(self.name.intern)
+    apply_on(Product).limit(0) != nil
+  rescue Exception => e
+    unless Rails.env.production?
+
+      puts "name: #{self.name}"
+      puts "arguments: #{self.arguments.inspect}"
+      puts e.message
+      puts e.backtrace
+    end
+    errors.add(:arguments, "are incorrect")
+  end
+
+  # test ordering scope by looking for name pattern or missed arguments
+  def is_ordering?
+    name =~ /^(ascend_by|descend_by)/ || arguments.blank?
+  end
+
+  def to_sentence
+    result = I18n.t(:sentence, :scope => [:product_scopes, :scopes, self.name], :default => "")
+    result = I18n.t(:name, :scope => [:product_scopes, :scopes, self.name]) if result.blank?
+    result % [*self.arguments]
+  end
+
+  def to_s
+    to_sentence
+  end
+end

data/app/models/property.rb

@@ -0,0 +1,18 @@
+class Property < ActiveRecord::Base
+  has_and_belongs_to_many :prototypes
+
+  has_many :product_properties, :dependent => :destroy
+  has_many :products, :through => :product_properties
+
+  validates :name, :presentation, :presence => true
+
+  scope :sorted, lambda { order(:name) }
+
+  def self.find_all_by_prototype(prototype)
+    id = prototype
+    if prototype.class == Prototype
+      id = prototype.id
+    end
+    joins('left join properties_prototypes on property_id = properties.id').where('prototype_id = ?', id)
+  end
+end