spree_core 0.30.0.beta1

data/app/models/checkout.rb

@@ -0,0 +1,141 @@
+class Checkout < ActiveRecord::Base
+  extend ValidationGroup::ActiveRecord::ActsMethods
+
+  before_update :check_addresses_on_duplication, :if => "!ship_address.nil? && !bill_address.nil?"
+  after_save :process_coupon_code
+  after_save :update_order_shipment
+  before_validation :clone_billing_address, :if => "@use_billing"
+
+  belongs_to :order
+  belongs_to :bill_address, :foreign_key => "bill_address_id", :class_name => "Address"
+  belongs_to :ship_address, :foreign_key => "ship_address_id", :class_name => "Address"
+  belongs_to :shipping_method
+  has_many :payments, :as => :payable
+
+  accepts_nested_attributes_for :bill_address
+  accepts_nested_attributes_for :ship_address
+  accepts_nested_attributes_for :payments
+
+  attr_accessor :coupon_code
+  attr_accessor :use_billing
+
+  validates :order_id, :shipping_method_id, :presence => true
+  validates :email, :format => { :with => /^\S+@\S+\.\S+$/ }
+
+  validation_group :register, :fields => ["email"]
+
+  validation_group :address, :fields=>["bill_address.firstname", "bill_address.lastname", "bill_address.phone",
+                                       "bill_address.zipcode", "bill_address.state", "bill_address.lastname",
+                                       "bill_address.address1", "bill_address.city", "bill_address.statename",
+                                       "bill_address.zipcode", "ship_address.firstname", "ship_address.lastname", "ship_address.phone",
+                                       "ship_address.zipcode", "ship_address.state", "ship_address.lastname",
+                                       "ship_address.address1", "ship_address.city", "ship_address.statename",
+                                       "ship_address.zipcode"]
+  validation_group :delivery, :fields => ["shipping_method_id"]
+
+  def completed_at
+    order.completed_at
+  end
+
+  # This is a temporary Shipment object for the purpose of showing available shiping rates in delivery step of checkout
+  def shipment
+    @shipment ||= Shipment.new(:order => order, :address => ship_address)
+  end
+
+
+  alias :ar_valid? :valid?
+  def valid?(context=nil)
+    # will perform partial validation when @checkout.enabled_validation_group :step is called
+    result = ar_valid?(context)
+    return result unless validation_group_enabled?
+
+    relevant_errors = errors.select { |attr, msg| @current_validation_fields.include?(attr) }
+    errors.clear
+    relevant_errors.each { |attr, msg| errors.add(attr, msg) }
+    relevant_errors.empty?
+  end
+
+  # checkout state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+  state_machine :initial => 'address' do
+    after_transition :to => 'complete', :do => :complete_order
+    before_transition :to => 'complete', :do => :process_payment
+    event :next do
+      transition :to => 'delivery', :from  => 'address'
+      transition :to => 'payment', :from => 'delivery'
+      transition :to => 'confirm', :from => 'payment', :if => Proc.new { Gateway.current and Gateway.current.payment_profiles_supported? }
+      transition :to => 'complete', :from => 'confirm'
+      transition :to => 'complete', :from => 'payment'
+    end
+  end
+  def self.state_names
+    state_machine.states.by_priority.map(&:name)
+  end
+
+  def shipping_methods(display_on=nil)
+    return [] unless ship_address
+    ShippingMethod.all_available(order,display_on)
+  end
+
+  def payment
+    payments.first
+  end
+
+  private
+
+  def check_addresses_on_duplication
+    if order.user
+      if order.user.ship_address.nil?
+        order.user.ship_address = ship_address
+      elsif ship_address.same_as?(order.user.ship_address)
+        #self.ship_address = order.user.ship_address
+      end
+      if order.user.bill_address.nil?
+        order.user.bill_address = bill_address
+      elsif bill_address.same_as?(order.user.bill_address)
+        #self.bill_address = order.user.bill_address
+      end
+    end
+    true
+  end
+
+  def clone_billing_address
+    if self.ship_address.nil?
+      self.ship_address = bill_address.clone
+    else
+      self.ship_address.attributes = bill_address.attributes.except("id", "updated_at", "created_at")
+    end
+    true
+  end
+
+  def complete_order
+    order.complete!
+    order.pay! if Spree::Config[:auto_capture]
+  end
+
+  def process_payment
+    return if order.payments.total == order.total
+    payments.each(&:process!)
+  end
+
+  def process_coupon_code
+    return unless @coupon_code and coupon = Promotion.find(:first, :conditions => ["UPPER(code) = ?",@coupon_code.upcase])
+    coupon.create_discount(order)
+    # recalculate order totals
+    order.save
+  end
+
+  # list of countries available for checkout
+  def self.countries
+    return Country.all unless zone = Zone.find_by_name(Spree::Config[:checkout_zone])
+    zone.country_list
+  end
+
+  def update_order_shipment
+    if order.shipment
+      order.shipment.shipping_method = shipping_method
+      order.shipment.address_id = ship_address.id unless ship_address.nil?
+      order.shipment.save
+    end
+  end
+
+end

data/app/models/configuration.rb

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

data/app/models/country.rb

@@ -0,0 +1,17 @@
+class Country < ActiveRecord::Base
+  has_many :states
+  
+  has_one     :zone_member, :as => :zoneable
+  has_one     :zone,        :through => :zone_member
+
+  scope :order_by_name, :order => :name  
+  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,240 @@
+class Creditcard < ActiveRecord::Base
+  has_many :payments, :as => :source
+
+  before_save :set_last_digits
+
+  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)
+    begin
+      if Spree::Config[:auto_capture]
+        purchase(payment.amount.to_f, payment)
+      else
+        authorize(payment.amount.to_f, payment)
+      end
+    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
+
+  def name?
+    first_name? && last_name?
+  end
+
+  def first_name?
+    !self.first_name.blank?
+  end
+
+  def last_name?
+    !self.last_name.blank?
+  end
+
+  def name
+    "#{self.first_name} #{self.last_name}"
+  end
+
+  def verification_value?
+    !verification_value.blank?
+  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
+
+
+
+
+  #RAILS3 TODO
+  # 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
+    response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))
+    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 => e
+    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.
+    response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment))
+    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 => e
+    gateway_error t(:unable_to_connect_to_gateway)
+  end
+
+  def capture(payment)
+    return unless payment.pending?
+    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
+    if response.success?
+      payment.response_code = response.authorization
+      payment.complete
+    else
+      payment.fail
+      gateway_error(response)
+    end
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  end
+
+  def void(payment)
+    response = payment_gateway.void(payment.response_code, self, minimal_gateway_options(payment))
+    if response.success?
+      payment.response_code = response.authorization
+      payment.void
+    else
+      gateway_error(response)
+    end
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  end
+
+  def credit(payment, amount)
+    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
+    if response.success?
+      Payment.create(:source => payment, :amount => amount.abs * -1, :response_code => response.authorization, :state => 'completed')
+    else
+      gateway_error(response)
+    end
+  rescue ActiveMerchant::ConnectionError => e
+    gateway_error I18n.t(:unable_to_connect_to_gateway)
+  end
+
+
+  def actions
+    %w{capture void credit}
+  end
+
+  # def can_capture?(payment)
+  #   authorization(payment).present? &&
+  #   has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE, CreditcardTxn::TxnType::VOID)
+  # end
+
+  # def can_void?(payment)
+  #   has_transaction_of_types?(payment, CreditcardTxn::TxnType::AUTHORIZE, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) &&
+  #   has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID)
+  # end
+
+  # # Can only refund a captured transaction but if transaction hasn't been cleared by merchant, refund may still fail
+  # def can_credit?(payment)
+  #   has_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) &&
+  #   has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID) and payment.order.outstanding_credit?
+  # end
+
+  def has_payment_profile?
+    gateway_customer_profile_id.present?
+  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 ENV['RAILS_ENV'] == "development"
+    self.class.type?(number)
+  end
+
+  def payment_gateway
+    @payment_gateway ||= Gateway.current
+  end
+
+  private
+
+    def has_transaction_of_types?(payment, *types)
+      (payment.txns.map(&:txn_type) & types).any?
+    end
+
+    def has_no_transaction_of_types?(payment, *types)
+      (payment.txns.map(&:txn_type) & types).none?
+    end
+
+    #RAILS 3 TODO
+    # # Override default behavior of Rails attr_readonly so that its never written to the database (not even on create)
+    # def attributes_with_quotes(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
+    #   attributes_with_quotes_default(include_primary_key, false, attribute_names)
+    # end
+
+    def remove_readonly_attributes(attributes)
+      if self.class.readonly_attributes.present?
+        attributes.delete_if { |key, value| self.class.readonly_attributes.include?(key.gsub(/\(.+/,"")) }
+      end
+      # extra logic for sanitizing the number and verification value based on preferences
+      attributes.delete_if { |key, value| key == "number" and !Spree::Config[:store_cc] }
+      attributes.delete_if { |key, value| key == "verification_value" and !Spree::Config[:store_cvv] }
+    end
+
+end

data/app/models/gateway/authorize_net.rb

@@ -0,0 +1,8 @@
+class Gateway::AuthorizeNet < Gateway
+	preference :login, :string
+	preference :password, :string
+	
+  def provider_class
+    ActiveMerchant::Billing::AuthorizeNetGateway
+  end	
+end

data/app/models/gateway/authorize_net_cim.rb

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

data/app/models/gateway/beanstream.rb

@@ -0,0 +1,164 @@
+class Gateway::Beanstream < Gateway
+  preference :login, :string
+  preference :user, :string
+  preference :password, :string
+  preference :secure_profile_api_key, :string
+
+  def provider_class
+    ActiveMerchant::Billing::BeanstreamGateway
+  end
+
+  def payment_profiles_supported?
+    true
+  end
+
+  def create_profile(creditcard, gateway_options)
+    if creditcard.gateway_customer_profile_id.nil?
+      options = options_for_create_customer_profile(creditcard, gateway_options)
+      verify_creditcard_name!(creditcard)
+      result = provider.store(creditcard, options)
+      if result.success?
+        creditcard.update_attributes(:gateway_customer_profile_id => result.params["customerCode"], :gateway_payment_profile_id => result.params["customer_vault_id"])
+      else
+        raise "Error creating profile: #{result.message}"
+      end
+    end
+  end
+  private
+  def verify_creditcard_name!(creditcard)
+    bill_address = creditcard.payments.first.payable.bill_address
+    creditcard.first_name = bill_address.firstname unless creditcard.first_name?
+    creditcard.last_name = bill_address.lastname   unless creditcard.last_name?
+  end
+
+  def options_for_create_customer_profile(creditcard, gateway_options)
+    checkout = creditcard.payments.first.payable
+    address = checkout.bill_address
+    { :email=>checkout.email,
+      :billing_address=>
+      { :name=>address.full_name,
+        :phone=>address.phone,
+        :address1=>address.address1,
+        :address2=>address.address2,
+        :city=>address.city,
+        :state=>address.state_name || address.state.abbr,
+        :country=>address.country.iso,
+        :zip=>address.zipcode
+      }
+    }.merge(gateway_options)
+  end
+
+  SECURE_PROFILE_URL = 'https://www.beanstream.com/scripts/payment_profile.asp'
+  SP_SERVICE_VERSION = '1.1'
+  PROFILE_OPERATIONS = {:new => 'N', :modify => 'M'}
+
+  ActiveMerchant::Billing::BeanstreamGateway.class_eval do
+
+    def store(credit_card, options = {})
+      post = {}
+      add_address(post, options)
+      add_credit_card(post, credit_card)
+      add_secure_profile_variables(post,options)
+      commit(post, true)
+    end
+
+    #can't actually delete a secure profile with the supplicaed API. This function sets the status of the profile to closed (C).
+    #Closed profiles will have to removed manually.
+    def delete(vault_id)
+      update(vault_id, false, {:status => "C"})
+    end
+
+    #alias_method :unstore, :delete
+
+    # Update the values (such as CC expiration) stored at
+    # the gateway.  The CC number must be supplied in the
+    # CreditCard object.
+    def update(vault_id, credit_card, options = {})
+      post = {}
+      add_address(post, options)
+      add_credit_card(post, credit_card)
+      options.merge!({:vault_id => vault_id, :operation => secure_profile_action(:modify)})
+      add_secure_profile_variables(post,options)
+      commit(post, true)
+    end
+
+    # CORE #
+
+    def secure_profile_action(type)
+      PROFILE_OPERATIONS[type] || PROFILE_OPERATIONS[:new]
+    end
+
+    def add_credit_card(post, credit_card)
+      if credit_card
+        if credit_card.has_payment_profile?
+          post[:customerCode] = credit_card.gateway_customer_profile_id
+        else
+          post[:trnCardOwner] = credit_card.name
+          post[:trnCardNumber] = credit_card.number
+          post[:trnExpMonth] = format(credit_card.month, :two_digits)
+          post[:trnExpYear] = format(credit_card.year, :two_digits)
+          post[:trnCardCvd] = credit_card.verification_value
+        end
+      end
+    end
+
+    def add_secure_profile_variables(post, options = {})
+      post[:serviceVersion] = SP_SERVICE_VERSION
+      post[:responseFormat] = 'QS'
+      post[:cardValidation] = (options[:cardValidation].to_i == 1) || '0'
+
+      post[:operationType] = options[:operationType] || options[:operation] || secure_profile_action(:new)
+      post[:customerCode] = options[:billing_id] || options[:vault_id] || false
+      post[:status] = options[:status]
+    end
+
+    def commit(params, use_profile_api = false)
+      post(post_data(params,use_profile_api),use_profile_api)
+    end
+
+    def post(data, use_profile_api)
+      response = parse(ssl_post((use_profile_api ? SECURE_PROFILE_URL : ActiveMerchant::Billing::BeanstreamGateway::URL), data))
+      response[:customer_vault_id] = response[:customerCode] if response[:customerCode]
+      build_response(success?(response), message_from(response), response,
+        :test => test? || response[:authCode] == "TEST",
+        :authorization => authorization_from(response),
+        :cvv_result => ActiveMerchant::Billing::BeanstreamGateway::CVD_CODES[response[:cvdId]],
+        :avs_result => { :code => (ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES.include? response[:avsId]) ? ActiveMerchant::Billing::BeanstreamGateway::AVS_CODES[response[:avsId]] : response[:avsId] }
+      )
+    end
+
+    def message_from(response)
+      response[:messageText] || response[:responseMessage]
+    end
+
+    def success?(response)
+      response[:responseType] == 'R' || response[:trnApproved] == '1' || response[:responseCode] == '1'
+    end
+
+    def add_source(post, source)
+      if source.is_a?(String) or source.is_a?(Integer)
+        post[:customerCode] = source
+      else
+        source.type.to_s == "check" ? add_check(post, source) : add_credit_card(post, source)
+      end
+    end
+
+    def post_data(params, use_profile_api)
+      params[:requestType] = 'BACKEND'
+      if use_profile_api
+        params[:merchantId] = @options[:login]
+        params[:passCode] = @options[:secure_profile_api_key]
+      else
+        params[:username] = @options[:user] if @options[:user]
+        params[:password] = @options[:password] if @options[:password]
+        params[:merchant_id] = @options[:login]
+      end
+      params[:vbvEnabled] = '0'
+      params[:scEnabled] = '0'
+
+      params.reject{|k, v| v.blank?}.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+    end
+
+  end
+
+end