My-Commerce_core 1.0.0

data/app/models/prototype.rb

@@ -0,0 +1,5 @@
+class Prototype < ActiveRecord::Base
+  has_and_belongs_to_many :properties
+  has_and_belongs_to_many :option_types
+  validates :name, :presence => true
+end

data/app/models/return_authorization.rb

@@ -0,0 +1,79 @@
+class ReturnAuthorization < ActiveRecord::Base
+  belongs_to :order
+  has_many :inventory_units
+  before_create :generate_number
+  before_save :force_positive_amount
+
+  validates :order, :presence => true
+  validates :amount, :numericality => true
+  validate :must_have_shipped_units
+
+  state_machine :initial => 'authorized' do
+    after_transition :to => 'received', :do => :process_return
+
+    event :receive do
+      transition :to => 'received', :from => 'authorized', :if => :allow_receive?
+    end
+    event :cancel do
+      transition :to => 'canceled', :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.authorize_return! 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.inventory_units.any?(&:shipped?)
+  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 process_return
+    inventory_units.each &:return!
+
+    credit = Adjustment.create(:source => self, :order_id => self.order.id, :amount => self.amount.abs * -1, :label => I18n.t("rma_credit"))
+    self.order.update!
+  end
+
+  def allow_receive?
+    !inventory_units.empty?
+  end
+
+  def force_positive_amount
+    self.amount = self.amount.abs
+  end
+end

data/app/models/role.rb

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

data/app/models/shipment.rb

@@ -0,0 +1,157 @@
+require 'ostruct'
+class Shipment < ActiveRecord::Base
+  belongs_to :order
+  belongs_to :shipping_method
+  belongs_to :address
+  has_many :state_events, :as => :stateful
+  has_many :inventory_units
+  has_one :adjustment, :as => :source
+
+  before_create :generate_shipment_number
+  after_destroy :release_inventory_units
+  after_save :ensure_correct_adjustment, :update_order
+
+  attr_accessor :special_instructions
+  accepts_nested_attributes_for :address
+  accepts_nested_attributes_for :inventory_units
+
+  validates :inventory_units, :presence => true, :if => :require_inventory
+  validates :shipping_method, :presence => true
+
+  make_permalink :field => :number
+
+  scope :shipped, where(:state => 'shipped')
+  scope :ready, where(:state => 'ready')
+  scope :pending, where(:state => 'pending')
+
+  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
+
+  # The adjustment amount associated with this shipment (if any.)  Returns only the first adjustment to match
+  # the shipment but there should never really be more than one.
+  def cost
+    adjustment ? adjustment.amount : 0
+  end
+
+  # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+  state_machine :initial => 'pending', :use_transactions => false do
+    event :ready do
+      transition :from => 'pending', :to => 'ready'
+    end
+    event :pend do
+      transition :from => 'ready', :to => 'pending'
+    end
+    event :ship do
+      transition :from => 'ready', :to => 'shipped'
+    end
+
+    after_transition :to => 'shipped', :do => :after_ship
+  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.complete? and Spree::Config[:track_inventory_levels]
+      order.line_items.select {|li| inventory_units.map(&:variant_id).include?(li.variant_id)}
+    else
+      order.line_items
+    end
+  end
+
+  # Updates various aspects of the Shipment while bypassing any callbacks.  Note that this method takes an explicit reference to the
+  # Order object.  This is necessary because the association actually has a stale (and unsaved) copy of the Order and so it will not
+  # yield the correct results.
+  def update!(order)
+    old_state = self.state
+    new_state = determine_state(order)
+    update_attribute_without_callbacks "state", determine_state(order)
+    after_ship if new_state == 'shipped' and old_state != 'shipped'
+  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 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_shipping_method
+    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
+
+  # Determines the appropriate +state+ according to the following logic:
+  #
+  # pending    unless +order.payment_state+ is +paid+
+  # shipped    if already shipped (ie. does not change the state)
+  # ready      all other cases
+  def determine_state(order)
+    return "pending" if self.inventory_units.any? {|unit| unit.backordered?}
+    return "shipped" if state == "shipped"
+    order.payment_state == "balance_due" ? "pending" : "ready"
+  end
+
+  # Determines whether or not inventory units should be associated with the shipment.  This is always +false+ when
+  # +Spree::Config[:track_inventory_levels]+ is set to +false.+  Otherwise its +true+ whenever the order is completed
+  # (and not canceled.)
+  def require_inventory
+    return false unless Spree::Config[:track_inventory_levels]
+    order.completed? && !order.canceled?
+  end
+
+  def after_ship
+    inventory_units.each &:ship!
+    ShipmentMailer.shipped_email(self).deliver
+  end
+
+  def ensure_correct_adjustment
+    if adjustment
+      adjustment.originator = shipping_method
+      adjustment.save
+    else
+      shipping_method.create_adjustment(I18n.t(:shipping), order, self, true)
+      reload #ensure adjustment is present on later saves
+    end
+  end
+
+  def update_order
+    order.update!
+  end
+end

data/app/models/shipping_category.rb

@@ -0,0 +1,3 @@
+class ShippingCategory < ActiveRecord::Base
+  validates :name, :presence => true
+end

data/app/models/shipping_method.rb

@@ -0,0 +1,25 @@
+class ShippingMethod < ActiveRecord::Base
+  DISPLAY =  [:both, :front_end, :back_end]
+  belongs_to :zone
+  has_many :shipments
+  validates :name, :calculator, :zone, :presence => true
+
+  calculated_adjustments
+
+  def available?(order, display_on=nil)
+    display_check = (self.display_on == display_on.to_s || self.display_on.blank?)
+    calculator_check = calculator.available?(order)
+    display_check && calculator_check
+  end
+
+  def available_to_order?(order, display_on=nil)
+    availability_check = available?(order,display_on)
+    zone_check = zone && zone.include?(order.ship_address)
+    availability_check && zone_check
+  end
+
+  def self.all_available(order, display_on=nil)
+    all.select { |method| method.available_to_order?(order,display_on)}
+  end
+
+end

data/app/models/spree/alert.rb

@@ -0,0 +1,13 @@
+class Spree::Alert < ActiveResource::Base
+  self.site = "http://alerts.spreecommerce.com/"
+  self.format = :json
+
+  def self.current(host)
+    find(:all, :params => { :version => Spree.version,
+                            :name => Spree::Config[:site_name],
+                            :host => host,
+                            :rails_env => Rails.env,
+                            :rails_version => Rails.version })
+  end
+end
+

data/app/models/state.rb

@@ -0,0 +1,16 @@
+class State < ActiveRecord::Base
+  belongs_to  :country
+
+  has_one :zone_member, :as => :zoneable
+  has_one :zone, :through => :zone_member
+
+  validates :country, :name, :presence => true
+
+  def <=>(other)
+    name <=> other.name
+  end
+
+  def to_s
+    name
+  end
+end

data/app/models/state_event.rb

@@ -0,0 +1,16 @@
+class StateEvent < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :stateful, :polymorphic => true
+  before_create :assign_user
+
+  def <=>(other)
+    created_at <=> other.created_at
+  end
+
+  def assign_user
+    # if Session.activated? && current_user_session = Session.find
+    #   self.user_id ||= current_user_session.user.id
+    # end
+    true   # don't stop the filters
+  end
+end

data/app/models/tax_category.rb

@@ -0,0 +1,15 @@
+class TaxCategory < ActiveRecord::Base
+  validates :name, :presence => true, :uniqueness => true
+
+  has_many :tax_rates
+
+  before_save :set_default_category
+
+  def set_default_category
+    #set existing default tax category to false if this one has been marked as default
+
+    if is_default && tax_category = TaxCategory.find(:first, :conditions => {:is_default => true})
+      tax_category.update_attribute(:is_default, false)
+    end
+  end
+end

data/app/models/tax_rate.rb

@@ -0,0 +1,16 @@
+class TaxRate < ActiveRecord::Base
+  belongs_to :zone
+  belongs_to :tax_category
+
+  validates :amount, :presence => true, :numericality => true
+
+  calculated_adjustments :default => Calculator::SalesTax
+  scope :by_zone, lambda { |zone| where("zone_id = ?", zone)}
+
+  # Searches all possible TaxRates and returns the Zone which represents the most appropriate match (if any.)
+  # To be considered for a match, the Zone must include the supplied address.  If multiple matches are
+  # found, the Zone with the highest rate will be returned.  This method will return +nil+ if no match is found.
+  def self.match(address)
+    TaxRate.all.select { |rate| rate.zone.include? address }
+  end
+end

data/app/models/taxon.rb

@@ -0,0 +1,52 @@
+class Taxon < ActiveRecord::Base
+  acts_as_nested_set :dependent => :destroy
+
+  belongs_to :taxonomy
+  has_and_belongs_to_many :products
+  before_create :set_permalink
+
+  validates :name, :presence => true
+  has_attached_file :icon,
+                :styles => { :mini => '32x32>', :normal => '128x128>' },
+                :default_style => :mini,
+                :url => "/assets/taxons/:id/:style/:basename.:extension",
+                :path => ":rails_root/public/assets/taxons/:id/:style/:basename.:extension",
+                :default_url => "/images/default_taxon.png"
+
+
+  include ::ProductFilters  # for detailed defs of filters
+
+  # indicate which filters should be used for a taxon
+  # this method should be customized to your own site
+  def applicable_filters
+    fs = []
+    # fs << ProductFilters.taxons_below(self)
+    ## unless it's a root taxon? left open for demo purposes
+
+    fs << ProductFilters.price_filter if ProductFilters.respond_to?(:price_filter)
+    fs << ProductFilters.brand_filter if ProductFilters.respond_to?(:brand_filter)
+    fs
+  end
+
+  # Creates permalink based on .to_url method provided by stringx gem
+  def set_permalink
+    if parent_id.nil?
+      self.permalink = name.to_url if self.permalink.blank?
+    else
+      parent_taxon = Taxon.find(parent_id)
+      self.permalink = [parent_taxon.permalink, (self.permalink.blank? ? name.to_url : self.permalink.split("/").last)].join('/')
+    end
+  end
+
+  def active_products
+    scope = self.products.active
+    scope = scope.on_hand unless Spree::Config[:show_zero_stock_products]
+    scope
+  end
+
+  private
+  # obsolete, kept for backwards compat
+  def escape(str)
+    str.blank? ? "" : str.to_url
+  end
+end

data/app/models/taxonomy.rb

@@ -0,0 +1,20 @@
+class Taxonomy < ActiveRecord::Base
+
+  validates :name, :presence => true
+  has_many :taxons, :dependent => :destroy
+  has_one :root, :class_name => 'Taxon', :conditions => "parent_id is null"
+  has_one :image, :as => :viewable, :order => :position, :dependent => :destroy
+  after_save :set_name
+
+  private
+
+  def set_name
+    if self.root
+      self.root.update_attribute(:name, self.name)
+    else
+      self.root = Taxon.create!({ :taxonomy_id => self.id, :name => self.name })
+  
+    end
+  end
+
+end

data/app/models/taxonomy.rb~

@@ -0,0 +1,22 @@
+class Taxonomy < ActiveRecord::Base
+
+  validates :name, :presence => true
+  has_many :taxons, :dependent => :destroy
+  has_one :root, :class_name => 'Taxon', :conditions => "parent_id is null"
+
+  after_save :set_name
+
+  private
+
+  def set_name
+    if self.root
+      p "asdgggggggggggggggggggggggggggggggggggggggggggggggggggggggggg rooot"
+      self.root.update_attribute(:name, self.name)
+    else
+      p "setnameeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeE"
+      self.root = Taxon.create!({ :taxonomy_id => self.id, :name => self.name })
+      @obj = Asset.create(params[:attachement])#({ :taxonomy_id => self.id, :name => self.name })
+    end
+  end
+
+end

data/app/models/tracker.rb

@@ -0,0 +1,5 @@
+class Tracker < ActiveRecord::Base
+  def self.current
+    Tracker.find(:first, :conditions => {:active => true, :environment => ENV['RAILS_ENV']})
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,21 @@
+# Default implementation of User.  This class is intended to be modified by extensions (ex. spree_auth)
+class User < ActiveRecord::Base
+
+  has_many :orders
+  belongs_to :ship_address, :foreign_key => "ship_address_id", :class_name => "Address"
+  belongs_to :bill_address, :foreign_key => "bill_address_id", :class_name => "Address"
+  scope :registered
+
+  def anonymous?
+    false
+  end
+
+  # Creates an anonymous user
+  def self.anonymous!
+    User.create
+  end
+
+  attr_accessor :password
+  attr_accessor :password_confirmation
+
+end

data/app/models/variant.rb

@@ -0,0 +1,104 @@
+class Variant < ActiveRecord::Base
+  belongs_to :product
+  delegate_belongs_to :product, :name, :description, :permalink, :available_on, :tax_category_id, :shipping_category_id, :meta_description, :meta_keywords
+
+  has_many :inventory_units
+  has_many :line_items
+  has_and_belongs_to_many :option_values
+  has_many :images, :as => :viewable, :order => :position, :dependent => :destroy
+
+  validate :check_price
+  validates :price, :presence => true
+  validates :cost_price, :numericality => true, :allow_nil => true if Variant.table_exists? && Variant.column_names.include?("cost_price")
+
+  before_save :touch_product
+
+  include ::Scopes::Variant
+  # default variant scope only lists non-deleted variants
+  scope :active, where("variants.deleted_at is null")
+  scope :deleted, where("not variants.deleted_at is null")
+
+  # default extra fields for shipping purposes
+  @fields = [ {:name => 'Weight', :only => [:variant], :format => "%.2f"},
+              {:name => 'Height', :only => [:variant], :format => "%.2f"},
+              {:name => 'Width',  :only => [:variant], :format => "%.2f"},
+              {:name => 'Depth',  :only => [:variant], :format => "%.2f"} ]
+
+  # Returns number of inventory units for this variant (new records haven't been saved to database, yet)
+  def on_hand
+    Spree::Config[:track_inventory_levels] ? self.count_on_hand : nil
+  end
+
+  # Adjusts the inventory units to match the given new level.
+  def on_hand=(new_level)
+    if Spree::Config[:track_inventory_levels]
+      new_level = new_level.to_i
+
+      # increase Inventory when
+      if new_level > on_hand
+        # fill backordered orders before creating new units
+        inventory_units.with_state("backordered").slice(0, new_level).each do |iu|
+          iu.fill_backorder
+          new_level -= 1
+        end
+      end
+
+      self.count_on_hand = new_level
+    else
+      raise "Cannot set on_hand value when Spree::Config[:track_inventory_levels] is false"
+    end
+  end
+
+  # returns number of units currently on backorder for this variant.
+  def on_backorder
+    inventory_units.with_state("backordered").size
+  end
+
+  # returns true if at least one inventory unit of this variant is "on_hand"
+  def in_stock?
+    Spree::Config[:track_inventory_levels] ? on_hand > 0 : true
+  end
+  alias in_stock in_stock?
+
+  def self.additional_fields
+    @fields
+  end
+
+  def self.additional_fields=(new_fields)
+    @fields = new_fields
+  end
+
+  # returns true if this variant is allowed to be placed on a new order
+  def available?
+    Spree::Config[:track_inventory_levels] ? (Spree::Config[:allow_backorders] || self.in_stock?) : true
+  end
+
+  def options_text
+    self.option_values.sort{|ov1, ov2| ov1.option_type.position <=> ov2.option_type.position}.map { |ov| "#{ov.option_type.presentation}: #{ov.presentation}" }.to_sentence({:words_connector => ", ", :two_words_connector => ", "})
+  end
+
+  def gross_profit
+    self.cost_price.nil? ? 0 : (self.price - self.cost_price)
+  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
+
+  private
+
+  # Ensures a new variant takes the product master price when price is not supplied
+  def check_price
+    if self.price.nil?
+      raise "Must supply price for variant or master.price for product." if self == product.master
+      self.price = product.master.price
+    end
+  end
+
+  def touch_product
+    product.touch unless is_master?
+  end
+end

data/app/models/zone.rb

@@ -0,0 +1,84 @@
+class Zone < ActiveRecord::Base
+  has_many :zone_members
+  has_many :tax_rates, :dependent => :destroy
+  has_many :shipping_methods
+
+  validates :name, :presence => true, :uniqueness => true
+  after_save :remove_defunct_members
+
+  alias :members :zone_members
+  accepts_nested_attributes_for :zone_members, :allow_destroy => true, :reject_if => proc { |a| a['zoneable_id'].blank? }
+
+  # WARNING during tets class method .global is declared to indicate global Zone to use with tests
+
+  #attr_accessor :type
+  def kind
+    member = self.members.last
+    case member && member.zoneable_type
+    when "State"  then "state"
+    when "Zone"   then "zone"
+    else
+      "country"
+    end
+  end
+
+  def kind=(value)
+    # do nothing - just here to satisfy the form
+  end
+
+  # alias to the new include? method
+  def in_zone?(address)
+    $stderr.puts "Warning: calling deprecated method :in_zone? use :include? instead."
+    include?(address)
+  end
+
+  def include?(address)
+    return false unless address
+
+    # NOTE: This is complicated by the fact that include? for HMP is broken in Rails 2.1 (so we use awkward index method)
+    members.any? do |zone_member|
+      case zone_member.zoneable_type
+      when "Zone"
+        zone_member.zoneable.include?(address)
+      when "Country"
+        zone_member.zoneable == address.country
+      when "State"
+        zone_member.zoneable == address.state
+      else
+        false
+      end
+    end
+  end
+
+  def self.match(address)
+    Zone.all.select {|zone| zone.include?(address)}
+  end
+
+  # convenience method for returning the countries contained within a zone (different then the countries method which only
+  # returns the zones children and does not consider the grand children if the children themselves are zones)
+  def country_list
+    members.map {|zone_member|
+      case zone_member.zoneable_type
+      when "Zone"
+        zone_member.zoneable.country_list
+      when "Country"
+        zone_member.zoneable
+      when "State"
+        zone_member.zoneable.country
+      else
+        nil
+      end
+    }.flatten.compact.uniq
+  end
+
+  def <=>(other)
+    name <=> other.name
+  end
+
+  private
+  def remove_defunct_members
+    zone_members.each do |zone_member|
+      zone_member.destroy if zone_member.zoneable_id.nil?
+    end
+  end
+end

data/app/models/zone_member.rb

@@ -0,0 +1,10 @@
+class ZoneMember < ActiveRecord::Base
+  belongs_to :zone
+  belongs_to :zoneable, :polymorphic => true
+
+  def name
+    return nil if zoneable.nil?
+    zoneable.name
+  end
+
+end