spree 0.11.4 → 0.30.0.beta1

data/app/models/product_group.rb

@@ -1,205 +0,0 @@
-# *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 Searchlogic
-#
-class ProductGroup < ActiveRecord::Base
-  validates_presence_of :name
-  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.condition?(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 Product.search_scopes.include?(scope_name.intern)
-      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.condition?(self.order_scope)
-      base_product_scope = base_product_scope.send(self.order_scope)
-    end
-
-    return self.product_scopes.reject {|s|
-             s.is_ordering?
-           }.inject(base_product_scope){|result, scope|
-             scope.apply_on(result)
-           }
-  end
-
-  # returns chain of named scopes generated from order scope and product scopes.
-  def dynamic_products(use_order = true)
-    apply_on(Product.scoped(nil), 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 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
-  
-end

data/app/models/product_option_type.rb

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

data/app/models/product_property.rb

@@ -1,15 +0,0 @@
-class ProductProperty < ActiveRecord::Base
-  belongs_to :product
-  belongs_to :property
-  
-  validates_presence_of :property
-  
-  # 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

@@ -1,56 +0,0 @@
-# *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
-
-  extend ::Scopes::Dynamic
-
-  # Get all products with this scope
-  def products
-    if Product.condition?(self.name)
-      Product.send(self.name, *self.arguments)
-    end
-  end
-
-  # Applies product scope on Product model or another named scope
-  def apply_on(another_scope)
-    another_scope.send(self.name, *self.arguments)
-  end
-
-  def before_validation_on_create
-    # Add default empty arguments so scope validates and errors aren't caused when previewing it
-    if args = Scopes::Product.arguments_for_scope_name(name)
-      self.arguments ||= ['']*args.length
-    end
-  end
-  
-  # checks validity of the named scope (if its safe and can be applied on Product)
-  def validate
-    errors.add(:name, "is not a valid scope name") unless Product.condition?(self.name)
-    apply_on(Product).limit(0) != nil
-  rescue Exception
-    errors.add(:arguments, "are incorrect")
-  end
-
-  # test ordering scope by looking for name pattern or :order clause
-  def is_ordering?
-    name =~ /^(ascend_by|descend_by)/ || apply_on(Product).scope(:find)[:order].present?
-  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

@@ -1,20 +0,0 @@
-class Property < ActiveRecord::Base
-  has_and_belongs_to_many :prototypes
-
-  has_many :product_properties, :dependent => :destroy, :attributes => true
-  has_many :products, :through => :product_properties
-
-  validates_presence_of :name, :presentation
-  
-  named_scope :sorted, :order => :name
-
-  def self.find_all_by_prototype(prototype)
-    id = prototype
-    if prototype.class == Prototype
-      id = prototype.id
-    end
-
-    find(:all, :conditions => [ 'prototype_id = ?', id ],
-         :joins => 'left join properties_prototypes on property_id = properties.id')
-  end
-end

data/app/models/prototype.rb

@@ -1,5 +0,0 @@
-class Prototype < ActiveRecord::Base
-  has_and_belongs_to_many :properties
-  has_and_belongs_to_many :option_types
-  validates_presence_of :name
-end

data/app/models/return_authorization.rb

@@ -1,72 +0,0 @@
-class ReturnAuthorization < ActiveRecord::Base
-  belongs_to :order
-  has_many :inventory_units
-  before_create :generate_number
-
-  validates_presence_of :order
-  validates_numericality_of :amount
-  validate :must_have_shipped_units
-
-  state_machine :initial => 'authorized' do
-    after_transition :to => 'received', :do => :add_credit
-
-    event :receive do
-      transition :to => 'received', :from => 'authorized', :if => :allow_receive?
-    end
-    event :cancel do
-      transition :to => 'cancelled', :from => 'authorized'
-    end
-  end
-
-  def add_variant(variant_id, quantity)
-    order_units = self.order.inventory_units.group_by(&:variant_id)
-    returned_units = self.inventory_units.group_by(&:variant_id)
-
-    count = 0
-
-    if returned_units[variant_id].nil? || returned_units[variant_id].size < quantity
-      count = returned_units[variant_id].nil? ? 0 : returned_units[variant_id].size
-
-      order_units[variant_id].each do |inventory_unit|
-        next unless inventory_unit.return_authorization.nil? && count < quantity
-
-        inventory_unit.return_authorization = self
-        inventory_unit.save!
-
-        count += 1
-      end
-    elsif returned_units[variant_id].size > quantity
-      (returned_units[variant_id].size - quantity).times do |i|
-        returned_units[variant_id][i].return_authorization_id = nil
-        returned_units[variant_id][i].save!
-      end
-    end
-
-    self.order.return_authorized! if self.inventory_units.reload.size > 0 && !self.order.awaiting_return?
-  end
-
-  private
-  def must_have_shipped_units
-    errors.add(:order, I18n.t("has_no_shipped_units")) if order.nil? || order.shipped_units.nil?
-  end
-
-  def generate_number
-    return if self.number
-
-    record = true
-    while record
-      random = "RMA#{Array.new(9){rand(9)}.join}"
-      record = ReturnAuthorization.find(:first, :conditions => ["number = ?", random])
-    end
-    self.number = random
-  end
-
-  def add_credit
-    credit = ReturnAuthorizationCredit.create(:adjustment_source => self, :order_id => self.order.id, :amount => self.amount, :description => "RMA Credit")
-    self.order.update_totals!
-  end
-
-  def allow_receive?
-    !inventory_units.empty?
-  end
-end

data/app/models/return_authorization_credit.rb

@@ -1,3 +0,0 @@
-class ReturnAuthorizationCredit < Credit
-
-end

data/app/models/role.rb

@@ -1,3 +0,0 @@
-class Role < ActiveRecord::Base
-  has_and_belongs_to_many :users
-end

data/app/models/shipment.rb

@@ -1,131 +0,0 @@
-require 'ostruct'
-class Shipment < ActiveRecord::Base
-  belongs_to :order
-  belongs_to :shipping_method
-  belongs_to :address
-  has_one    :shipping_charge,   :as => :adjustment_source
-  alias charge shipping_charge
-  has_many :state_events, :as => :stateful
-  has_many :inventory_units
-  before_create :generate_shipment_number
-  after_create :set_correct_state
-  after_save :create_shipping_charge
-  after_destroy :release_inventory_units
-
-  attr_accessor :special_instructions
-  accepts_nested_attributes_for :address
-  accepts_nested_attributes_for :inventory_units
-
-  validates_presence_of :inventory_units, :if => Proc.new { |unit| !%w(in_progress canceled).include?(unit.order.state) }
-  make_permalink :field => :number
-
-  def to_param
-    self.number if self.number
-    generate_shipment_number unless self.number
-    self.number.parameterize.to_s.upcase
-  end
-
-  def shipped=(value)
-    return unless value == "1" && shipped_at.nil?
-    self.shipped_at = Time.now
-  end
-
-  def create_shipping_charge
-    if shipping_method
-      self.shipping_charge ||= ShippingCharge.create({
-          :order => order,
-          :description => description_for_shipping_charge,
-          :adjustment_source => self,
-        })
-
-      self.shipping_charge.update_attribute(:description, description_for_shipping_charge) unless self.shipping_charge.description == description_for_shipping_charge
-    end
-  end
-
-  def cost
-    shipping_charge.amount if shipping_charge
-  end
-
-  # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-  state_machine :initial => 'pending' do
-    event :ready do
-      transition :from => 'pending', :to => 'ready_to_ship'
-    end
-    event :pend do
-      transition :from => 'ready_to_ship', :to => 'pending'
-    end
-    event :ship do
-      transition :from => 'ready_to_ship', :to => 'shipped'
-    end
-
-    after_transition :to => 'shipped', :do => :transition_order
-  end
-
-  def editable_by?(user)
-    !shipped?
-  end
-
-  def manifest
-    inventory_units.group_by(&:variant).map do |i|
-      OpenStruct.new(:variant => i.first, :quantity => i.last.length)
-    end
-  end
-
-  def line_items
-    if order.checkout_complete
-      order.line_items.select {|li| inventory_units.map(&:variant_id).include?(li.variant_id)}
-    else
-      order.line_items
-    end
-  end
-
-  def recalculate_needed?
-    changed? or !address.same_as?(Address.find(address.id))
-  end
-
-  def recalculate_order
-    shipping_charge.update_attribute(:description, description_for_shipping_charge)
-    order.update_adjustments
-    order.update_totals!
-    order.save
-  end
-
-  private
-
-  def generate_shipment_number
-    return self.number unless self.number.blank?
-    record = true
-    while record
-      random = "H" + Array.new(11){rand(9)}.join
-      record = Shipment.find(:first, :conditions => ["number = ?", random])
-    end
-    self.number = random
-  end
-  
-  def set_correct_state
-    if pending? and order.checkout_complete and !order.outstanding_balance?
-      ready
-    end
-  end
-
-  def description_for_shipping_charge
-    "#{I18n.t(:shipping)} (#{shipping_method.name})"
-  end
-
-  def transition_order
-    update_attribute(:shipped_at, Time.now)
-    # transition order to shipped if all shipments have been shipped
-    order.ship! if order.shipments.all?(&:shipped?)
-  end
-
-  def validate
-    unless shipping_method.nil?
-      errors.add :shipping_method, I18n.t("is_not_available_to_shipment_address") unless shipping_method.zone.include?(address)
-    end
-  end
-
-  def release_inventory_units
-    inventory_units.each {|unit| unit.update_attribute(:shipment_id, nil)}
-  end
-
-end