start_activemerchant 1.50.0

data/lib/active_merchant/billing/gateways/orbital/orbital_soft_descriptors.rb

@@ -0,0 +1,47 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class OrbitalSoftDescriptors < Model
+      PHONE_FORMAT_1 = /\A\d{3}-\d{3}-\d{4}\z/
+      PHONE_FORMAT_2 = /\A\d{3}-\w{7}\z/
+
+      # ==== Tampa PNS Soft Descriptors
+      # The support for Soft Descriptors via the PNS Host is only for customers processing through Chase
+      # Paymentech Canada.
+
+      # Unlike Salem, the only value that gets passed on the cardholder statement is the Merchant Name field.
+      # And for these customers, it is a maximum of 25 bytes of data.
+      #
+      # All other Soft Descriptor fields can optionally be sent, but will not be submitted to the settlement host
+      # and will not display on the cardholder statement.
+
+      attr_accessor :merchant_name, :product_description, :merchant_city, :merchant_phone, :merchant_url, :merchant_email
+
+      def initialize(options = {})
+        self.merchant_name = options[:merchant_name]
+        self.merchant_city = options[:merchant_city]
+        self.merchant_phone = options[:merchant_phone]
+        self.merchant_url = options[:merchant_url]
+        self.merchant_email = options[:merchant_email]
+      end
+
+      def validate
+        errors = []
+
+        errors << [:merchant_name, "is required"] if self.merchant_name.blank?
+        errors << [:merchant_name, "is required to be 25 bytes or less"] if self.merchant_name.bytesize > 25
+
+        if(!empty?(self.merchant_phone) && !self.merchant_phone.match(PHONE_FORMAT_1) && !self.merchant_phone.match(PHONE_FORMAT_2))
+          errors << [:merchant_phone, "is required to follow \"NNN-NNN-NNNN\" or \"NNN-AAAAAAA\" format"]
+        end
+
+        [:merchant_email, :merchant_url].each do |attr|
+          unless self.send(attr).blank?
+            errors << [attr, "is required to be 13 bytes or less"] if(self.send(attr).bytesize > 13)
+          end
+        end
+
+        errors_hash(errors)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PacNetRavenGateway < Gateway
+
+      AVS_ADDRESS_CODES = {
+        'avs_address_unavailable'   => 'X',
+        'avs_address_not_checked'   => 'X',
+        'avs_address_matched'       => 'Y',
+        'avs_address_not_matched'   => 'N',
+        'avs_address_partial_match' => 'N'
+      }
+
+      AVS_POSTAL_CODES = {
+        'avs_postal_unavailable'   => 'X',
+        'avs_postal_not_checked'   => 'X',
+        'avs_postal_matched'       => 'Y',
+        'avs_postal_not_matched'   => 'N',
+        'avs_postal_partial_match' => 'N'
+      }
+
+      CVV2_CODES = {
+        'cvv2_matched'     => 'Y',
+        'cvv2_not_matched' => 'N',
+        'cvv2_unavailable' => 'X',
+        'cvv2_not_checked' => 'X'
+      }
+
+      self.test_url = 'https://demo.deepcovelabs.com/realtime/'
+      self.live_url = 'https://raven.pacnetservices.com/realtime/'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = [:visa, :master]
+      self.money_format = :cents
+      self.default_currency = 'USD'
+      self.homepage_url = 'http://www.pacnetservices.com/'
+      self.display_name = 'Raven PacNet'
+
+      def initialize(options = {})
+        requires!(options, :user, :secret, :prn)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard)
+        add_currency_code(post, money, options)
+        add_address(post, options)
+        post['PRN'] = @options[:prn]
+
+        commit('cc_preauth', money, post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_currency_code(post, money, options)
+        add_creditcard(post, creditcard)
+        add_address(post, options)
+        post['PRN'] = @options[:prn]
+
+        commit('cc_debit', money, post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        post['TrackingNumber'] = authorization
+        post['PymtType'] = options[:pymt_type] || 'cc_debit'
+
+        commit('void', nil, post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post['PreauthNumber'] = authorization
+        post['PRN'] = @options[:prn]
+        add_currency_code(post, money, options)
+
+        commit('cc_settle', money, post)
+      end
+
+      def refund(money, template_number, options = {})
+        post = {}
+        post['PRN'] = @options[:prn]
+        post['TemplateNumber'] = template_number
+        add_currency_code(post, money, options)
+
+        commit('cc_refund', money, post)
+      end
+
+      private
+
+      def add_creditcard(post, creditcard)
+        post['CardNumber'] = creditcard.number
+        post['Expiry'] = expdate(creditcard)
+        post['CVV2'] = creditcard.verification_value if creditcard.verification_value
+      end
+
+      def add_currency_code(post, money, options)
+        post['Currency'] = options[:currency] || currency(money)
+      end
+
+      def add_address(post, options)
+        if address = options[:billing_address] || options[:address]
+          post['BillingStreetAddressLineOne']   = address[:address1].to_s
+          post['BillingStreetAddressLineFour']  = address[:address2].to_s
+          post['BillingPostalCode']             = address[:zip].to_s
+        end
+      end
+
+      def parse(body)
+        Hash[body.split('&').map{|x| x.split('=').map{|y| CGI.unescape(y)}}]
+      end
+
+      def commit(action, money, parameters)
+        parameters['Amount'] = amount(money) unless action == 'void'
+
+        data = ssl_post url(action), post_data(action, parameters)
+
+        response = parse(data)
+        response[:action] = action
+
+        message = message_from(response)
+
+        test_mode = test? || message =~ /TESTMODE/
+
+        Response.new(success?(response), message, response,
+          :test => test_mode,
+          :authorization => response['TrackingNumber'],
+          :fraud_review => fraud_review?(response),
+          :avs_result => {
+                          :postal_match => AVS_POSTAL_CODES[response['AVSPostalResponseCode']],
+                          :street_match => AVS_ADDRESS_CODES[response['AVSAddressResponseCode']]
+                         },
+          :cvv_result => CVV2_CODES[response['CVV2ResponseCode']]
+        )
+      end
+
+      def url(action)
+        (test? ? self.test_url : self.live_url) + endpoint(action)
+      end
+
+      def endpoint(action)
+        return 'void' if action == 'void'
+        'submit'
+      end
+
+      def fraud_review?(response)
+        false
+      end
+
+      def success?(response)
+        if %w(cc_settle cc_debit cc_preauth cc_refund).include?(response[:action])
+          !response['ApprovalCode'].nil? and response['ErrorCode'].nil? and response['Status'] == 'Approved'
+        elsif response[:action] = 'void'
+          !response['ApprovalCode'].nil? and response['ErrorCode'].nil? and response['Status'] == 'Voided'
+        end
+      end
+
+      def message_from(response)
+        return response['Message'] if response['Message']
+
+        if response['Status'] == 'Approved'
+          "This transaction has been approved"
+        elsif response['Status'] == 'Declined'
+          "This transaction has been declined"
+        elsif response['Status'] == 'Voided'
+          "This transaction has been voided"
+        else
+          response['Status']
+        end
+      end
+
+      def post_data(action, parameters = {})
+        post = {}
+
+        post['PymtType']      = action
+        post['RAPIVersion']   = '2'
+        post['UserName']      = @options[:user]
+        post['Timestamp']     = timestamp
+        post['RequestID']     = request_id
+        post['Signature']     = signature(action, post, parameters)
+
+        request = post.merge(parameters).collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join("&")
+        request
+      end
+
+      def timestamp
+        Time.now.strftime("%Y-%m-%dT%H:%M:%S.Z")
+      end
+
+      def request_id
+        SecureRandom.uuid
+      end
+
+      def signature(action, post, parameters = {})
+        string = if %w(cc_settle cc_debit cc_preauth cc_refund).include?(action)
+          post['UserName'] + post['Timestamp'] + post['RequestID'] + post['PymtType'] + parameters['Amount'].to_s + parameters['Currency']
+        elsif action == 'void'
+          post['UserName'] + post['Timestamp'] + post['RequestID'] + parameters['TrackingNumber']
+        else
+          post['UserName']
+        end
+        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new(@options[:secret]), @options[:secret], string)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,122 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PagoFacilGateway < Gateway
+      self.test_url = 'https://www.pagofacil.net/st/public/Wsrtransaccion/index/format/json?'
+      self.live_url = 'https://www.pagofacil.net/ws/public/Wsrtransaccion/index/format/json?'
+
+      self.supported_countries = ['MX']
+      self.default_currency = 'MXN'
+      self.supported_cardtypes = [:visa, :master, :american_express, :jcb]
+
+      self.homepage_url = 'http://www.pagofacil.net/'
+      self.display_name = 'PagoFacil'
+
+      def initialize(options={})
+        requires!(options, :branch_id, :merchant_id, :service_id)
+        super
+      end
+
+      def purchase(money, credit_card, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment(post, credit_card)
+        add_address(post, options)
+        add_customer_data(post, options)
+        add_merchant_data(post)
+
+        commit(post)
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email]
+        post[:celular] = options[:cellphone]
+      end
+
+      def add_address(post, options)
+        address = options.fetch(:billing_address, {})
+        post[:calleyNumero] = address[:address1]
+        post[:colonia] = address[:address2]
+        post[:municipio] = address[:city]
+        post[:estado] = address[:state]
+        post[:pais] = address[:country]
+        post[:telefono] = address[:phone]
+        post[:cp] = address[:zip]
+      end
+
+      def add_invoice(post, money, options)
+        post[:monto] = amount(money)
+        post[:idPedido] = options[:order_id]
+        add_currency(post, money, options)
+      end
+
+      def add_currency(post, money, options)
+        currency = options.fetch(:currency, currency(money))
+        unless currency == self.class.default_currency
+          post[:divisa] = currency
+        end
+      end
+
+      def add_payment(post, credit_card)
+        post[:nombre] = credit_card.first_name
+        post[:apellidos] = credit_card.last_name
+        post[:numeroTarjeta] = credit_card.number
+        post[:cvt] = credit_card.verification_value
+        post[:mesExpiracion] = sprintf("%02d", credit_card.month)
+        post[:anyoExpiracion] = credit_card.year.to_s.slice(-2, 2)
+      end
+
+      def add_merchant_data(post)
+        post[:idSucursal] = options.fetch(:branch_id)
+        post[:idUsuario] = options.fetch(:merchant_id)
+        post[:idServicio] = options.fetch(:service_id)
+      end
+
+      def parse(body)
+        JSON.parse(body)["WebServices_Transacciones"]["transaccion"]
+      rescue JSON::ParserError
+        json_error(body)
+      end
+
+      def commit(parameters)
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_post(url, post_data(parameters)))
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          test: test?
+        )
+      end
+
+      def success_from(response)
+        response["autorizado"] == "1" ||
+          response["autorizado"] == true
+      end
+
+      def message_from(response)
+        response["texto"]
+      end
+
+      def authorization_from(response)
+        response["autorizacion"]
+      end
+
+      def post_data(parameters = {})
+        {
+          method: 'transaccion',
+          data: parameters
+        }.to_query
+      end
+
+      def json_error(response)
+        {
+          "texto" => 'Invalid response received from the PagoFacil API.',
+          "raw_response" => response
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,246 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PayConexGateway < Gateway
+      include Empty
+
+      self.test_url = "https://cert.payconex.net/api/qsapi/3.8/"
+      self.live_url = "https://secure.payconex.net/api/qsapi/3.8/"
+
+      self.supported_countries = %w(US CA)
+      self.default_currency = "USD"
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
+
+      self.homepage_url = "http://www.bluefincommerce.com/"
+      self.display_name = "PayConex"
+
+      def initialize(options={})
+        requires!(options, :account_id, :api_accesskey)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit("SALE", post)
+      end
+
+      def authorize(money, payment_method, options={})
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit("AUTHORIZATION", post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_reference_params(post, authorization, options)
+        add_amount(post, money, options)
+        commit("CAPTURE", post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_reference_params(post, authorization, options)
+        add_amount(post, money, options)
+        commit("REFUND", post)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        add_reference_params(post, authorization, options)
+        commit("REVERSAL", post)
+      end
+
+      def credit(money, payment_method, options={})
+        if payment_method.is_a?(String)
+          raise ArgumentError, "Reference credits are not supported. Please supply the original credit card or use the #refund method."
+        end
+
+        post = {}
+        add_auth_purchase_params(post, money, payment_method, options)
+        commit("CREDIT", post)
+      end
+
+      def verify(payment_method, options={})
+        authorize(0, payment_method, options)
+      end
+
+      def store(payment_method, options={})
+        post = {}
+        add_credentials(post)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+        add_common_options(post, options)
+        commit("STORE", post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        force_utf8(transcript).
+          gsub(%r((api_accesskey=)\w+), '\1[FILTERED]').
+          gsub(%r((card_number=)\w+), '\1[FILTERED]').
+          gsub(%r((card_verification=)\w+), '\1[FILTERED]')
+      end
+
+      private
+
+      def force_utf8(string)
+        return nil unless string
+        binary = string.encode("BINARY", invalid: :replace, undef: :replace, replace: "?")   # Needed for Ruby 2.0 since #encode is a no-op if the string is already UTF-8. It's not needed for Ruby 2.1 and up since it's not a no-op there.
+        binary.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+      end
+
+      def add_credentials(post)
+        post[:account_id] = @options[:account_id]
+        post[:api_accesskey] = @options[:api_accesskey]
+      end
+
+      def add_auth_purchase_params(post, money, payment_method, options)
+        add_credentials(post)
+        add_payment_method(post, payment_method)
+        add_address(post, options)
+        add_common_options(post, options)
+        add_amount(post, money, options)
+        add_if_present(post, :email, options[:email])
+      end
+
+      def add_reference_params(post, authorization, options)
+        add_credentials(post)
+        add_common_options(post, options)
+        add_token_id(post, authorization)
+      end
+
+      def add_amount(post, money, options)
+        post[:transaction_amount] = amount(money)
+        currency_code = (options[:currency] || currency(money))
+        add_if_present(post, :currency, currency_code)
+      end
+
+      def add_payment_method(post, payment_method)
+        case payment_method
+        when String
+          add_token_payment_method(post, payment_method)
+        when Check
+          add_check(post, payment_method)
+        else
+          if payment_method.respond_to?(:track_data) && payment_method.track_data.present?
+            add_card_present_payment_method(post, payment_method)
+          else
+            add_credit_card(post, payment_method)
+          end
+        end
+      end
+
+      def add_credit_card(post, payment_method)
+        post[:tender_type] = "CARD"
+        post[:card_number] = payment_method.number
+        post[:card_expiration] = expdate(payment_method)
+        post[:card_verification] = payment_method.verification_value
+        post[:first_name] = payment_method.first_name
+        post[:last_name] = payment_method.last_name
+      end
+
+      def add_token_payment_method(post, payment_method)
+        post[:tender_type] = "CARD"
+        post[:token_id] = payment_method
+        post[:reissue] = true
+      end
+
+      def add_card_present_payment_method(post, payment_method)
+        post[:tender_type] = "CARD"
+        post[:card_tracks] = payment_method.track_data
+      end
+
+      def add_check(post, payment_method)
+        post[:tender_type] = "ACH"
+        post[:first_name] = payment_method.first_name
+        post[:last_name] = payment_method.last_name
+        post[:bank_account_number] = payment_method.account_number
+        post[:bank_routing_number] = payment_method.routing_number
+        post[:check_number] = payment_method.number
+        add_if_present(post, :ach_account_type, payment_method.account_type)
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address]
+        return unless address
+
+        add_if_present(post, :street_address1, address[:address1])
+        add_if_present(post, :street_address2, address[:address2])
+        add_if_present(post, :city, address[:city])
+        add_if_present(post, :state, address[:state])
+        add_if_present(post, :zip, address[:zip])
+        add_if_present(post, :country, address[:country])
+        add_if_present(post, :phone, address[:phone])
+      end
+
+      def add_common_options(post, options)
+        add_if_present(post, :transaction_description, options[:description])
+        add_if_present(post, :custom_id, options[:custom_id])
+        add_if_present(post, :custom_data, options[:custom_data])
+        add_if_present(post, :ip_address, options[:ip])
+        add_if_present(post, :payment_type, options[:payment_type])
+        add_if_present(post, :cashier, options[:cashier])
+
+        post[:disable_cvv] = options[:disable_cvv] unless options[:disable_cvv].nil?
+        post[:response_format] = 'JSON'
+      end
+
+      def add_if_present(post, key, value)
+        post[key] = value unless empty?(value)
+      end
+
+      def add_token_id(post, authorization)
+        post[:token_id] = authorization
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, params)
+        raw_response = ssl_post(url, post_data(action, params))
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: response["transaction_id"],
+          :avs_result => AVSResult.new(code: response["avs_response"]),
+          :cvv_result => CVVResult.new(response["cvv2_response"]),
+          test: test?
+        )
+
+      rescue JSON::ParserError
+        unparsable_response(raw_response)
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def success_from(response)
+        response["transaction_approved"] || !response["error"]
+      end
+
+      def message_from(response)
+        success_from(response) ? response["authorization_message"] : response["error_message"]
+      end
+
+      def post_data(action, params)
+        params[:transaction_type] = action
+        params.map {|k, v| "#{k}=#{CGI.escape(v.to_s)}"}.join('&')
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from PayConex. Please contact PayConex 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
+
+    end
+  end
+end