My-Commerce_core 1.0.0

data/app/helpers/checkout_helper.rb

@@ -0,0 +1,31 @@
+module CheckoutHelper
+
+  def checkout_progress
+    if Gateway.current and Gateway.current.payment_profiles_supported?
+      states = %w(address delivery payment confirm complete)
+    else
+      states = %w(address delivery payment complete)
+    end
+    items = states.map do |state|
+      text = t("order_state.#{state}").titleize
+
+      css_classes = []
+      current_index = states.index(@order.state)
+      state_index = states.index(state)
+
+      if state_index < current_index
+        css_classes << 'completed'
+        text = link_to text, checkout_state_path(state)
+      end
+
+      css_classes << 'next' if state_index == current_index + 1
+      css_classes << 'current' if state == @order.state
+      css_classes << 'first' if state_index == 0
+      css_classes << 'last' if state_index == states.length - 1
+      # It'd be nice to have separate classes but combining them with a dash helps out for IE6 which only sees the last class
+      content_tag('li', content_tag('span', text), :class => css_classes.join('-'))
+    end
+    content_tag('ol', raw(items.join("\n")), :class => 'progress-steps', :id => "checkout-step-#{@order.state}")
+  end
+
+end

data/app/helpers/hook_helper.rb

@@ -0,0 +1,20 @@
+module HookHelper
+
+  # Allow hooks to be used in views like this:
+  #
+  #   <%= hook :some_hook %>
+  #
+  #   <%= hook :some_hook do %>
+  #     <p>Some HTML</p>
+  #   <% end %>
+  #
+  def hook(hook_name, locals = {}, &block)
+    content = block_given? ? capture(&block) : ''
+    Spree::ThemeSupport::Hook.render_hook(hook_name, content, self, locals)
+  end
+
+  def locals_hash(names, binding)
+    names.inject({}) {|memo, key| memo[key.to_sym] = eval(key, binding); memo}
+  end
+
+end

data/app/helpers/orders_helper.rb

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

data/app/helpers/products_helper.rb

@@ -0,0 +1,30 @@
+module ProductsHelper
+  # returns the formatted change in price (from the master price) for the specified variant (or simply return
+  # the variant price if no master price was supplied)
+  def variant_price_diff(variant)
+    return product_price(variant) unless variant.product.master.price
+    diff = product_price(variant, :format_as_currency => false) - product_price(variant.product, :format_as_currency => false)
+    return nil if diff == 0
+    if diff > 0
+      "(#{t("add")}: #{format_price diff.abs})"
+    else
+      "(#{t("subtract")}: #{format_price diff.abs})"
+    end
+  end
+
+  # returns the price of the product to show for display purposes
+  def product_price(product_or_variant, options={})
+    options.assert_valid_keys(:format_as_currency, :show_vat_text)
+    options.reverse_merge! :format_as_currency => true, :show_vat_text => Spree::Config[:show_price_inc_vat]
+
+    amount = product_or_variant.price
+    amount += Calculator::Vat.calculate_tax_on(product_or_variant) if Spree::Config[:show_price_inc_vat]
+    options.delete(:format_as_currency) ? format_price(amount, options) : amount
+  end
+
+  # converts line breaks in product description into <p> tags (for html display purposes)
+  def product_description(product)
+    raw(product.description.gsub(/^(.*)$/, '<p>\1</p>'))
+  end
+
+end

data/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/app/helpers/spree/base_helper.rb

@@ -0,0 +1,119 @@
+module Spree::BaseHelper
+
+  def link_to_cart(text = t('cart'))
+    return "" if current_page?(cart_path)
+    css_class = nil
+    if current_order.nil? or current_order.line_items.empty?
+      text = "#{text}: (#{t('empty')})"
+      css_class = 'empty'
+    else
+      text = "#{text}: (#{current_order.item_count}) #{order_price(current_order)}"
+      css_class = 'full'
+    end
+    link_to text, cart_path, :class => css_class
+  end
+
+  def order_price(order, options={})
+    options.assert_valid_keys(:format_as_currency, :show_vat_text, :show_price_inc_vat)
+    options.reverse_merge! :format_as_currency => true, :show_vat_text => true
+
+    # overwrite show_vat_text if show_price_inc_vat is false
+    options[:show_vat_text] = Spree::Config[:show_price_inc_vat]
+
+    amount =  order.item_total
+    amount += Calculator::Vat.calculate_tax(order) if Spree::Config[:show_price_inc_vat]
+
+    options.delete(:format_as_currency) ? number_to_currency(amount) : amount
+  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
+
+  # human readable list of variant options
+  def variant_options(v, allow_back_orders = Spree::Config[:allow_backorders], include_style = true)
+    list = v.options_text
+    list = include_style ? "<span class =\"out-of-stock\">(" + t("out_of_stock") + ") #{list}</span>" : "#{t("out_of_stock")} #{list}" unless (allow_back_orders || v.in_stock?)
+    list
+  end
+
+  Image.attachment_definitions[:attachment][:styles].each do |style, v|
+    define_method "#{style}_image" do |product, *options|
+      options = options.first || {}
+      if product.images.empty?
+        image_tag "noimage/#{style}.jpg", options
+      else
+        image = product.images.first
+        options.reverse_merge! :alt => image.alt.blank? ? product.name : image.alt
+        image_tag image.attachment.url(style), options
+      end
+    end
+  end
+
+  def meta_data_tags
+    object = instance_variable_get('@'+controller_name.singularize)
+    return unless object
+    "".tap do |tags|
+      if object.respond_to?(:meta_keywords) and object.meta_keywords.present?
+        tags << tag('meta', :name => 'keywords', :content => object.meta_keywords) + "\n"
+      end
+      if object.respond_to?(:meta_description) and object.meta_description.present?
+        tags << tag('meta', :name => 'description', :content => object.meta_description) + "\n"
+      end
+    end
+  end
+
+  def stylesheet_tags(paths=stylesheet_paths)
+    paths.blank? ? '' : stylesheet_link_tag(paths, :cache => true)
+  end
+
+  def stylesheet_paths
+    paths = Spree::Config[:stylesheets]
+    if (paths.blank?)
+      []
+    else
+      paths.split(',')
+    end
+  end
+
+  def logo(image_path=Spree::Config[:logo])
+    link_to image_tag(image_path), root_path
+  end
+
+  def available_countries
+    return Country.all unless zone = Zone.find_by_name(Spree::Config[:checkout_zone])
+    zone.country_list
+  end
+  
+  def format_price(price, options={})
+    options.assert_valid_keys(:show_vat_text)
+    options.reverse_merge! :show_vat_text => Spree::Config[:show_price_inc_vat]
+    formatted_price = number_to_currency(price)
+    if options[:show_vat_text]
+      I18n.t(:price_with_vat_included, :price => formatted_price)
+    else
+      formatted_price
+    end
+  end
+  
+  # generates nested url to product based on supplied taxon
+  def seo_url(taxon, product = nil)
+    return '/t/' + taxon.permalink if product.nil?
+    warn "DEPRECATION: the /t/taxon-permalink/p/product-permalink urls are "+
+      "not used anymore. Use product_url instead. (called from #{caller[0]})"
+    return product_url(product)
+  end
+  
+  def current_orders_product_count
+    if current_order.blank? || current_order.item_count < 1
+      return 0
+    else
+      return current_order.item_count
+    end
+  end
+
+end

data/app/helpers/taxons_helper.rb

@@ -0,0 +1,32 @@
+module TaxonsHelper
+  def breadcrumbs(taxon, separator=" » ")
+    return "" if current_page?("/")
+    separator = raw(separator)
+    crumbs = [content_tag(:li, link_to(t(:home) , root_path) + separator)]
+    if taxon
+      crumbs << content_tag(:li, link_to(t('products') , products_path) + separator)
+      crumbs << taxon.ancestors.collect { |ancestor| content_tag(:li, link_to(ancestor.name , seo_url(ancestor)) + separator) } unless taxon.ancestors.empty?
+      crumbs << content_tag(:li, content_tag(:span, taxon.name))
+    else
+      crumbs << content_tag(:li, content_tag(:span, t('products')))
+    end
+    crumb_list = content_tag(:ul, raw(crumbs.flatten.map{|li| li.mb_chars}.join))
+    content_tag(:div, crumb_list + tag(:br, {:class => 'clear'}, false, true), :class => 'breadcrumbs')
+  end
+
+
+  # Retrieves the collection of products to display when "previewing" a taxon.  This is abstracted into a helper so
+  # that we can use configurations as well as make it easier for end users to override this determination.  One idea is
+  # to show the most popular products for a particular taxon (that is an exercise left to the developer.)
+  def taxon_preview(taxon, max=4)
+    products = taxon.active_products.limit(max)
+    if (products.size < max) && Spree::Config[:show_descendents]
+      taxon.descendants.each do |taxon|
+        to_get = max - products.length
+        products += taxon.active_products.limit(to_get)
+        break if products.size >= max
+      end
+    end
+    products
+  end
+end

data/app/helpers/trackers_helper.rb

@@ -0,0 +1,2 @@
+module TrackersHelper
+end

data/app/mailers/order_mailer.rb

@@ -0,0 +1,19 @@
+class OrderMailer < ActionMailer::Base
+  helper "spree/base"
+
+  def confirm_email(order, resend=false)
+    @order = order
+    subject = (resend ? "[RESEND] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope =>'order_mailer.confirm_email')} ##{order.number}"
+    mail(:to => order.email,
+         :subject => subject)
+  end
+
+  def cancel_email(order, resend=false)
+    @order = order
+    subject = (resend ? "[RESEND] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope => 'order_mailer.cancel_email')} ##{order.number}"
+    mail(:to => order.email,
+         :subject => subject)
+  end
+end

data/app/mailers/shipment_mailer.rb

@@ -0,0 +1,11 @@
+class ShipmentMailer < ActionMailer::Base
+  helper "spree/base"
+
+  def shipped_email(shipment, resend=false)
+    @shipment = shipment
+    subject = (resend ? "[RESEND] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope => 'shipment_mailer.shipped_email')} ##{shipment.order.number}"
+    mail(:to => shipment.order.email,
+         :subject => subject)
+  end
+end

data/app/models/address.rb

@@ -0,0 +1,115 @@
+class Address < ActiveRecord::Base
+  belongs_to :country
+  belongs_to :state
+
+  has_many :shipments
+
+  validates :firstname, :lastname, :address1, :city, :zipcode, :country, :phone, :presence => true
+  validate :state_validate
+
+  # disconnected since there's no code to display error messages yet OR matching client-side validation
+  def phone_validate
+    return if phone.blank?
+    n_digits = phone.scan(/[0-9]/).size
+    valid_chars = (phone =~ /^[-+()\/\s\d]+$/)
+    if !(n_digits > 5 && valid_chars)
+      errors.add(:phone, :invalid)
+    end
+  end
+
+  def state_validate
+    #skip state validation without country (also required)
+    #or when disabled by perfernce
+    return if self.country_id.blank? || !Spree::Config[:address_requires_state]
+
+    #ensure associated state belongs to country
+    if self.state_id.present?
+      if self.state.country_id == self.country_id
+
+          self.state_name = nil #not required as we have a valid state and country combo
+      else
+        if self.state_name.present?
+
+          self.state_id = nil
+        else
+          errors.add(:state, :invalid)
+        end
+      end
+    end
+
+    #ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
+    if self.state_name.present?
+      country = Country.where(:id => self.country_id).try(:first)
+
+      if country.states.present?
+        states = country.states.where(["name = ? OR abbr = ?",self.state_name, self.state_name])
+
+        if states.size == 1
+          self.state = states.first
+          self.state_name = nil
+        else
+          errors.add(:state, :invalid)
+        end
+      end
+    end
+
+    #ensure at least one state field is populated
+    if self.state_id.blank? && self.state_name.blank?
+      errors.add(:state, :blank)
+    end
+
+  end
+
+  def self.default
+    new :country_id => Spree::Config[:default_country_id]
+  end
+
+  # can modify an address if it's not been used in an order (but checkouts controller has finer control)
+  # def editable?
+  #   new_record? || (shipments.empty? && checkouts.empty?)
+  # end
+
+  def full_name
+    self.firstname + " " + self.lastname
+  end
+
+  def state_text
+    state.nil? ? state_name : (state.abbr.blank? ? state.name : state.abbr)
+  end
+
+  def zone
+    (state && state.zone) ||
+    (country && country.zone)
+  end
+
+  def zones
+    Zone.match(self)
+  end
+
+  def same_as?(other)
+    return false if other.nil?
+    attributes.except("id", "updated_at", "created_at") ==  other.attributes.except("id", "updated_at", "created_at")
+  end
+  alias same_as same_as?
+
+  def to_s
+    "#{full_name}: #{address1}"
+  end
+
+  def clone
+    Address.new(self.attributes.except("id", "updated_at", "created_at"))
+  end
+
+  def ==(other_address)
+    self_attrs = self.attributes
+    other_attrs = other_address.respond_to?(:attributes) ? other_address.attributes : {}
+
+    [self_attrs, other_attrs].each { |attrs| attrs.except!("id", "created_at", "updated_at", "order_id") }
+
+    self_attrs == other_attrs
+  end
+
+  def empty?
+    attributes.except("id", "created_at", "updated_at", "order_id", "country_id").all? {|_,v| v.nil?}
+  end
+end

data/app/models/adjustment.rb

@@ -0,0 +1,47 @@
+# Adjustments represent a change to the +item_total+ of an Order.  Each adjustment has an +amount+ that be either
+# positive or negative.  Adjustments have two useful boolean flags
+#
+# +mandatory+
+#
+# If this flag is set to true then it means the the charge is required and will not be removed from the
+# order, even if the amount is zero.  In other words a record will be created even if the amount is zero.
+# This is  useful for representing things such as shipping and tax charges where you may want to make it explicitly
+# clear that no charge was made for such things.
+#
+# +locked+
+#
+# The charge is never to be udpated.  Typically you would want to freeze certain adjustments after checkout.
+# One use case for this is if you want to lock a shipping adjustment so that its value does not change
+# in the future when making other trivial edits to the order (like an email change).
+class Adjustment < ActiveRecord::Base
+  belongs_to :order
+  belongs_to :source, :polymorphic => true
+  belongs_to :originator, :polymorphic => true
+
+  validates :label, :presence => true
+  validates :amount, :numericality => true
+
+  scope :tax, lambda { where(:label => I18n.t(:tax)) }
+  scope :shipping, lambda { where(:label => I18n.t(:shipping)) }
+  scope :optional, where(:mandatory => false)
+
+  after_save { order.update! }
+  after_destroy { order.update! }
+
+  # Checks if adjustment is applicable for the order. Should return _true_ if adjustment should be preserved and
+  # _false_ if removed. Default behaviour is to preserve adjustment if amount is present and non 0.  Exceptions
+  # are made if the adjustment is considered +mandatory+.
+  def applicable?
+    mandatory || amount != 0
+  end
+
+  # Tells the adjustment that its time to update itself.  Adjustments will delegate this request to their Originator
+  # when present, but only if +locked+ is false.  Adjustments that are +locked+ will never change their amount.
+  # The new adjustment amount will be set by by the +originator+ and is not automatically saved.  This makes it save
+  # to use this method in an after_save hook for other models without causing an infinite recursion problem.  If there
+  # is no +originator+ then this method will have no effect.
+  def update!
+    return if locked? || originator.nil?
+    originator.update_adjustment(self, source)
+  end
+end

data/app/models/app_configuration.rb

@@ -0,0 +1,44 @@
+class AppConfiguration < Configuration
+
+  preference :site_name, :string, :default => 'Spree Demo Site'
+  preference :default_seo_title, :string, :default => ''
+  preference :site_url, :string, :default => 'demo.spreecommerce.com'
+  preference :default_locale, :string, :default => 'en'
+  preference :allow_locale_switching, :boolean, :default => true
+  preference :default_country_id, :integer, :default => 214
+  preference :allow_backorders, :boolean, :default => true
+  preference :allow_backorder_shipping, :boolean, :default => false # should only be true if you don't need to track inventory
+  preference :track_inventory_levels, :boolean, :default => true # will not track on_hand values for variants /products
+  preference :create_inventory_units, :boolean, :default => true # should only be false when track_inventory_levels is false, also disables RMA's
+  preference :show_descendents, :boolean, :default => true
+  preference :show_zero_stock_products, :boolean, :default => true
+  preference :orders_per_page, :integer, :default => 15
+  preference :show_only_complete_orders_by_default, :boolean, :default => false
+  preference :admin_products_per_page, :integer, :default => 10
+  preference :admin_pgroup_preview_size, :integer, :default => 10
+  preference :products_per_page, :integer, :default => 10
+  preference :logo, :string, :default => '/images/admin/bg/spree_50.png'
+  preference :stylesheets, :string, :default => 'screen' # Comma separate multiple stylesheets, e.g. 'screen,mystyle'
+  preference :admin_interface_logo, :string, :default => "admin/bg/spree_50.png"
+  preference :allow_ssl_in_production, :boolean, :default => true
+  preference :allow_ssl_in_development_and_test, :boolean, :default => false
+  preference :allow_guest_checkout, :boolean, :default => true
+  preference :alternative_billing_phone,  :boolean, :default => false # Request extra phone for bill addr
+  preference :alternative_shipping_phone, :boolean, :default => false # Request extra phone for ship addr
+  preference :shipping_instructions,      :boolean, :default => false # Request instructions/info for shipping
+  preference :show_price_inc_vat, :boolean, :default => false
+  preference :auto_capture, :boolean, :default => false # automatically capture the creditcard (as opposed to just authorize and capture later)
+  preference :address_requires_state, :boolean, :default => true # should state/state_name be required
+  preference :checkout_zone, :string, :default => nil # replace with the name of a zone if you would like to limit the countries
+  preference :always_put_site_name_in_title, :boolean, :default => true
+  preference :cache_static_content, :boolean, :default => true
+  preference :use_content_controller, :boolean, :default => true
+  preference :allow_checkout_on_gateway_error, :boolean, :default => false
+  preference :select_taxons_from_tree, :boolean, :default => false # provide opportunity to select taxons from tree instead of search with autocomplete
+  preference :check_for_spree_alerts, :boolean, :default => true
+  preference :dismissed_spree_alerts, :string, :default => ''
+  preference :last_check_for_spree_alerts, :string, :default => nil
+
+  validates :name, :presence => true, :uniqueness => true
+
+end

data/app/models/asset.rb

@@ -0,0 +1,4 @@
+class Asset < ActiveRecord::Base
+  belongs_to :viewable, :polymorphic => true
+  acts_as_list :scope => :viewable
+end

data/app/models/billing_integration.rb

@@ -0,0 +1,23 @@
+class BillingIntegration < PaymentMethod
+
+  validates :name, :presence => true
+
+  preference :server, :string, :default => 'test'
+  preference :test_mode, :boolean, :default => true
+
+  def provider
+    integration_options = options
+    ActiveMerchant::Billing::Base.integration_mode = integration_options[:server].to_sym
+    integration_options = options
+    integration_options[:test] = true if integration_options[:test_mode]
+    @provider ||= provider_class.new(integration_options)
+  end
+
+  def options
+    options_hash = {}
+    self.preferences.each do |key,value|
+      options_hash[key.to_sym] = value
+    end
+    options_hash
+  end
+end

data/app/models/calculator/flat_percent_item_total.rb

@@ -0,0 +1,19 @@
+class Calculator::FlatPercentItemTotal < Calculator
+  preference :flat_percent, :decimal, :default => 0
+
+  def self.description
+    I18n.t("flat_percent")
+  end
+
+  def self.register
+    super
+    ShippingMethod.register_calculator(self)
+  end
+
+  def compute(object)
+    return unless object.present? and object.line_items.present?
+    item_total = object.line_items.map(&:amount).sum
+    value = item_total * self.preferred_flat_percent / 100.0
+    (value * 100).round.to_f / 100
+  end
+end

data/app/models/calculator/flat_rate.rb

@@ -0,0 +1,16 @@
+class Calculator::FlatRate < Calculator
+  preference :amount, :decimal, :default => 0
+
+  def self.description
+    I18n.t("flat_rate_per_order")
+  end
+
+  def self.register
+    super
+    ShippingMethod.register_calculator(self)
+  end
+
+  def compute(object=nil)
+    self.preferred_amount
+  end
+end

data/app/models/calculator/flexi_rate.rb

@@ -0,0 +1,32 @@
+class Calculator::FlexiRate < Calculator
+  preference :first_item,      :decimal, :default => 0
+  preference :additional_item, :decimal, :default => 0
+  preference :max_items,       :decimal, :default => 0
+
+  def self.description
+    I18n.t("flexible_rate")
+  end
+
+  def self.available?(object)
+    true
+  end
+
+  def self.register
+    super
+    ShippingMethod.register_calculator(self)
+  end
+
+  def compute(object)
+    sum = 0
+    max = self.preferred_max_items
+    items_count = object.line_items.map(&:quantity).sum
+    items_count.times do |i|
+      if (i % max == 0) && (max > 0)
+        sum += self.preferred_first_item
+      else
+        sum += self.preferred_additional_item
+      end
+    end
+    return(sum)
+  end
+end

data/app/models/calculator/per_item.rb

@@ -0,0 +1,16 @@
+class Calculator::PerItem < Calculator
+  preference :amount, :decimal, :default => 0
+
+  def self.description
+    I18n.t("flat_rate_per_item")
+  end
+
+  def self.register
+    super
+    ShippingMethod.register_calculator(self)
+  end
+
+  def compute(object=nil)
+    self.preferred_amount * object.line_items.length
+  end
+end

data/app/models/calculator/price_bucket.rb

@@ -0,0 +1,30 @@
+class Calculator::PriceBucket < Calculator
+  preference :minimal_amount, :decimal, :default => 0
+  preference :normal_amount, :decimal, :default => 0
+  preference :discount_amount, :decimal, :default => 0
+
+  def self.description
+    I18n.t("price_bucket")
+  end
+
+  def self.register
+    super
+    #Promotion.register_calculator(self)
+    ShippingMethod.register_calculator(self)
+  end
+
+  # as object we always get line items, as calculable we have Coupon, ShippingMethod
+  def compute(object)
+    if object.is_a?(Array)
+      base = object.map{ |o| o.respond_to?(:amount) ? o.amount : o.to_d }.sum
+    else
+      base = object.respond_to?(:amount) ? object.amount : object.to_d
+    end
+
+    if base >= self.preferred_minimal_amount
+      self.preferred_normal_amount
+    else
+      self.preferred_discount_amount
+    end
+  end
+end