apispree_core 0.0.0

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

data/app/stylesheets/_buttons.less

@@ -0,0 +1,80 @@
+@import "_mixins";
+
+button, a.button, input.button {
+  .rounded_corners(0.3em);
+  background: #efefef url(../images/buttons/bg-button.png) center left repeat-x !important;
+  border-style: solid;
+  border-width: 1px !important;
+  border-color: #ddd #999 #999 #ddd !important;
+  -moz-outline-radius: .3em;
+  color: #111;
+  display: inline-block;
+  font-family: Helvetica Neue, Helvetica, Arial, Sans-serif;
+  font-size: 1.1em !important;
+  font-size-adjust: none;
+  font-stretch: normal;
+  font-style: normal;
+  font-variant: normal;
+  font-weight: normal;
+  line-height: 1.2em;
+  margin: 0px;
+  overflow: visible;
+  padding: 10px 17px;
+  text-decoration: none;
+  text-transform: lowercase;
+  width: auto;
+  height: auto;
+  cursor: pointer;
+}
+
+button.primary, a.button.primary, input.button.primary {
+  font-weight: bold;
+  color: #000;
+}
+
+button.disabled, a.button.disabled, input.button.disabled{
+  font-weight: bold;
+  color: #999;
+}
+
+button:hover, a.button:hover, input.button:hover {
+  background-image: url(../images/buttons/bg-button-hover.png) !important;
+}
+
+button.large, a.button.large, input.button.large {
+  .rounded_corners(0.3em);
+  font-size: 1.4em !important;
+  line-height: 1.4em;
+}
+
+button.small, a.button.small, input.button.small {
+  .rounded_corners(4px);
+  font-size: .9em;
+  line-height: 1.4em;
+  padding: 5px 10px;
+}
+
+button.small img, a.button.small img, input.button.small img {
+  margin: 0 3px 0 0 !important;
+}
+
+button.update img, button.checkout img, a.button.update img, a.button.checkout img, input.button.update img, input.button.checkout img {
+  margin-right: 7px;
+}
+
+button img, a.button img, input.button img {
+  vertical-align: middle;
+}
+
+button:focus, a.button:focus, input.button:focus {
+  outline: none;
+}
+
+button::-moz-focus-inner {
+  padding: 0px;
+  border: none;
+}
+
+p a.button img, p button img {
+  margin: 0 5px 0 0;
+}