koffsite_payments 3.0.0

data/lib/offsite_payments/integrations/paxum.rb

@@ -0,0 +1,114 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    # Documentation:
+    # https://www.paxum.com/payment_docs/page.php?name=apiIntroduction
+    module Paxum
+      mattr_accessor :test_url
+      self.test_url = 'https://paxum.com/payment/phrame.php?action=displayProcessPaymentLogin'
+
+      mattr_accessor :production_url
+      self.production_url = 'https://paxum.com/payment/phrame.php?action=displayProcessPaymentLogin'
+
+      mattr_accessor :signature_parameter_name
+      self.signature_parameter_name = 'key'
+
+      def self.service_url
+        mode = OffsitePayments.mode
+        case mode
+        when :production
+          self.production_url
+        when :test
+          self.test_url
+        else
+          raise StandardError, "Integration mode set to an invalid value: #{mode}"
+        end
+      end
+
+      def self.helper(order, account, options = {})
+        Helper.new(order, account, options)
+      end
+
+      def self.notification(query_string, options = {})
+        Notification.new(query_string, options)
+      end
+
+      module Common
+        def generate_signature_string
+          @raw_post.slice!(0) if @raw_post.starts_with?("&")
+          @raw_post = CGI.unescape(@raw_post)
+          @raw_post = "&#{@raw_post}" unless @raw_post.starts_with?("&")
+          arr = @raw_post.split('&')
+          arr.delete(arr.last)
+          data = arr.join('&')
+
+          (data + secret)
+        end
+
+        def generate_signature
+          Digest::MD5.hexdigest(generate_signature_string)
+        end
+      end
+
+      class Helper < OffsitePayments::Helper
+        include Common
+
+        def initialize(order, account, options = {})
+          @paxum_options = options.dup
+          options.delete(:description)
+          options.delete(:fail_url)
+          options.delete(:success_url)
+          options.delete(:result_url)
+          super
+          add_field "button_type_id", "1"
+          add_field "variables", "notify_url=#{@paxum_options[:result_url]}"
+          @paxum_options.each do |key, value|
+            add_field mappings[key], value
+          end
+        end
+
+        def form_fields
+          @fields
+        end
+
+        def params
+          @fields
+        end
+
+        mapping :account, 'business_email'
+        mapping :amount, 'amount'
+        mapping :currency, 'currency'
+        mapping :order, 'item_id'
+        mapping :description, 'item_name'
+        mapping :fail_url, 'cancel_url'
+        mapping :success_url, 'finish_url'
+        mapping :result_url, 'notify_url'
+      end
+
+      class Notification < OffsitePayments::Notification
+        include Common
+
+        def initialize(post, options = {})
+          @raw_post = post.dup
+          post.slice!(0)
+          super
+        end
+
+        def self.recognizes?(params)
+          (params.has_key?('transaction_item_id') && params.has_key?('transaction_amount'))
+        end
+
+        def security_key
+          params["key"]
+        end
+
+        def secret
+          @options[:secret]
+        end
+
+        def acknowledge(authcode = nil)
+          (security_key == generate_signature)
+        end
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/pay_fast.rb

@@ -0,0 +1,269 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    # Documentation:
+    # https://www.payfast.co.za/s/std/integration-guide
+    module PayFast
+      # Overwrite this if you want to change the PayFast sandbox url
+      mattr_accessor :process_test_url
+      self.process_test_url = 'https://sandbox.payfast.co.za/eng/process'
+
+      # Overwrite this if you want to change the PayFast production url
+      mattr_accessor :process_production_url
+      self.process_production_url = 'https://www.payfast.co.za/eng/process'
+
+      # Overwrite this if you want to change the PayFast sandbox url
+      mattr_accessor :validate_test_url
+      self.validate_test_url = 'https://sandbox.payfast.co.za/eng/query/validate'
+
+      # Overwrite this if you want to change the PayFast production url
+      mattr_accessor :validate_production_url
+      self.validate_production_url = 'https://www.payfast.co.za/eng/query/validate'
+
+      mattr_accessor :signature_parameter_name
+      self.signature_parameter_name = 'signature'
+
+      def self.service_url
+        mode = OffsitePayments.mode
+        case mode
+        when :production
+          self.process_production_url
+        when :test
+          self.process_test_url
+        else
+          raise StandardError, "Integration mode set to an invalid value: #{mode}"
+        end
+      end
+
+      def self.validate_service_url
+        mode = OffsitePayments.mode
+        case mode
+        when :production
+          self.validate_production_url
+        when :test
+          self.validate_test_url
+        else
+          raise StandardError, "Integration mode set to an invalid value: #{mode}"
+        end
+      end
+
+      def self.helper(order, account, options = {})
+        Helper.new(order, account, options)
+      end
+
+      def self.notification(query_string, options = {})
+        Notification.new(query_string, options)
+      end
+
+      def self.return(post, options = {})
+        Return.new(post, options)
+      end
+
+      module Common
+        def generate_signature(type)
+          string = case type
+          when :request
+            request_signature_string
+          when :notify
+            notify_signature_string
+          end
+
+          Digest::MD5.hexdigest(string)
+        end
+
+        def request_attributes
+          [:merchant_id, :merchant_key, :return_url, :cancel_url,
+           :notify_url, :name_first, :name_last, :email_address,
+           :payment_id, :amount, :item_name, :item_description,
+           :custom_str1, :custom_str2, :custom_str3, :custom_str4,
+           :custom_str5, :custom_int1, :custom_int2, :custom_int3,
+           :custom_int4, :custom_int5, :email_confirmation,
+           :confirmation_address]
+        end
+
+        def request_signature_string
+          request_attributes.map do |attr|
+            "#{mappings[attr]}=#{CGI.escape(@fields[mappings[attr]])}" if @fields[mappings[attr]].present?
+          end.compact.join('&')
+        end
+
+        def notify_signature_string
+          params.map do |key, value|
+            "#{key}=#{CGI.escape(value)}" unless key == PayFast.signature_parameter_name
+          end.compact.join('&')
+        end
+      end
+
+      class Helper < OffsitePayments::Helper
+        include Common
+
+        def initialize(order, account, options = {})
+          super
+          add_field('merchant_id', account)
+          add_field('merchant_key', options.delete(:credential2))
+          add_field('m_payment_id', order)
+        end
+
+        def form_fields
+          @fields
+        end
+
+        def params
+          @fields
+        end
+
+        mapping :merchant_id, 'merchant_id'
+        mapping :merchant_key, 'merchant_key'
+        mapping :return_url, 'return_url'
+        mapping :cancel_return_url, 'cancel_url'
+        mapping :notify_url, 'notify_url'
+        mapping :name_first, 'name_first'
+        mapping :name_last, 'name_last'
+        mapping :email_address, 'email_address'
+        mapping :payment_id, 'm_payment_id'
+        mapping :amount, 'amount'
+        mapping :item_name, 'item_name'
+        mapping :description, 'item_name'
+
+        mapping :customer, :first_name => 'name_first',
+                           :last_name  => 'name_last',
+                           :email      => 'email_address',
+                           :phone      => 'phone'
+
+        5.times { |i| mapping :"custom_str#{i}", "custom_str#{i}" }
+        5.times { |i| mapping :"custom_int#{i}", "custom_int#{i}" }
+
+        mapping :email_confirmation, 'email_confirmation'
+        mapping :confirmation_address, 'confirmation_address'
+      end
+
+      # Parser and handler for incoming ITN from PayFast.
+      # The Example shows a typical handler in a rails application.
+      #
+      # Example
+      #
+      #   class BackendController < ApplicationController
+      #     include OffsitePayments::Integrations
+      #
+      #     def pay_fast_itn
+      #       notify = PayFast::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 < OffsitePayments::Notification
+        include ActiveMerchant::PostsData
+        include Common
+
+        # Was the transaction complete?
+        def complete?
+          status == "Completed"
+        end
+
+        # Status of transaction. List of possible values:
+        # <tt>COMPLETE</tt>::
+        def status
+          if params['payment_status'] == "COMPLETE"
+            "Completed"
+          else
+            "Failed"
+          end
+        end
+
+        # Id of this transaction (uniq PayFast transaction id)
+        def transaction_id
+          params['pf_payment_id']
+        end
+
+        # Id of this transaction (uniq Shopify transaction id)
+        def item_id
+          params['m_payment_id']
+        end
+
+        # The total amount which the payer paid.
+        def gross
+          params['amount_gross']
+        end
+
+        # The total in fees which was deducted from the amount.
+        def fee
+          params['amount_fee']
+        end
+
+        # The net amount credited to the receiver's account.
+        def amount
+          params['amount_net']
+        end
+
+        # The name of the item being charged for.
+        def item_name
+          params['item_name']
+        end
+
+        # The Merchant ID as given by the PayFast system. Used to uniquely identify the receiver's account.
+        def merchant_id
+          params['merchant_id']
+        end
+
+        def currency
+          nil
+        end
+
+        # Generated hash depends on params order so use OrderedHash instead of Hash
+        def empty!
+          super
+          @params  = ActiveSupport::OrderedHash.new
+        end
+
+        # Acknowledge the transaction to PayFast. This method has to be called after a new
+        # ITN arrives. PayFast will verify that all the information we received are correct and will return a
+        # VERIFIED or INVALID status.
+        #
+        # Example:
+        #
+        #   def pay_fast_itn
+        #     notify = PayFastNotification.new(request.raw_post)
+        #
+        #     if notify.acknowledge
+        #       ... process order ... if notify.complete?
+        #     else
+        #       ... log possible hacking attempt ...
+        #     end
+        def acknowledge(authcode = nil)
+          if params[PayFast.signature_parameter_name] == generate_signature(:notify)
+            response = ssl_post(PayFast.validate_service_url, notify_signature_string,
+              'Content-Type' => "application/x-www-form-urlencoded",
+              'Content-Length' => "#{notify_signature_string.size}"
+            )
+            raise StandardError.new("Faulty PayFast result: #{response}") unless ['VALID', 'INVALID'].include?(response)
+
+            response == "VALID"
+          end
+        end
+      end
+
+      class Return < OffsitePayments::Return
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/pay_u_latam.rb

@@ -0,0 +1,246 @@
+require 'builder'
+
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module PayULatam
+
+      mattr_accessor :test_url
+      self.test_url = 'https://stg.api.payulatam.com/payments-api/4.0/service.cgi'
+
+      mattr_accessor :production_url
+      self.production_url = 'https://api.payulatam.com/payments-api/4.0/service.cgi'
+
+      QUERIES_API_TEST_URL = 'https://stg.api.payulatam.com/reports-api/4.0/service.cgi'
+      QUERIES_API_LIVE_URL = 'https://api.payulatam.com/reports-api/4.0/service.cgi'
+
+      QUERY_COMMANDS = {
+          :orderId       => 'ORDER_DETAIL',
+          :referenceCode => 'ORDER_DETAIL_BY_REFERENCE_CODE',
+          :transactionId => 'TRANSACTION_RESPONSE_DETAIL',
+      }
+
+      def self.service_url
+        mode = OffsitePayments.mode
+        case mode
+          when :production
+            self.production_url
+          when :test
+            self.test_url
+          else
+            raise StandardError, "Integration mode set to an invalid value: #{mode}"
+        end
+      end
+
+      def self.queries_url
+        mode = OffsitePayments.mode
+        case mode
+          when :production
+            QUERIES_API_LIVE_URL
+          when :test
+            QUERIES_API_TEST_URL
+          else
+            raise StandardError, "Integration mode set to an invalid value: #{mode}"
+        end
+      end
+
+      def self.helper(order, account, options = {})
+        Helper.new(order, account, options)
+      end
+
+      class Helper < OffsitePayments::Helper
+
+        mapping :customer,
+                :name       => 'name',
+                :email      => 'email',
+                :phone      => 'phone',
+                :dni_number => 'dniNumber'
+
+        mapping :billing_address,
+                :address1 => 'address1',
+                :city     => 'city',
+                :state    => 'state',
+                :country  => 'country'
+
+        mapping :amount, 'amount'
+        mapping :currency, 'currency'
+        mapping :order, 'order'
+        mapping :description, 'description'
+
+        mapping :language, 'language'
+        mapping :payment_method, 'paymentMethod'
+        mapping :expiration_date, 'expirationDate'
+
+        # These credentials are mandatory:
+        #
+        # credential2: api_login
+        # credential3: api_key
+        # credential4: account_id
+        def initialize(order, merchant_id, options = {})
+          super
+          @merchant_id = merchant_id
+          @options     = options
+
+          add_field 'language', 'en'
+        end
+
+        def api_login
+          @options[:credential2]
+        end
+
+        def api_key
+          @options[:credential3]
+        end
+
+        def account_id
+          @options[:credential4]
+        end
+
+        def merchant_id
+          @merchant_id
+        end
+
+        def form_method
+          'GET'
+        end
+
+        def form_fields
+          cash_request = send_request(PayULatam.service_url, build_cash_request)
+
+          raise ActionViewHelperError, "Invalid response: #{cash_request}" unless success_cash_request_response?(cash_request)
+
+          {
+              :order_id        => cash_request['transactionResponse']['orderId'],
+              :transaction_id  => cash_request['transactionResponse']['transactionId'],
+              :url             => cash_request['transactionResponse']['extraParameters']['URL_PAYMENT_RECEIPT_HTML'],
+              :expiration_date => cash_request['transactionResponse']['extraParameters']['EXPIRATION_DATE'],
+          }
+        end
+
+        def order_status(order_id)
+          request_status = send_request(PayULatam.queries_url, build_query_request(:orderId, order_id))
+
+          raise ActionViewHelperError, "Invalid response: #{request_status}" unless success_response?(request_status)
+          # Not found?
+          return nil if request_status['result'].nil? or request_status['result']['payload'].nil?
+
+          {
+              :order_id       => request_status['result']['payload']['id'],
+              :status         => request_status['result']['payload']['status'],
+              :reference_code => request_status['result']['payload']['referenceCode'],
+              :description    => request_status['result']['payload']['description']
+          }
+        end
+
+        def transaction_status(transaction_id)
+          request_status = send_request(PayULatam.queries_url, build_query_request(:transactionId, transaction_id))
+
+          raise ActionViewHelperError, "Invalid response: #{request_status}" unless success_response?(request_status)
+          # Not found?
+          return nil if request_status['result'].nil? or request_status['result']['payload'].nil?
+
+          {
+              :status            => request_status['result']['payload']['state'],
+              :traceability_code => request_status['result']['payload']['trazabilityCode'],
+              :authorization     => request_status['result']['payload']['authorizationCode']
+          }
+        end
+
+        def orders_statuses(reference_code)
+          request_status = send_request(PayULatam.queries_url, build_query_request(:referenceCode, reference_code))
+
+          raise ActionViewHelperError, "Invalid response: #{request_status}" unless success_response?(request_status)
+          # Not found?
+          return nil if request_status['result'].nil?
+
+          request_status['result']['payload']
+        end
+
+        private
+
+        def send_request(url, request_body)
+          uri              = URI.parse(url)
+          http             = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl     = true
+          # PayULatam's test server has an improperly installed cert
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE if test?
+
+          request              = Net::HTTP::Post.new(uri.request_uri)
+          request['Accept']    = 'application/json'
+          request.content_type = 'application/json'
+          request.body         = request_body
+
+          response = http.request(request)
+          JSON.parse(response.body)
+        rescue JSON::ParserError
+          response.body
+        end
+
+        def build_cash_request
+          shipping_address           = {}
+          shipping_address[:street1] = @fields['address1'] unless @fields['address1'].nil?
+          shipping_address[:city]    = @fields['city'] unless @fields['city'].nil?
+          shipping_address[:state]   = @fields['state'] unless @fields['state'].nil?
+          shipping_address[:country] = @fields['country'] unless @fields['country'].nil?
+          shipping_address[:phone]   = @fields['phone'] unless @fields['phone'].nil?
+
+          buyer                   = {}
+          buyer[:fullName]        = @fields['name'] unless @fields['name'].nil?
+          buyer[:emailAddress]    = @fields['email'] unless @fields['email'].nil?
+          buyer[:dniNumber]       = @fields['dniNumber'] unless @fields['dniNumber'].nil?
+          buyer[:shippingAddress] = shipping_address
+
+          order                    = {}
+          order[:accountId]        = account_id
+          order[:referenceCode]    = @fields['order']
+          order[:description]      = @fields['description']
+          order[:language]         = @fields['language']
+          order[:signature]        = signature
+          order[:shippingAddress]  = {:country => @fields['country']} unless @fields['country'].nil?
+          order[:buyer]            = buyer
+          order[:additionalValues] = {:TX_VALUE => {:value => @fields['amount'].to_i, :currency => @fields['currency']}}
+
+          transaction                  = {}
+          transaction[:order]          = order
+          transaction[:type]           = 'AUTHORIZATION_AND_CAPTURE'
+          transaction[:paymentMethod]  = @fields['paymentMethod']
+          transaction[:expirationDate] = @fields['expirationDate'] unless @fields['expirationDate'].nil?
+
+          request               = build_base_request('SUBMIT_TRANSACTION')
+          request[:transaction] = transaction
+
+          request.to_json
+        end
+
+        def build_query_request(key, value)
+          request           = build_base_request(QUERY_COMMANDS[key])
+          request[:details] = {key => value}
+
+          request.to_json
+        end
+
+        def build_base_request(command)
+          request            = {}
+          request[:language] = @fields['language']
+          request[:command]  = command
+          # Should always be false, even in test mode
+          request[:test]     = 'false'
+          request[:merchant] = {:apiLogin => api_login, :apiKey => api_key}
+          request
+        end
+
+        def signature
+          raw = "#{api_key}~#{merchant_id}~#{@fields['order']}~#{@fields['amount']}~#{@fields['currency']}"
+          Digest::MD5.hexdigest(raw)
+        end
+
+        def success_cash_request_response?(cash_request_response)
+          success_response?(cash_request_response) and cash_request_response['transactionResponse'].is_a?(Hash) and cash_request_response['transactionResponse']['errorCode'].nil?
+        end
+
+        def success_response?(response)
+          response.is_a?(Hash) and response['code'] == 'SUCCESS' and response['error'].nil?
+        end
+      end
+    end
+  end
+end