railscart 0.0.1

data/starter-app/vendor/plugins/railscart/app/helpers/admin/overview_helper.rb

@@ -0,0 +1,12 @@
+module Admin::OverviewHelper
+  def render_ordes(orders, later=false)
+    text = []
+    if orders.any?
+      # TODO: handle Order objects, create partials for this
+      # orders.each_with_index {|order, i| text << render(:partial => "#{order.mode}_event", :locals => {:order => order, :shaded => (i % 2 > 0), :later => later}) }
+    else
+      text << %w(<li class="order-none shade">No orders</li>)
+    end
+    %(<ul class="orders">#{text.join}</ul>)
+  end
+end

data/starter-app/vendor/plugins/railscart/app/helpers/admin/users_helper.rb

@@ -0,0 +1,2 @@
+module Admin::UsersHelper
+end

data/starter-app/vendor/plugins/railscart/app/helpers/admin/variations_helper.rb

@@ -0,0 +1,2 @@
+module Admin::VariationsHelper
+end

data/starter-app/vendor/plugins/railscart/app/helpers/cart_helper.rb

@@ -0,0 +1,6 @@
+module CartHelper
+  def previous_location
+    session[:PREVIOUS_LOCATION]
+  end
+end
+

data/starter-app/vendor/plugins/railscart/app/helpers/checkout_helper.rb

@@ -0,0 +1,17 @@
+require 'shipping/flat_rate'
+require 'tax/sales_tax'
+
+module CheckoutHelper
+  CREDIT_CARD_TYPES = [
+    ["Visa", "visa"], 
+    ["Master Card", "master"],
+    ["Discover", "discover"], 
+    ["American Express", "american_express"]
+  ].freeze
+  
+  #for some reason i had to define a method ... apparently constants are not mixed in
+  #in the view helper (not sure but that's my guess)
+  def credit_card_types
+    CREDIT_CARD_TYPES
+  end  
+end

data/starter-app/vendor/plugins/railscart/app/helpers/rails_cart/base_helper.rb

@@ -0,0 +1,67 @@
+module RailsCart::BaseHelper
+  require 'paginating_find'
+  
+  def stylesheets
+    stylesheets = [stylesheet_link_tag("railscart", :plugin=>"railscart")]
+    #stylesheets = [stylesheet_link_tag("railscart-admin.css", :plugin=>"railscart")]
+    ["#{controller.controller_name}/_controller", "#{controller.controller_name}/#{:action_name}"].each do |stylesheet|
+      if File.exists? "#{RAILS_ROOT}/public/stylesheets/#{stylesheet}.css" 
+        stylesheets << stylesheet_link_tag(stylesheet)   
+      else
+        stylesheets << stylesheet_link_tag(stylesheet, :plugin=>"railscart") if File.exists? "#{RAILS_ROOT}/public/plugin_assets/railscart/stylesheets/#{stylesheet}.css"
+      end
+    end
+    stylesheets.compact.join("\n")
+  end
+  
+  def windowed_pagination_links(pagingEnum, options)
+    link_to_current_page = options[:link_to_current_page]
+    always_show_anchors = options[:always_show_anchors]
+    padding = options[:window_size]
+
+    current_page = pagingEnum.page
+    html = ''
+
+    #Calculate the window start and end pages 
+    padding = padding < 0 ? 0 : padding
+    first = pagingEnum.page_exists?(current_page  - padding) ? current_page - padding : 1
+    last = pagingEnum.page_exists?(current_page + padding) ? current_page + padding : pagingEnum.last_page
+
+    # Print start page if anchors are enabled
+    html << yield(1) if always_show_anchors and not first == 1
+
+  # Print window pages
+  first.upto(last) do |page|
+    (current_page == page && !link_to_current_page) ? html << page : html << yield(page)
+  end
+
+  # Print end page if anchors are enabled
+  html << yield(pagingEnum.last_page) if always_show_anchors and not last == pagingEnum.last_page
+  html
+  end 
+  
+  def add_product_link(text, product) 
+    link_to_remote text, {:url => {:controller => "cart", 
+              :action => "add", :id => product}}, 
+              {:title => "Add to Cart", 
+               :href => url_for( :controller => "cart", 
+                          :action => "add", :id => product)} 
+  end 
+  
+  def remove_product_link(text, product) 
+    link_to_remote text, {:url => {:controller => "cart", 
+                       :action => "remove", 
+                       :id => product}}, 
+                       {:title => "Remove item", 
+                         :href => url_for( :controller => "cart", 
+                                     :action => "remove", :id => product)} 
+  end 
+  
+  def todays_short_date
+    utc_to_local(Time.now.utc).to_ordinalized_s(:stub)
+  end
+ 
+  def yesterdays_short_date
+    utc_to_local(Time.now.utc.yesterday).to_ordinalized_s(:stub)
+  end  
+end

data/starter-app/vendor/plugins/railscart/app/helpers/search_helper.rb

@@ -0,0 +1,10 @@
+module SearchHelper
+  def search_options
+    options = {}
+    return options if params[:search].nil?
+    params[:search].each do |name, value|
+      options["search[#{name}]"] = value
+    end
+    options
+  end
+end

data/starter-app/vendor/plugins/railscart/app/helpers/store_helper.rb

@@ -0,0 +1,3 @@
+module StoreHelper
+  
+end

data/starter-app/vendor/plugins/railscart/app/models/address.rb

@@ -0,0 +1,17 @@
+class Address < ActiveRecord::Base
+  belongs_to :country
+  belongs_to :state
+  
+  validates_presence_of :firstname
+  validates_presence_of :lastname
+  validates_presence_of :address1
+  validates_presence_of :city
+  validates_presence_of :state
+  validates_presence_of :zipcode
+  validates_presence_of :country
+  validates_presence_of :phone
+  
+  def full_name
+    self.firstname + " " + self.lastname
+  end
+end

data/starter-app/vendor/plugins/railscart/app/models/cart.rb

@@ -0,0 +1,37 @@
+class Cart < ActiveRecord::Base
+  has_many :cart_items, :dependent => :destroy do
+    def in_cart(product, variation = nil)
+      if variation
+        find :first, :conditions => ['product_id = ? and variation_id = ?', product.id, variation.id]
+      else
+        find :first, :conditions => ['product_id = ?', product.id]
+      end
+    end
+  end
+  has_many :products, :through => :cart_items
+
+  def total
+    cart_items.inject(0) {|sum, n| n.price * n.quantity + sum}
+  end
+  
+  def add_product(product, variation = nil)
+    current_item = cart_items.in_cart(product, variation)
+    if current_item
+      current_item.increment_quantity
+    else
+      current_item = CartItem.new(:quantity => 1, :product => product, :variation => variation)
+      cart_items << current_item
+    end
+    current_item
+  end
+  
+  def remove_product(product, variation = nil)
+    current_item = cart_items.in_cart(product, variation)
+    if current_item.quantity > 1
+      current_item.decrement_quantity
+    else
+      CartItem.destroy(current_item.id)
+    end
+    current_item
+  end
+end

data/starter-app/vendor/plugins/railscart/app/models/cart_item.rb

@@ -0,0 +1,28 @@
+class CartItem < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :variation
+  belongs_to :cart
+  
+  validates_presence_of :product, :quantity
+  validates_numericality_of :quantity, :only_integer => true
+  
+  def validate
+    unless quantity && quantity >= 0
+      errors.add(:quantity, "must be a positive value")
+    end
+  end
+  
+  def increment_quantity
+    self.quantity += 1
+  end
+
+  def decrement_quantity
+    self.quantity -= 1
+  end
+  
+  def price
+    pe = self.variation ? self.variation.price_effect : 0
+    self.product.price + pe
+  end
+  
+end

data/starter-app/vendor/plugins/railscart/app/models/category.rb

@@ -0,0 +1,66 @@
+class Category < ActiveRecord::Base
+  has_many :products
+  acts_as_list :scope => :parent_id
+  acts_as_tree :order => :position
+  has_and_belongs_to_many :tax_treatments
+  has_many :variations, :as => :variable, :dependent => :destroy
+  validates_presence_of :name
+  
+  def ancestors_name
+    if parent
+      parent.ancestors_name + parent.name + ':'
+    else
+      ""
+    end
+  end
+
+  def long_name
+    ancestors_name + name
+  end
+  
+  def before_save
+    self.parent = nil if parent == self
+  end
+  
+  # Serious Ruby hacking going on here.  We alias the original method for the association as added by 
+  # ActiveRecord and then override it so we can return the parent category's variations if they are present.
+  alias :ar_variations :variations
+  def variations
+    v = ar_variations
+    return v unless v.empty?
+    if self.parent and not self.parent.variations.empty?
+      # return a frozen copy of the parent category's variations
+      return Array.new(self.parent.variations).freeze   
+    else
+      # return category variations
+      return v
+    end
+  end   
+
+  # Serious Ruby hacking going on here.  We alias the original method for the association as added by 
+  # ActiveRecord and then override it so we can return the parent category's treatments if they are present.
+  alias :ar_tax_treatments :tax_treatments
+  def tax_treatments
+    tt = ar_tax_treatments
+    return tt unless tt.empty?
+    if self.parent and not self.parent.tax_treatments.empty?
+      # return a frozen copy of the parent category's treatments
+      return Array.new(self.parent.tax_treatments).freeze   
+    else
+      # return category tax treatments
+      return tt
+    end
+  end   
+  
+  # category may have a new parent so we should be sure to remove any db records associated with 
+  # the previous parent-child relationship 
+  def before_update
+    return if self.parent.nil?
+    return if self.variations.frozen? and self.tax_treatments.frozen? # variations and treatments were inherited from previous parent - leave them alone
+    unless self.parent.variations.empty? # new parent has no variations to inherit - leave the current ones alone
+      self.ar_variations.each do |v|
+        v.destroy
+      end
+    end
+  end
+end

data/starter-app/vendor/plugins/railscart/app/models/country.rb

@@ -0,0 +1,3 @@
+class Country < ActiveRecord::Base
+  has_many :states
+end

data/starter-app/vendor/plugins/railscart/app/models/line_item.rb

@@ -0,0 +1,24 @@
+class LineItem < ActiveRecord::Base
+  belongs_to :order
+  belongs_to :product
+  belongs_to :variation
+
+  validates_presence_of :product
+  validates_numericality_of :quantity
+  validates_numericality_of :price
+  
+  def self.from_cart_item(cart_item)
+    line_item = self.new
+    line_item.product = cart_item.product
+    line_item.quantity = cart_item.quantity
+    line_item.price = cart_item.price
+    line_item.variation = cart_item.variation
+    line_item
+  end  
+  
+  def total
+    self.price * self.quantity  
+  end
+  
+end
+

data/starter-app/vendor/plugins/railscart/app/models/option.rb

@@ -0,0 +1,4 @@
+class Option < ActiveRecord::Base
+  has_many :option_groups, :dependent => :destroy
+  has_many :option_values, :through => :option_groups
+end

data/starter-app/vendor/plugins/railscart/app/models/option_group.rb

@@ -0,0 +1,6 @@
+class OptionGroup < ActiveRecord::Base
+  belongs_to :option
+  belongs_to :option_value
+  
+  validates_presence_of :option, :option_value
+end

data/starter-app/vendor/plugins/railscart/app/models/option_value.rb

@@ -0,0 +1,4 @@
+class OptionValue < ActiveRecord::Base
+  has_many :option_groups
+  has_many :options, :through => :option_groups
+end

data/starter-app/vendor/plugins/railscart/app/models/order.rb

@@ -0,0 +1,86 @@
+class Order < ActiveRecord::Base
+  has_many :txns
+  has_many :line_items
+  belongs_to :user
+  belongs_to :bill_address, :class_name => "Address", :foreign_key => :bill_address_id
+  belongs_to :ship_address, :class_name => "Address", :foreign_key => :ship_address_id
+
+  enumerable_constant :status, :constants => ORDER_STATES
+  enumerable_constant :ship_method, :constants => SHIPPING_METHODS
+
+  #TODO - validate presence of user once we have the means to add one through controller
+  validates_presence_of :line_items
+  validates_associated :line_items, :message => "are not valid"
+  validates_numericality_of :tax_amount
+  validates_numericality_of :ship_amount
+  validates_numericality_of :item_total
+  validates_numericality_of :total
+
+  def self.new_from_cart(cart)
+    return nil if cart.cart_items.empty?
+    order = self.new
+    order.line_items = cart.cart_items.map do |item|
+      LineItem.from_cart_item(item)
+    end
+    order
+  end
+
+  def self.generate_order_number
+    record = true
+    while record
+      random = Array.new(9){rand(9)}.join
+      record = find(:first, :conditions => ["number = ?", random])
+    end
+    return random
+  end
+
+  # total of line items (no tax or shipping inc.)
+  def item_total
+    tot = 0
+    self.line_items.each do |li|
+      tot += li.total
+    end
+    self.item_total = tot
+  end
+  
+  def total
+    self.total = self.item_total + self.ship_amount + self.tax_amount
+  end
+
+
+  # Generate standard options used by ActiveMerchant gateway for authorize, capture, etc. 
+  def self.gateway_options(order)
+    billing_address = {:name => order.bill_address.full_name,
+                       :address1 => order.bill_address.address1,
+                       :address2 => order.bill_address.address2, 
+                       :city => order.bill_address.city,
+                       :state => order.bill_address.state.abbr, 
+                       :zip => order.bill_address.zipcode,
+                       :country => order.bill_address.country.name,
+                       :phone => order.bill_address.phone}
+    shipping_address = {:name => order.ship_address.full_name,
+                       :address1 => order.ship_address.address1,
+                       :address2 => order.ship_address.address2, 
+                       :city => order.ship_address.city,
+                       :state => order.ship_address.state.abbr, 
+                       :zip => order.ship_address.zipcode,
+                       :country => order.ship_address.country.name,
+                       :phone => order.ship_address.phone}
+    options = {:billing_address => billing_address, :shipping_address => shipping_address}
+    options.merge(self.minimal_gateway_options(order))
+  end
+ 
+  # Generates a minimal set of gateway options.  There appears to be some issues with passing in 
+  # a billing address when authorizing/voiding a previously captured transaction.  So omits these 
+  # options in this case since they aren't necessary.  
+  def self.minimal_gateway_options(order)
+    {:email => order.user.email, 
+     :customer => order.user.login, 
+     :ip => order.ip_address, 
+     :order_id => order.number,
+     :shipping => order.ship_amount * 100,
+     :tax => order.tax_amount * 100, 
+     :subtotal => order.item_total * 100}  
+  end
+
+end

data/starter-app/vendor/plugins/railscart/app/models/order_mailer.rb

@@ -0,0 +1,20 @@
+class OrderMailer < ActionMailer::Base
+  def confirm(order, resend = false)
+    @subject    = (resend ? "[RESEND] " : "") 
+    @subject    += 'Order Confirmation #' + order.number
+    @body       = {"order" => order}
+    @recipients = order.user.email
+    @from       = ORDER_FROM
+    @bcc        = ORDER_BCC unless ORDER_BCC.empty? or resend
+    @sent_on    = Time.now
+  end
+  
+  def cancel(order)
+    @subject    = '[CANCEL] Order Confirmation #' + order.number
+    @body       = {"order" => order}
+    @recipients = order.user.email
+    @from       = ORDER_FROM
+    @bcc        = ORDER_BCC unless ORDER_BCC.empty?
+    @sent_on    = Time.now
+  end  
+end