activemerchant 1.41.0 → 1.42.0

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

@@ -0,0 +1,158 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SwipeCheckoutGateway < Gateway
+      TRANSACTION_APPROVED_MSG = 'Transaction approved'
+      TRANSACTION_DECLINED_MSG = 'Transaction declined'
+
+      LIVE_URLS = {
+        'NZ' => 'https://api.swipehq.com',
+        'CA' => 'https://api.swipehq.ca'
+      }
+      self.test_url = 'https://api.swipehq.com'
+
+      TRANSACTION_API = '/createShopifyTransaction.php'
+
+      self.supported_countries = %w[ NZ CA ]
+      self.default_currency = 'NZD'
+      self.supported_cardtypes = [:visa, :master]
+      self.homepage_url = 'https://www.swipehq.com/checkout'
+      self.display_name = 'Swipe Checkout'
+      self.money_format = :dollars
+
+      # Swipe Checkout requires the merchant's email and API key for authorization.
+      # This can be found under Settings > API Credentials after logging in to your
+      # Swipe Checkout merchant console at https://merchant.swipehq.[com|ca]
+      #
+      # :region determines which Swipe URL is used, this can be one of "NZ" or "CA".
+      # Currently Swipe Checkout has New Zealand and Canadian domains (swipehq.com
+      # and swipehq.ca respectively). Merchants must use the region that they
+      # signed up in for authentication with their merchant ID and API key to succeed.
+      def initialize(options = {})
+        requires!(options, :login, :api_key, :region)
+        super
+      end
+
+      # Transfers funds immediately.
+      # Note that Swipe Checkout only supports purchase at this stage
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_invoice(post, options)
+        add_creditcard(post, creditcard)
+        add_customer_data(post, creditcard, options)
+        add_amount(post, money, options)
+
+        commit('sale', money, post)
+      end
+
+      private
+
+      def add_customer_data(post, creditcard, options)
+        post[:email] = options[:email]
+        post[:ip_address] = options[:ip]
+
+        address = options[:billing_address] || options[:address]
+        return if address.nil?
+
+        post[:company] = address[:company]
+
+        # groups all names after the first into the last name param
+        post[:first_name], post[:last_name] = address[:name].split(' ', 2)
+        post[:address] = "#{address[:address1]}, #{address[:address2]}"
+        post[:city] = address[:city]
+        post[:country] = address[:country]
+        post[:mobile] = address[:phone]     # API only has a "mobile" field, no "phone"
+      end
+
+      def add_invoice(post, options)
+        # store shopping-cart order ID in Swipe for merchant's records
+        post[:td_user_data] = options[:order_id] if options[:order_id]
+        post[:td_item] = options[:description] if options[:description]
+        post[:td_description] = options[:description] if options[:description]
+        post[:item_quantity] = "1"
+      end
+
+      def add_creditcard(post, creditcard)
+        post[:card_number] = creditcard.number
+        post[:card_type] = creditcard.brand
+        post[:name_on_card] = "#{creditcard.first_name} #{creditcard.last_name}"
+        post[:card_expiry] = expdate(creditcard)
+        post[:secure_number] = creditcard.verification_value
+      end
+
+      def expdate(creditcard)
+        year  = format(creditcard.year, :two_digits)
+        month = format(creditcard.month, :two_digits)
+
+        "#{month}#{year}"
+      end
+
+      def add_amount(post, money, options)
+        post[:amount] = money.to_s
+
+        post[:currency] = (options[:currency] || currency(money))
+      end
+
+      def commit(action, money, parameters)
+        case action
+        when "sale"
+          begin
+            response = call_api(TRANSACTION_API, parameters)
+
+            # response code and message params should always be present
+            code = response["response_code"]
+            message = response["message"]
+
+            if code == 200
+              result = response["data"]["result"]
+              success = (result == 'accepted' || (test? && result == 'test-accepted'))
+
+              Response.new(success,
+                success ?
+                TRANSACTION_APPROVED_MSG :
+                TRANSACTION_DECLINED_MSG,
+                response,
+                :test => test?
+              )
+            else
+              build_error_response(message, response)
+            end
+          rescue ResponseError => e
+            raw_response = e.response.body
+            build_error_response("ssl_post() with url #{url} raised ResponseError: #{e}")
+          rescue JSON::ParserError => e
+            msg = 'Invalid response received from the Swipe Checkout API. ' +
+                  'Please contact support@optimizerhq.com if you continue to receive this message.' +
+                  " (Full error message: #{e})"
+            build_error_response(msg)
+          end
+        end
+      end
+
+      def call_api(api, params=nil)
+        params ||= {}
+        params[:merchant_id] = @options[:login]
+        params[:api_key] = @options[:api_key]
+
+        # ssl_post() returns the response body as a string on success,
+        # or raises a ResponseError exception on failure
+        JSON.parse(ssl_post(url(@options[:region], api), params.to_query))
+      end
+
+      def url(region, api)
+        ((test? ? self.test_url : LIVE_URLS[region]) + api)
+      end
+
+      def build_error_response(message, params={})
+        Response.new(
+          false,
+          message,
+          params,
+          :test => test?
+        )
+      end
+    end
+  end
+end
+

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

@@ -2,20 +2,20 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
 
     class UsaEpayTransactionGateway < Gateway
-      self.test_url = 'https://sandbox.usaepay.com/gate.php'
-      self.live_url = 'https://www.usaepay.com/gate.php'
+      self.live_url = 'https://www.usaepay.com/gate'
+      self.test_url = 'https://sandbox.usaepay.com/gate'
 
-      self.supported_cardtypes = [:visa, :master, :american_express]
-      self.supported_countries = ['US']
-      self.homepage_url = 'http://www.usaepay.com/'
-      self.display_name = 'USA ePay'
+      self.supported_cardtypes  = [:visa, :master, :american_express]
+      self.supported_countries  = ['US']
+      self.homepage_url         = 'http://www.usaepay.com/'
+      self.display_name         = 'USA ePay'
 
       TRANSACTIONS = {
-        :authorization => 'authonly',
-        :purchase => 'sale',
-        :capture => 'capture',
-        :refund => 'refund',
-        :void => 'void'
+        :authorization  => 'cc:authonly',
+        :purchase       => 'cc:sale',
+        :capture        => 'cc:capture',
+        :refund         => 'cc:refund',
+        :void           => 'cc:void'
       }
 
       def initialize(options = {})
@@ -31,6 +31,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, credit_card, options)
         add_customer_data(post, options)
+        add_split_payments(post, options)
 
         commit(:authorization, post)
       end
@@ -43,6 +44,7 @@ module ActiveMerchant #:nodoc:
         add_credit_card(post, credit_card)
         add_address(post, credit_card, options)
         add_customer_data(post, options)
+        add_split_payments(post, options)
 
         commit(:purchase, post)
       end
@@ -66,7 +68,7 @@ module ActiveMerchant #:nodoc:
         commit(:void, post)
       end
 
-      private
+    private
 
       def add_amount(post, money)
         post[:amount] = amount(money)
@@ -108,16 +110,16 @@ module ActiveMerchant #:nodoc:
       def add_address_for_type(type, post, credit_card, address)
         prefix = address_key_prefix(type)
 
-        post[address_key(prefix, 'fname')] = credit_card.first_name
-        post[address_key(prefix, 'lname')] = credit_card.last_name
-        post[address_key(prefix, 'company')] = address[:company] unless address[:company].blank?
-        post[address_key(prefix, 'street')] = address[:address1] unless address[:address1].blank?
-        post[address_key(prefix, 'street2')] = address[:address2] unless address[:address2].blank?
-        post[address_key(prefix, 'city')] = address[:city] unless address[:city].blank?
-        post[address_key(prefix, 'state')] = address[:state] unless address[:state].blank?
-        post[address_key(prefix, 'zip')] = address[:zip] unless address[:zip].blank?
-        post[address_key(prefix, 'country')] = address[:country] unless address[:country].blank?
-        post[address_key(prefix, 'phone')] = address[:phone] unless address[:phone].blank?
+        post[address_key(prefix, 'fname')]    = credit_card.first_name
+        post[address_key(prefix, 'lname')]    = credit_card.last_name
+        post[address_key(prefix, 'company')]  = address[:company]   unless address[:company].blank?
+        post[address_key(prefix, 'street')]   = address[:address1]  unless address[:address1].blank?
+        post[address_key(prefix, 'street2')]  = address[:address2]  unless address[:address2].blank?
+        post[address_key(prefix, 'city')]     = address[:city]      unless address[:city].blank?
+        post[address_key(prefix, 'state')]    = address[:state]     unless address[:state].blank?
+        post[address_key(prefix, 'zip')]      = address[:zip]       unless address[:zip].blank?
+        post[address_key(prefix, 'country')]  = address[:country]   unless address[:country].blank?
+        post[address_key(prefix, 'phone')]    = address[:phone]     unless address[:phone].blank?
       end
 
       def address_key_prefix(type)
@@ -132,15 +134,29 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_invoice(post, options)
-        post[:invoice] = options[:order_id]
-        post[:description] = options[:description]
+        post[:invoice]      = options[:order_id]
+        post[:description]  = options[:description]
       end
 
       def add_credit_card(post, credit_card)
-        post[:card]  = credit_card.number
-        post[:cvv2] = credit_card.verification_value if credit_card.verification_value?
+        post[:card]   = credit_card.number
+        post[:cvv2]   = credit_card.verification_value if credit_card.verification_value?
         post[:expir]  = expdate(credit_card)
-        post[:name] = credit_card.name
+        post[:name]   = credit_card.name
+      end
+
+      # see: http://wiki.usaepay.com/developer/transactionapi#split_payments
+      def add_split_payments(post, options)
+        return unless options[:split_payments].is_a?(Array)
+        options[:split_payments].each_with_index do |payment, index|
+          prefix = '%02d' % (index + 2)
+          post["#{prefix}key"]         = payment[:key]
+          post["#{prefix}amount"]      = amount(payment[:amount])
+          post["#{prefix}description"] = payment[:description]
+        end
+
+        # When blank it's 'Stop'. 'Continue' is another one
+        post['onError'] = options[:on_error] || 'Void'
       end
 
       def parse(body)
@@ -151,32 +167,32 @@ module ActiveMerchant #:nodoc:
         end
 
         {
-          :status => fields['UMstatus'],
-          :auth_code => fields['UMauthCode'],
-          :ref_num => fields['UMrefNum'],
-          :batch => fields['UMbatch'],
-          :avs_result => fields['UMavsResult'],
-          :avs_result_code => fields['UMavsResultCode'],
-          :cvv2_result => fields['UMcvv2Result'],
+          :status           => fields['UMstatus'],
+          :auth_code        => fields['UMauthCode'],
+          :ref_num          => fields['UMrefNum'],
+          :batch            => fields['UMbatch'],
+          :avs_result       => fields['UMavsResult'],
+          :avs_result_code  => fields['UMavsResultCode'],
+          :cvv2_result      => fields['UMcvv2Result'],
           :cvv2_result_code => fields['UMcvv2ResultCode'],
           :vpas_result_code => fields['UMvpasResultCode'],
-          :result => fields['UMresult'],
-          :error => fields['UMerror'],
-          :error_code => fields['UMerrorcode'],
-          :acs_url => fields['UMacsurl'],
-          :payload => fields['UMpayload']
+          :result           => fields['UMresult'],
+          :error            => fields['UMerror'],
+          :error_code       => fields['UMerrorcode'],
+          :acs_url          => fields['UMacsurl'],
+          :payload          => fields['UMpayload']
         }.delete_if{|k, v| v.nil?}
       end
 
       def commit(action, parameters)
-        url = (self.test? ? self.test_url : self.live_url)
-        response = parse( ssl_post(url, post_data(action, parameters)) )
+        url = (test? ? self.test_url : self.live_url)
+        response = parse(ssl_post(url, post_data(action, parameters)))
 
         Response.new(response[:status] == 'Approved', message_from(response), response,
-          :test => test?,
-          :authorization => response[:ref_num],
-          :cvv_result => response[:cvv2_result_code],
-          :avs_result => { :code => response[:avs_result_code] }
+          :test           => test?,
+          :authorization  => response[:ref_num],
+          :cvv_result     => response[:cvv2_result_code],
+          :avs_result     => { :code => response[:avs_result_code] }
         )
       end
 
@@ -191,7 +207,7 @@ module ActiveMerchant #:nodoc:
 
       def post_data(action, parameters = {})
         parameters[:command]  = TRANSACTIONS[action]
-        parameters[:key] = @options[:login]
+        parameters[:key]      = @options[:login]
         parameters[:software] = 'Active Merchant'
         parameters[:testmode] = (@options[:test] ? 1 : 0)
 

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

@@ -68,8 +68,7 @@ module ActiveMerchant #:nodoc:
           :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)
+          :publisher => 'active_merchant'
         })
 
         {

data/lib/active_merchant/billing/integrations/bit_pay.rb

@@ -13,8 +13,8 @@ module ActiveMerchant #:nodoc:
         mattr_accessor :invoicing_url
         self.invoicing_url = 'https://bitpay.com/api/invoice'
 
-        def self.notification(post)
-          Notification.new(post)
+        def self.notification(post, options = {})
+          Notification.new(post, options)
         end
 
         def self.helper(order, account, options = {})

data/lib/active_merchant/billing/integrations/bit_pay/helper.rb

@@ -6,20 +6,14 @@ module ActiveMerchant #:nodoc:
           def initialize(order_id, account, options)
             super
             @account = account
-            add_field('orderID', order_id)
-            add_field('posData', options[:authcode])
-            add_field('currency', options[:currency])
-            add_field('fullNotifications', 'true')
-            add_field('transactionSpeed', options[:transactionSpeed] || "high")
-            add_field('address1', options[:address1])
 
-            generate_invoice_id
+            add_field('posData', {'orderId' => order_id}.to_json)
+            add_field('fullNotifications', true)
+            add_field('transactionSpeed', 'high')
           end
 
-          # Replace with the real mapping
           mapping :amount, 'price'
-
-          mapping :order, 'orderID'        
+          mapping :order, 'orderID'
           mapping :currency, 'currency'
 
           mapping :customer, :first_name => 'buyerName',
@@ -37,20 +31,20 @@ module ActiveMerchant #:nodoc:
           mapping :return_url, 'redirectURL'
           mapping :id, 'id'
 
-          def generate_invoice_id
-            invoice_data = ssl_post(BitPay.invoicing_url)
-
-            add_field('id', JSON.parse(invoice_data.body)['id'])
-          end
-
           def form_method
             "GET"
           end
 
+          def form_fields
+            invoice = create_invoice
+
+            {"id" => invoice['id']}
+          end
+
           private
 
-          def ssl_post(url, options = {})
-            uri = URI.parse(url)
+          def create_invoice
+            uri = URI.parse(BitPay.invoicing_url)
             http = Net::HTTP.new(uri.host, uri.port)
             http.use_ssl = true
 
@@ -59,7 +53,9 @@ module ActiveMerchant #:nodoc:
             request.body = @fields.to_json
             request.basic_auth @account, ''
 
-            http.request(request)
+            response = http.request(request)
+            JSON.parse(response.body)
+          rescue JSON::ParseError
           end
         end
       end

data/lib/active_merchant/billing/integrations/bit_pay/notification.rb

@@ -6,13 +6,29 @@ module ActiveMerchant #:nodoc:
       module BitPay
         class Notification < ActiveMerchant::Billing::Integrations::Notification
           def complete?
-            status == "complete"
+            status == "Completed"
           end
 
           def transaction_id
             params['id']
           end
 
+          def item_id
+            JSON.parse(params['posData'])['orderId']
+          rescue JSON::ParserError
+          end
+
+          def status
+            case params['status']
+            when 'complete'
+              'Completed'
+            when 'confirmed'
+              'Pending'
+            when 'invalid'
+              'Failed'
+            end
+          end
+
           # When was this payment received by the client.
           def received_at
             params['invoiceTime'].to_i
@@ -22,32 +38,34 @@ module ActiveMerchant #:nodoc:
             params['currency']
           end
 
-          def amount
-            params['price']
+          def gross
+            params['price'].to_f
           end
 
-          # the money amount we received in X.2 decimal.
-          def btcPrice 
-            params['btcPrice'].to_f
-          end
+          def acknowledge(authcode = nil)
+            uri = URI.parse("#{ActiveMerchant::Billing::Integrations::BitPay.invoicing_url}/#{transaction_id}")
 
-          def status
-            params['status'].downcase
-          end
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
 
-          def acknowledge(authcode = nil)
-            authcode == params['posData']
+            request = Net::HTTP::Get.new(uri.path)
+            request.basic_auth @options[:credential1], ''
+
+            response = http.request(request)
+
+            posted_json = JSON.parse(@raw).tap { |j| j.delete('currentTime') }
+            parse(response.body)
+            retrieved_json = JSON.parse(@raw).tap { |j| j.delete('currentTime') }
+
+            posted_json == retrieved_json
+          rescue JSON::ParserError
           end
 
           private
-
-          # Take the posted data and move the relevant data into a hash
-          def parse(post)
-            @raw = post.to_s
-            for line in @raw.split('&')
-              key, value = *line.scan( %r{^([A-Za-z0-9_.]+)\=(.*)$} ).flatten
-              params[key] = CGI.unescape(value)
-            end
+          def parse(body)
+            @raw = body
+            @params = JSON.parse(@raw)
+          rescue JSON::ParserError
           end
         end
       end