apispree_core 0.0.0

data/app/models/gateway.rb

@@ -0,0 +1,48 @@
+class Gateway < PaymentMethod
+	delegate_belongs_to :provider, :authorize, :purchase, :capture, :void, :credit
+
+	validates :name, :type, :presence => true
+
+  preference :server, :string, :default => 'test'
+  preference :test_mode, :boolean, :default => true
+
+  def payment_source_class
+    Creditcard
+  end
+
+  # instantiates the selected gateway and configures with the options stored in the database
+  def self.current
+    super
+	end
+
+  def provider
+    gateway_options = options
+    ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+    @provider ||= provider_class.new(gateway_options)
+  end
+
+	def options
+    options_hash = {}
+    self.preferences.each do |key,value|
+      options_hash[key.to_sym] = value
+    end
+    options_hash
+	end
+
+	def method_missing(method, *args)
+	 	if @provider.nil? || !@provider.respond_to?(method)
+			super
+		else
+      provider.send(method)
+		end
+	end
+
+	def payment_profiles_supported?
+	  false
+  end
+
+  def method_type
+    "gateway"
+  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

data/app/models/gateway/beanstream.rb

@@ -0,0 +1,187 @@
+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(payment)
+    creditcard = payment.source
+    if creditcard.gateway_customer_profile_id.nil?
+      options = options_for_create_customer_profile(creditcard, {})
+      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
+        creditcard.gateway_error(result) if creditcard.respond_to? :gateway_error
+        creditcard.source.gateway_error(result)
+      end
+    end
+  end
+
+  def capture(transaction, creditcard, gateway_options)
+    beanstream_gateway.capture((transaction.amount*100).round, transaction.response_code, gateway_options)
+  end
+
+  def void(transaction_response, creditcard, gateway_options)
+    beanstream_gateway.void(transaction_response, gateway_options)
+  end
+
+  def credit(amount, creditcard, response_code, gateway_options = {})
+    amount = (amount * -1) if amount < 0
+    beanstream_gateway.credit(amount, response_code, gateway_options)
+  end
+
+  private
+
+  def beanstream_gateway
+    ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
+    gateway_options = options
+    ActiveMerchant::Billing::BeanstreamGateway.new(gateway_options)
+  end
+
+  def verify_creditcard_name!(creditcard)
+    bill_address = creditcard.payments.first.order.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)
+    order = creditcard.payments.first.order
+    address = order.bill_address
+    { :email=>order.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

data/app/models/gateway/bogus.rb

@@ -0,0 +1,80 @@
+class Gateway::Bogus < Gateway
+  TEST_VISA = "4111111111111111"
+  TEST_MC = "5500000000000004"
+  TEST_AMEX = "340000000000009"
+  TEST_DISC = "6011000000000004"
+
+  VALID_CCS = ["1", TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC]
+
+  attr_accessor :test
+
+  def provider_class
+    self.class
+  end
+
+  def preferences
+    {}
+  end
+
+  def create_profile(payment)
+    # simulate the storage of credit card profile using remote service
+    success = VALID_CCS.include? payment.source.number
+    payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+  end
+
+  def authorize(money, creditcard, options = {})
+    profile_id = creditcard.gateway_customer_profile_id
+    if VALID_CCS.include? creditcard.number or (profile_id and profile_id.starts_with? "BGS-")
+      ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345', :avs_result => {:code => 'A'})
+    else
+      ActiveMerchant::Billing::Response.new(false, "Bogus Gateway: Forced failure", {:message => 'Bogus Gateway: Forced failure'}, :test => true)
+    end
+  end
+
+  def purchase(money, creditcard, options = {})
+    profile_id = creditcard.gateway_customer_profile_id
+    if VALID_CCS.include? creditcard.number  or (profile_id and profile_id.starts_with? "BGS-")
+      ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345', :avs_result => {:code => 'A'})
+    else
+      ActiveMerchant::Billing::Response.new(false, "Bogus Gateway: Forced failure", :message => 'Bogus Gateway: Forced failure', :test => true)
+    end
+  end
+
+  def credit(money, creditcard, response_code, options = {})
+    ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345')
+  end
+
+  def capture(authorization, creditcard, gateway_options)
+    if authorization.response_code == "12345"
+      ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '67890')
+    else
+      ActiveMerchant::Billing::Response.new(false, "Bogus Gateway: Forced failure", :error => 'Bogus Gateway: Forced failure', :test => true)
+    end
+
+  end
+
+  def void(response_code, creditcard, options = {})
+    ActiveMerchant::Billing::Response.new(true, "Bogus Gateway: Forced success", {}, :test => true, :authorization => '12345')
+  end
+
+  def test?
+    # Test mode is not really relevant with bogus gateway (no such thing as live server)
+    true
+  end
+
+  def payment_profiles_supported?
+    true
+  end
+
+  private
+  def generate_profile_id(success)
+    record = true
+    prefix = success ? "BGS" : "FAIL"
+    while record
+      random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
+      record = Creditcard.find(:first, :conditions => ["gateway_customer_profile_id = ?", random])
+    end
+    random
+  end
+
+end