activemerchant-nsp 1.27.0

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

@@ -0,0 +1,155 @@
+require 'net/http'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Paypal
+        # Parser and handler for incoming Instant payment notifications from paypal. 
+        # The Example shows a typical handler in a rails application. Note that this
+        # is an example, please read the Paypal API documentation for all the details
+        # on creating a safe payment controller.
+        #
+        # Example
+        #  
+        #   class BackendController < ApplicationController
+        #     include ActiveMerchant::Billing::Integrations
+        #
+        #     def paypal_ipn
+        #       notify = Paypal::Notification.new(request.raw_post)
+        #   
+        #       order = Order.find(notify.item_id)
+        #     
+        #       if notify.acknowledge 
+        #         begin
+        #           
+        #           if notify.complete? and order.total == notify.amount
+        #             order.status = 'success' 
+        #             
+        #             shop.ship(order)
+        #           else
+        #             logger.error("Failed to verify Paypal's notification, please investigate")
+        #           end
+        #   
+        #         rescue => e
+        #           order.status        = 'failed'      
+        #           raise
+        #         ensure
+        #           order.save
+        #         end
+        #       end
+        #   
+        #       render :nothing
+        #     end
+        #   end
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+          include PostsData
+          
+          # Was the transaction complete?
+          def complete?
+            status == "Completed"
+          end
+
+          # When was this payment received by the client. 
+          # sometimes it can happen that we get the notification much later. 
+          # One possible scenario is that our web application was down. In this case paypal tries several 
+          # times an hour to inform us about the notification
+          def received_at
+            parsed_time_fields = DateTime._strptime(params['payment_date'], "%H:%M:%S %b %d, %Y %z")
+            Time.mktime(*parsed_time_fields.values_at(:year, :mon, :mday, :hour, :min, :sec, :zone))
+          end
+
+          # Status of transaction. List of possible values:
+          # <tt>Canceled-Reversal</tt>::
+          # <tt>Completed</tt>::
+          # <tt>Denied</tt>::
+          # <tt>Expired</tt>::
+          # <tt>Failed</tt>::
+          # <tt>In-Progress</tt>::
+          # <tt>Partially-Refunded</tt>::
+          # <tt>Pending</tt>::
+          # <tt>Processed</tt>::
+          # <tt>Refunded</tt>::
+          # <tt>Reversed</tt>::
+          # <tt>Voided</tt>::
+          def status
+            params['payment_status']
+          end
+
+          # Id of this transaction (paypal number)
+          def transaction_id
+            params['txn_id']
+          end
+
+          # What type of transaction are we dealing with? 
+          #  "cart" "send_money" "web_accept" are possible here. 
+          def type
+            params['txn_type']
+          end
+
+          # the money amount we received in X.2 decimal.
+          def gross
+            params['mc_gross']
+          end
+
+          # the markup paypal charges for the transaction
+          def fee
+            params['mc_fee']
+          end
+
+          # What currency have we been dealing with
+          def currency
+            params['mc_currency']
+          end
+
+          # This is the item number which we submitted to paypal 
+          # The custom field is also mapped to item_id because PayPal
+          # doesn't return item_number in dispute notifications
+          def item_id
+            params['item_number'] || params['custom']
+          end
+
+          # This is the invoice which you passed to paypal 
+          def invoice
+            params['invoice']
+          end   
+
+          # Was this a test transaction?
+          def test?
+            params['test_ipn'] == '1'
+          end
+          
+          def account
+            params['business'] || params['receiver_email']
+          end
+
+          # Acknowledge the transaction to paypal. This method has to be called after a new 
+          # ipn arrives. Paypal will verify that all the information we received are correct and will return a 
+          # ok or a fail. 
+          # 
+          # Example:
+          # 
+          #   def paypal_ipn
+          #     notify = PaypalNotification.new(request.raw_post)
+          #
+          #     if notify.acknowledge 
+          #       ... process order ... if notify.complete?
+          #     else
+          #       ... log possible hacking attempt ...
+          #     end
+          def acknowledge
+            payload =  raw
+
+            response = ssl_post(Paypal.service_url + '?cmd=_notify-validate', payload, 
+              'Content-Length' => "#{payload.size}",
+              'User-Agent'     => "Active Merchant -- http://activemerchant.org"
+            )
+            
+            raise StandardError.new("Faulty paypal result: #{response}") unless ["VERIFIED", "INVALID"].include?(response)
+
+            response == "VERIFIED"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/paypal/return.rb

@@ -0,0 +1,10 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Paypal
+        class Return < ActiveMerchant::Billing::Integrations::Return
+	      end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module ActiveMerchant
+  module Billing
+    module Integrations
+      module PaypalPaymentsAdvanced
+        autoload :Helper, 'active_merchant/billing/integrations/paypal_payments_advanced/helper.rb'
+
+        mattr_accessor :service_url
+        self.service_url = 'https://payflowlink.paypal.com'
+
+        def self.notification(post, options = {})
+          PayflowLink::Notification.new(post)
+        end
+
+        def self.return(query_string, options = {})
+          Return.new(query_string)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ActiveMerchant
+  module Billing
+    module Integrations
+      module PaypalPaymentsAdvanced
+        class Helper < PayflowLink::Helper
+
+          def initialize(order, account, options)
+            super
+            add_field('partner', 'PayPal')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Pxpay
+        autoload :Helper, 'active_merchant/billing/integrations/pxpay/helper.rb'
+        autoload :Notification, 'active_merchant/billing/integrations/pxpay/notification.rb'
+        autoload :Return, 'active_merchant/billing/integrations/pxpay/return.rb'
+
+        TOKEN_URL = 'https://sec.paymentexpress.com/pxpay/pxaccess.aspx'
+
+        LIVE_URL = 'https://sec.paymentexpress.com/pxpay/pxpay.aspx'
+
+        def self.token_url
+          TOKEN_URL
+        end
+
+        def self.service_url
+          LIVE_URL
+        end
+
+        def self.notification(post, options={})
+          Notification.new(post, options)
+        end
+
+        def self.return(query_string, options={})
+          Return.new(query_string, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'active_support/core_ext/float/rounding.rb' # Float#round(precision)
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Pxpay
+        # An example. Note the username as a parameter and transaction key you
+        # will want to use later. The amount that you pass in will be *rounded*,
+        # so preferably pass in X.2 decimal so that no rounding occurs.  You need
+        # to set :credential2 to your PxPay secret key.
+        #
+        # PxPay accounts have Failproof Notification enabled by default which means
+        # in addition to the user being redirected to your return_url, the return_url will
+        # be accessed by the PxPay servers directly, immediately after transaction success.
+        #
+        #  payment_service_for('order_id', 'pxpay_user_ID', :service => :pxpay, 
+        #                       :amount => 157.0, :currency => 'USD', :credential2 => 'pxpay_key') do |service|
+        #
+        #   service.customer :email => 'customer@email.com'
+        #
+        #   service.description 'Order 123 for MyStore'
+        #
+        #   # Must specify both a return_url or PxPay will show an error instead of
+        #   # capturing credit card details.
+        #
+        #   service.return_url "http://t/pxpay/payment_received_notification_sub_step"
+        #
+        #   # These fields will be copied verbatim to the Notification
+        #   service.custom1 'custom text 1'
+        #   service.custom2 ''
+        #   service.custom3 ''
+        #   # See the helper.rb file for various custom fields
+        # end
+
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+          include PostsData
+          mapping :account, 'PxPayUserId'
+          mapping :credential2, 'PxPayKey'
+          mapping :currency, 'CurrencyInput'
+          mapping :description, 'MerchantReference'
+          mapping :order, 'TxnId'
+          mapping :customer, :email => 'EmailAddress'
+
+          mapping :custom1, 'TxnData1'
+          mapping :custom2, 'TxnData2'
+          mapping :custom3, 'TxnData3'
+
+          def initialize(order, account, options = {})
+            super
+            add_field 'AmountInput', "%.2f" % options[:amount].to_f.round(2)
+            add_field 'EnableAddBillCard', '0'
+            add_field 'TxnType', 'Purchase'
+          end
+
+          def return_url(url)
+            add_field 'UrlSuccess', url
+            add_field 'UrlFail', url
+          end
+
+          def form_fields
+            # if either return URLs are blank PxPay will generate a token but redirect user to error page.
+            raise "error - must specify return_url" if @fields['UrlSuccess'].blank?
+            raise "error - must specify cancel_return_url" if @fields['UrlFail'].blank?
+
+            result = request_secure_redirect
+            raise "error - failed to get token - message was #{result[:redirect]}" unless result[:valid] == "1"
+
+            url = URI.parse(result[:redirect])
+
+            CGI.parse(url.query)
+          end
+
+          def form_method
+            "GET"
+          end
+
+          private
+          def generate_request
+            xml = REXML::Document.new
+            root = xml.add_element('GenerateRequest')
+
+            @fields.each do | k, v |
+              root.add_element(k).text = v
+            end
+
+            xml.to_s
+          end
+
+          def request_secure_redirect
+            request = generate_request
+
+            response = ssl_post(Pxpay.token_url, request)
+            xml = REXML::Document.new(response)
+            root = REXML::XPath.first(xml, "//Request")
+            valid = root.attributes["valid"]
+            redirect = root.elements["URI"].text
+
+            # example positive response:
+            # <Request valid="1"><URI>https://sec.paymentexpress.com/pxpay/pxpay.aspx?userid=PxpayUser&amp;request=REQUEST_TOKEN</URI></Request>
+
+            # example negative response:
+            # <Request valid="0"><URI>Invalid TxnType</URI></Request>
+
+            {:valid => valid, :redirect => redirect}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+
+      module Pxpay
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+          include PostsData
+          include RequiresParameters
+
+          def initialize(query_string, options={})
+            # PxPay appends ?result=...&userid=... to whatever return_url was specified, even if that URL ended with a ?query.
+            # So switch the first ? if present to a &
+            query_string[/\?/] = '&' if query_string[/\?/]
+            super
+
+            @encrypted_params = @params
+            @params = {}
+
+            requires! @encrypted_params, "result"
+            requires! @options, :credential1, :credential2
+
+            decrypt_transaction_result(@encrypted_params["result"])
+          end
+
+          # was the notification a validly formed request?
+          def acknowledge
+            @valid == '1'
+          end
+
+          def status
+            return 'Failed' unless success?
+            return 'Completed' if complete?
+            'Error'
+          end
+
+          def complete?
+            @params['TxnType'] == 'Purchase' && success?
+          end
+
+          def cancelled?
+            !success?
+          end
+
+          # for field definitions see
+          # http://www.paymentexpress.com/Technical_Resources/Ecommerce_Hosted/PxPay
+
+          def success?
+            @params['Success'] == '1'
+          end
+
+          def gross
+            @params['AmountSettlement']
+          end
+
+          def currency
+            @params['CurrencySettlement']
+          end
+
+          def account
+            @params['userid']
+          end
+
+          def item_id
+            @params['TxnId']
+          end
+
+          def currency_input
+            @params['CurrencyInput']
+          end
+
+          def auth_code
+            @params['AuthCode']
+          end
+
+          def card_type
+            @params['CardName']
+          end
+
+          def card_holder_name
+            @params['CardHolderName']
+          end
+
+          def card_number
+            @params['CardNumber']
+          end
+
+          def expiry_date
+            @params['DateExpiry']
+          end
+
+          def client_ip
+            @params['ClientInfo']
+          end
+
+          def order_id
+            item_id
+          end
+
+          def payer_email
+            @params['EmailAddress']
+          end
+
+          def transaction_id
+            @params['DpsTxnRef']
+          end
+
+          def settlement_date
+            @params['DateSettlement']
+          end
+
+          # Indication of the uniqueness of a card number
+          def txn_mac
+            @params['TxnMac']
+          end
+
+          def message
+            @params['ResponseText']
+          end
+
+          def optional_data
+            [@params['TxnData1'],@fields['TxnData2'],@fields['TxnData3']]
+          end
+
+          # When was this payment was received by the client.
+          def received_at
+            settlement_date
+          end
+
+          # Was this a test transaction?
+          def test?
+            nil
+          end
+
+          private
+
+          def decrypt_transaction_result(encrypted_result)
+            request_xml = REXML::Document.new
+            root = request_xml.add_element('ProcessResponse')
+
+            root.add_element('PxPayUserId').text = @options[:credential1]
+            root.add_element('PxPayKey').text = @options[:credential2]
+            root.add_element('Response').text = encrypted_result
+
+            @raw = ssl_post(Pxpay.token_url, request_xml.to_s)
+
+            response_xml = REXML::Document.new(@raw)
+            root = REXML::XPath.first(response_xml)
+            @valid = root.attributes["valid"]
+            @params = {}
+            root.elements.each { |e| @params[e.name] = e.text }
+          end
+
+        end
+      end
+    end
+  end
+end