My-Commerce_core 1.0.0

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

data/app/models/gateway/authorize_net.rb

@@ -0,0 +1,19 @@
+class Gateway::AuthorizeNet < Gateway
+	preference :login, :string
+	preference :password, :string
+
+  def provider_class
+    ActiveMerchant::Billing::AuthorizeNetGateway
+  end
+
+  def options
+    # add :test key in the options hash, as that is what the ActiveMerchant::Billing::AuthorizeNetGateway expects
+    if self.prefers? :test_mode
+      self.class.default_preferences[:test] = true
+    else
+      self.class.default_preferences.delete(:test)
+    end
+
+    super
+  end
+end

data/app/models/gateway/authorize_net_cim.rb

@@ -0,0 +1,132 @@
+class Gateway::AuthorizeNetCim < Gateway
+  preference :login, :string
+  preference :password, :string
+  preference :test_mode, :boolean, :default => false
+  preference :validate_on_profile_create, :boolean, :default => false
+
+  ActiveMerchant::Billing::Response.class_eval do
+    attr_writer :authorization
+  end
+
+  def provider_class
+    self.class
+  end
+
+  def options
+    # add :test key in the options hash, as that is what the ActiveMerchant::Billing::AuthorizeNetGateway expects
+    if self.prefers? :test_mode
+      self.class.default_preferences[:test] = true
+    else
+      self.class.default_preferences.delete(:test)
+    end
+
+    super
+  end
+
+  def authorize(amount, creditcard, gateway_options)
+    create_transaction(amount, creditcard, :auth_only)
+  end
+
+  def purchase(amount, creditcard, gateway_options)
+    create_transaction(amount, creditcard, :auth_capture)
+  end
+
+  def capture(authorization, creditcard, gateway_options)
+    create_transaction((authorization.amount * 100).round, creditcard, :prior_auth_capture, :trans_id => authorization.response_code)
+  end
+
+  def credit(amount, creditcard, response_code, gateway_options)
+    create_transaction(amount, creditcard, :refund, :trans_id => response_code)
+  end
+
+  def void(response_code, creditcard, gateway_options)
+    create_transaction(nil, creditcard, :void, :trans_id => response_code)
+  end
+
+  def payment_profiles_supported?
+    true
+  end
+
+  # Create a new CIM customer profile ready to accept a payment
+  def create_profile(payment)
+    if payment.source.gateway_customer_profile_id.nil?
+      profile_hash = create_customer_profile(payment)
+      payment.source.update_attributes(:gateway_customer_profile_id => profile_hash[:customer_profile_id], :gateway_payment_profile_id => profile_hash[:customer_payment_profile_id])
+    end
+  end
+
+  # simpler form
+  def create_profile_from_card(card)
+    if card.gateway_customer_profile_id.nil?
+      profile_hash = create_customer_profile(card)
+      card.update_attributes(:gateway_customer_profile_id => profile_hash[:customer_profile_id], :gateway_payment_profile_id => profile_hash[:customer_payment_profile_id])
+    end
+  end
+
+
+  private
+
+    # Create a transaction on a creditcard
+    # Set up a CIM profile for the card if one doesn't exist
+    # Valid transaction_types are :auth_only, :capture_only and :auth_capture
+    def create_transaction(amount, creditcard, transaction_type, options = {})
+      #create_profile(creditcard, creditcard.gateway_options)
+      creditcard.save
+      if amount
+        amount = "%.2f" % (amount/100.0) # This gateway requires formated decimal, not cents
+      end
+      transaction_options = {
+        :type => transaction_type,
+        :amount => amount,
+        :customer_profile_id => creditcard.gateway_customer_profile_id,
+        :customer_payment_profile_id => creditcard.gateway_payment_profile_id,
+      }.update(options)
+      t = cim_gateway.create_customer_profile_transaction(:transaction => transaction_options)
+      logger.debug("\nAuthorize Net CIM Transaction")
+      logger.debug("  transaction_options: #{transaction_options.inspect}")
+      logger.debug("  response: #{t.inspect}\n")
+      t
+    end
+
+    # Create a new CIM customer profile ready to accept a payment
+    def create_customer_profile(payment)
+      options = options_for_create_customer_profile(payment)
+      response = cim_gateway.create_customer_profile(options)
+      if response.success?
+        { :customer_profile_id => response.params["customer_profile_id"],
+          :customer_payment_profile_id => response.params["customer_payment_profile_id_list"].values.first }
+      else
+        payment.gateway_error(response) if payment.respond_to? :gateway_error
+        payment.source.gateway_error(response)
+      end
+    end
+
+    def options_for_create_customer_profile(payment)
+      if payment.is_a? Creditcard
+        info = { :bill_to => generate_address_hash(payment.address), :payment => { :credit_card => payment } }
+      else
+        info = { :bill_to => generate_address_hash(payment.order.bill_address),
+                 :payment => { :credit_card => payment.source } }
+      end
+      validation_mode = preferred_validate_on_profile_create ? preferred_server.to_sym : :none
+
+      { :profile => { :merchant_customer_id => "#{Time.now.to_f}",
+                      #:ship_to_list => generate_address_hash(creditcard.checkout.ship_address),
+                      :payment_profiles => info },
+        :validation_mode => validation_mode }
+    end
+
+    # As in PaymentGateway but with separate name fields
+    def generate_address_hash(address)
+      return {} if address.nil?
+      {:first_name => address.firstname, :last_name => address.lastname, :address1 => address.address1, :address2 => address.address2, :city => address.city,
+       :state => address.state_text, :zip => address.zipcode, :country => address.country.iso, :phone => address.phone}
+    end
+
+    def cim_gateway
+      ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+      gateway_options = options
+      ActiveMerchant::Billing::AuthorizeNetCimGateway.new(gateway_options)
+    end
+
+end