spree_core 0.70.7 → 1.0.0.rc1

data/app/models/adjustment.rb

@@ -1,67 +0,0 @@
-
-# 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).
-#
-# +eligible?+
-#
-#  This boolean attributes stores whether this adjustment is currently eligible for its order. Only eligible
-#  adjustments count towards the order's adjustment total. This allows an adjustment to be preserved if it
-#  becomes ineligible so it might be reinstated.
-#
-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(:originator_type => "TaxRate") }
-  scope :shipping, lambda { where(:label => I18n.t(:shipping)) }
-  scope :optional, where(:mandatory => false)
-  scope :eligible, where(:eligible => true)
-
-  after_save { order.update! }
-  after_destroy { order.update! }
-
-  # Update the boolean _eligible_ attribute which deterimes which adjustments count towards the order's
-  # adjustment_total.
-  def set_eligibility
-    update_attribute_without_callbacks(:eligible,
-                                       mandatory ||
-                                       (amount != 0 && eligible_for_originator?))
-  end
-
-  # Allow originator of the adjustment to perform an additional eligibility of the adjustment
-  # Should return _true_ if originator is absent or doesn't implement _eligible?_
-  def eligible_for_originator?
-    return true if originator.nil?
-    !originator.respond_to?(:eligible?) || originator.eligible?(source)
-  end
-
-
-  # Update both the eligibility and amount of the adjustment. Adjustments delegate updating of amount 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.
-  def update!
-    return if locked?
-    set_eligibility
-    if originator.present?
-      originator.update_adjustment(self, source)
-    end
-  end
-
-end

data/app/models/app_configuration.rb

@@ -1,48 +0,0 @@
-class AppConfiguration < Configuration
-
-  preference :site_name, :string, :default => 'Spree Demo Site'
-  preference :default_seo_title, :string, :default => ''
-  preference :default_meta_description, :string, :default => 'Spree demo site'
-  preference :default_meta_keywords, :string, :default => 'spree, demo'
-  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 => true
-  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 => 'admin/bg/spree_50.png'
-  preference :stylesheets, :string, :default => 'reset,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 :shipment_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 :max_level_in_taxons_menu, :integer, :default => 1 # maximum nesting level in taxons menu
-  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

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

data/app/models/billing_integration.rb

@@ -1,23 +0,0 @@
-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.rb

@@ -1,44 +0,0 @@
-class Calculator < ActiveRecord::Base
-  belongs_to :calculable, :polymorphic => true
-
-  # This method must be overriden in concrete calculator.
-  #
-  # It should return amount computed based on #calculable and/or optional parameter
-  def compute(something=nil)
-    raise(NotImplementedError, "please use concrete calculator")
-  end
-
-  # overwrite to provide description for your calculators
-  def self.description
-    "Base Caclulator"
-  end
-
-  ###################################################################
-
-  def self.register(*klasses)
-    # @@calculators.add(self)
-    # klasses.each do |klass|
-    #   klass = klass.constantize if klass.is_a?(String)
-    #   klass.register_calculator(self)
-    # end
-    # self
-  end
-
-  # Returns all calculators applicable for kind of work
-  # If passed nil, will return only general calculators
-  def self.calculators
-    Rails.application.config.spree.calculators.all
-  end
-
-  def to_s
-    self.class.name.titleize.gsub("Calculator\/", "")
-  end
-
-  def description
-    self.class.description
-  end
-
-  def available?(object)
-    return true #should be overridden if needed
-  end
-end

data/app/models/calculator/flat_percent_item_total.rb

@@ -1,14 +0,0 @@
-class Calculator::FlatPercentItemTotal < Calculator
-  preference :flat_percent, :decimal, :default => 0
-
-  def self.description
-    I18n.t("flat_percent")
-  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

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

data/app/models/calculator/flexi_rate.rb

@@ -1,27 +0,0 @@
-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 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

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

data/app/models/calculator/price_sack.rb

@@ -1,24 +0,0 @@
-class Calculator::PriceSack < 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_sack")
-  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

data/app/models/calculator/sales_tax.rb

@@ -1,43 +0,0 @@
-class Calculator::SalesTax < Calculator
-
-  def self.description
-    I18n.t("sales_tax")
-  end
-
-  def self.calculate_tax(order, rates)
-    ActiveSupport::Deprecation.warn("please use Calculator::SalesTax#compute instead", caller)
-
-    return 0 if rates.empty?
-    # note: there is a bug with associations in rails 2.1 model caching so we're using this hack
-    # (see http://rails.lighthouseapp.com/projects/8994/tickets/785-caching-models-fails-in-development)
-    cache_hack = rates.first.respond_to?(:tax_category_id)
-
-    taxable_totals = {}
-    order.line_items.each do |line_item|
-      next unless tax_category = line_item.variant.product.tax_category
-      next unless rate = rates.find { | sales_rate | sales_rate.tax_category_id == tax_category.id } if cache_hack
-      next unless rate = rates.find { | sales_rate | sales_rate.tax_category == tax_category } unless cache_hack
-
-      taxable_totals[tax_category] ||= 0
-      taxable_totals[tax_category] += line_item.total
-    end
-
-    return 0 if taxable_totals.empty?
-    tax = 0
-    rates.each do |rate|
-      tax_category = rate.tax_category unless cache_hack
-      tax_category = TaxCategory.find(rate.tax_category_id) if cache_hack
-      next unless taxable_total = taxable_totals[tax_category]
-      tax += taxable_total * rate.amount
-    end
-    tax
-  end
-
-  def compute(order)
-    rate = self.calculable
-    line_items = order.line_items.select { |i| i.product.tax_category == rate.tax_category }
-    line_items.inject(0) {|sum, line_item|
-      sum += line_item.total * rate.amount
-    }
-  end
-end

data/app/models/calculator/vat.rb

@@ -1,42 +0,0 @@
-class Calculator::Vat < Calculator
-
-  def self.description
-    I18n.t("vat")
-  end
-
-  def self.calculate_tax_on(taxable)
-    # taxable may be product or variant
-    taxable = taxable.product if taxable.respond_to?(:product)
-    (taxable.price * taxable.effective_tax_rate).round(2, BigDecimal::ROUND_HALF_UP)
-  end
-
-  # computes vat for line_items associated with order, and tax rate and
-  # now coupon discounts are taken into account in tax calcs
-  # and tax is added to shipment if :shipment_inc_vat is set
-  # coupons and shipment are applied if this object is the rate for the default category
-  #           (also items with no category get this rate applied)
-  def compute(order)
-    rate = self.calculable
-    tax = 0
-
-    if rate.tax_category.is_default
-      order.adjustments.each do | adjust |
-        next if adjust.originator_type == "TaxRate"
-        next if adjust.originator_type == "ShippingMethod" and not Spree::Config[:shipment_inc_vat]
-
-        tax += (adjust.amount * rate.amount).round(2, BigDecimal::ROUND_HALF_UP)
-      end
-    end
-
-    order.line_items.each do  | line_item|
-      if line_item.product.tax_category  #only apply this calculator to products assigned this rates category
-        next unless line_item.product.tax_category == rate.tax_category
-      else
-        next unless rate.tax_category.is_default # and apply to products with no category, if this is the default rate
-      end
-      tax += (line_item.price * rate.amount).round(2, BigDecimal::ROUND_HALF_UP) * line_item.quantity
-    end
-
-    tax
-  end
-end

data/app/models/configuration.rb

@@ -1,3 +0,0 @@
-class Configuration < ActiveRecord::Base
-
-end

data/app/models/country.rb

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

data/app/models/creditcard.rb

@@ -1,272 +0,0 @@
-class Creditcard < ActiveRecord::Base
-  has_many :payments, :as => :source
-
-  before_save :set_last_digits
-  after_validation :set_card_type
-
-  attr_accessor :number, :verification_value
-
-  validates :month, :year, :numericality => { :only_integer => true }
-  validates :number, :presence => true, :unless => :has_payment_profile?, :on => :create
-  validates :verification_value, :presence => true, :unless => :has_payment_profile?, :on => :create
-
-  def process!(payment)
-    if Spree::Config[:auto_capture]
-      purchase(payment.amount.to_f, payment)
-    else
-      authorize(payment.amount.to_f, payment)
-    end
-  end
-
-  def set_last_digits
-    number.to_s.gsub!(/\s/,'') unless number.nil?
-    verification_value.to_s.gsub!(/\s/,'') unless number.nil?
-    self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
-  end
-
-  # cheap hack to get to the type? method from deep within ActiveMerchant without stomping on
-  # potentially existing methods in CreditCard
-  class CardDetector
-    class << self
-      include ActiveMerchant::Billing::CreditCardMethods::ClassMethods
-    end
-  end
-
-  # sets self.cc_type while we still have the card number
-  def set_card_type
-    self.cc_type ||= CardDetector.type?(self.number)
-  end
-
-  def name?
-    first_name? && last_name?
-  end
-
-  def first_name?
-    first_name.present?
-  end
-
-  def last_name?
-    last_name.present?
-  end
-
-  def name
-    "#{first_name} #{last_name}"
-  end
-
-  def verification_value?
-    verification_value.present?
-  end
-
-  # Show the card number, with all but last 4 numbers replace with "X". (XXXX-XXXX-XXXX-4338)
-  def display_number
-   "XXXX-XXXX-XXXX-#{last_digits}"
-  end
-
-  #RAILS 3 TODO
-  #alias :attributes_with_quotes_default :attributes_with_quotes
-
-
-  # needed for some of the ActiveMerchant gateways (eg. SagePay)
-  def brand
-    cc_type
-  end
-
-  scope :with_payment_profile, where("gateway_customer_profile_id IS NOT NULL")
-
-  def authorize(amount, payment)
-    # ActiveMerchant is configured to use cents so we need to multiply order total by 100
-    payment_gateway = payment.payment_method
-    check_environment(payment_gateway)
-
-    response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))
-    record_log payment, response
-
-    if response.success?
-      payment.response_code = response.authorization
-      payment.avs_response = response.avs_result['code']
-      payment.pend
-    else
-      payment.failure
-      gateway_error(response)
-    end
-  rescue ActiveMerchant::ConnectionError => e
-    gateway_error e
-  end
-
-  def purchase(amount, payment)
-    #combined Authorize and Capture that gets processed by the ActiveMerchant gateway as one single transaction.
-    payment_gateway = payment.payment_method
-    check_environment(payment_gateway)
-
-    response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment))
-    record_log payment, response
-
-    if response.success?
-      payment.response_code = response.authorization
-      payment.avs_response = response.avs_result['code']
-      payment.complete
-    else
-      payment.failure
-      gateway_error(response) unless response.success?
-    end
-  rescue ActiveMerchant::ConnectionError => e
-    gateway_error e
-  end
-
-  def capture(payment)
-    return unless payment.pending?
-    payment_gateway = payment.payment_method
-    check_environment(payment_gateway)
-
-    if payment_gateway.payment_profiles_supported?
-      # Gateways supporting payment profiles will need access to creditcard object because this stores the payment profile information
-      # so supply the authorization itself as well as the creditcard, rather than just the authorization code
-      response = payment_gateway.capture(payment, self, minimal_gateway_options(payment, false))
-    else
-      # Standard ActiveMerchant capture usage
-      response = payment_gateway.capture((payment.amount * 100).round, payment.response_code, minimal_gateway_options(payment, false))
-    end
-
-    record_log payment, response
-
-    if response.success?
-      payment.response_code = response.authorization
-      payment.complete
-    else
-      payment.failure
-      gateway_error(response)
-    end
-  rescue ActiveMerchant::ConnectionError => e
-    gateway_error e
-  end
-
-  def void(payment)
-    payment_gateway = payment.payment_method
-    check_environment(payment_gateway)
-
-    response = payment_gateway.void(payment.response_code, minimal_gateway_options(payment, false))
-    record_log payment, response
-
-    if response.success?
-      payment.response_code = response.authorization
-      payment.void
-    else
-      gateway_error(response)
-    end
-  rescue ActiveMerchant::ConnectionError => e
-    gateway_error e
-  end
-
-  def credit(payment)
-    payment_gateway = payment.payment_method
-    check_environment(payment_gateway)
-
-    amount = payment.credit_allowed >= payment.order.outstanding_balance.abs ? payment.order.outstanding_balance.abs : payment.credit_allowed.abs
-    if payment_gateway.payment_profiles_supported?
-      response = payment_gateway.credit((amount * 100).round, self, payment.response_code, minimal_gateway_options(payment, false))
-    else
-      response = payment_gateway.credit((amount * 100).round, payment.response_code, minimal_gateway_options(payment, false))
-    end
-
-    record_log payment, response
-
-    if response.success?
-      Payment.create(:order => payment.order,
-                    :source => payment,
-                    :payment_method => payment.payment_method,
-                    :amount => amount.abs * -1,
-                    :response_code => response.authorization,
-                    :state => 'completed')
-    else
-      gateway_error(response)
-    end
-  rescue ActiveMerchant::ConnectionError => e
-    gateway_error e
-  end
-
-  def actions
-    %w{capture void credit}
-  end
-
-  # Indicates whether its possible to capture the payment
-  def can_capture?(payment)
-    payment.state == "pending"
-  end
-
-  # Indicates whether its possible to void the payment.
-  def can_void?(payment)
-    payment.state == "void" ? false : true
-  end
-
-  # Indicates whether its possible to credit the payment.  Note that most gateways require that the
-  # payment be settled first which generally happens within 12-24 hours of the transaction.
-  def can_credit?(payment)
-    return false unless payment.state == "completed"
-    return false unless payment.order.payment_state == "credit_owed"
-    payment.credit_allowed > 0
-  end
-
-  def has_payment_profile?
-    gateway_customer_profile_id.present?
-  end
-
-  def record_log(payment, response)
-    payment.log_entries.create(:details => response.to_yaml)
-  end
-
-  def gateway_error(error)
-    if error.is_a? ActiveMerchant::Billing::Response
-      text = error.params['message'] || error.params['response_reason_text'] || error.message
-    elsif error.is_a? ActiveMerchant::ConnectionError
-      text = I18n.t(:unable_to_connect_to_gateway)  
-    else
-      text = error.to_s
-    end
-    logger.error(I18n.t('gateway_error'))
-    logger.error("  #{error.to_yaml}")
-    raise Spree::GatewayError.new(text)
-  end
-
-  def gateway_options(payment)
-    options = {:billing_address  => generate_address_hash(payment.order.bill_address),
-               :shipping_address => generate_address_hash(payment.order.ship_address)}
-    options.merge minimal_gateway_options(payment)
-  end
-
-  # Generates an ActiveMerchant compatible address hash from one of Spree's address objects
-  def generate_address_hash(address)
-    return {} if address.nil?
-    {:name => address.full_name, :address1 => address.address1, :address2 => address.address2, :city => address.city,
-     :state => address.state_text, :zip => address.zipcode, :country => address.country.iso, :phone => address.phone}
-  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 minimal_gateway_options(payment, totals=true)
-
-    options = {:email    => payment.order.email,
-               :customer => payment.order.email,
-               :ip       => payment.order.ip_address,
-               :order_id => payment.order.number}
-    if totals
-      options.merge!({ :shipping => payment.order.ship_total * 100,
-                       :tax      => payment.order.tax_total * 100,
-                       :subtotal => payment.order.item_total * 100 })
-    end
-    options
-  end
-
-  def spree_cc_type
-    return "visa" if ENV['RAILS_ENV'] == "development"
-    self.cc_type
-  end
-
-  # Saftey check to make sure we're not accidentally performing operations on a live gateway.
-  # Ex. When testing in staging environment with a copy of production data.
-  def check_environment(gateway)
-    return if gateway.environment == Rails.env
-    message = I18n.t(:gateway_config_unavailable) + " - #{Rails.env}"
-    raise Spree::GatewayError.new(message)
-  end
-end