rfcommerce_core 0.0.3

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.rb

@@ -0,0 +1,46 @@
+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
+
+  ###################################################################
+
+  @@calculators = Set.new
+  # Registers calculator to be used with selected kinds of operations
+  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
+    @@calculators.to_a
+  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

@@ -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

data/app/models/calculator/sales_tax.rb

@@ -0,0 +1,48 @@
+class Calculator::SalesTax < Calculator
+
+  def self.description
+    I18n.t("sales_tax")
+  end
+
+  def self.register
+    super
+    TaxRate.register_calculator(self)
+  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

@@ -0,0 +1,63 @@
+class Calculator::Vat < Calculator
+
+  def self.description
+    I18n.t("vat")
+  end
+
+  def self.register
+    super
+    TaxRate.register_calculator(self)
+  end
+
+  # list the vat rates for the default country
+  def self.default_rates
+    origin = Country.find(Spree::Config[:default_country_id])
+    calcs = Calculator::Vat.includes(:calculable => :zone).select {
+      |vat| vat.calculable.zone.country_list.include?(origin)
+    }
+    calcs.collect { |calc| calc.calculable }
+  end
+
+  def self.calculate_tax(order, rates=default_rates)
+    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 { | vat_rate | vat_rate.tax_category_id == tax_category.id } if cache_hack
+      next unless rate = rates.find { | vat_rate | vat_rate.tax_category == tax_category } unless cache_hack
+      taxable_totals[tax_category] ||= 0
+      taxable_totals[tax_category] += line_item.price * rate.amount * line_item.quantity
+    end
+
+    return 0 if taxable_totals.empty?
+    tax = 0
+    taxable_totals.values.each do |total|
+      tax += total
+    end
+    tax
+  end
+
+  # TODO: Refactor this method after integrating #54 to use default address
+  def self.calculate_tax_on(product_or_variant)
+    vat_rates = default_rates
+
+    return 0 if vat_rates.nil?
+    return 0 unless tax_category = product_or_variant.is_a?(Product) ? product_or_variant.tax_category : product_or_variant.product.tax_category
+    return 0 unless rate = vat_rates.find { | vat_rate | vat_rate.tax_category_id == tax_category.id }
+
+    (product_or_variant.is_a?(Product) ? product_or_variant.price : product_or_variant.price) * rate.amount
+  end
+
+  # computes vat for line_items associated with order, and tax rate
+  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.price * rate.amount * line_item.quantity)
+    }
+  end
+end

data/app/models/configuration.rb

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

data/app/models/country.rb

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

@@ -0,0 +1,267 @@
+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.fail
+      gateway_error(response)
+    end
+  rescue ActiveMerchant::ConnectionError
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  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.fail
+      gateway_error(response) unless response.success?
+    end
+  rescue ActiveMerchant::ConnectionError
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  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))
+    else
+      # Standard ActiveMerchant capture usage
+      response = payment_gateway.capture((payment.amount * 100).round, payment.response_code, minimal_gateway_options(payment))
+    end
+
+    record_log payment, response
+
+    if response.success?
+      payment.response_code = response.authorization
+      payment.complete
+    else
+      payment.fail
+      gateway_error(response)
+    end
+  rescue ActiveMerchant::ConnectionError
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  end
+
+  def void(payment)
+    payment_gateway = payment.payment_method
+    check_environment(payment_gateway)
+
+    response = payment_gateway.void(payment.response_code, minimal_gateway_options(payment))
+    record_log payment, response
+
+    if response.success?
+      payment.response_code = response.authorization
+      payment.void
+    else
+      gateway_error(response)
+    end
+  rescue ActiveMerchant::ConnectionError
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  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))
+    else
+      response = payment_gateway.credit((amount * 100).round, payment.response_code, minimal_gateway_options(payment))
+    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
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  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
+    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)
+    {:email    => payment.order.email,
+     :customer => payment.order.email,
+     :ip       => payment.order.ip_address,
+     :order_id => payment.order.number,
+     :shipping => payment.order.ship_total * 100,
+     :tax      => payment.order.tax_total * 100,
+     :subtotal => payment.order.item_total * 100}
+  end
+
+  def spree_cc_type
+    return "visa" if ::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