abtain_billing 1.0 → 1.02

data/lib/active_merchant/billing/gateways/exact.rb

@@ -1,222 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class ExactGateway < Gateway
-      URL = 'https://secure2.e-xact.com/vplug-in/transaction/rpc-enc/service.asmx'
-      
-      API_VERSION = "8.5"
-      
-      TEST_LOGINS = [ {:login => "A00049-01", :password => "test1"},
-                      {:login => "A00427-01", :password => "testus"} ]
-      
-      TRANSACTIONS = { :sale          => "00",
-                       :authorization => "01",
-                       :capture       => "32",
-                       :credit        => "34" }
-      
-
-      ENVELOPE_NAMESPACES = { 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
-                              'xmlns:env' => 'http://schemas.xmlsoap.org/soap/envelope/',
-                              'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance'
-                            }
-                            
-      SEND_AND_COMMIT_ATTRIBUTES = { 'xmlns:n1' => "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/Request",
-                                     'env:encodingStyle' => 'http://schemas.xmlsoap.org/soap/encoding/'
-                                   }
-                                   
-      SEND_AND_COMMIT_SOURCE_ATTRIBUTES = { 'xmlns:n2' => 'http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/encodedTypes',
-                                            'xsi:type' => 'n2:Transaction'
-                                          }
-      
-      POST_HEADERS = { 'soapAction' => "http://secure2.e-xact.com/vplug-in/transaction/rpc-enc/SendAndCommit",
-                       'Content-Type' => 'text/xml' 
-                     }
-                     
-      SUCCESS = "true"
-      
-      SENSITIVE_FIELDS = [ :verification_str2, :expiry_date, :card_number ]
-      
-      self.supported_cardtypes = [:visa, :master, :american_express, :jcb, :discover]
-      self.supported_countries = ['CA', 'US']
-      self.homepage_url = 'http://www.e-xact.com'
-      self.display_name = 'E-xact'
-  
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        @options = options
-        
-        if TEST_LOGINS.include?( { :login => options[:login], :password => options[:password] } )
-          @test_mode = true
-        end
-      
-        super
-      end
-      
-      def test?
-        @test_mode || Base.gateway_mode == :test
-      end
-      
-      def authorize(money, credit_card, options = {})
-        commit(:authorization, build_sale_or_authorization_request(money, credit_card, options))
-      end
-      
-      def purchase(money, credit_card, options = {})
-        commit(:sale, build_sale_or_authorization_request(money, credit_card, options))
-      end
-    
-      def capture(money, authorization, options = {})
-        commit(:capture, build_capture_or_credit_request(money, authorization, options))
-      end
-
-      def credit(money, authorization, options = {})
-        commit(:credit, build_capture_or_credit_request(money, authorization, options))
-      end
-         
-      private                       
-      def build_request(action, body)
-        xml = Builder::XmlMarkup.new
-        
-        xml.instruct!
-        xml.tag! 'env:Envelope', ENVELOPE_NAMESPACES do
-          xml.tag! 'env:Body' do
-            xml.tag! 'n1:SendAndCommit', SEND_AND_COMMIT_ATTRIBUTES do
-              xml.tag! 'SendAndCommitSource', SEND_AND_COMMIT_SOURCE_ATTRIBUTES do
-                add_credentials(xml)
-                add_transaction_type(xml, action)
-                xml << body
-              end
-            end
-          end
-        end
-        xml.target!
-      end
-                
-      def build_sale_or_authorization_request(money, credit_card, options)
-        xml = Builder::XmlMarkup.new
- 
-        add_amount(xml, money)
-        add_credit_card(xml, credit_card)
-        add_customer_data(xml, options)
-        add_invoice(xml, options)
-        
-        xml.target!        
-      end
-      
-      def build_capture_or_credit_request(money, identification, options)
-        xml = Builder::XmlMarkup.new
-  
-        add_identification(xml, identification)
-        add_amount(xml, money)
-        add_customer_data(xml, options)
-    
-        xml.target!
-      end
-      
-      def add_credentials(xml)
-        xml.tag! 'ExactID', @options[:login]
-        xml.tag! 'Password', @options[:password]
-      end
-      
-      def add_transaction_type(xml, action)
-        xml.tag! 'Transaction_Type', TRANSACTIONS[action]
-      end
-      
-      def add_identification(xml, identification)
-        authorization_num, transaction_tag = identification.split(';')
- 
-        xml.tag! 'Authorization_Num', authorization_num
-        xml.tag! 'Transaction_Tag', transaction_tag
-      end
-      
-      def add_amount(xml, money)
-        xml.tag! 'DollarAmount', amount(money)
-      end
-      
-      def add_credit_card(xml, credit_card)
-        xml.tag! 'Card_Number', credit_card.number
-        xml.tag! 'Expiry_Date', expdate(credit_card)
-        xml.tag! 'CardHoldersName', credit_card.name
-        
-        if credit_card.verification_value?
-          xml.tag! 'CVD_Presence_Ind', '1'
-          xml.tag! 'VerificationStr2', credit_card.verification_value
-        end
-      end
-      
-      def add_customer_data(xml, options)
-        xml.tag! 'Customer_Ref', options[:customer]
-        xml.tag! 'Client_IP', options[:ip]
-        xml.tag! 'Client_Email', options[:email]
-      end
-
-      def add_address(xml, options)
-        if address = options[:billing_address] || options[:address]
-          xml.tag! 'ZipCode', address[:zip]       
-        end    
-      end
-
-      def add_invoice(xml, options)
-        xml.tag! 'Reference_No', options[:order_id]
-        xml.tag! 'Reference_3',  options[:description]
-      end
-      
-      def expdate(credit_card)
-        "#{format(credit_card.month, :two_digits)}#{format(credit_card.year, :two_digits)}"
-      end
-      
-      def commit(action, request)
-         response = parse(ssl_post(URL, build_request(action, request), POST_HEADERS))
-      
-         Response.new(successful?(response), message_from(response), response,
-           :test => test?,
-           :authorization => authorization_from(response),
-           :avs_result => { :code => response[:avs] },
-           :cvv_result => response[:cvv2]
-         )
-      end
-      
-      def successful?(response)
-        response[:transaction_approved] == SUCCESS
-      end
-      
-      def authorization_from(response)
-        if response[:authorization_num] && response[:transaction_tag]
-           "#{response[:authorization_num]};#{response[:transaction_tag]}"        
-        else
-           ''
-        end
-      end
-      
-      def message_from(response)
-        if response[:faultcode] && response[:faultstring]
-          response[:faultstring]
-        elsif response[:error_number] != '0'
-          response[:error_description]
-        else
-          result = response[:exact_message] || ''
-          result << " - #{response[:bank_message]}" unless response[:bank_message].blank?
-          result
-        end
-      end
-      
-      def parse(xml)
-        response = {}
-        xml = REXML::Document.new(xml)
-        
-        if root = REXML::XPath.first(xml, "//types:TransactionResult")
-          parse_elements(response, root)
-        elsif root = REXML::XPath.first(xml, "//soap:Fault")
-          parse_elements(response, root)
-        end
-
-        response.delete_if{ |k,v| SENSITIVE_FIELDS.include?(k) }
-      end
-
-      def parse_elements(response, root)
-        root.elements.to_a.each do |node|
-          response[node.name.gsub(/EXact/, 'Exact').underscore.to_sym] = (node.text || '').strip
-        end
-      end
-    end
-  end
-end
-

data/lib/active_merchant/billing/gateways/first_pay.rb

@@ -1,172 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:    
-    class FirstPayGateway < Gateway
-      class FirstPayPostData < PostData
-        # Fields that will be sent even if they are blank
-        self.required_fields = [ :action, :amount, :trackid ]   
-      end
-
-      # both URLs are IP restricted
-      TEST_URL = 'https://apgcert.first-pay.com/AcqENGIN/SecureCapture'
-      LIVE_URL = 'https://acqengin.first-pay.com/AcqENGIN/SecureCapture'
-      
-      # The countries the gateway supports merchants from as 2 digit ISO country codes
-      self.supported_countries = ['US']
-      
-      # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master]
-      
-      # The homepage URL of the gateway
-      self.homepage_url = 'http://www.first-pay.com'
-      
-      # The name of the gateway
-      self.display_name = 'First Pay'
-      
-      # all transactions are in cents
-      self.money_format = :cents
-      
-      ACTIONS = {
-        'sale' => 1,
-        'credit' => 2,
-        'void' => 3
-      }
-      
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        @options = options
-        super
-      end  
-      
-      def purchase(money, creditcard, options = {})
-        post = FirstPayPostData.new
-        add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, options)
-        add_customer_data(post, options)
-        
-        commit('sale', money, post)
-      end                       
-      
-      def credit(money, reference, options = {})
-        raise ArgumentError, "Both TransactionID and CreditCard are required" unless reference.is_a?(String) && options[:credit_card]
-
-        post = FirstPayPostData.new
-        add_invoice(post, options)
-        add_creditcard(post, options[:credit_card])
-        add_address(post, options)
-        add_customer_data(post, options)
-        add_credit_data(post, reference)
-      
-        commit('credit', money, post)
-      end
-      
-      def void(money, creditcard, options = {})
-        post = FirstPayPostData.new
-        add_creditcard(post, creditcard)
-        add_void_data(post, options)
-        add_invoice(post, options)
-        add_customer_data(post, options)
-        
-        commit('void', money, post)
-      end
-      
-      
-      private
-      
-      def add_customer_data(post, options)
-        post[:cardip] = options[:ip]
-        post[:email] = options[:email]
-      end
-      
-      def add_address(post, options)
-        if billing_address = options[:billing_address] || options[:address]
-          post[:addr]     = billing_address[:address1].to_s + ' ' + billing_address[:address2].to_s
-          post[:city]     = billing_address[:city]
-          post[:state]    = billing_address[:state]
-          post[:zip]      = billing_address[:zip]                             
-          post[:country]  = billing_address[:country]
-        end
-      end
-      
-      def add_invoice(post, options)
-        post[:trackid] = rand(Time.now)
-      end
-      
-      def add_creditcard(post, creditcard)
-        post[:member] = creditcard.first_name.to_s + " " + creditcard.last_name.to_s
-        post[:card] = creditcard.number
-        post[:exp] = expdate(creditcard)
-      end
-      
-      def expdate(credit_card)
-        year  = sprintf("%.4i", credit_card.year)
-        month = sprintf("%.2i", credit_card.month)
-
-        "#{month}#{year[-2..-1]}"
-      end
-      
-      def add_credit_data(post, transaction_id)
-        post[:transid] = transaction_id
-      end
-      
-      def add_void_data(post, options)
-        post[:transid] = options[:transactionid]
-      end
-      
-      def commit(action, money, post)
-        response = parse( ssl_post(test? ? TEST_URL : LIVE_URL, post_data(action, post, money)) )
-                
-        Response.new(response[:response] == 'CAPTURED', response[:message], response,
-          :test => test?,
-          :authorization => response[:authorization],
-          :avs_result => { :code => response[:avsresponse] },
-          :cvv_result => response[:cvvresponse])
-      end
-      
-      def parse(body)
-        response = {}
-        
-        # check for an error first
-        if body.include?('!ERROR!')
-          response[:response] = 'ERROR'
-          response[:message] = error_message_from(body)
-        else
-          # a capture / not captured response will be : delimited
-          split = body.split(':')
-          response[:response] = split[0]
-          
-          # FirstPay docs are worthless. turns out the transactionid is required for credits
-          # so we need to store that in authorization, not the actual auth.
-          if response[:response] == 'CAPTURED'
-            response[:message] = 'CAPTURED'
-            response[:authorization] = split[9] # actually the transactionid
-            response[:auth] = split[1]
-            response[:avsresponse] = split[3]
-            response[:cvvresponse] = split[17]
-          else
-            # NOT CAPTURED response
-            response[:message] = split[1]
-            response[:transactionid] = split[9]
-          end
-        end
-        
-        return response
-      end
-      
-      def error_message_from(response)
-        # error messages use this format - '!ERROR! 704-MISSING BASIC DATA TYPE:card, exp, zip, addr, member, amount\n'
-        response.split("! ")[1].chomp
-      end
-      
-      def post_data(action, post, money)
-        post[:vid]        = @options[:login]  
-        post[:password]   = @options[:password]
-        post[:action]     = ACTIONS[action]
-        post[:amount]     = amount(money)
-        
-        return post.to_post_data
-      end
-    end
-  end
-end
-

data/lib/active_merchant/billing/gateways/instapay.rb

@@ -1,164 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class InstapayGateway < Gateway
-      GATEWAY_URL = 'https://trans.instapaygateway.com/cgi-bin/process.cgi'
-
-      # The countries the gateway supports merchants from as 2 digit ISO country codes
-      self.supported_countries = ['US']
-      self.money_format = :dollars
-      self.default_currency = 'USD'
-      # The card types supported by the payment gateway
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
-
-      # The homepage URL of the gateway
-      self.homepage_url = 'http://www.instapayllc.com'
-
-      # The name of the gateway
-      self.display_name = 'InstaPay'
-      
-      SUCCESS         = "Accepted"
-      SUCCESS_MESSAGE = "The transaction has been approved"
-
-      def initialize(options = {})
-        requires!(options, :login)
-        @options = options
-        super
-      end
-
-      def authorize(money, creditcard, options = {})
-        post = {}
-        post[:authonly] = 1
-        add_amount(post, money)
-        add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, options)
-        add_customer_data(post, options)
-
-        commit('ns_quicksale_cc', post)
-      end
-
-      def purchase(money, creditcard, options = {})
-        post = {}
-        add_amount(post, money)
-        add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, options)
-        add_customer_data(post, options)
-
-        commit('ns_quicksale_cc', post)
-      end
-      
-      def capture(money, authorization, options = {})
-        post = {}
-        add_amount(post, money)
-        add_reference(post, authorization)        
-        commit('ns_quicksale_cc', post)
-      end
-
-      private
-      
-      def add_amount(post, money)
-        post[:amount] = amount(money)
-      end
-      
-      def add_reference(post, reference)
-        post[:postonly] = reference
-      end
-        
-      def add_customer_data(post, options)
-        post[:ci_email]       = options[:email]
-        post["ci_IP Address"] = options[:ip]
-      end
-
-      def add_address(post, options)
-        if address = options[:billing_address] || options[:address]
-          post[:ci_billaddr1]   = address[:address1]
-          post[:ci_billaddr2]   = address[:address2]
-          post[:ci_billcity]    = address[:city]
-          post[:ci_billstate]   = address[:state]
-          post[:ci_billzip]     = address[:zip]
-          post[:ci_billcountry] = address[:country]
-          post[:ci_phone]       = address[:phone]
-        end
-
-        if address = options[:shipping_address]
-          post[:ci_shipaddr1]   = address[:address1]
-          post[:ci_shipaddr2]   = address[:address2]
-          post[:ci_shipcity]    = address[:city]
-          post[:ci_shipstate]   = address[:state]
-          post[:ci_shipzip]     = address[:zip]
-          post[:ci_shipcountry] = address[:country]  
-        end
-      end
-
-      def add_invoice(post, options)
-        post[:merchantordernumber] = options[:order_id]
-        post[:ci_memo]             = options[:description]
-        post[:pocustomerrefid]     = options[:invoice]
-      end
-
-      def add_creditcard(post, creditcard)
-        post[:ccnum]   = creditcard.number
-        post[:expmon]  = format(creditcard.month, :two_digits)
-        post[:cvv2]    = creditcard.verification_value if creditcard.verification_value?
-        post[:expyear] = creditcard.year
-        post[:ccname]  = creditcard.name
-      end
-
-      def parse(body)
-        results = {}
-        fields = body.split("\r\n")
-        
-        response = fields[1].split('=')        
-        response_data = response[1].split(':')
-        
-        if response[0] == SUCCESS
-          results[:success] = true
-          results[:message] = SUCCESS_MESSAGE
-          results[:transaction_type] = response_data[0]
-          results[:authorization_code] = response_data[1]
-          results[:reference_number] = response_data[2]
-          results[:batch_number] = response_data[3]
-          results[:transaction_id] = response_data[4]
-          results[:avs_result] = response_data[5]
-          results[:authorize_net] = response_data[6]
-          results[:cvv_result] = response_data[7]
-        else
-          results[:success] = false
-          results[:result] = response_data[0]
-          results[:response_code] = response_data[1]
-          results[:message] = response_data[2]
-        end
-
-        fields[1..-1].each do |pair|
-          key, value = pair.split('=')
-          results[key] = value
-        end
-        results
-      end
-
-      def commit(action, parameters)
-        data = ssl_post GATEWAY_URL , post_data(action, parameters)
-        response = parse(data)
-
-        Response.new(response[:success] , response[:message], response,
-          :authorization => response[:transaction_id],
-          :avs_result => { :code => response[:avs_result] },
-          :cvv_result => response[:cvv_result]
-        )
-      end
-
-      def post_data(action, parameters = {})
-        post = {}
-        post[:acctid] = @options[:login]
-        if(@options[:password])
-          post[:merchantpin] = @options[:password]
-        end
-        post[:action] = action
-        request = post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
-        request
-      end
-    end
-  end
-end
-