archetype2142_activemerchant 1.124.0

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

@@ -0,0 +1,223 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    #
+    # NETPAY Gateway
+    #
+    # Support for NETPAY's HTTP Connector payment gateway in Mexico.
+    #
+    # The gateway sends requests as HTTP POST and receives the response details
+    # in the HTTP header, making the process really rather simple.
+    #
+    # Support for calls to the authorize and capture methods have been included
+    # as per the Netpay manuals, however, your millage may vary with these
+    # methods. At the time of writing (January 2013) they were not fully
+    # supported by the production or test gateways. This situation is
+    # expected to change within a few weeks/months.
+    #
+    # Purchases can be cancelled (`#void`) only within 24 hours of the
+    # transaction. After this, a refund should be performed instead.
+    #
+    # In addition to the regular ActiveMerchant transaction options, NETPAY
+    # also supports a `:mode` parameter. This allows testing to be performed
+    # in production and force specific results.
+    #
+    #  * 'P' - Production
+    #  * 'A' - Approved
+    #  * 'D' - Declined
+    #  * 'R' - Random (Approved or Declined)
+    #  * 'T' - Test
+    #
+    # For example:
+    #
+    #     response = @gateway.purchase(1000, card, :mode => 'D')
+    #     response.success  # false
+    #
+    class NetpayGateway < Gateway
+      self.test_url = 'http://200.57.87.243:8855'
+      self.live_url = 'https://suite.netpay.com.mx/acquirerprd'
+
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      self.supported_countries = ['MX']
+
+      self.default_currency = 'MXN'
+
+      # The card types supported by the payment gateway
+      self.supported_cardtypes = %i[visa master american_express diners_club]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.netpay.com.mx'
+
+      # The name of the gateway
+      self.display_name = 'NETPAY Gateway'
+
+      CURRENCY_CODES = {
+        'MXN' => '484'
+      }
+
+      # The header keys that we will provide in the response params hash
+      RESPONSE_KEYS = %w[ResponseMsg ResponseText ResponseCode TimeIn TimeOut AuthCode OrderId CardTypeName MerchantId IssuerAuthDate]
+
+      def initialize(options = {})
+        requires!(options, :store_id, :login, :password)
+        super
+      end
+
+      # Send an authorization request
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+
+        commit('PreAuth', post, options)
+      end
+
+      # Capture an authorization
+      def capture(money, authorization, options = {})
+        post = {}
+        add_order_id(post, order_id_from(authorization))
+        add_amount(post, money, options)
+
+        commit('PostAuth', post, options)
+      end
+
+      # Cancel an auth/purchase within first 24 hours
+      def void(authorization, options = {})
+        post = {}
+        order_id, amount, currency = split_authorization(authorization)
+        add_order_id(post, order_id)
+        post['Total'] = (options[:amount] || amount)
+        post['CurrencyCode'] = currency
+
+        commit('Refund', post, options)
+      end
+
+      # Make a purchase.
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, options)
+        add_amount(post, money, options)
+
+        commit('Auth', post, options)
+      end
+
+      # Perform a Credit transaction.
+      def refund(money, authorization, options = {})
+        post = {}
+        add_order_id(post, order_id_from(authorization))
+        add_amount(post, money, options)
+
+        commit('Credit', post, options)
+      end
+
+      private
+
+      def add_login_data(post)
+        post['StoreId']     = @options[:store_id]
+        post['UserName']    = @options[:login]
+        post['Password']    = @options[:password]
+      end
+
+      def add_action(post, action, options)
+        post['ResourceName'] = action
+        post['ContentType']  = 'Transaction'
+        post['Mode']         = options[:mode] || 'P'
+      end
+
+      def add_order_id(post, order_id)
+        post['OrderId'] = order_id
+      end
+
+      def add_amount(post, money, options)
+        post['Total'] = amount(money)
+        post['CurrencyCode'] = currency_code(options[:currency] || currency(money))
+      end
+
+      def add_customer_data(post, options)
+        post['IPAddress'] = options[:ip] unless options[:ip].blank?
+      end
+
+      def add_invoice(post, options)
+        post['Comments'] = options[:description] if options[:description]
+      end
+
+      def add_creditcard(post, creditcard)
+        post['CardNumber']   = creditcard.number
+        post['ExpDate']      = expdate(creditcard)
+        post['CustomerName'] = creditcard.name
+        post['CVV2']         = creditcard.verification_value unless creditcard.verification_value.nil?
+      end
+
+      def build_authorization(request_params, response_params)
+        [response_params['OrderId'], request_params['Total'], request_params['CurrencyCode']].join('|')
+      end
+
+      def split_authorization(authorization)
+        order_id, amount, currency = authorization.split('|')
+        [order_id, amount, currency]
+      end
+
+      def order_id_from(authorization)
+        split_authorization(authorization).first
+      end
+
+      def expdate(credit_card)
+        year  = sprintf('%.4i', credit_card.year)
+        month = sprintf('%.2i', credit_card.month)
+
+        "#{month}/#{year[-2..-1]}"
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(response, request_params)
+        response_params = params_from_response(response)
+
+        success = (response_params['ResponseCode'] == '00')
+        message = response_params['ResponseText'] || response_params['ResponseMsg']
+        options = @options.merge(test: test?,
+                                 authorization: build_authorization(request_params, response_params))
+
+        Response.new(success, message, response_params, options)
+      end
+
+      def commit(action, parameters, options)
+        add_login_data(parameters)
+        add_action(parameters, action, options)
+
+        post = parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+        parse(ssl_post(url, post), parameters)
+      end
+
+      # Override the regular handle response so we can access the headers
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300
+          response
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
+      # Return a hash containing all the useful, or informative values from netpay
+      def params_from_response(response)
+        params = {}
+        RESPONSE_KEYS.each do |k|
+          params[k] = response[k] unless response[k].to_s.empty?
+        end
+        params
+      end
+
+      def currency_code(currency)
+        return currency if currency =~ /^\d+$/
+
+        CURRENCY_CODES[currency]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,238 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetworkMerchantsGateway < Gateway
+      self.live_url = self.test_url = 'https://secure.networkmerchants.com/api/transact.php'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'http://www.nmi.com/'
+      self.display_name = 'Network Merchants (NMI)'
+
+      self.money_format = :dollars
+      self.default_currency = 'USD'
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(money, creditcard_or_vault_id, options = {})
+        post = build_auth_post(money, creditcard_or_vault_id, options)
+        commit('auth', post)
+      end
+
+      def purchase(money, creditcard_or_vault_id, options = {})
+        post = build_purchase_post(money, creditcard_or_vault_id, options)
+        commit('sale', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = build_capture_post(money, authorization, options)
+        commit('capture', post)
+      end
+
+      def void(authorization, options = {})
+        post = build_void_post(authorization, options)
+        commit('void', post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = build_refund_post(money, authorization, options)
+        commit('refund', post)
+      end
+
+      def store(creditcard, options = {})
+        post = build_store_post(creditcard, options)
+        commit_vault('add_customer', post)
+      end
+
+      def unstore(customer_vault_id, options = {})
+        post = build_unstore_post(customer_vault_id, options)
+        commit_vault('delete_customer', post)
+      end
+
+      private
+
+      def build_auth_post(money, creditcard_or_vault_id, options)
+        post = {}
+        add_order(post, options)
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_vault_id, options)
+        add_amount(post, money, options)
+        post
+      end
+
+      def build_purchase_post(money, creditcard, options)
+        build_auth_post(money, creditcard, options)
+      end
+
+      def build_capture_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money, options)
+        post
+      end
+
+      def build_void_post(authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        post
+      end
+
+      def build_refund_post(money, authorization, options)
+        post = {}
+        post[:transactionid] = authorization
+        add_amount(post, money, options)
+        post
+      end
+
+      def build_store_post(creditcard_or_check, options)
+        post = {}
+        add_address(post, options)
+        add_shipping_address(post, options)
+        add_payment_method(post, creditcard_or_check, options)
+        post
+      end
+
+      def build_unstore_post(customer_vault_id, options)
+        post = {}
+        post['customer_vault_id'] = customer_vault_id
+        post
+      end
+
+      def add_order(post, options)
+        post[:orderid] = options[:order_id]
+        post[:orderdescription] = options[:description]
+      end
+
+      def add_address(post, options)
+        post[:email] = options[:email]
+        post[:ipaddress] = options[:ip]
+
+        address = options[:billing_address] || options[:address] || {}
+        post[:address1] = address[:address1]
+        post[:address2] = address[:address2]
+        post[:city] = address[:city]
+        post[:state] = address[:state].blank? ? 'n/a' : address[:state]
+        post[:zip] = address[:zip]
+        post[:country] = address[:country]
+        post[:phone] = address[:phone]
+      end
+
+      def add_shipping_address(post, options)
+        shipping_address = options[:shipping_address] || {}
+        post[:shipping_address1] = shipping_address[:address1]
+        post[:shipping_address2] = shipping_address[:address2]
+        post[:shipping_city] = shipping_address[:city]
+        post[:shipping_state] = shipping_address[:state]
+        post[:shipping_zip] = shipping_address[:zip]
+        post[:shipping_country] = shipping_address[:country]
+      end
+
+      def add_swipe_data(post, creditcard, options)
+        # unencrypted tracks
+        if creditcard.respond_to?(:track_data) && creditcard.track_data.present?
+          post[:track_1] = creditcard.track_data
+        else
+          post[:track_1] = options[:track_1]
+          post[:track_2] = options[:track_2]
+          post[:track_3] = options[:track_3]
+        end
+
+        # encrypted tracks
+        post[:magnesafe_track_1] = options[:magnesafe_track_1]
+        post[:magnesafe_track_2] = options[:magnesafe_track_2]
+        post[:magnesafe_track_3] = options[:magnesafe_track_3]
+        post[:magnesafe_magneprint] = options[:magnesafe_magneprint]
+        post[:magnesafe_ksn] = options[:magnesafe_ksn]
+        post[:magnesafe_magneprint_status] = options[:magnesafe_magneprint_status]
+      end
+
+      def add_payment_method(post, payment_source, options)
+        post[:processor_id] = options[:processor_id]
+        post[:customer_vault] = 'add_customer' if options[:store]
+
+        add_swipe_data(post, payment_source, options)
+
+        if payment_source.is_a?(Check)
+          check = payment_source
+          post[:firstname] = check.first_name
+          post[:lastname] = check.last_name
+          post[:checkname] = check.name
+          post[:checkaba] = check.routing_number
+          post[:checkaccount] = check.account_number
+          post[:account_type] = check.account_type
+          post[:account_holder_type] = check.account_holder_type
+          post[:payment] = 'check'
+        elsif payment_source.respond_to?(:number)
+          creditcard = payment_source
+          post[:firstname] = creditcard.first_name
+          post[:lastname] = creditcard.last_name
+          post[:ccnumber] = creditcard.number
+          post[:ccexp] = format(creditcard.month, :two_digits) + format(creditcard.year, :two_digits)
+          post[:cvv] = creditcard.verification_value
+          post[:payment] = 'creditcard'
+        else
+          post[:customer_vault_id] = payment_source
+        end
+      end
+
+      def add_login(post)
+        post[:username] = @options[:login]
+        post[:password] = @options[:password]
+      end
+
+      def add_amount(post, money, options)
+        post[:currency] = options[:currency] || currency(money)
+        post[:amount] = amount(money)
+      end
+
+      def commit_vault(action, parameters)
+        commit(nil, parameters.merge(customer_vault: action))
+      end
+
+      def commit(action, parameters)
+        raw = parse(ssl_post(self.live_url, build_request(action, parameters)))
+
+        success = (raw['response'] == ResponseCodes::APPROVED)
+
+        authorization = authorization_from(success, parameters, raw)
+
+        Response.new(success, raw['responsetext'], raw,
+          test: test?,
+          authorization: authorization,
+          avs_result: { code: raw['avsresponse'] },
+          cvv_result: raw['cvvresponse'])
+      end
+
+      def build_request(action, parameters)
+        parameters[:type] = action if action
+        add_login(parameters)
+        parameters.to_query
+      end
+
+      def authorization_from(success, parameters, response)
+        return nil unless success
+
+        authorization = response['transactionid']
+        authorization = response['customer_vault_id'] if parameters[:customer_vault] && (authorization.nil? || authorization.empty?)
+
+        authorization
+      end
+
+      class ResponseCodes
+        APPROVED = '1'
+        DENIED = '2'
+        ERROR = '3'
+      end
+
+      def parse(raw_response)
+        rsp = CGI.parse(raw_response)
+        rsp.keys.each { |k| rsp[k] = rsp[k].first } # flatten out the values
+        rsp
+      end
+    end
+  end
+end