activemerchant 1.0.0

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

@@ -0,0 +1,265 @@
+#  This class implements the Psigate gateway for the ActiveMerchant module.
+#  Psigate = http://www.psigate.com/ The class  is currently set up to use
+#  the psigate test server while rails is in testing or developement mode.
+#  The real server will be used while in production mode.
+#  
+#  Modifications by Sean O'Hara ( sohara at sohara dot com )
+#  
+#  Usage for a PreAuth (authorize) is as follows:
+#  
+#  twenty = Money.ca_dollar(2000)
+#  gateway = PsigateGateway.new({
+#    :store_id => 'teststore',
+#    :password => 'psigate1234',
+#  })
+#  
+#  creditcard = CreditCard.new({
+#    :number => '4242424242424242',
+#    :month => 8,
+#    :year => 2006,
+#    :first_name => 'Longbob',
+#    :last_name => 'Longsen'
+#  })
+#  response = @gateway.authorize(twenty, creditcard, {:order_id =>  1234,
+#     :billing_address => {
+#  	  :address1 => '123 fairweather Lane',
+#  	  :address2 => 'Apt B',
+#  	  :city => 'New York',
+#  	  :state => 'NY',
+#  	  :country => 'U.S.A.',
+#  	  :zip => '10010'},
+#    :email => 'jack@yahoo.com'
+#    })
+
+require 'rexml/document'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+
+    class PsigateGateway < Gateway
+     
+      # URL
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+
+      TEST_URL  = 'https://dev.psigate.com:7989/Messenger/XMLMessenger'
+      LIVE_URL  = 'https://secure.psigate.com:7934/Messenger/XMLMessenger'
+      
+      def initialize(options = {})
+        requires!(options, :login, :password)
+      
+        options[:store_id] ||= options[:login]
+      
+        # these are the defaults for the psigate test server
+        @options = {
+          :store_id   => "teststore",
+          :password   => "testpass",          
+        }.update(options)                           
+        super      
+      end      
+    
+      # Psigate PreAuth
+      def authorize(money, creditcard, options = {})
+        requires!(options, :order_id)                                                          
+        options.update({ :CardAction => "1" })
+        commit(money, creditcard, options)      
+      end
+      
+      # Psigate Sale
+      def purchase(money, creditcard, options = {})
+        requires!(options, :order_id)                                                          
+        options.update({ :CardAction => "0" })
+        commit(money, creditcard, options)     
+      end
+      
+      # Psigate PostAuth
+      def capture(money, authorization, options = {})
+        options.update({ :CardAction => "2", :order_id => authorization })
+        commit(money, nil, options)
+      end
+      
+
+      # Psigate Credit
+      def credit(money, authorization, options = {})
+        options.update({ :CardAction => "3", :order_id => authorization })
+        commit(money, nil, options)
+      end
+ 
+      # We support visa and master card
+      def self.supported_cardtypes
+        [:visa, :master]
+      end
+         
+      private                       
+    
+      def commit(money, creditcard, options = {}) 
+        parameters = parameters(money, creditcard, options)                                
+        
+        if result = test_result_from_cc_number(parameters[:CardNumber])
+          return result
+        end
+        
+        data = ssl_post post_data(parameters)
+        @response = parse(data)
+        success = (@response[:approved] == "APPROVED")
+        message = message_form(@response)
+        Response.new(success, message, @response, :test => test?, :authorization => response[:orderid])
+      end
+                                               
+      # Parse psigate response xml into a convinient hash
+      def parse(xml)
+        #  <?xml version="1.0" encoding="UTF-8"?>
+        #  <Result>
+        #  <TransTime>Tue Jun 27 22:19:58 EDT 2006</TransTime>
+        #  <OrderID>1004</OrderID>
+        #  <TransactionType>POSTAUTH</TransactionType>
+        #  <Approved>APPROVED</Approved>
+        #  <ReturnCode>Y:123456:0abcdef:M:X:NNN</ReturnCode>
+        #  <ErrMsg></ErrMsg>
+        #  <TaxTotal>0.00</TaxTotal>
+        #  <ShipTotal>0.00</ShipTotal>
+        #  <SubTotal>20.00</SubTotal>
+        #  <FullTotal>20.00</FullTotal>
+        #  <PaymentType>CC</PaymentType>
+        #  <CardNumber>......1111</CardNumber>
+        #  <TransRefNumber>1bd6f76ad1a25804</TransRefNumber>
+        #  <CardIDResult>M</CardIDResult>
+        #  <AVSResult>X</AVSResult>
+        #  <CardAuthNumber>123456</CardAuthNumber>
+        #  <CardRefNumber>0abcdef</CardRefNumber>
+        #  <CardType>VISA</CardType>
+        #  <IPResult>NNN</IPResult>
+        #  <IPCountry>UN</IPCountry>
+        #  <IPRegion>UNKNOWN</IPRegion>
+        #  <IPCity>UNKNOWN</IPCity>
+        #  </Result>   
+
+        response = {:message => "Global Error Receipt", :complete => false}
+
+        xml = REXML::Document.new(xml)          
+        xml.elements.each('//Result/*') do |node|
+
+          response[node.name.downcase.to_sym] = normalize(node.text)
+
+        end unless xml.root.nil?
+
+        response
+      end     
+
+      def post_data(parameters = {})
+        xml = REXML::Document.new
+        xml << REXML::XMLDecl.new
+        root  = xml.add_element("Order")
+        
+        for key, value in parameters
+          root.add_element(key.to_s).text = value if value
+        end    
+
+        xml.to_s
+      end
+      
+      
+      # Set up the parameters hash just once so we don't have to do it
+      # for every action. 
+      def parameters(money, creditcard, options = {})
+        
+        
+        params = {
+          # General order paramters
+          :StoreID => @options[:store_id],
+          :Passphrase => @options[:password],
+          :TestResult => options[:test_result],
+          :OrderID => options[:order_id],
+          :UserID => options[:user_id],
+          :Phone => options[:phone],
+          :Fax => options[:fax],
+          :Email => options[:email],
+          
+          # Credit Card paramaters
+          :PaymentType => "CC",
+          :CardAction => options[:CardAction],
+          
+          # Financial paramters
+          :CustomerIP => options[:ip],
+          :SubTotal => amount(money),
+          :Tax1 => options[:tax1],
+          :Tax2 => options[:tax2],
+          :ShippingTotal => options[:shipping_total],
+        }
+
+        if creditcard
+          exp_month = sprintf("%.2i", creditcard.month) unless creditcard.month.blank?
+          exp_year = creditcard.year.to_s[2,2] unless creditcard.year.blank?
+          card_id_code = creditcard.verification_value.blank? ? nil : "1"
+
+          params.update( 
+            :CardNumber => creditcard.number,
+            :CardExpMonth => exp_month,
+            :CardExpYear => exp_year,
+            :CardIDCode => card_id_code,
+            :CardIDNumber => creditcard.verification_value
+          )
+        end
+        
+        if address = options[:billing_address] || options[:address]           
+          params[:Bname] = address[:name] || creditcard.name 
+          params[:Baddress1]    = address[:address1] unless address[:address1].blank?
+          params[:Baddress2]    = address[:address2] unless address[:address2].blank?
+          params[:Bcity]        = address[:city]     unless address[:city].blank?
+          params[:Bprovince]    = address[:state]    unless address[:state].blank?
+          params[:Bpostalcode]  = address[:zip]      unless address[:zip].blank?
+          params[:Bcountry]     = address[:country]  unless address[:country].blank?
+          params[:Bcompany]     = address[:company]  unless address[:company].blank?
+        end
+        
+        if address = options[:shipping_address] || options[:address]                   
+          params[:Sname]        = address[:name] || creditcard.name 
+          params[:Saddress1]    = address[:address1] unless address[:address1].blank?
+          params[:Saddress2]    = address[:address2] unless address[:address2].blank?
+          params[:Scity]        = address[:city]     unless address[:city].blank?
+          params[:Sprovince]    = address[:state]    unless address[:state].blank?
+          params[:Spostalcode]  = address[:zip]      unless address[:zip].blank?
+          params[:Scountry]     = address[:country]  unless address[:country].blank?
+          params[:Scompany]     = address[:company]  unless address[:company].blank?
+        end
+       	 	
+        return params
+      end
+      
+      # Redefine ssl_post to use correct url depending on test mode
+      def ssl_post(data)
+        # In my case I only want the LIVE_URL to be used when in prodcution mode 
+        # because Psigate charges for all transactions
+        uri = URI.parse(test? ? TEST_URL : LIVE_URL )
+        http = Net::HTTP.new(uri.host, uri.port) 
+
+        http.verify_mode    = OpenSSL::SSL::VERIFY_NONE unless @ssl_strict
+        http.use_ssl        = true
+
+        http.post(uri.path, data).body 
+      end
+      
+      
+      def message_form(response)
+        if response[:approved] == "APPROVED"
+          return 'Success'
+        else
+          return 'Unspecified error' if response[:errmsg].blank?
+          return response[:errmsg].gsub(/[^\w]/, ' ').split.join(" ").capitalize
+        end
+      end
+
+      # Make a ruby type out of the response string
+      def normalize(field)
+        case field
+        when "true"   then true
+        when "false"  then false
+        when ""       then nil
+        when "null"   then nil
+        else field
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,330 @@
+begin
+  require 'tclink'
+rescue LoadError
+  # Ignore, but we will fail hard if someone actually tries to use this gateway 
+end
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    
+    # To get started using TrustCommerce with active_merchant, download the tclink library from http://www.trustcommerce.com/tclink.html,
+    # following the instructions available there to get it working on your system. Once it is installed, you should be able to make sure
+    # that it is visible to your ruby install by opening irb and typing "require 'tclink'", which should return "true".
+    #
+    # TO USE:
+    # First, make sure you have everything setup correctly and all of your dependencies in place with:
+    # 
+    #   require 'rubygems'
+    #   require 'money'
+    #   require 'active_merchant'
+    #
+    # The second line is a require for the 'money' library. Make sure you have it installed with 'gem install money'
+    #
+    # Using the money library, create a money object. Pass the dollar value in cents. In this case, $10 US becomes 1000.
+    #
+    #   tendollar = Money.us_dollar(1000)
+    #
+    # Next, create a credit card object using a TC approved test card.
+    #
+    #   creditcard = ActiveMerchant::Billing::CreditCard.new(
+    #	    :number => '4111111111111111',
+    #	    :month => 8,
+    #	    :year => 2006,
+    #	    :first_name => 'Longbob',
+    #     :last_name => 'Longsen'
+    #   )
+    #
+    # To finish setting up, create the active_merchant object you will be using, with the TrustCommerce gateway. If you have a
+    # functional TrustCommerce account, replace login and password with your account info. Otherwise the defaults will work for
+    # testing.
+    #
+    #   gateway = ActiveMerchant::Billing::Base.gateway(:trust_commerce).new(:login => "TestMerchant", :password => "password")
+    #
+    # Now we are ready to process our transaction
+    #
+    #   response = gateway.purchase(tendollar, creditcard)
+    #
+    # Sending a transaction to TrustCommerce with active_merchant returns a Response object, which consistently allows you to:
+    #
+    # 1) Check whether the transaction was successful
+    #
+    #   response.success?
+    #
+    # 2) Retrieve any message returned by TrustCommerce, either a "transaction was successful" note or an explanation of why the
+    # transaction was rejected.
+    #
+    #   response.message
+    #
+    # 3) Retrieve and store the unique transaction ID returned by Trust Commerece, for use in referencing the transaction in the future.
+    #
+    #   response.params["transid"]
+    #
+    # This should be enough to get you started with Trust Commerce and active_merchant. For further information, review the methods
+    # below and the rest of active_merchant's documentation, as well as Trust Commerce's user and developer documentation.
+    
+    class TrustCommerceGateway < Gateway
+      SUCCESS_TYPES = ["approved", "accepted"]
+      
+      DECLINE_CODES = {
+        "decline"       => "The credit card was declined",
+        "avs"           => "AVS failed; the address entered does not match the billing address on file at the bank",
+        "cvv"           => "CVV failed; the number provided is not the correct verification number for the card",
+        "call"          => "The card must be authorized manually over the phone",
+        "expiredcard"   => "Issuer was not certified for card verification",
+        "carderror"     => "Card number is invalid",
+        "authexpired"   => "Attempt to postauth an expired (more than 14 days old) preauth",
+        "fraud"         => "CrediGuard fraud score was below requested threshold",
+        "blacklist"     => "CrediGuard blacklist value was triggered", 
+        "velocity"      => "CrediGuard velocity control value was triggered",
+        "dailylimit"    => "Daily limit in transaction count or amount as been reached",
+        "weeklylimit"   => "Weekly limit in transaction count or amount as been reached",
+        "monthlylimit"  => "Monthly limit in transaction count or amount as been reached"
+      }
+      
+      BADDATA_CODES = {
+        "missingfields"       => "One or more parameters required for this transaction type were not sent",
+        "extrafields"         => "Parameters not allowed for this transaction type were sent",
+        "badformat"           => "A field was improperly formatted, such as non-digit characters in a number field",
+        "badlength"           => "A field was longer or shorter than the server allows",
+        "merchantcantaccept"  => "The merchant can't accept data passed in this field",
+        "mismatch"            => "Data in one of the offending fields did not cross-check with the other offending field"
+      }
+      
+      ERROR_CODES = {
+        "cantconnect"   => "Couldn't connect to the TrustCommerce gateway",
+        "dnsfailure"    => "The TCLink software was unable to resolve DNS hostnames",
+        "linkfailure"   => "The connection was established, but was severed before the transaction could complete",
+        "failtoprocess" => "The bank servers are offline and unable to authorize transactions"
+      }
+      
+      # URL
+      attr_reader :url 
+      attr_reader :response
+      attr_reader :options
+
+      self.money_format = :cents
+      
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        # these are the defaults for trustcommerce
+        @options = {
+          :login      => "TestMerchant",
+          :password   => "password"
+        }.update(options)
+
+        super
+      end
+      
+      # authorize() is the first half of the preauth(authorize)/postauth(capture) model. The TC API docs call this
+      # preauth, we preserve active_merchant's nomenclature of authorize() for consistency with the rest of the library. This
+      # method simply checks to make sure funds are available for a transaction, and returns a transid that can be used later to
+      # postauthorize (capture) the funds.
+      
+      def authorize(money, creditcard, options = {})
+        parameters = {
+          :amount => amount(money),
+        }                                                             
+        
+        add_creditcard(parameters, creditcard)
+        add_address(parameters, options)
+        commit('preauth', parameters)
+      end
+      
+      # purchase() is a simple sale. This is one of the most common types of transactions, and is extremely simple. All that you need
+      # to process a purchase are an amount in cents or a money object and a creditcard object.
+      
+      def purchase(money, creditcard, options = {})        
+        parameters = {
+          :amount => amount(money),
+        }                                                             
+        
+        add_creditcard(parameters, creditcard)
+        add_address(parameters, options)
+        commit('sale', parameters)
+      end
+
+      # capture() is the second half of the preauth(authorize)/postauth(capture) model. The TC API docs call this
+      # postauth, we preserve active_merchant's nomenclature of capture() for consistency with the rest of the library. To process
+      # a postauthorization with TC, you need an amount in cents or a money object, and a TC transid.
+      
+      def capture(money, authorization, options = {})
+        parameters = {
+          :amount => amount(money),
+          :transid => authorization,
+        }
+                                                  
+        commit('postauth', parameters)
+      end
+      
+      # credit() allows you to return money to a card that was previously billed. You need to supply the amount, in cents or a money object,
+      # that you want to refund, and a TC transid for the transaction that you are refunding.
+      
+      def credit(money, identification, options = {})  
+        parameters = {
+          :amount => amount(money),
+          :transid => identification,
+        }
+                                                  
+        commit('credit', parameters)
+      end
+      
+      # recurring() a TrustCommerce account that is activated for Citatdel, TrustCommerce's
+      # hosted customer billing info database.
+      #
+      # Recurring billing uses the same TC action as a plain-vanilla 'store', but we have a separate method for clarity. It can be called
+      # like store, with the addition of a required 'periodicity' parameter:
+      # 
+      # The parameter :periodicity should be specified as either :bimonthly, :monthly, :biweekly, :weekly, :yearly or :daily
+      #
+      #   gateway.recurring(tendollar, creditcard, :periodicity => :weekly)
+      #
+      # You can optionally specify how long you want payments to continue using 'payments'
+            
+      def recurring(money, creditcard, options = {})        
+        requires!(options, [:periodicity, :bimonthly, :monthly, :biweekly, :weekly, :yearly, :daily] )
+      
+        cycle = case options[:periodicity]
+        when :monthly
+          '1m'
+        when :bimonthly
+          '2m'
+        when :weekly
+          '1w'
+        when :biweekly
+          '2w'
+        when :yearly
+          '1y'
+        when :daily
+          '1d'
+        end
+        
+        parameters = {
+          :amount => amount(money),
+          :cycle => cycle,
+          :verify => options[:verify] || 'y',
+          :billingid => options[:billingid] || nil,
+          :payments => options[:payments] || nil,
+        }
+        
+        add_creditcard(parameters, creditcard)
+                                                  
+        commit('store', parameters)
+      end      
+      
+      # store() requires a TrustCommerce account that is activated for Citatdel. You can call it with a credit card and a billing ID
+      # you would like to use to reference the stored credit card info for future captures. Use 'verify' to specify whether you want
+      # to simply store the card in the DB, or you want TC to verify the data first.
+      
+      def store(creditcard, options = {})   
+        parameters = {
+          :verify => options[:verify] || 'y',
+          :billingid => options[:billingid] || nil,
+        }
+        
+        add_creditcard(parameters, creditcard)
+        add_address(parameters, options)                              
+        commit('store', parameters)
+      end
+      
+      # To unstore a creditcard stored in Citadel using store() or recurring(), all that is required is the billing id. When you run
+      # unstore() the information will be removed and a Response object will be returned indicating the success of the action.
+      def unstore(identification, options = {})
+        parameters = {
+          :billingid => identification,
+        }
+                                                  
+        commit('unstore', parameters)
+      end      
+            
+      def self.supported_cardtypes
+        [:visa, :master, :discover, :american_express, :diners_club, :jcb]
+      end
+      
+      private
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+
+        "#{month}#{year[-2..-1]}"
+      end
+      
+      def add_creditcard(params, creditcard)
+        params[:media]     = "cc"
+        params[:name]      = creditcard.name
+        params[:cc]        = creditcard.number      
+        params[:exp]       = expdate(creditcard)
+        params[:cvv]       = creditcard.verification_value if creditcard.verification_value?
+      end
+      
+      def add_address(params, options)
+        address = options[:billing_address] || options[:address]
+        
+        if address          
+          params[:address1]  = address[:address1] unless address[:address1].blank?
+          params[:address2]  = address[:address2] unless address[:address2].blank?
+          params[:city]      = address[:city]     unless address[:city].blank?
+          params[:state]     = address[:state]    unless address[:state].blank?
+          params[:zip]       = address[:zip]      unless address[:zip].blank?
+          params[:country]   = address[:country]  unless address[:country].blank?
+          params[:avs]       = 'n'
+        end        
+      end
+      
+      def clean_and_stringify_params(parameters)
+        # TCLink wants us to send a hash with string keys, and activemerchant pushes everything around with
+        # symbol keys. Before sending our input to TCLink, we convert all our keys to strings and dump the symbol keys.
+        # We also remove any pairs with nil values, as these confuse TCLink.
+        parameters.keys.reverse.each do |key|
+          if parameters[key]
+            parameters[key.to_s] = parameters[key]
+          end
+          parameters.delete(key)
+        end
+      end
+  
+      def commit(action, parameters)
+        test = test? || parameters[:test_request]
+        parameters[:custid]      = @options[:login]
+        parameters[:password]    = @options[:password]
+        parameters[:demo]        = test ? 'y' : 'n'
+        parameters[:action]      = action
+                
+        if result = test_result_from_cc_number(parameters[:cc])
+          return result
+        end
+        
+        begin        
+          clean_and_stringify_params(parameters)
+        
+          data = TCLink.send(parameters)
+          # to be considered successful, transaction status must be either "approved" or "accepted"
+          success = SUCCESS_TYPES.include?(data["status"])
+          message = message_from(data)
+       
+          Response.new(success, message, data, :test => test, :authorization => data["transid"] )
+        rescue NameError => e 
+          if e.message =~ /constant TCLink/
+            raise 'Trust Commerce requires "tclink" library from http://www.trustcommerce.com/tclink.html'        
+          else
+            raise
+          end
+        end
+        
+      end
+      
+      def message_from(data)        
+        status = case data["status"]
+        when "decline" 
+          return DECLINE_CODES[data["declinetype"]]
+        when "baddata"
+          return BADDATA_CODES[data["error"]]
+        when "error"
+          return ERROR_CODES[data["errortype"]]
+        else
+          return "The transaction was successful"
+        end
+      end
+      
+    end
+  end
+end