tanga_activemerchant 1.37.0

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

@@ -0,0 +1,173 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FatZebraGateway < Gateway
+      self.live_url    = "https://gateway.fatzebra.com.au/v1.0"
+      self.test_url = "https://gateway.sandbox.fatzebra.com.au/v1.0"
+
+      self.supported_countries = ['AU']
+      self.default_currency = 'AUD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :jcb]
+
+      self.homepage_url = 'https://www.fatzebra.com.au/'
+      self.display_name = 'Fat Zebra'
+
+      # Setup a new instance of the gateway.
+      #
+      # The options hash should include :username and :token
+      # You can find your username and token at https://dashboard.fatzebra.com.au
+      # Under the Your Account section
+      def initialize(options = {})
+        requires!(options, :username, :token)
+        @username = options[:username]
+        @token    = options[:token]
+        super
+      end
+
+      # To create a purchase on a credit card use:
+      #
+      #   purchase(money, creditcard)
+      #
+      # To charge a tokenized card
+      #
+      #   purchase(money, "abzy87u", :cvv => "123")
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        post[:reference] = options[:order_id]
+        post[:customer_ip] = options[:ip]
+
+        commit(:post, 'purchases', post)
+      end
+
+      # Refund a transaction
+      #
+      # amount - Integer - the amount to refund
+      # txn_id - String - the original transaction to be refunded
+      # reference - String - your transaction reference
+      def refund(money, txn_id, reference)
+        post = {}
+
+        post[:amount] = money
+        post[:transaction_id] = txn_id
+        post[:reference] = reference
+
+        commit(:post, "refunds", post)
+      end
+
+      # Tokenize a credit card
+      #
+      # The token is returned in the Response#authorization
+      def store(creditcard)
+        post = {}
+        add_creditcard(post, creditcard)
+
+        commit(:post, "credit_cards", post)
+      end
+
+      private
+
+      # Add the money details to the request
+      def add_amount(post, money, options)
+        post[:amount] = money
+      end
+
+      # Add the credit card details to the request
+      def add_creditcard(post, creditcard, options = {})
+        if creditcard.respond_to?(:number)
+          post[:card_number] = creditcard.number
+          post[:card_expiry] = "#{creditcard.month}/#{creditcard.year}"
+          post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+          post[:card_holder] = creditcard.name if creditcard.name
+        elsif creditcard.is_a?(String)
+          post[:card_token] = creditcard
+          post[:cvv] = options[:cvv]
+        elsif creditcard.is_a?(Hash)
+          deprecated "Passing the credit card as a Hash is deprecated. Use a String and put the (optional) CVV in the options hash instead."
+          post[:card_token] = creditcard[:token]
+          post[:cvv] = creditcard[:cvv]
+        else
+          raise ArgumentError.new("Unknown credit card format #{creditcard.inspect}")
+        end
+      end
+
+      # Post the data to the gateway
+      def commit(method, uri, parameters=nil)
+        response = begin
+          parse(ssl_request(method, get_url(uri), parameters.to_json, headers))
+        rescue ResponseError => e
+          return Response.new(false, "Invalid Login") if(e.response.code == "401")
+          parse(e.response.body)
+        end
+
+        success = success_from(response)
+        Response.new(
+          success,
+          message_from(response),
+          response,
+          :test => response["test"],
+          :authorization => authorization_from(response, success)
+        )
+      end
+
+      def success_from(response)
+        (
+          response["successful"] &&
+          response["response"] &&
+          (response["response"]["successful"] || response["response"]["token"])
+        )
+      end
+
+      def authorization_from(response, success)
+        if success
+          (response["response"]["id"] || response["response"]["token"])
+        else
+          nil
+        end
+      end
+
+      def message_from(response)
+        if !response["errors"].empty?
+          response["errors"].join(", ")
+        elsif response["response"]["message"]
+          response["response"]["message"]
+        else
+          "Unknown Error"
+        end
+      end
+
+      # Parse the returned JSON, if parse errors are raised then return a detailed error.
+      def parse(response)
+        begin
+          JSON.parse(response)
+        rescue JSON::ParserError
+          msg = 'Invalid JSON response received from Fat Zebra. Please contact support@fatzebra.com.au if you continue to receive this message.'
+          msg += "  (The raw response returned by the API was #{response.inspect})"
+          {
+            "successful" => false,
+            "response" => {},
+            "errors" => [msg]
+          }
+        end
+      end
+
+      # Build the URL based on the AM mode and the URI
+      def get_url(uri)
+        base = test? ? self.test_url : self.live_url
+        base + "/" + uri
+      end
+
+      # Builds the auth and U-A headers for the request
+      def headers
+        {
+          "Authorization" => "Basic " + Base64.strict_encode64(@username.to_s + ":" + @token.to_s).strip,
+          "User-Agent" => "Fat Zebra v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FederatedCanadaGateway < Gateway
+      # Same URL for both test and live, testing is done by using the test username (demo) and password (password).
+      self.live_url = self.test_url = 'https://secure.federatedgateway.com/api/transact.php'
+
+      APPROVED, DECLINED, ERROR = 1, 2, 3
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['CA']
+
+      self.default_currency = 'CAD'
+
+      # 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.federatedcanada.com/'
+
+      # The name of the gateway
+      self.display_name = 'Federated Canada'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        commit('sale', money, post)
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        add_customer_data(post, options)
+        commit('auth', money, post)
+      end
+
+      def capture(money, authorization, options = {})
+        options[:transactionid] = authorization
+        commit('capture', money, options)
+      end
+
+      def void(authorization, options = {})
+        options[:transactionid] = authorization
+        commit('void', nil, options)
+      end
+
+      def refund(money, authorization, options = {})
+        commit('refund', money, options.merge(:transactionid => authorization))
+      end
+
+      def credit(money, authorization, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, authorization, options)
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post[:firstname] = options[:first_name]
+        post[:lastname] = options[:last_name]
+
+        post[:email] = options[:email]
+      end
+
+      def add_address(post, options)
+        if address = (options[:billing_address] || options[:address])
+          post[:company] = address[:company]
+          post[:address1] = address[:address1]
+          post[:address2] = address[:address2]
+          post[:city]    = address[:city]
+          post[:state]   = address[:state]
+          post[:zip]     = address[:zip]
+          post[:country] = address[:country]
+          post[:phone] = address[:phone]
+        end
+        if address = options[:shipping_address]
+          post[:shipping_firstname] = address[:first_name]
+          post[:shipping_lastname] = address[:last_name]
+          post[:shipping_company] = address[:company]
+          post[:shipping_address1] = address[:address1]
+          post[:shipping_address2] = address[:address2]
+          post[:shipping_city]    = address[:city]
+          post[:shipping_state]   = address[:state]
+          post[:shipping_zip]     = address[:zip]
+          post[:shipping_country] = address[:country]
+          post[:shipping_email]   = address[:email]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:ccnumber] = creditcard.number
+        post[:ccexp] = expdate(creditcard)
+        post[:cvv] = creditcard.verification_value
+      end
+
+      def expdate(creditcard)
+        year  = sprintf("%.4i", creditcard.year)
+        month = sprintf("%.2i", creditcard.month)
+        "#{month}#{year[-2..-1]}"
+      end
+
+      def parse(body)
+        body.split('&').inject({}) do |memo, x|
+          k, v = x.split('=')
+          memo[k] = v
+          memo
+        end
+      end
+
+      def commit(action, money, parameters)
+        parameters[:amount] = amount(money)
+        data = ssl_post(self.live_url, post_data(action, parameters))
+        response = parse(data)
+        message = message_from(response)
+        test_mode = test?
+
+        Response.new(success?(response), message, response,
+          :test => test?,
+          :authorization => response['transactionid'],
+          :avs_result => {:code =>  response['avsresponse']},
+          :cvv_result => response['cvvresponse']
+        )
+      end
+
+      def success?(response)
+        response['response'] == '1'
+      end
+
+      def test?
+        (@options[:login].eql?('demo')) && (@options[:password].eql?('password'))
+      end
+
+      def message_from(response)
+        case response['response'].to_i
+        when APPROVED
+          "Transaction Approved"
+        when DECLINED
+          "Transaction Declined"
+        else
+          "Error in transaction data or system error"
+        end
+      end
+
+      def post_data(action, parameters = {})
+        parameters[:type] = action
+        parameters[:username] = @options[:login]
+        parameters[:password] = @options[:password]
+        parameters.map{|k, v| "#{k}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/cc5'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FinansbankGateway < CC5Gateway
+      self.live_url = self.test_url = 'https://www.fbwebpos.com/servlet/cc5ApiServer'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['US', 'TR']
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = [:visa, :master]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'https://www.fbwebpos.com/'
+
+      # The name of the gateway
+      self.display_name = 'Finansbank WebPOS'
+    end
+  end
+end
+

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

@@ -0,0 +1,176 @@
+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
+      self.test_url = 'https://apgcert.first-pay.com/AcqENGIN/SecureCapture'
+      self.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)
+        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 refund(money, reference, options = {})
+        requires!(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 credit(money, reference, options = {})
+        deprecated CREDIT_DEPRECATION_MESSAGE
+        refund(money, reference, options)
+      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.to_i)
+      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? ? self.test_url : self.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
+