payment_gateway_solutions 0.0.1

data/lib/gateway_card.rb

@@ -0,0 +1,50 @@
+class GatewayCard
+  include GatewayErrors
+  
+  attr_accessor :card_number, :cvv, :expiration_month, :expiration_year
+
+  def initialize(card_number, cvv, expiration_month, expiration_year)
+    self.card_number      = card_number.to_s.gsub(/\s/, "")
+    self.cvv              = cvv.to_s
+    self.expiration_month = expiration_month.to_s
+    self.expiration_year  = format('%04d', expiration_year)
+    
+    self.validate
+  end
+
+  def validate
+    ######## Card Number Validation ##########
+    ######## start ##########
+    raise CardNumberInvalid unless self.card_number  =~ /^\d+$/ # Ensure card contains only digits
+    
+    ######## LUHN ALGORITHM TO CHECK CARD NUMBER #######
+    ######## start ########
+    arr = card.split('').reverse.each_with_index.map {|d, index| (index.odd? ? 2*(d.to_i) : d.to_i)}
+    raise CardNumberInvalid unless (arr.join.split('').inject(0) {|tot, d| tot + d.to_i}) % 10 == 0
+    ######## end ##########
+    ######## end ##########
+
+    ######## CVV Validation #########
+    raise  CardCVVInvalid if (self.cvv != "") and (!(self.cvv  =~ /^\d+$/ ) or self.cvv.length > 4 or self.cvv.to_i == 0)
+  
+    ######## Expiration Month Validation #########
+    raise CardExpirationMonthInvalid unless [1..12].index(self.expiration_month.to_i)
+
+    ######## Expiration Year Validation #########
+    ######## start #########
+    raise CardExpirationYearInvalid if (!(self.expiration_year  =~ /^\d+$/ ) or self.expiration_year.length > 4 or self.expiration_year.to_i == 0)
+    
+    begin
+      self.expiration_year = Date.parse(self.expiration_year.to_s + "0101").strftime("%y")
+    rescue
+      raise CardExpirationYearInvalid
+    end
+    ######## end ##########
+    
+    raise CardExpireError if (self.expiration_month + self.expiration_year).to_i < Time.now.strftime("%m%y")
+  end
+
+  def authorize_net_credit_card
+    return AuthorizeNet::CreditCard.new(self.card_number, self.expiration_month.to_s + self.expiration_year.to_s, {:card_code => self.cvv})
+  end
+end

data/lib/gateway_customer.rb

@@ -0,0 +1,86 @@
+class GatewayCustomer
+  include GatewayErrors
+
+  attr_accessor :first_name, :last_name, :email_id, :address, :city, :state, :zip, :cell_phone, :home_phone, :office_phone, :office_ext, :fax, :country
+
+  def initialize(first_name, last_name, email_id)
+    self.first_name = first_name.to_s.gsub(/\s/, "")
+    self.last_name  = last_name.to_s.gsub(/\s/, "")
+    self.email_id   = email_id.to_s.gsub(/\s/, "")
+  end
+
+  def convert_to_fortis_input
+    return {
+      :first_name       => self.first_name,
+      :last_name        => self.last_name,
+      :email            => self.email_id,
+      :address          => self.address,
+      :city             => self.city,
+      :state            => self.state,
+      :zip              => self.zip,
+      :cell_phone       => self.cell_phone,
+      :office_phone     => self.office_phone,
+      :office_ext_phone => self.office_ext,
+      :home_phone       => self.home_phone
+    }
+  end
+
+  def convert_to_authorize_net_input(card = nil)
+    customer = {
+      :description      =>  "Diaspark Payment Gateway",
+      :email            =>  self.email_id,
+
+      :payment_profiles  =>
+        [{
+          :cust_type     =>  AuthorizeNet::CIM::PaymentProfile::CustomerType::INDIVIDUAL,
+
+          :first_name       => self.first_name,
+          :last_name        => self.last_name,
+
+          :address          => self.address,
+          :city             => self.city,
+          :state            => self.state,
+          :zip              => self.zip,
+          :phone            => self.cell_phone,
+          :fax              => self.fax,
+          :country          => self.country
+        }]
+    }
+
+    if card
+      raise TransactionGatewayInvalidCardType unless card.class == GatewayCard
+
+      customer[:payment_profiles][0].merge!({
+          :card_num   =>  card.card_number,
+          :exp_date   =>  "#{card.expiration_month}#{card.expiration_year}"
+        })
+    end
+
+    return customer
+  end
+
+  def convert_to_braintree_input(card = nil)
+    customer = {
+      :first_name       => self.first_name,
+      :last_name        => self.last_name,
+      :email            => self.email_id
+    }
+
+    if card
+      raise TransactionGatewayInvalidCardType unless card.class == GatewayCard
+
+      customer.merge!(
+        {:credit_card =>
+            {
+            :number           => card.card_number,
+            :cvv              => card.cvv,
+            :expiration_month => card.expiration_month,
+            :expiration_year  => card.expiration_year,
+            :options          => {:verify_card      =>  "1"}
+          }
+        })
+    end
+
+    return customer
+  end
+end

data/lib/gateway_customer_profile.rb

@@ -0,0 +1,10 @@
+class GatewayCustomerProfile < GatewayCustomer
+  include GatewayErrors
+
+  attr_accessor :profile_id, :payment_profile_id
+
+  def initialize(profile_id, payment_profile_id)
+    self.profile_id = profile_id.to_s
+    self.payment_profile_id  = payment_profile_id.to_s
+  end
+end

data/lib/gateway_errors.rb

@@ -0,0 +1,97 @@
+module GatewayErrors
+  class TransactionGatewayError < StandardError
+    def initialize(msg = "Transaction gateway error.")
+      super(msg)
+    end
+  end
+
+  class TransactionGatewayInvalidCardType < TransactionGatewayError
+    def initialize(msg = "Card type is invalid.")
+      super(msg)
+    end
+  end
+
+  class TransactionGatewayInvalidAmount < TransactionGatewayError
+    def initialize(msg = "Amount should be greater than zero.")
+      super(msg)
+    end
+  end
+
+  class TransactionInvalid < TransactionGatewayError
+    def initialize(msg = "Validations preveneted transaction from being created.")
+      super(msg)
+    end
+  end
+
+  class TransactionDeclined < TransactionGatewayError
+    def initialize(msg = "Transaction is declined.")
+      super(msg)
+    end
+  end
+
+  class TransactionIDInvalid < TransactionGatewayError
+    def initialize(msg = "Transaction id shouldn't be blank.")
+      super(msg)
+    end
+  end
+
+  class TransactionSettlementError < TransactionGatewayError
+    def initialize(msg = "Transaction can't settle.")
+      super(msg)
+    end
+  end
+
+  class TransactionGatewayNotSupported < TransactionGatewayError
+    def initialize(msg = "Transaction gateway not supported.")
+      super(msg)
+    end
+  end
+
+  class ConnectionNotMade < StandardError
+    def initialize(msg = "Connection is not established to perform transaction, check connection.")
+      super(msg)
+    end
+  end
+
+  class CardError < StandardError
+    def initialize(msg = "Card error.")
+      super(msg)
+    end
+  end
+
+  class CardNumberInvalid < CardError
+    def initialize(msg = "Card number is invalid")
+      super(msg)
+    end
+  end
+
+  class CardExpirationYearInvalid < CardError
+    def initialize(msg = "Card expiration year is invalid")
+      super(msg)
+    end
+  end
+
+  class CardExpirationMonthInvalid < CardError
+    def initialize(msg = "Card expiration month is invalid")
+      super(msg)
+    end
+  end
+
+  class CardExpireError < CardError
+    def initialize(msg = "Card is expired.")
+      super(msg)
+    end
+  end
+
+  class InvalidCustomerType < TransactionGatewayError
+    def initialize(msg = "Customer type is invalid.")
+      super(msg)
+    end
+  end
+
+  class InvalidPaymentProfileType < TransactionGatewayError
+    def initialize(msg = "Payment profile type is invalid.")
+      super(msg)
+    end
+  end
+end

data/lib/payment_gateway.rb

@@ -0,0 +1,8 @@
+require 'gateway_errors'
+require 'gateway_card'
+require 'gateway_customer'
+require 'gateway_customer_profile'
+require 'transaction_gateway/result'
+require 'transaction_gateway/braintree_gateway'
+require 'transaction_gateway/authorize_net_gateway'
+require 'transaction_gateway/fortis_gateway'

data/lib/transaction_gateway/authorize_net_gateway.rb

@@ -0,0 +1,125 @@
+require "authorize-net"
+
+#This is patch for constant incorrect name in gem in CIM capture_only.
+module AuthorizeNet
+  module CIM
+    module Fields
+      TRASNACTION_CAPTURE_FIELDS = TRANSACTION_CAPTURE_FIELDS
+    end
+  end
+end
+
+module TransactionGateway
+  class AuthorizeNetGateway < Result
+    include GatewayErrors
+
+    attr_accessor :login_id, :transaction_key, :gateway
+
+    private
+    def get_aim_transaction_object
+      return AuthorizeNet::AIM::Transaction.new(self.login_id, self.transaction_key, :gateway => self.gateway)
+    end
+
+    def get_cim_transaction_object
+      return AuthorizeNet::CIM::Transaction.new(self.login_id, self.transaction_key, :gateway => self.gateway)
+    end
+
+    public
+    def initialize(login_id, transaction_key, environment = :sandbox)
+      self.login_id         = login_id
+      self.transaction_key  = transaction_key
+
+      environment = environment.to_s.gsub(/\s/, '').downcase
+      self.gateway  = (environment == "") ? :sandbox : environment.to_sym
+    end
+
+    def self.gateway_url(environment = :sandbox)
+      environment = environment.to_s.gsub(/\s/, "").downcase
+      environment = "sandbox" if environment == ""
+      return AuthorizeNet::XmlTransaction.new("","", :gateway => environment.to_sym).instance_variable_get(:@gateway)
+    end
+
+    def create_transaction(card_or_profile, amount, settle = false)
+      raise TransactionGatewayInvalidAmount if amount.to_f <= 0
+
+      case card_or_profile
+      when GatewayCard
+        transaction = get_aim_transaction_object
+        if settle == true
+          result = transaction.purchase(amount, card_or_profile.authorize_net_credit_card)
+        else
+          result = transaction.authorize(amount, card_or_profile.authorize_net_credit_card)
+        end
+
+      when GatewayCustomerProfile
+        transaction = get_cim_transaction_object
+        type = :auth_only
+        type = :prior_auth_capture if settle == true
+
+        result = transaction.create_transaction(type, amount, card_or_profile.profile_id.to_s, card_or_profile.payment_profile_id.to_s, nil)
+
+      else
+        raise TransactionGatewayInvalidCardType
+      end
+
+      return handle_result(result, AUTHORIZEDOTNET)
+    end
+
+    def settle_transaction(transaction_id, amount = nil)
+      raise TransactionIDInvalid if transaction_id.to_s.gsub(/\s/, "") == ""
+
+      capture_transaction = get_aim_transaction_object
+
+      result = capture_transaction.prior_auth_capture(transaction_id, amount)
+
+      return handle_result(result, AUTHORIZEDOTNET)
+    end
+
+    def refund(profile, amount)
+      raise InvalidPaymentProfileType unless profile.class == GatewayCustomerProfile
+      raise TransactionGatewayInvalidAmount if amount.to_f == 0
+
+      transaction = get_cim_transaction_object
+      result = transaction.create_transaction(:refund, amount.abs, profile.profile_id.to_s, profile.payment_profile_id.to_s, nil)
+
+      return handle_result(result, AUTHORIZEDOTNET)
+    end
+
+    def void_transaction(transaction_id)
+      transaction = get_aim_transaction_object
+      result = transaction.void(transaction_id)
+      return handle_result(result, AUTHORIZEDOTNET)
+    end
+
+    def create_customer_profile(customer, card = nil)
+      raise InvalidCustomerType unless customer.class == GatewayCustomer
+
+      transaction = get_cim_transaction_object
+      result = transaction.create_profile(customer.convert_to_authorize_net_input(card), {:validation_mode => :liveMode})
+
+      return handle_result(result, AUTHORIZEDOTNET)
+    end
+
+    def create_card_account(card, customer_profile_id)
+      raise TransactionGatewayInvalidCardType unless card.class == GatewayCard
+      
+      transaction = get_cim_transaction_object
+      payment_profile = AuthorizeNet::CIM::PaymentProfile.new(:payment_method => card.authorize_net_credit_card)
+      result = transaction.create_payment_profile(payment_profile, customer_profile_id)
+
+      return handle_result(result, AUTHORIZEDOTNET)
+    end
+
+    def force_settle(profile, authorize_code, amount)
+      raise InvalidPaymentProfileType unless profile.class == GatewayCustomerProfile
+      raise TransactionGatewayInvalidAmount if amount.to_f <= 0
+
+      transaction = get_cim_transaction_object
+      transaction.set_fields( {:auth_code => authorize_code})
+
+      result = transaction.create_transaction(:capture_only, amount, profile.profile_id.to_s, profile.payment_profile_id.to_s, nil)
+      
+      return handle_result(result, AUTHORIZEDOTNET)
+    end
+  end
+end

data/lib/transaction_gateway/braintree_gateway.rb

@@ -0,0 +1,146 @@
+module TransactionGateway
+  class BraintreeGateway < Result
+    require "braintree"
+
+    include GatewayErrors
+
+    attr_accessor :merchant_id, :public_key, :private_key, :environment
+
+    def initialize(merchant_id, public_key, private_key, environment = :sandbox)
+      self.merchant_id  = merchant_id
+      self.public_key   = public_key
+      self.private_key  = private_key
+      
+      self.environment  = environment.to_s.gsub(/\s/, '').downcase
+      self.environment  = (self.environment == "") ? :sandbox : self.environment.to_sym
+    end
+
+    def configure_braintree
+      Braintree::Configuration.environment  = self.environment
+      Braintree::Configuration.merchant_id  = self.merchant_id
+      Braintree::Configuration.public_key   = self.public_key
+      Braintree::Configuration.private_key  = self.private_key
+    end
+
+    def create_transaction(card_or_profile, amount, settle = false, customer = nil)
+      raise TransactionGatewayInvalidAmount if amount.to_f <= 0
+
+      case card_or_profile
+      when GatewayCard
+        credit_card = {
+          :credit_card =>
+            {
+            :number =>  card_or_profile.card_number,
+            :expiration_month => card_or_profile.expiration_month,
+            :expiration_year => card_or_profile.expiration_year,
+            :cvv => card_or_profile.cvv
+          }
+        }
+
+      when GatewayCustomerProfile
+        credit_card ={:payment_method_token   =>  card_or_profile.payment_profile_id}
+
+      else
+        raise TransactionGatewayInvalidCardType unless card_or_profile.class == GatewayCard
+      end
+
+      sale_info = { :amount => amount }
+      
+      sale_info[:options] = {
+        :submit_for_settlement => true
+      } if settle == true
+
+      sale_info[:customer] = {
+        :first_name => customer.first_name,
+        :last_name => customer.last_name,
+        :email => customer.email_id
+      } if customer and customer.class == GatewayCustomer
+
+      sale_info.merge!(credit_card)
+
+      configure_braintree
+
+      result = Braintree::Transaction.sale(sale_info)
+
+      return handle_result(result, BRAINTREE)
+    end
+
+    def settle_transaction(transaction_id, amount = nil)
+      raise TransactionIDInvalid if transaction_id.to_s.gsub(/\s/, "") == ""
+
+      configure_braintree
+
+      result = Braintree::Transaction.submit_for_settlement(transaction_id, amount)
+      
+      return handle_result(result, BRAINTREE)
+    end
+
+    def void_transaction(transaction_id)
+      configure_braintree
+      
+      result = Braintree::Transaction.void(transaction_id)
+      return handle_result(result, BRAINTREE)
+    end
+
+    def refund(profile, amount)
+      raise InvalidPaymentProfileType unless profile.class == GatewayCustomerProfile
+      raise TransactionGatewayInvalidAmount if amount.to_f == 0
+
+      configure_braintree
+
+      result = Braintree::Transaction.credit(
+        :amount                 =>  amount.abs,
+        :payment_method_token   =>  profile.payment_profile_id
+      )
+      return handle_result(result, BRAINTREE)
+    end
+
+    def create_customer_profile(customer, card = nil)
+      raise InvalidCustomerType unless customer.class == GatewayCustomer
+
+      configure_braintree
+
+      result = Braintree::Customer.create(customer.convert_to_braintree_input(card))
+      return handle_result(result, BRAINTREE)
+    end
+
+    def create_card_account(card, customer_profile_id)
+      raise TransactionGatewayInvalidCardType unless card.class == GatewayCard
+
+      configure_braintree
+
+      result = Braintree::Customer.update(customer_profile_id,
+        :credit_card => {
+          :number           => card.card_number,
+          :cvv              => card.cvv,
+          :expiration_month => card.expiration_month,
+          :expiration_year  => card.expiration_year
+        })
+      
+      return handle_result(result, BRAINTREE)
+    end
+
+    #Patched for voice authorization settlement. Not provided any method from Braintree in Ruby but referred from Braintree control panel new transaction HTML page.
+    def force_settle(profile, authorize_code, amount)
+      raise InvalidPaymentProfileType unless profile.class == GatewayCustomerProfile
+      raise TransactionGatewayInvalidAmount if amount.to_f <= 0
+      
+      configure_braintree
+
+      sale_info = {
+        :type                         => :sale,
+        :amount                       => amount,
+        :voice_authorization          => "1",
+        :processor_authorization_code => authorize_code,
+        :payment_method_token         => profile.payment_profile_id,
+      }
+      
+      gateway = Braintree::Gateway.new(Braintree::Configuration.instantiate)
+      transaction = Braintree::TransactionGateway.new(gateway)
+      Braintree::Util.verify_keys(Braintree::TransactionGateway._create_signature.concat([:voice_authorization, :processor_authorization_code]) , sale_info)
+      result = transaction._do_create("/transactions", :transaction => sale_info)
+
+      return handle_result(result, BRAINTREE)
+    end
+  end
+end

data/lib/transaction_gateway/fortis_gateway.rb

@@ -0,0 +1,141 @@
+module TransactionGateway
+  class FortisGateway < Result
+    require 'cgi'
+    
+    include GatewayErrors
+
+    attr_accessor :user_id, :user_api_key, :location_api_key, :api
+
+    module API
+      VERSION       = "v1"
+      AUTHONLYPATH  = "/cardTransactions/authOnly"
+      SETTLEPATH    = "/cardTransactions/?/authComplete" #replace ? with card_transaction_id
+      REFUND        = "/cardTransactions/refund"
+      VOID          = "/cardTransactions/?/void" #replace ? with card_transaction_id
+      CAPTURE_FORCE = "/cardTransactions/force"
+      CONTACT       = "/contacts"
+      CARD_ACCOUNT  = "/cardAccounts"
+    end
+
+    private
+    def convert_hash_to_query(params)
+      URI.encode(params.map{|key, value| "#{CGI::escape(key)}=#{CGI::escape(value)}" if value}.select{|value| value if value}.join("&"))
+    end
+
+    def call_request(path, body = {}, request_type = "PUT")
+      credentials = Hash.new
+      credentials[:user_id]            =  self.user_id
+      credentials[:user_api_key]       =  self.user_api_key
+      credentials[:location_api_key]   =  self.location_api_key
+
+      uri = URI.parse(File.join(self.api, API::VERSION, path))
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http.use_ssl = true
+
+      response = http.start do |http1|
+        if request_type.to_s.upcase == "POST"
+          request = Net::HTTP::Post.new("#{uri.path}?#{convert_hash_to_query(credentials)}", {'Content-Type' => 'application/x-www-form-urlencoded'})
+        else
+          request = Net::HTTP::Put.new("#{uri.path}?#{convert_hash_to_query(credentials)}", {'Content-Type' => 'application/x-www-form-urlencoded'})
+        end
+        request.body = convert_hash_to_query(body)
+        http1.request(request)
+      end
+
+      return response.body
+    end
+
+    public
+    def initialize(user_id, user_api_key, location_api_key, environment = :sandbox)
+      self.user_id          = user_id
+      self.user_api_key     = user_api_key
+      self.location_api_key = location_api_key
+
+      case environment.to_s.gsub(/\s/, '').downcase.to_sym
+      when :production
+        self.api = "https://api.zeamster.com"
+      else
+        self.api = "https://api.sandbox.zeamster.com"
+      end
+    end
+
+    def self.gateway_url(environment = :sandbox)
+      environment = environment.to_s.gsub(/\s/, "").downcase
+      environment = "sandbox" if environment == ""
+      return self.new("", "", "", environment.to_sym).api
+    end
+
+    def create_transaction(card, amount)
+      raise TransactionGatewayInvalidCardType unless card.class == GatewayCard
+      raise TransactionGatewayInvalidAmount if amount.to_f <= 0
+
+      sale_info ={
+        :cv                 =>  card.cvv,
+        :card_number        =>  card.card_number,
+        :exp_date           =>  "#{card.expiration_month}#{card.expiration_year}",
+        :transaction_amount =>  amount
+      }
+
+      return handle_result(call_request(API::AUTHONLYPATH, sale_info, "POST"), FORTIS)
+    end
+
+    def settle_transaction(card_transaction_id, amount = nil)
+      sale_info = {}
+      sale_info = {:transaction_amount =>  amount} if amount
+      return handle_result(call_request(API::SETTLEPATH.gsub('?', card_transaction_id), sale_info), FORTIS)
+    end
+
+    def refund(profile, amount)
+      raise InvalidPaymentProfileType unless profile.class == GatewayCustomerProfile
+      raise TransactionGatewayInvalidAmount, "Amount to refund shouldn't equal to zero." if amount.to_f == 0
+
+      sale_info ={
+        :card_account_id    =>  profile.profile_id,
+        :transaction_amount =>  amount.abs
+      }
+
+      return handle_result(call_request(API::REFUND, sale_info, "POST"), FORTIS)
+    end
+
+    def void_transaction(transaction_id)
+      return handle_result(call_request(API::VOID.gsub('?', transaction_id)), FORTIS)
+    end
+
+    def create_customer_profile(customer, card = nil)
+      raise InvalidCustomerType unless customer.class == GatewayCustomer
+      
+
+      result = handle_result(call_request(API::CONTACT, customer.convert_to_fortis_input, "POST"), FORTIS)
+
+      result = create_card_account(card, result["contact"]["contact_id"]) if card
+        
+      return result
+    end
+
+    def create_card_account(card, customer_profile_id)
+      raise TransactionGatewayInvalidCardType unless card.class == GatewayCard
+
+      sale_info ={
+        :contact_id     =>  customer_profile_id,
+        :card_number    =>  card.card_number,
+        :exp_date       =>  "#{card.expiration_month}#{card.expiration_year}"
+      }
+
+      return handle_result(call_request(API::CARD_ACCOUNT, sale_info, "POST"), FORTIS)
+    end
+
+    def force_settle(profile, authorize_code, amount)
+      raise InvalidPaymentProfileType unless profile.class == GatewayCustomerProfile
+      raise TransactionGatewayInvalidAmount if amount.to_f <= 0
+
+      sale_info ={
+        :card_account_id    =>  profile.payment_profile_id,
+        :transaction_amount =>  amount,
+        :auth               =>  authorize_code
+      }
+
+      return handle_result(call_request(API::CAPTURE_FORCE, sale_info, "POST"), FORTIS)
+    end
+  end
+end

data/lib/transaction_gateway/result.rb

@@ -0,0 +1,79 @@
+require 'json'
+
+module TransactionGateway
+  class Result
+    BRAINTREE       = 'BT'
+    AUTHORIZEDOTNET = 'ADN'
+    FORTIS          = 'FORTIS'
+
+    include GatewayErrors
+
+    ########## HANDLE GETWAY RESPONSE #############
+    def handle_result(result, gateway)
+      case gateway
+
+      when BRAINTREE
+        return handle_braintree_result(result)
+
+      when AUTHORIZEDOTNET
+        return handle_authorize_net_result(result)
+
+      when FORTIS
+        return handle_fortis_result(result)
+        
+      else
+        raise TransactionGatewayNotSupported
+      end
+      
+      raise ConnectionNotMade
+    end
+    
+    private
+    
+    ############# HANDLE BRAINTREE RESPONSE ###############
+    def handle_braintree_result(result)
+      if result.success?
+        if transaction = result.send(result.instance_variable_get("@attrs")[0])
+          return transaction
+        else
+          raise TransactionGatewayError, result.errors.inspect.to_s
+        end
+      else
+        raise TransactionDeclined, result.message
+      end if result
+    end
+    
+    ############# HANDLE AUTHORIZE.NET RESPONSE ###############
+    def handle_authorize_net_result(result)
+      if result
+        if result.direct_response
+          result = result.direct_response
+        else
+          return result if result.result_code.to_s.upcase == "OK"
+          raise TransactionDeclined, result.message_text
+        end   if(result.class == AuthorizeNet::CIM::Response)
+
+        if result.transaction
+          raise TransactionDeclined, result.response_reason_text unless result.response_code == "1"
+              
+          return result
+        else
+          raise TransactionGatewayError, result.response_reason_text
+        end
+      end
+    end
+    
+    ############# HANDLE FORTIS RESPONSE ###############
+    def handle_fortis_result(result)
+      begin
+        result = JSON.parse(result)
+      rescue Exception => ex
+        raise TransactionGatewayError, [result, ex.message]
+      end if(result.class != Hash)
+
+      raise TransactionDeclined, [result["errors"]] if(result["valid"].to_s.upcase != "TRUE" or (result["errors"].to_s.gsub(/s/, "") != ""))
+
+      return result
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: payment_gateway_solutions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Kunal Lalge
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: authorize-net
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: braintree
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.25.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.25.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+description: Multiple Payment Gateway support. Authorize.net, Braintree, Fortis
+email: kunallalge@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/payment_gateway.rb
+- lib/gateway_card.rb
+- lib/gateway_customer.rb
+- lib/gateway_customer_profile.rb
+- lib/gateway_errors.rb
+- lib/transaction_gateway/braintree_gateway.rb
+- lib/transaction_gateway/authorize_net_gateway.rb
+- lib/transaction_gateway/fortis_gateway.rb
+- lib/transaction_gateway/result.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Payment Gateway Solutions
+test_files: []