swiss-crm-activemerchant-v2 1.0.20

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

@@ -0,0 +1,158 @@
+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 = %i[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 = {})
+        ActiveMerchant.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 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)
+
+        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 'active_merchant/billing/gateways/cc5'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FinansbankGateway < CC5Gateway
+      self.live_url = 'https://www.fbwebpos.com/servlet/cc5ApiServer'
+      self.test_url = 'https://entegrasyon.asseco-see.com.tr/fim/api'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = %w[US TR]
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = %i[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/finix.rb

@@ -0,0 +1,348 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FinixGateway < Gateway
+      include Empty
+
+      SUCCESS_CODES = [200, 201].freeze
+
+      SOFT_DECLINE_CODES = %w[
+        INSUFFICIENT_FUNDS
+        EXCEEDS_APPROVAL_LIMIT
+        CARD_VELOCITY_EXCEEDED
+        PROCESSOR_TIMEOUT
+        TRANSACTION_NOT_ALLOWED
+      ].freeze
+
+      COUNTRY_CODE  = { 'US' => 'USA', 'CA' => 'CAN' }.freeze
+
+      API_VERSION = '2018-01-01'.freeze
+      BASIC_AUTH_PREFIX = 'Basic '.freeze
+      CONTENT_TYPE = 'application/json'.freeze
+
+      self.test_url = 'https://finix.sandbox-payments-api.com'
+      self.live_url = 'https://finix.live-payments-api.com'
+      self.supported_countries = %w[US CA]
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.default_currency = 'USD'
+      self.money_format = :cents
+      self.homepage_url = 'https://finixpayments.com'
+      self.display_name = 'Finix'
+
+      def initialize(options = {})
+        requires!(options, :username, :password, :merchant_id)
+        super
+        @username = options[:username]
+        @password = options[:password]
+        @merchant_id = options[:merchant_id]
+      end
+
+      def purchase(amount, payment_source, options = {})
+        post = {}
+        add_invoice(post, amount, options)
+        add_payment_source(post, payment_source, options)
+        add_idempotency_id(post, options)
+
+        verification_data = options[:verification_data] || {}
+        commit('transaction', post, verification_data, options)
+      end
+
+      def refund(amount, authorization, options = {})
+        post = {}
+        add_refund_data(post, amount, authorization, options)
+
+        commit('reversals', post, options)
+      end
+
+      private
+
+      def add_payment_source(post, payment_source, options)
+        return attach_existing_instrument(post, payment_source, options) if existing_customer?(options)
+
+        identity = create_new_identity(options)
+        return identity unless identity.success?
+
+        attach_new_instrument(post, identity.authorization, payment_source, options)
+      end
+
+      def existing_customer?(options)
+        options[:customer_identity].present?
+      end
+
+      def attach_existing_instrument(post, payment_source, options)
+        instrument_id = payment_source[:finix_payment_instrument_id]
+
+        if instrument_id.present?
+          attach_existing_instrument_data(post, instrument_id, options)
+        else
+          create_and_attach_new_instrument(post, payment_source, options)
+        end
+      end
+
+      def attach_existing_instrument_data(post, instrument_id, options)
+        payment_instrument = fetch_payment_instrument(instrument_id)
+
+        options[:verification_data] = {
+          avs_result: payment_instrument.dig('address_verification'),
+          cvv_result: payment_instrument.dig('security_code_verification')
+        }
+
+        post[:instrument_id] = instrument_id
+      end
+
+      def create_and_attach_new_instrument(post, payment_source, options)
+        instrument = create_payment_instrument(options[:customer_identity], payment_source, options)
+
+        return instrument unless instrument.success?
+
+        post[:instrument_id] = instrument.params['id']
+      end
+
+      def create_new_identity(options)
+        identity = create_identity(options)
+        options[:identity_id] = identity.authorization if identity.success?
+        identity
+      end
+
+      def attach_new_instrument(post, identity_id, payment_source, options)
+        instrument = create_payment_instrument(identity_id, payment_source, options)
+        return instrument unless instrument.success?
+
+        options[:verification_data] = {
+          avs_result: instrument.params['address_verification'],
+          cvv_result: instrument.params['security_code_verification']
+        }
+
+        post[:instrument_id] = instrument.params['id']
+      end
+
+      def create_identity(options)
+        post = {}
+        add_identity_data(post, options)
+
+        commit('identities', post, nil, options)
+      end
+
+      def create_payment_instrument(identity_id, payment_source, options)
+        post = {}
+        post[:identity] = identity_id
+        add_payment_method(post, payment_source, options)
+        add_address(post, options)
+        commit('payment_instruments', post, nil, options)
+      end
+
+      def fetch_payment_instrument(payment_instrument_id)
+        raw_response = ssl_get("#{url}/payment_instruments/#{payment_instrument_id}", headers)
+        response = parse(raw_response)
+      end
+
+      def add_refund_data(post, amount, authorization, options)
+        post[:amount] = amount
+        post[:transaction_id] = authorization
+        add_idempotency_id(post, options) if options['idempotency_id'].present?
+      end
+
+      def add_idempotency_id(post, options)
+        post[:idempotency_id] = options['idempotency_id']
+      end
+
+      def add_identity_data(post, options)
+        billing               = options[:billing_address] || {}
+        first_name, last_name = split_names(billing[:name])
+
+        post[:type]           = 'BUSINESS'
+        post[:identity_roles] = ['BUYER']
+        post[:entity]         = {
+                                  first_name: first_name,
+                                  last_name: last_name,
+                                  email: options[:email],
+                                  phone: billing[:phone],
+                                  personal_address: build_address(billing)
+                                }
+      end
+
+      def add_payment_method(post, payment_source, options)
+        billing                 = options[:billing_address] || {}
+        post[:type]             = 'PAYMENT_CARD'
+        post[:name]             = billing[:name]
+        post[:number]           = payment_source.number
+        post[:expiration_month] = payment_source.month
+        post[:expiration_year]  = payment_source.year
+        post[:security_code]    = payment_source.verification_value
+      end
+
+      def add_invoice(post, amount, options)
+        post[:amount]   = amount
+        post[:currency] = options[:currency] || default_currency
+        post[:merchant] = @merchant_id
+        post[:tags] = {
+            purpose: 'sale',
+            order_id: options[:order_id],
+            customer_id: options[:customer_id]
+          }.compact
+      end
+
+      def add_address(post, options)
+        billing        = options[:billing_address] || {}
+        post[:address] = build_address(billing)
+      end
+
+      def add_reference(post, authorization)
+        post[:transaction_id] = authorization
+      end
+
+      def build_address(data)
+        {
+          line1: data[:address1],
+          city: data[:city],
+          region: data[:state],
+          postal_code: data[:zip].to_s.gsub(/\s+/, ''),
+          country: COUNTRY_CODE[data[:country]] || data[:country]
+        }
+      end
+
+      def commit(action, params, verification_data = nil, options = {})
+        request_url  = build_request_url(action, params)
+        payload      = build_payload(action, params)
+        raw_response = ssl_post(request_url, payload.to_json, headers)
+        response     = parse(raw_response).merge('customer_identity' => options[:identity_id]).compact
+        succeeded    = ['identities', 'payment_instruments'].include?(action) ?
+                        profile_created_successful?(response) :
+                        success_from(response)
+
+        Response.new(
+          succeeded,
+          message_from(succeeded, response),
+          response,
+          error_code: error_code_from(succeeded, response),
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: verification_data&.dig(:avs_result)),
+          cvv_result: CVVResult.new(verification_data&.dig(:cvv_result)),
+          test: test?,
+          response_type: response_type(response['state']),
+          response_http_code: @response_http_code,
+          request_endpoint: request_url,
+          request_method: :post,
+          request_body: payload
+        )
+      end
+
+      def build_request_url(action, params)
+        case action
+        when 'identities'
+          "#{url}/identities"
+        when 'payment_instruments'
+          "#{url}/payment_instruments"
+        when 'transaction'
+          "#{url}/transfers"
+        when 'reversals'
+          "#{url}/transfers/#{params[:transaction_id]}/reversals"
+        end
+      end
+
+      def build_payload(action, params)
+        case action
+        when 'reversals'
+          {
+            amount: params[:amount],
+            idempotency_id: params[:idempotency_id],
+            tags: params[:tags]
+          }
+        when 'transaction'
+          {
+            amount: params[:amount],
+            currency: params[:currency] || default_currency,
+            merchant: @merchant_id,
+            source: params[:instrument_id],
+            idempotency_id: params[:idempotency_id],
+            tags: params[:tags]
+          }
+        else
+          params
+        end
+      end
+
+      def headers
+        {
+          'Content-Type'  => CONTENT_TYPE,
+          'Authorization' => basic_auth_header,
+          'Finix-Version' => API_VERSION
+        }
+      end
+
+      def basic_auth_header
+        BASIC_AUTH_PREFIX + Base64.strict_encode64("#{@username}:#{@password}")
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response['state'] == 'SUCCEEDED'
+      end
+
+      def profile_created_successful?(response)
+        return true if response['id'].present?
+
+        errors = response.dig('_embedded', 'errors')
+        if errors.present?
+          return false
+        end
+
+        false
+      end
+
+      def message_from(succeeded, response)
+        state = response["state"]
+
+        case state
+        when "FAILED"
+          response['failure_message']
+        when "PENDING", "SUCCEEDED", "CANCELED"
+          state.capitalize
+        else
+          response.dig('_embedded', 'errors', 0, 'message')
+        end
+      end
+
+      def error_code_from(succeeded, response)
+        return nil if succeeded
+
+        if response['_embedded'] && response['_embedded']['errors']
+          response['_embedded']['errors'].first['code']
+        else
+          response['failure_code']
+        end
+      end
+
+      def authorization_from(response)
+        response['id']
+      end
+
+      def response_type(state)
+        case state
+        when 'SUCCEEDED'            then 0
+        when 'FAILED'               then 2
+        when 'CANCELED', 'DECLINED' then 1
+        else 1
+        end
+      end
+
+      def split_names(name)
+        name_parts = name.to_s.split
+        first_name = name_parts.first || ''
+        last_name  = name_parts[1..]&.join(' ') || ''
+        [first_name, last_name]
+      end
+
+      def handle_response(response)
+        @response_http_code = response.code.to_i
+        response.body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FirstGivingGateway < Gateway
+      self.test_url = 'http://usapisandbox.fgdev.net'
+      self.live_url = 'https://api.firstgiving.com'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.homepage_url = 'http://www.firstgiving.com/'
+      self.default_currency = 'USD'
+      self.display_name = 'FirstGiving'
+
+      def initialize(options = {})
+        requires!(options, :application_key, :security_token, :charity_id)
+        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)
+        add_donation_data(post, money, options)
+        commit('/donation/creditcard', post)
+      end
+
+      def refund(money, identifier, options = {})
+        get = {}
+        get[:transactionId] = identifier
+        get[:tranType] = 'REFUNDREQUEST'
+        commit('/transaction/refundrequest?' + encode(get))
+      end
+
+      private
+
+      def add_donation_data(post, money, options)
+        post[:amount] = amount(money)
+        post[:charityId] = @options[:charity_id]
+        post[:description] = (options[:description] || 'Purchase')
+        post[:currencyCode] = (options[:currency] || currency(money))
+      end
+
+      def add_customer_data(post, options)
+        post[:billToEmail] = (options[:email] || 'activemerchant@example.com')
+        post[:remoteAddr]  = (options[:ip] || '127.0.0.1')
+      end
+
+      def add_address(post, options)
+        if (billing_address = (options[:billing_address] || options[:address]))
+          post[:billToAddressLine1]  = billing_address[:address1]
+          post[:billToCity]          = billing_address[:city]
+          post[:billToState]         = billing_address[:state]
+          post[:billToZip]           = billing_address[:zip]
+          post[:billToCountry]       = billing_address[:country]
+        end
+      end
+
+      def add_invoice(post, options)
+        post[:orderId] = options[:order_id]
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:billToFirstName]     = creditcard.first_name
+        post[:billToLastName]      = creditcard.last_name
+        post[:ccNumber]            = creditcard.number
+        post[:ccType]              = creditcard_brand(creditcard.brand)
+        post[:ccExpDateMonth]      = creditcard.month
+        post[:ccExpDateYear]       = creditcard.year
+        post[:ccCardValidationNum] = creditcard.verification_value
+      end
+
+      def parse(body)
+        response = {}
+
+        xml = Nokogiri::XML(body)
+        element = xml.xpath('//firstGivingDonationApi/firstGivingResponse').first
+
+        element.attributes.each do |name, attribute|
+          response[name] = attribute.content
+        end
+        element.children.each do |child|
+          next if child.text?
+
+          response[child.name] = child.text
+        end
+
+        response
+      end
+
+      def commit(action, post = nil)
+        url = (test? ? self.test_url : self.live_url) + action
+
+        begin
+          if post
+            response = parse(ssl_post(url, post_data(post), headers))
+          else
+            response = parse(ssl_get(url, headers))
+          end
+        rescue ResponseError => e
+          response = parse(e.response.body)
+        end
+
+        Response.new(
+          (response['acknowledgement'] == 'Success'),
+          (response['friendlyErrorMessage'] || response['verboseErrorMessage'] || response['acknowledgement']),
+          response,
+          authorization: response['transactionId'],
+          test: test?
+        )
+      end
+
+      def post_data(post)
+        post.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      def encode(hash)
+        hash.collect { |(k, v)| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def creditcard_brand(brand)
+        case brand
+        when 'visa' then 'VI'
+        when 'master' then 'MC'
+        when 'discover' then 'DI'
+        when 'american_express' then 'AX'
+        else
+          raise "Unhandled credit card brand #{brand}"
+        end
+      end
+
+      def headers
+        {
+          'User-Agent'        => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          'JG_APPLICATIONKEY' => @options[:application_key].to_s,
+          'JG_SECURITYTOKEN'  => @options[:security_token].to_s
+        }
+      end
+    end
+  end
+end