swiss-activemerchant 1.0.1

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

@@ -0,0 +1,253 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PaywayDotComGateway < Gateway
+      self.test_url = 'https://paywaywsdev.com/PaywayWS/Payment/CreditCard'
+      self.live_url = 'https://paywayws.com/PaywayWS/Payment/CreditCard'
+
+      self.supported_countries = %w[US CA]
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.money_format = :cents
+
+      self.homepage_url = 'http://www.payway.com'
+      self.display_name = 'Payway Gateway'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        '5012' => STANDARD_ERROR_CODE[:card_declined],
+        '5035' => STANDARD_ERROR_CODE[:invalid_number],
+        '5037' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        '5045' => STANDARD_ERROR_CODE[:incorrect_zip]
+      }
+
+      # Payway to standard AVSResult codes.
+      AVS_MAPPING = {
+        'N1'  => 'I', #  No address given with order
+        'N2'  => 'I', #  Bill-to address did not pass
+        '““'  => 'R', #  AVS not performed (Blanks returned)
+        'IU'  => 'G', #  AVS not performed by Issuer
+        'ID'  => 'S', #  Issuer does not participate in AVS
+        'IE'  => 'E', #  Edit Error - AVS data is invalid
+        'IS'  => 'R', #  System unavailable or time-out
+        'IB'  => 'B', #  Street address match. Postal code not verified due to incompatible formats (both were sent).
+        'IC'  => 'C', #  Street address and postal code not verified due to incompatible format (both were sent).
+        'IP'  => 'P', #  Postal code match. Street address not verified due to incompatible formats (both were sent).
+        'A1'  => 'K', #  Accountholder name matches
+        'A3'  => 'V', #  Accountholder name, billing address and postal code.
+        'A4'  => 'L', #  Accountholder name and billing postal code match
+        'A7'  => 'O', #  Accountholder name and billing address match
+        'B3'  => 'H', #  Accountholder name incorrect, billing address and postal code match
+        'B4'  => 'F', #  Accountholder name incorrect, billing postal code matches
+        'B7'  => 'T', #  Accountholder name incorrect, billing address matches
+        'B8'  => 'N', #  Accountholder name, billing address and postal code are all incorrect
+        '??'  => 'R', #  A double question mark symbol indicates an unrecognized response from association
+        'I1'  => 'X', #  Zip code +4 and Address Match
+        'I2'  => 'W', #  Zip code +4 Match
+        'I3'  => 'Y', #  Zip code and Address Match
+        'I4'  => 'Z', #  Zip code Match
+        'I5'  => 'M', #  +4 and Address Match
+        'I6'  => 'W', #  +4 Match
+        'I7'  => 'A', #  Address Match
+        'I8'  => 'C', #  No Match
+      }
+
+      PAYWAY_WS_SUCCESS = '5000'
+
+      SCRUB_PATTERNS = [
+        %r(("password\\?":\\?")[^\\]+),
+        %r(("fsv\\?":\\?")\d+),
+        %r(("fsv\\?": \\?")\d+),
+        %r(("accountNumber\\?":\\?")\d+),
+        %r(("accountNumber\\?": \\?")[^\\]+),
+        %r(("Invalid account number: )\d+)
+      ].freeze
+
+      SCRUB_REPLACEMENT = '\1[FILTERED]'
+
+      def initialize(options = {})
+        requires!(options, :login, :password, :company_id, :source_id)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('sale', post)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('authorize', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_transaction_name(post, authorization, options)
+
+        commit('capture', post)
+      end
+
+      def credit(money, payment, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_payment(post, payment, options)
+        add_card_transaction_details(post, money, options)
+        add_address(post, payment, options)
+
+        commit('credit', post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_common(post, options)
+        add_card_transaction_name(post, authorization, options)
+
+        commit('void', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        SCRUB_PATTERNS.inject(transcript) do |text, pattern|
+          text.gsub(pattern, SCRUB_REPLACEMENT)
+        end
+      end
+
+      private
+
+      def add_common(post, options)
+        post[:userName] = @options[:login]
+        post[:password] = @options[:password]
+        post[:companyId] = @options[:company_id]
+        post[:cardTransaction] = {}
+        post[:cardTransaction][:sourceId] = @options[:source_id]
+      end
+
+      def add_address(post, payment, options)
+        post[:cardAccount] ||= {}
+        address = options[:billing_address] || options[:address] || {}
+        first_name, last_name = split_names(address[:name])
+        full_address = "#{address[:address1]} #{address[:address2]}".strip
+        phone = address[:phone] || address[:phone_number]
+
+        post[:cardAccount][:firstName] = first_name      if first_name
+        post[:cardAccount][:lastName]  = last_name       if last_name
+        post[:cardAccount][:address]   = full_address    if full_address
+        post[:cardAccount][:city]      = address[:city]  if address[:city]
+        post[:cardAccount][:state]     = address[:state] if address[:state]
+        post[:cardAccount][:zip]       = address[:zip]   if address[:zip]
+        post[:cardAccount][:phone]     = phone           if phone
+      end
+
+      def add_card_transaction_details(post, money, options)
+        post[:cardTransaction][:amount] = amount(money)
+        eci_type = options[:eci_type].nil? ? '1' : options[:eci_type]
+        post[:cardTransaction][:eciType] = eci_type
+        post[:cardTransaction][:processorSoftDescriptor] = options[:processor_soft_descriptor] if options[:processor_soft_descriptor]
+        post[:cardTransaction][:tax] = options[:tax] if options[:tax]
+      end
+
+      def add_card_transaction_name(post, identifier, options)
+        post[:cardTransaction][:name] = identifier
+      end
+
+      def add_card_payment(post, payment, options)
+        # credit_card
+        post[:accountInputMode] = 'primaryAccountNumber'
+
+        post[:cardAccount] ||= {}
+        post[:cardAccount][:accountNumber]  = payment.number
+        post[:cardAccount][:fsv]            = payment.verification_value
+        post[:cardAccount][:expirationDate] = expdate(payment)
+        post[:cardAccount][:email]          = options[:email] if options[:email]
+      end
+
+      def expdate(credit_card)
+        year  = format(credit_card.year, :four_digits)
+        month = format(credit_card.month, :two_digits)
+
+        month + year
+      end
+
+      def parse(body)
+        body.blank? ? {} : JSON.parse(body)
+      end
+
+      def commit(action, parameters)
+        parameters[:request] = action
+
+        url = (test? ? test_url : live_url)
+        payload = parameters.to_json unless parameters.nil?
+
+        response =
+          begin
+            parse(ssl_request(:post, url, payload, headers))
+          rescue ResponseError => e
+            return Response.new(false, 'Invalid Login') if e.response.code == '401'
+
+            parse(e.response.body)
+          end
+
+        success = success_from(response)
+        avs_result_code = response['cardTransaction'].nil? || response['cardTransaction']['addressVerificationResults'].nil? ? '' : response['cardTransaction']['addressVerificationResults']
+        avs_result = AVSResult.new(code: AVS_MAPPING[avs_result_code])
+        cvv_result = CVVResult.new(response['cardTransaction']['fraudSecurityResults']) if response['cardTransaction'] && response['cardTransaction']['fraudSecurityResults']
+
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          test: test?,
+          error_code: error_code_from(response),
+          authorization: authorization_from(response),
+          avs_result: avs_result,
+          cvv_result: cvv_result
+        )
+      end
+
+      def success_from(response)
+        response['paywayCode'] == PAYWAY_WS_SUCCESS
+      end
+
+      def error_code_from(response)
+        return '' if success_from(response)
+
+        error = !STANDARD_ERROR_CODE_MAPPING[response['paywayCode']].nil? ? STANDARD_ERROR_CODE_MAPPING[response['paywayCode']] : STANDARD_ERROR_CODE[:processing_error]
+        return error
+      end
+
+      def message_from(success, response)
+        return '' if response['paywayCode'].nil?
+
+        return response['paywayCode'] + '-' + 'success' if success
+
+        response['paywayCode']
+      end
+
+      def authorization_from(response)
+        return '' if !success_from(response) || response['cardTransaction'].nil?
+
+        response['cardTransaction']['name']
+      end
+
+      def headers
+        {
+          'Accept'        => 'application/json',
+          'Content-type'  => 'application/json'
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,273 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PinGateway < Gateway
+      self.test_url = 'https://test-api.pinpayments.com/1'
+      self.live_url = 'https://api.pinpayments.com/1'
+
+      self.default_currency = 'AUD'
+      self.money_format = :cents
+      self.supported_countries = %w(AU NZ)
+      self.supported_cardtypes = %i[visa master american_express diners_club discover jcb]
+      self.homepage_url = 'http://www.pinpayments.com/'
+      self.display_name = 'Pin Payments'
+
+      def initialize(options = {})
+        requires!(options, :api_key)
+        super
+      end
+
+      # Create a charge using a credit card, card token or customer token
+      #
+      # To charge a credit card: purchase([money], [creditcard hash], ...)
+      # To charge a customer: purchase([money], [token], ...)
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_customer_data(post, options)
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_address(post, creditcard, options)
+        add_capture(post, options)
+        add_metadata(post, options)
+        add_3ds(post, options)
+
+        commit(:post, 'charges', post, options)
+      end
+
+      # Create a customer and associated credit card. The token that is returned
+      # can be used instead of a credit card parameter in the purchase method
+      def store(creditcard, options = {})
+        post = {}
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit(:post, 'customers', post, options)
+      end
+
+      # Unstore a customer and associated credit card.
+      def unstore(token)
+        customer_token =
+          if /cus_/.match?(token)
+            get_customer_token(token)
+          else
+            token
+          end
+        commit(:delete, "customers/#{CGI.escape(customer_token)}", {}, {})
+      end
+
+      # Refund a transaction
+      def refund(money, token, options = {})
+        commit(:post, "charges/#{CGI.escape(token)}/refunds", { amount: amount(money) }, options)
+      end
+
+      # Authorize an amount on a credit card. Once authorized, you can later
+      # capture this charge using the charge token that is returned.
+      def authorize(money, creditcard, options = {})
+        options[:capture] = false
+
+        purchase(money, creditcard, options)
+      end
+
+      # Captures a previously authorized charge. Capturing only part of the original
+      # authorization is currently not supported.
+      def capture(money, token, options = {})
+        commit(:put, "charges/#{CGI.escape(token)}/capture", { amount: amount(money) }, options)
+      end
+
+      # Voids a previously authorized charge.
+      def void(token, options = {})
+        commit(:put, "charges/#{CGI.escape(token)}/void", {}, options)
+      end
+
+      # Updates the credit card for the customer.
+      def update(token, creditcard, options = {})
+        post = {}
+        token = get_customer_token(token)
+
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_address(post, creditcard, options)
+        commit(:put, "customers/#{CGI.escape(token)}", post, options)
+      end
+
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(/(number\\?":\\?")(\d*)/, '\1[FILTERED]').
+          gsub(/(cvc\\?":\\?")(\d*)/, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_amount(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:currency] = post[:currency].upcase if post[:currency]
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] if options[:email]
+        post[:ip_address] = options[:ip] if options[:ip]
+      end
+
+      def add_address(post, creditcard, options)
+        return if creditcard.kind_of?(String)
+
+        address = (options[:billing_address] || options[:address])
+        return unless address
+
+        post[:card] ||= {}
+        post[:card].merge!(
+          address_line1: address[:address1],
+          address_city: address[:city],
+          address_postcode: address[:zip],
+          address_state: address[:state],
+          address_country: address[:country]
+        )
+      end
+
+      def add_invoice(post, options)
+        post[:description] = options[:description] || 'Active Merchant Purchase'
+        post[:reference] = options[:reference] if options[:reference]
+      end
+
+      def add_capture(post, options)
+        capture = options[:capture]
+
+        post[:capture] = capture != false
+      end
+
+      def add_creditcard(post, creditcard)
+        if creditcard.respond_to?(:number)
+          post[:card] ||= {}
+
+          post[:card].merge!(
+            number: creditcard.number,
+            expiry_month: creditcard.month,
+            expiry_year: creditcard.year,
+            cvc: creditcard.verification_value,
+            name: creditcard.name
+          )
+        elsif creditcard.kind_of?(String)
+          if /^card_/.match?(creditcard)
+            post[:card_token] = get_card_token(creditcard)
+          else
+            post[:customer_token] = creditcard
+          end
+        end
+      end
+
+      def get_customer_token(token)
+        token.split(/;(?=cus)/).last
+      end
+
+      def get_card_token(token)
+        token.split(/;(?=cus)/).first
+      end
+
+      def add_metadata(post, options)
+        post[:metadata] = options[:metadata] if options[:metadata]
+      end
+
+      def add_3ds(post, options)
+        if options[:three_d_secure]
+          post[:three_d_secure] = {}
+          post[:three_d_secure][:version] = options[:three_d_secure][:version] if options[:three_d_secure][:version]
+          post[:three_d_secure][:eci] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+          post[:three_d_secure][:cavv] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
+          post[:three_d_secure][:transaction_id] = options[:three_d_secure][:ds_transaction_id] || options[:three_d_secure][:xid]
+        end
+      end
+
+      def headers(params = {})
+        result = {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Basic #{Base64.strict_encode64(options[:api_key] + ':').strip}"
+        }
+
+        result['X-Partner-Key'] = params[:partner_key] if params[:partner_key]
+        result['X-Safe-Card'] = params[:safe_card] if params[:safe_card]
+        result
+      end
+
+      def commit(method, action, params, options)
+        url = "#{test? ? test_url : live_url}/#{action}"
+
+        begin
+          raw_response = ssl_request(method, url, post_data(params), headers(options))
+          body = parse(raw_response)
+        rescue ResponseError => e
+          body = parse(e.response.body)
+        end
+
+        if body.nil?
+          no_content_response
+        elsif body['response']
+          success_response(body)
+        elsif body['error']
+          error_response(body)
+        end
+      rescue JSON::ParserError
+        return unparsable_response(raw_response)
+      end
+
+      def success_response(body)
+        response = body['response']
+        Response.new(
+          true,
+          response['status_message'],
+          body,
+          authorization: token(response),
+          test: test?
+        )
+      end
+
+      def error_response(body)
+        Response.new(
+          false,
+          body['error_description'],
+          body,
+          authorization: nil,
+          test: test?
+        )
+      end
+
+      def no_content_response
+        Response.new(
+          true,
+          nil,
+          {},
+          test: test?
+        )
+      end
+
+      def unparsable_response(raw_response)
+        message = 'Invalid JSON response received from Pin Payments. Please contact support@pinpayments.com if you continue to receive this message.'
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+
+      def token(response)
+        if response['token'].start_with?('cus')
+          "#{response.dig('card', 'token')};#{response['token']}"
+        else
+          response['token']
+        end
+      end
+
+      def parse(body)
+        JSON.parse(body) unless body.nil? || body.length == 0
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+    end
+  end
+end