koffsite_payments 3.0.0

data/lib/offsite_payments/integrations/paypal_payments_advanced.rb

@@ -0,0 +1,23 @@
+module OffsitePayments
+  module Integrations
+    module PaypalPaymentsAdvanced
+      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
+
+      class Helper < PayflowLink::Helper
+        def initialize(order, account, options)
+          super
+          add_field('partner', 'PayPal')
+        end
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/paysbuy.rb

@@ -0,0 +1,71 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module Paysbuy
+      mattr_accessor :test_url
+      self.test_url = 'https://demo.paysbuy.com/paynow.aspx'
+
+      mattr_accessor :production_url
+      self.production_url = 'https://www.paysbuy.com/paynow.aspx'
+
+      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
+
+      class Helper < OffsitePayments::Helper
+        mapping :account, 'biz'
+        mapping :amount, 'amt'
+        mapping :order, 'inv'
+        mapping :description, 'itm'
+        mapping :notify_url, 'postURL'
+      end
+
+      class Notification < OffsitePayments::Notification
+        SUCCESS = '00'
+        FAIL = '99'
+        PENDING = '02'
+
+        def complete?
+          status == 'Completed'
+        end
+
+        def item_id
+          params['result'][2..-1]
+        end
+
+        def status
+          status_code = params['result'][0..1]
+          case status_code
+          when SUCCESS
+            'Completed'
+          when FAIL
+            'Failed'
+          when PENDING
+            'Pending'
+          else
+            raise "Unknown status code"
+          end
+        end
+
+        def acknowledge(authcode = nil)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/payu_in.rb

@@ -0,0 +1,266 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module PayuIn
+      mattr_accessor :test_url
+      mattr_accessor :production_url
+
+      self.test_url = 'https://test.payu.in/_payment.php'
+      self.production_url = 'https://secure.payu.in/_payment.php'
+
+      def self.service_url
+        OffsitePayments.mode == :production ? self.production_url : self.test_url
+      end
+
+      def self.notification(post, options = {})
+        Notification.new(post, options)
+      end
+
+      def self.return(post, options = {})
+        Return.new(post, options)
+      end
+
+      def self.checksum(merchant_id, secret_key, payload_items )
+        Digest::SHA512.hexdigest([merchant_id, *payload_items, secret_key].join("|"))
+      end
+
+      class Helper < OffsitePayments::Helper
+
+        CHECKSUM_FIELDS = [ 'txnid', 'amount', 'productinfo', 'firstname', 'email', 'udf1', 'udf2', 'udf3', 'udf4',
+                            'udf5', 'udf6', 'udf7', 'udf8', 'udf9', 'udf10']
+
+        mapping :amount, 'amount'
+        mapping :account, 'key'
+        mapping :order, 'txnid'
+        mapping :description, 'productinfo'
+
+        mapping :customer, :first_name => 'firstname',
+          :last_name  => 'lastname',
+          :email => 'email',
+          :phone => 'phone'
+
+        mapping :billing_address, :city => 'city',
+          :address1 => 'address1',
+          :address2 => 'address2',
+          :state => 'state',
+          :zip => 'zip',
+          :country => 'country'
+
+        # Which tab you want to be open default on PayU
+        # CC (CreditCard) or NB (NetBanking)
+        mapping :mode, 'pg'
+
+        mapping :notify_url, 'notify_url'
+        mapping :return_url, ['surl', 'furl']
+        mapping :cancel_return_url, 'curl'
+        mapping :checksum, 'hash'
+
+        mapping :user_defined, { :var1 => 'udf1',
+          :var2 => 'udf2',
+          :var3 => 'udf3',
+          :var4 => 'udf4',
+          :var5 => 'udf5',
+          :var6 => 'udf6',
+          :var7 => 'udf7',
+          :var8 => 'udf8',
+          :var9 => 'udf9',
+          :var10 => 'udf10'
+        }
+
+        def initialize(order, account, options = {})
+          super
+          @options = options
+          self.pg = 'CC'
+        end
+
+        def form_fields
+          sanitize_fields
+          @fields.merge(mappings[:checksum] => generate_checksum)
+        end
+
+        def generate_checksum
+          checksum_payload_items = CHECKSUM_FIELDS.map { |field| @fields[field] }
+
+          PayuIn.checksum(@fields["key"], @options[:credential2], checksum_payload_items )
+        end
+
+        def sanitize_fields
+          ['address1', 'address2', 'city', 'state', 'country', 'productinfo', 'email', 'phone'].each do |field|
+            @fields[field].gsub!(/[^a-zA-Z0-9\-_@\/\s.]/, '') if @fields[field]
+          end
+        end
+
+      end
+
+      class Notification < OffsitePayments::Notification
+        def initialize(post, options = {})
+          super(post, options)
+          @merchant_id = options[:credential1]
+          @secret_key = options[:credential2]
+        end
+
+        def complete?
+          status == "Completed"
+        end
+
+        def status
+          case transaction_status.downcase
+          when 'success' then 'Completed'
+          when 'failure' then 'Failed'
+          when 'pending' then 'Pending'
+          end
+        end
+
+        def invoice_ok?( order_id )
+          order_id.to_s == invoice.to_s
+        end
+
+        # Order amount should be equal to gross - discount
+        def amount_ok?( order_amount, order_discount = BigDecimal.new( '0.0' ) )
+          BigDecimal.new( gross ) == order_amount && BigDecimal.new( discount.to_s ) == order_discount
+        end
+
+        # Status of transaction return from the PayU. List of possible values:
+        # <tt>SUCCESS</tt>::
+        # <tt>PENDING</tt>::
+        # <tt>FAILURE</tt>::
+        def transaction_status
+          params['status']
+        end
+
+        # ID of this transaction (PayU.in number)
+        def transaction_id
+          params['mihpayid']
+        end
+
+        # Mode of Payment
+        #
+        # 'CC' for credit-card
+        # 'NB' for net-banking
+        # 'CD' for cheque or DD
+        # 'CO' for Cash Pickup
+        def type
+          params['mode']
+        end
+
+        # What currency have we been dealing with
+        def currency
+          'INR'
+        end
+
+        def item_id
+          params['txnid']
+        end
+
+        # This is the invoice which you passed to PayU.in
+        def invoice
+          params['txnid']
+        end
+
+        # Merchant Id provided by the PayU.in
+        def account
+          params['key']
+        end
+
+        # original amount send by merchant
+        def gross
+          params['amount']
+        end
+
+        # This is discount given to user - based on promotion set by merchants.
+        def discount
+          params['discount']
+        end
+
+        # Description offer for what PayU given the offer to user - based on promotion set by merchants.
+        def offer_description
+          params['offer']
+        end
+
+        # Information about the product as send by merchant
+        def product_info
+          params['productinfo']
+        end
+
+        # Email of the customer
+        def customer_email
+          params['email']
+        end
+
+        # Phone of the customer
+        def customer_phone
+          params['phone']
+        end
+
+        # Firstname of the customer
+        def customer_first_name
+          params['firstname']
+        end
+
+        # Lastname of the customer
+        def customer_last_name
+          params['lastname']
+        end
+
+        # Full address of the customer
+        def customer_address
+          { :address1 => params['address1'], :address2 => params['address2'],
+            :city => params['city'], :state => params['state'],
+            :country => params['country'], :zipcode => params['zipcode'] }
+        end
+
+        def user_defined
+          @user_defined ||= 10.times.map { |i| params["udf#{i + 1}"] }
+        end
+
+        def checksum
+          params['hash']
+        end
+
+        def message
+          @message || params['error']
+        end
+
+        def acknowledge(authcode = nil)
+          checksum_ok?
+        end
+
+        def checksum_ok?
+          checksum_fields = [transaction_status, *user_defined.reverse, customer_email, customer_first_name, product_info, gross, invoice]
+
+          unless Digest::SHA512.hexdigest([@secret_key, *checksum_fields, @merchant_id].join("|")) == checksum
+            @message = 'Return checksum not matching the data provided'
+            return false
+          end
+          true
+        end
+      end
+
+      class Return < OffsitePayments::Return
+        def initialize(query_string, options = {})
+          super
+          @notification = Notification.new(query_string, options)
+        end
+
+        def transaction_id
+          @notification.transaction_id
+        end
+
+        def status( order_id, order_amount )
+          if @notification.invoice_ok?( order_id ) && @notification.amount_ok?( BigDecimal.new(order_amount) )
+            @notification.status
+          else
+            'Mismatch'
+          end
+        end
+
+        def success?
+          status( @params['txnid'], @params['amount'] ) == 'Completed'
+        end
+
+        def message
+          @notification.message
+        end
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/payu_in_paisa.rb

@@ -0,0 +1,46 @@
+module OffsitePayments
+  module Integrations
+    module PayuInPaisa
+      mattr_accessor :test_url
+      mattr_accessor :production_url
+
+      self.test_url = 'https://test.payu.in/_payment.php'
+      self.production_url = 'https://secure.payu.in/_payment.php'
+
+      def self.service_url
+        OffsitePayments.mode == :production ? self.production_url : self.test_url
+      end
+
+      def self.notification(post, options = {})
+        Notification.new(post, options)
+      end
+
+      def self.return(post, options = {})
+        Return.new(post, options)
+      end
+
+      class Helper < PayuIn::Helper
+        mapping :service_provider, 'service_provider'
+
+        def initialize(order, account, options = {})
+          super
+          self.service_provider = 'payu_paisa'
+          self.user_defined = { :var2 => order }
+        end
+      end
+
+      class Notification < PayuIn::Notification
+        def item_id
+          params['udf2']
+        end
+      end
+
+      class Return < PayuIn::Return
+        def initialize(query_string, options = {})
+          super
+          @notification = Notification.new(query_string, options)
+        end
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/platron.rb

@@ -0,0 +1,153 @@
+require 'builder'
+
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    # Platron API: www.platron.ru/PlatronAPI.pdf‎
+    module Platron
+      mattr_accessor :service_url
+      self.service_url = 'https://www.platron.ru/payment.php'
+
+      def self.notification(raw_post)
+        Notification.new(raw_post)
+      end
+
+      def self.generate_signature_string(params, path, secret)
+        sorted_params = params.sort_by{|k,v| k.to_s}.collect{|k,v| v}
+        [path, sorted_params, secret].flatten.compact.join(';')
+      end
+
+      def self.generate_signature(params, path, secret)
+        Digest::MD5.hexdigest(generate_signature_string(params, path, secret))
+      end
+
+      class Helper < OffsitePayments::Helper
+        def initialize(order, account, options = {})
+          @secret_key = options.delete(:secret)
+          @path = options.delete(:path)
+          description = options.delete(:description)
+          super
+          self.add_field('pg_salt', rand(36**15).to_s(36))
+          self.add_field('pg_description', description)
+        end
+
+        def form_fields
+          @fields.merge('pg_sig' => Common.generate_signature(@fields, @path, @secret_key))
+        end
+
+        def params
+          @fields
+        end
+
+        mapping :account, 'pg_merchant_id'
+        mapping :amount, 'pg_amount'
+        mapping :order, 'pg_order_id'
+        mapping :description, 'pg_description'
+        mapping :currency, 'pg_currency'
+      end
+
+      class Notification < OffsitePayments::Notification
+        def initialize(*args)
+          super
+          @signature = params.delete('pg_sig')
+        end
+
+        def complete?
+          params['pg_result']
+        end
+
+        def order_id
+          params['pg_order_id']
+        end
+
+        def platron_payment_id
+          params['pg_payment_id']
+        end
+
+        def currency
+          params['pg_ps_currency']
+        end
+
+        def payment_system
+          params['pg_payment_system']
+        end
+
+        def user_phone
+          params['pg_user_phone']
+        end
+
+        def card_brand
+          params['pg_card_brand']
+        end
+
+        def captured
+          params['pg_captured']
+        end
+
+        def overpayment
+          params['pg_overpayment']
+        end
+
+        def failure_code
+          params['pg_failure_code']
+        end
+
+        def failure_description
+          params['pg_failure_description']
+        end
+
+        def payment_date
+          params['pg_payment_date']
+        end
+
+        def salt
+          params['pg_salt']
+        end
+
+        def signature
+          @signature
+        end
+
+        def net_amount
+          params['pg_net_amount']
+        end
+
+        def ps_amount
+          params['pg_ps_amount']
+        end
+
+        def ps_full_amount
+          params['pg_ps_full_amount']
+        end
+
+        def amount
+          params['pg_amount']
+        end
+
+        def secret
+          @options[:secret]
+        end
+
+        def path
+          @options[:path]
+        end
+
+        def acknowledge(authcode = nil)
+          signature == Platron.generate_signature(params, path, secret)
+        end
+
+        def success_response(path,secret)
+          salt = rand(36**15).to_s(36)
+          xml = ""
+          doc = Builder::XmlMarkup.new(:target => xml)
+          sign = Platron.generate_signature({:pg_status => 'ok', :pg_salt => salt}, path, secret)
+          doc.response do
+            doc.pg_status 'ok'
+            doc.pg_salt salt
+            doc.pg_sig sign
+          end
+          xml
+        end
+      end
+    end
+  end
+end