activemerchant 1.38.0 → 1.79.2

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

@@ -0,0 +1,209 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class VisanetPeruGateway < Gateway
+      include Empty
+      self.display_name = "VisaNet Peru Gateway"
+      self.homepage_url = "http://www.visanet.com.pe"
+
+      self.test_url = "https://devapi.vnforapps.com/api.tokenization/api/v2/merchant"
+      self.live_url = "https://api.vnforapps.com/api.tokenization/api/v2/merchant"
+
+      self.supported_countries = ["US", "PE"]
+      self.default_currency = "PEN"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+
+      def initialize(options={})
+        requires!(options, :access_key_id, :secret_access_key, :merchant_id)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run() do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        params = {}
+
+        add_invoice(params, amount, options)
+        add_payment_method(params, payment_method)
+        add_antifraud_data(params, options)
+        params[:email] = options[:email] || 'unknown@email.com'
+        params[:createAlias] = false
+
+        commit("authorize", params)
+      end
+
+      def capture(authorization, options={})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit("deposit", params)
+      end
+
+      def void(authorization, options={})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit("void", params)
+      end
+
+      def refund(amount, authorization, options={})
+        params = {}
+        add_auth_order_id(params, authorization, options)
+        commit("cancelDeposit", params)
+      end
+
+      def verify(credit_card, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, credit_card, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((\"cardNumber\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv2Code\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      CURRENCY_CODES = Hash.new{|h,k| raise ArgumentError.new("Unsupported currency: #{k}")}
+      CURRENCY_CODES["USD"] = 840
+      CURRENCY_CODES["PEN"] = 604
+
+      def add_invoice(params, money, options)
+        # Visanet Peru expects a 9-digit numeric purchaseNumber
+        params[:purchaseNumber] = (SecureRandom.random_number(900_000_000) + 100_000_000).to_s
+        params[:externalTransactionId] = options[:order_id]
+        params[:amount] = amount(money)
+        params[:currencyId] = CURRENCY_CODES[options[:currency] || currency(money)]
+      end
+
+      def add_auth_order_id(params, authorization, options)
+        params[:purchaseNumber] = authorization
+        params[:externalTransactionId] = options[:order_id]
+      end
+
+      def add_payment_method(params, payment_method)
+        params[:firstName] = payment_method.first_name
+        params[:lastName] = payment_method.last_name
+        params[:cardNumber] = payment_method.number
+        params[:cvv2Code] = payment_method.verification_value
+        params[:expirationYear] = format(payment_method.year, :four_digits)
+        params[:expirationMonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_antifraud_data(params, options)
+        antifraud = {}
+
+        if billing_address = options[:billing_address] || options[:address]
+          antifraud[:billTo_street1] = billing_address[:address1]
+          antifraud[:billTo_city] = billing_address[:city]
+          antifraud[:billTo_state] = billing_address[:state]
+          antifraud[:billTo_country] = billing_address[:country]
+          antifraud[:billTo_postalCode] = billing_address[:zip]
+        end
+
+        antifraud[:deviceFingerprintId] = options[:device_fingerprint_id] || SecureRandom.hex(16)
+        antifraud[:merchantDefineData] = options[:merchant_define_data] if options[:merchant_define_data]
+
+        params[:antifraud] = antifraud
+      end
+
+      def commit(action, params)
+        begin
+          raw_response = ssl_request(method(action), url(action, params), params.to_json, headers)
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response_error(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          Response.new(
+            success_from(response),
+            message_from(response),
+            response,
+            :test => test?,
+            :authorization => authorization_from(params),
+            :error_code => response["errorCode"]
+          )
+        end
+      end
+
+      def headers
+        {
+          "Authorization" => "Basic " + Base64.strict_encode64("#{@options[:access_key_id]}:#{@options[:secret_access_key]}").strip,
+          "Content-Type"  => "application/json"
+        }
+      end
+
+      def url(action, params)
+        if (action == "authorize")
+          "#{base_url}/#{@options[:merchant_id]}"
+        else
+          "#{base_url}/#{@options[:merchant_id]}/#{action}/#{params[:purchaseNumber]}"
+        end
+      end
+
+      def method(action)
+        (action == "authorize") ? :post : :put
+      end
+
+      def authorization_from(params)
+        params[:purchaseNumber]
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        response["errorCode"] == 0
+      end
+
+      def message_from(response)
+        if empty?(response["errorMessage"]) || response["errorMessage"] == "[ ]"
+          response["data"]["DSC_COD_ACCION"]
+        else
+          response["errorMessage"]
+        end
+      end
+
+      def response_error(raw_response)
+        begin
+          response = parse(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          return Response.new(
+            false,
+            message_from(response),
+            response,
+            :test => test?,
+            :authorization => response["transactionUUID"],
+            :error_code => response["errorCode"]
+          )
+        end
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from VisanetPeruGateway. Please contact VisanetPeruGateway 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

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

@@ -13,25 +13,23 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://webpay.jp/'
       self.display_name = 'WebPay'
 
-      def authorize(money, credit_card, options = {})
-        raise NotImplementedError.new
-      end
-
-      def capture(money, credit_card, options = {})
-        raise NotImplementedError.new
+      def capture(money, authorization, options = {})
+        post = {}
+        add_amount(post, money, options)
+        add_application_fee(post, options)
+        commit(:post, "charges/#{CGI.escape(authorization)}/capture", post)
       end
 
       def refund(money, identification, options = {})
-        post = {:amount => localized_amount(money)}
-        commit_options = generate_meta(options)
-
+        post = {}
+        add_amount(post, money, options)
         MultiResponse.run do |r|
-          r.process { commit(:post, "charges/#{CGI.escape(identification)}/refund", post, commit_options) }
+          r.process { commit(:post, "charges/#{CGI.escape(identification)}/refund", post, options) }
 
           return r unless options[:refund_fee_amount]
 
-          r.process { fetch_application_fees(identification, commit_options) }
-          r.process { refund_application_fee(options[:refund_fee_amount], application_fee_from_response(r), commit_options) }
+          r.process { fetch_application_fees(identification, options) }
+          r.process { refund_application_fee(options[:refund_fee_amount], application_fee_from_response(r), options) }
         end
       end
 
@@ -39,13 +37,41 @@ module ActiveMerchant #:nodoc:
         raise NotImplementedError.new
       end
 
-      def localized_amount(money, currency = self.default_currency)
-        non_fractional_currency?(currency) ? (amount(money).to_f / 100).floor : amount(money)
+      def add_customer(post, creditcard, options)
+        post[:customer] = options[:customer] if options[:customer] && !creditcard.respond_to?(:number)
       end
 
-      def add_amount(post, money, options)
-        post[:currency] = (options[:currency] || currency(money)).downcase
-        post[:amount] = localized_amount(money, post[:currency].upcase)
+      def store(creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard, options)
+        post[:description] = options[:description]
+        post[:email] = options[:email]
+
+        if options[:customer]
+          MultiResponse.run(:first) do |r|
+            r.process { commit(:post, "customers/#{CGI.escape(options[:customer])}/", post, options) }
+
+            return r unless options[:set_default] and r.success? and !r.params["id"].blank?
+
+            r.process { update_customer(options[:customer], :default_card => r.params["id"]) }
+          end
+        else
+          commit(:post, 'customers', post, options)
+        end
+      end
+
+      def update(customer_id, creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard, options)
+        commit(:post, "customers/#{CGI.escape(customer_id)}", post, options)
+      end
+
+      private
+
+      def create_post_for_auth_or_purchase(money, creditcard, options)
+        stripe_post = super
+        stripe_post[:description] ||= stripe_post.delete(:metadata).try(:[], :email)
+        stripe_post
       end
 
       def json_error(raw_response)
@@ -59,20 +85,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def headers(options = {})
-        @@ua ||= JSON.dump({
-          :bindings_version => ActiveMerchant::VERSION,
-          :lang => 'ruby',
-          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
-          :platform => RUBY_PLATFORM,
-          :publisher => 'active_merchant',
-          :uname => (RUBY_PLATFORM =~ /linux|darwin/i ? `uname -a 2>/dev/null`.strip : nil)
-        })
-
         {
           "Authorization" => "Basic " + Base64.encode64(@api_key.to_s + ":").strip,
           "User-Agent" => "Webpay/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
-          "X-Webpay-Client-User-Agent" => @@ua,
-          "X-Webpay-Client-User-Metadata" => options[:meta].to_json
+          "X-Webpay-Client-User-Agent" => user_agent,
+          "X-Webpay-Client-User-Metadata" => {:ip => options[:ip]}.to_json
         }
       end
     end

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

@@ -0,0 +1,238 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WepayGateway < Gateway
+      self.test_url = 'https://stage.wepayapi.com/v2'
+      self.live_url = 'https://wepayapi.com/v2'
+
+      self.supported_countries = ['US', 'CA']
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'https://www.wepay.com/'
+      self.default_currency = 'USD'
+      self.display_name = 'WePay'
+
+      def initialize(options = {})
+        requires!(options, :client_id, :account_id, :access_token)
+        super(options)
+      end
+
+      def purchase(money, payment_method, options = {})
+        post = {}
+        if payment_method.is_a?(String)
+          MultiResponse.run do |r|
+            r.process { authorize_with_token(post, money, payment_method, options) }
+            r.process { capture(money, r.authorization, options) }
+          end
+        else
+          MultiResponse.run do |r|
+            r.process { store(payment_method, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
+            r.process { capture(money, r.authorization, options) }
+          end
+        end
+      end
+
+      def authorize(money, payment_method, options = {})
+        post = {}
+        if payment_method.is_a?(String)
+          authorize_with_token(post, money, payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { store(payment_method, options) }
+            r.process { authorize_with_token(post, money, r.authorization, options) }
+          end
+        end
+      end
+
+      def capture(money, identifier, options = {})
+        checkout_id, original_amount = split_authorization(identifier)
+
+        post = {}
+        post[:checkout_id] = checkout_id
+        if(money && (original_amount != amount(money)))
+          post[:amount] = amount(money)
+        end
+        commit('/checkout/capture', post, options)
+      end
+
+      def void(identifier, options = {})
+        post = {}
+        post[:checkout_id] = split_authorization(identifier).first
+        post[:cancel_reason] = (options[:description] || "Void")
+        commit('/checkout/cancel', post, options)
+      end
+
+      def refund(money, identifier, options = {})
+        checkout_id, original_amount = split_authorization(identifier)
+
+        post = {}
+        post[:checkout_id] = checkout_id
+        if(money && (original_amount != amount(money)))
+          post[:amount] = amount(money)
+        end
+        post[:refund_reason] = (options[:description] || "Refund")
+        post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
+        post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
+        commit("/checkout/refund", post, options)
+      end
+
+      def store(creditcard, options = {})
+        post = {}
+        post[:client_id] = @options[:client_id]
+        post[:user_name] = "#{creditcard.first_name} #{creditcard.last_name}"
+        post[:email] = options[:email] || "unspecified@example.com"
+        post[:cc_number] = creditcard.number
+        post[:cvv] = creditcard.verification_value unless options[:recurring]
+        post[:expiration_month] = creditcard.month
+        post[:expiration_year] = creditcard.year
+
+        if(billing_address = (options[:billing_address] || options[:address]))
+          post[:address] = {}
+          post[:address]["address1"] = billing_address[:address1] if billing_address[:address1]
+          post[:address]["city"]     = billing_address[:city] if billing_address[:city]
+          post[:address]["country"]  = billing_address[:country]  if billing_address[:country]
+          post[:address]["region"]   = billing_address[:state]  if billing_address[:state]
+          post[:address]["postal_code"] = billing_address[:zip]
+        end
+
+        if options[:recurring] == true
+          post[:client_secret] = @options[:client_secret]
+          commit('/credit_card/transfer', post, options)
+        else
+          post[:original_device] = options[:device_fingerprint] if options[:device_fingerprint]
+          post[:original_ip] = options[:ip] if options[:ip]
+          commit('/credit_card/create', post, options)
+        end
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((\\?"cc_number\\?":\\?")[^\\"]+(\\?"))i, '\1[FILTERED]\2').
+          gsub(%r((\\?"cvv\\?":\\?")[^\\"]+(\\?"))i, '\1[FILTERED]\2').
+          gsub(%r((Authorization: Bearer )\w+)i, '\1[FILTERED]\2')
+      end
+
+      private
+
+      def authorize_with_token(post, money, token, options)
+        add_token(post, token)
+        add_product_data(post, money, options)
+        commit('/checkout/create', post, options)
+      end
+
+      def add_product_data(post, money, options)
+        post[:account_id] = @options[:account_id]
+        post[:amount] = amount(money)
+        post[:short_description] = (options[:description] || "Purchase")
+        post[:type] = (options[:type] || "goods")
+        post[:currency] = (options[:currency] || currency(money))
+        post[:long_description] = options[:long_description] if options[:long_description]
+        post[:payer_email_message] = options[:payer_email_message] if options[:payer_email_message]
+        post[:payee_email_message] = options[:payee_email_message] if options[:payee_email_message]
+        post[:reference_id] = options[:order_id] if options[:order_id]
+        post[:unique_id] = options[:unique_id] if options[:unique_id]
+        post[:redirect_uri] = options[:redirect_uri] if options[:redirect_uri]
+        post[:callback_uri] = options[:callback_uri] if options[:callback_uri]
+        post[:fallback_uri] = options[:fallback_uri] if options[:fallback_uri]
+        post[:require_shipping] = options[:require_shipping] if options[:require_shipping]
+        post[:shipping_fee] = options[:shipping_fee] if options[:shipping_fee]
+        post[:charge_tax] = options[:charge_tax] if options[:charge_tax]
+        post[:mode] = options[:mode] if options[:mode]
+        post[:preapproval_id] = options[:preapproval_id] if options[:preapproval_id]
+        post[:prefill_info] = options[:prefill_info] if options[:prefill_info]
+        post[:funding_sources] = options[:funding_sources] if options[:funding_sources]
+        post[:payer_rbits] = options[:payer_rbits] if options[:payer_rbits]
+        post[:transaction_rbits] = options[:transaction_rbits] if options[:transaction_rbits]
+        add_fee(post, options)
+      end
+
+      def add_token(post, token)
+        payment_method = {}
+        payment_method[:type] = "credit_card"
+        payment_method[:credit_card] = {
+          id: token,
+          auto_capture: false
+        }
+
+        post[:payment_method] = payment_method
+      end
+
+      def add_fee(post, options)
+        if options[:application_fee] || options[:fee_payer]
+          post[:fee] = {}
+          post[:fee][:app_fee] = options[:application_fee] if options[:application_fee]
+          post[:fee][:fee_payer] = options[:fee_payer] if options[:fee_payer]
+        end
+      end
+
+      def parse(response)
+        JSON.parse(response)
+      end
+
+      def commit(action, params, options={})
+        begin
+          response = parse(ssl_post(
+            ((test? ? test_url : live_url) + action),
+            params.to_json,
+            headers(options)
+          ))
+        rescue ResponseError => e
+          response = parse(e.response.body)
+        end
+
+        return Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, params),
+          test: test?
+        )
+
+      rescue JSON::ParserError
+        return unparsable_response(response)
+      end
+
+      def success_from(response)
+        (!response["error"])
+      end
+
+      def message_from(response)
+        (response["error"] ? response["error_description"] : "Success")
+      end
+
+      def authorization_from(response, params)
+        return response["credit_card_id"].to_s if response["credit_card_id"]
+
+        original_amount = response["amount"].nil? ? nil : sprintf("%0.02f", response["amount"])
+        [response["checkout_id"], original_amount].join('|')
+      end
+
+      def split_authorization(authorization)
+        auth, original_amount = authorization.to_s.split("|")
+        [auth, original_amount]
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from WePay. Please contact WePay support 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 headers(options)
+        headers = {
+          "Content-Type"      => "application/json",
+          "User-Agent"        => "ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
+          "Authorization"     => "Bearer #{@options[:access_token]}"
+        }
+        headers["Api-Version"] = options[:version] if options[:version]
+        headers["Client-IP"] = options[:ip] if options[:ip]
+        headers["WePay-Risk-Token"] = options[:risk_token] if options[:risk_token]
+
+        headers
+      end
+    end
+  end
+end