RubyGems - abtain_billing - Versions diffs - 1.0 → 1.02 - Mend

abtain_billing 1.0 → 1.02

Files changed (237) hide show

data/lib/active_merchant/billing/gateways/sallie_mae.rb DELETED Viewed

@@ -1,144 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class SallieMaeGateway < Gateway
-      URL = 'https://trans.salliemae.com/cgi-bin/process.cgi'
-      # 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, :american_express, :discover]
-      # The homepage URL of the gateway
-      self.homepage_url = 'http://www.salliemae.com/'
-      # The name of the gateway
-      self.display_name = 'Sallie Mae'
-      def initialize(options = {})
-        requires!(options, :login)
-        @options = options
-        super
-      end
-      def test?
-        @options[:login] == "TEST0"
-      end
-      def authorize(money, creditcard, options = {})
-        post = PostData.new
-        add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, creditcard, options)
-        add_customer_data(post, options)
-        commit(:authonly, money, post)
-      end
-      def purchase(money, creditcard, options = {})
-        post = PostData.new
-        add_invoice(post, options)
-        add_creditcard(post, creditcard)
-        add_address(post, creditcard, options)
-        add_customer_data(post, options)
-        commit(:sale, money, post)
-      end
-      def capture(money, authorization, options = {})
-        post = PostData.new
-        post[:postonly] = authorization
-        commit(:capture, money, post)
-      end
-      private
-      def add_customer_data(post, options)
-        if address = options[:billing_address] || options[:shipping_address] || options[:address]
-          post[:ci_phone] = address[:phone].to_s
-        end
-        post[:ci_email] = options[:email].to_s unless options[:email].blank?
-        post[:ci_IP]    = options[:ip].to_s unless options[:ip].blank?
-      end
-      def add_address(post, creditcard, options)
-        if address = options[:billing_address] || options[:address]
-          post[:ci_billaddr1] = address[:address1].to_s
-          post[:ci_billaddr2] = address[:address2].to_s unless address[:address2].blank?
-          post[:ci_billcity]  = address[:city].to_s
-          post[:ci_billstate] = address[:state].to_s
-          post[:ci_billzip]   = address[:zip].to_s
-        end
-        if shipping_address = options[:shipping_address] || options[:address]
-          post[:ci_shipaddr1] = shipping_address[:address1].to_s
-          post[:ci_shipaddr2] = shipping_address[:address2].to_s unless shipping_address[:address2].blank?
-          post[:ci_shipcity]  = shipping_address[:city].to_s
-          post[:ci_shipstate] = shipping_address[:state].to_s
-          post[:ci_shipzip]   = shipping_address[:zip].to_s
-        end
-      end
-      def add_invoice(post, options)
-        memo = "OrderID: #{options[:order_id]}\nDescription: #{options[:description]}"
-        post[:ci_memo] = memo
-      end
-      def add_creditcard(post, creditcard)
-        post[:ccnum]   = creditcard.number.to_s
-        post[:ccname]  = creditcard.name.to_s
-        post[:cvv2]    = creditcard.verification_value.to_s if creditcard.verification_value?
-        post[:expmon]  = creditcard.month.to_s
-        post[:expyear] = creditcard.year.to_s
-      end
-      def parse(body)
-        h = {}
-        body.gsub!("<html><body><plaintext>", "")
-        body.
-          split("\r\n").
-          map do |i|
-            a = i.split("=")
-            h[a.first] = a.last unless a.first.nil?
-          end
-        h
-      end
-      def commit(action, money, parameters)
-        parameters[:acctid] = @options[:login].to_s
-        parameters[:subid]  = @options[:sub_id].to_s unless @options[:sub_id].blank?
-        parameters[:amount] = amount(money)
-        case action
-        when :sale
-          parameters[:action] = "ns_quicksale_cc"
-        when :authonly
-          parameters[:action] = "ns_quicksale_cc"
-          parameters[:authonly] = 1
-        when :capture
-          parameters[:action] = "ns_quicksale_cc"
-        end
-        response = parse(ssl_post(URL, parameters.to_post_data) || "")
-        Response.new(successful?(response), message_from(response), response,
-          :test => test?,
-          :authorization => response["refcode"]
-        )
-      end
-      def successful?(response)
-        response["Status"] == "Accepted"
-      end
-      def message_from(response)
-        if successful?(response)
-          "Accepted"
-        else
-          response["Reason"].split(":")[2].capitalize unless response["Reason"].nil?
-        end
-      end
-    end
-  end
-end

data/lib/active_merchant/billing/gateways/secure_pay.rb DELETED Viewed

@@ -1,31 +0,0 @@
-require File.dirname(__FILE__) + '/authorize_net'
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class SecurePayGateway < AuthorizeNetGateway
-      self.live_url = self.test_url = 'https://www.securepay.com/AuthSpayAdapter/process.aspx'
-      self.homepage_url = 'http://www.securepay.com/'
-      self.display_name = 'SecurePay'
-      # Limit support to purchase() for the time being
-      # JRuby chokes here
-      # undef_method :authorize, :capture, :void, :credit
-      undef_method :authorize
-      undef_method :capture
-      undef_method :void
-      undef_method :credit
-      def test?
-        Base.gateway_mode == :test
-      end
-      private
-      def split(response)
-        response.split('%')
-      end
-    end
-  end
-end

data/lib/active_merchant/billing/gateways/secure_pay_au.rb DELETED Viewed

@@ -1,157 +0,0 @@
-require 'rexml/document'
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class SecurePayAuGateway < Gateway
-      API_VERSION = 'xml-4.2'
-      TEST_URL = 'https://www.securepay.com.au/test/payment'
-      LIVE_URL = 'https://www.securepay.com.au/xmlapi/payment'
-      self.supported_countries = ['AU']
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :jcb]
-      # The homepage URL of the gateway
-      self.homepage_url = 'http://securepay.com.au'
-      # The name of the gateway
-      self.display_name = 'SecurePay'
-      class_inheritable_accessor :request_timeout
-      self.request_timeout = 60
-      self.money_format = :cents
-      self.default_currency = 'AUD'
-      # 0 Standard Payment
-      # 4 Refund
-      # 6 Client Reversal (Void)
-      # 10 Preauthorise
-      # 11 Preauth Complete (Advice)
-      TRANSACTIONS = {
-        :purchase => 0,
-        :authorization => 10,
-        :capture => 11,
-        :void => 6,
-        :credit => 4
-      }
-      SUCCESS_CODES = [ '00', '08', '11', '16', '77' ]
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        @options = options
-        super
-      end
-      def test?
-        @options[:test] || super
-      end
-      def purchase(money, credit_card, options = {})
-        commit :purchase, build_purchase_request(money, credit_card, options)
-      end
-      private
-      def build_purchase_request(money, credit_card, options)
-        xml = Builder::XmlMarkup.new
-        xml.tag! 'amount', amount(money)
-        xml.tag! 'currency', options[:currency] || currency(money)
-        xml.tag! 'purchaseOrderNo', options[:order_id].to_s.gsub(/[ ']/, '')
-        xml.tag! 'CreditCardInfo' do
-          xml.tag! 'cardNumber', credit_card.number
-          xml.tag! 'expiryDate', expdate(credit_card)
-          xml.tag! 'cvv', credit_card.verification_value if credit_card.verification_value?
-        end
-        xml.target!
-      end
-      def build_request(action, body)
-        xml = Builder::XmlMarkup.new
-        xml.instruct!
-        xml.tag! 'SecurePayMessage' do
-          xml.tag! 'MessageInfo' do
-            xml.tag! 'messageID', Utils.generate_unique_id.slice(0, 30)
-            xml.tag! 'messageTimestamp', generate_timestamp
-            xml.tag! 'timeoutValue', request_timeout
-            xml.tag! 'apiVersion', API_VERSION
-          end
-          xml.tag! 'MerchantInfo' do
-            xml.tag! 'merchantID', @options[:login]
-            xml.tag! 'password', @options[:password]
-          end
-          xml.tag! 'RequestType', 'Payment'
-          xml.tag! 'Payment' do
-            xml.tag! 'TxnList', "count" => 1 do
-              xml.tag! 'Txn', "ID" => 1 do
-                xml.tag! 'txnType', TRANSACTIONS[action]
-                xml.tag! 'txnSource', 23
-                xml << body
-              end
-            end
-          end
-        end
-        xml.target!
-      end
-      def commit(action, request)
-        response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, build_request(action, request)))
-        Response.new(success?(response), message_from(response), response,
-          :test => test?,
-          :authorization => authorization_from(response)
-        )
-      end
-      def success?(response)
-        SUCCESS_CODES.include?(response[:response_code])
-      end
-      def authorization_from(response)
-        response[:txn_id]
-      end
-      def message_from(response)
-        response[:response_text] || response[:status_description]
-      end
-      def expdate(credit_card)
-        "#{format(credit_card.month, :two_digits)}/#{format(credit_card.year, :two_digits)}"
-      end
-      def parse(body)
-        xml = REXML::Document.new(body)
-        response = {}
-        xml.root.elements.to_a.each do |node|
-          parse_element(response, node)
-        end
-        response
-      end
-      def parse_element(response, node)
-        if node.has_elements?
-          node.elements.each{|element| parse_element(response, element) }
-        else
-          response[node.name.underscore.to_sym] = node.text
-        end
-      end
-      # YYYYDDMMHHNNSSKKK000sOOO
-      def generate_timestamp
-        time = Time.now.utc
-        time.strftime("%Y%d%m%H%M%S#{time.usec}+000")
-      end
-    end
-  end
-end

data/lib/active_merchant/billing/gateways/secure_pay_tech.rb DELETED Viewed

@@ -1,113 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class SecurePayTechGateway < Gateway
-      class SecurePayTechPostData < PostData
-        self.required_fields = [ :OrderReference, :CardNumber, :CardExpiry, :CardHolderName, :CardType, :MerchantID, :MerchantKey, :Amount, :Currency ]
-      end
-      URL = 'https://tx.securepaytech.com/web/HttpPostPurchase'
-      PAYMENT_GATEWAY_RESPONSES = {
-        1 => "Transaction OK",
-        2 => "Insufficient funds",
-        3 => "Card expired",
-        4 => "Card declined",
-        5 => "Server error",
-        6 => "Communications error",
-        7 => "Unsupported transaction type",
-        8 => "Bad or malformed request",
-        9 => "Invalid card number"
-      }
-      self.default_currency = 'NZD'
-      self.supported_countries = ['NZ']
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
-      self.homepage_url = 'http://www.securepaytech.com/'
-      self.display_name = 'SecurePayTech'
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        @options = options
-        super
-      end
-      def purchase(money, creditcard, options = {})
-        post = SecurePayTechPostData.new
-        add_invoice(post, money, options)
-        add_creditcard(post, creditcard)
-        commit(:purchase, post)
-      end
-      private
-      def add_invoice(post, money, options)
-        post[:Amount] = amount(money)
-        post[:Currency] = options[:currency] || currency(money)
-        post[:OrderReference] = options[:order_id]
-      end
-      def add_creditcard(post, creditcard)
-        post[:CardNumber] = creditcard.number
-        post[:CardExpiry] = expdate(creditcard)
-        post[:CardHolderName] = creditcard.name
-        if creditcard.verification_value?
-          post[:EnableCSC] = 1
-          post[:CSC] = creditcard.verification_value
-        end
-        # SPT will autodetect this
-        post[:CardType] = 0
-      end
-      def parse(body)
-        response = CGI.unescape(body).split(',')
-        result = {}
-        result[:result_code] = response[0].to_i
-        if response.length == 2
-          result[:fail_reason] = response[1]
-        else
-          result[:merchant_transaction_reference] = response[1]
-          result[:receipt_number] = response[2]
-          result[:transaction_number] = response[3]
-          result[:authorisation_id] = response[4]
-          result[:batch_number] = response[5]
-        end
-        result
-      end
-      def commit(action, post)
-        response = parse( ssl_post(URL, post_data(action, post) ) )
-        Response.new(response[:result_code] == 1, message_from(response), response,
-          :test => test?,
-          :authorization => response[:merchant_transaction_reference]
-        )
-      end
-      def message_from(result)
-        PAYMENT_GATEWAY_RESPONSES[result[:result_code]]
-      end
-      def post_data(action, post)
-        post[:MerchantID] = @options[:login]
-        post[:MerchantKey] = @options[:password]
-        post.to_s
-      end
-      def expdate(creditcard)
-        year = sprintf("%.4i", creditcard.year)
-        month = sprintf("%.2i", creditcard.month)
-        "#{month}#{year[-2..-1]}"
-      end
-    end
-  end
-end