offsite_payments 2.0.0

data/lib/offsite_payments/integrations/ipay88.rb

@@ -0,0 +1,240 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module Ipay88
+      def self.service_url
+        "https://www.mobile88.com/epayment/entry.asp"
+      end
+
+      def self.requery_url
+        "https://www.mobile88.com/epayment/enquiry.asp"
+      end
+
+      def self.return(query_string, options={})
+        Return.new(query_string, options)
+      end
+
+      class Helper < OffsitePayments::Helper
+        include ActiveMerchant::RequiresParameters
+
+        # Currencies supported
+        #   MYR (Malaysian Ringgit - for all payment methods except China Union Pay and PayPal)
+        #   USD (US Dollar - only for PayPal)
+        #   CNY (Yuan Renminbi - only for China Union Pay)
+        SUPPORTED_CURRENCIES = %w[MYR USD CNY]
+
+        # Languages supported
+        #   ISO-8859-1 (English)
+        #   UTF-8      (Unicode)
+        #   GB2312     (Chinese Simplified)
+        #   GD18030    (Chinese Simplified)
+        #   BIG5       (Chinese Traditional)
+        SUPPORTED_LANGS      = %w[ISO-8859-1 UTF-8 GB2312 GD18030 BIG5]
+
+        # Payment methods supported
+        #   8  (Alliance Online Transfer)
+        #   10 (AmBank)
+        #   21 (China Union Pay)
+        #   20 (CIMB Click)
+        #   2  (Credit Card MYR)
+        #   16 (FPX)
+        #   15 (Hong Leong Bank Transfer)
+        #   6  (Maybank2u.com)
+        #   23 (MEPS Cash)
+        #   17 (Mobile Money)
+        #   33 (PayPal)
+        #   14 (RHB)
+        PAYMENT_METHODS      = %w[8 10 21 20 2 16 15 6 23 17 33 14]
+
+        attr_reader :amount_in_cents, :merchant_key
+
+        def initialize(order, account, options = {})
+          requires!(options, :amount, :currency, :credential2)
+          @merchant_key = options[:credential2]
+          @amount_in_cents = options[:amount]
+          super
+          add_field mappings[:signature], signature
+        end
+
+        def amount_in_dollars
+          sprintf("%.2f", @amount_in_cents.to_f/100)
+        end
+
+        def amount=(money)
+          @amount_in_cents = money.respond_to?(:cents) ? money.cents : money
+          raise ArgumentError, "amount must be a Money object or an integer" if money.is_a?(String)
+          raise ActionViewHelperError, "amount must be greater than $0.00" if @amount_in_cents.to_i <= 0
+
+          add_field mappings[:amount], amount_in_dollars
+        end
+
+        def currency(symbol)
+          raise ArgumentError, "unsupported currency" unless SUPPORTED_CURRENCIES.include?(symbol)
+          add_field mappings[:currency], symbol
+        end
+
+        def language(lang)
+          raise ArgumentError, "unsupported language" unless SUPPORTED_LANGS.include?(lang)
+          add_field mappings[:language], lang
+        end
+
+        def payment(pay_method)
+          raise ArgumentError, "unsupported payment method" unless PAYMENT_METHODS.include?(pay_method.to_s)
+          add_field mappings[:payment], pay_method
+        end
+
+        def customer(params = {})
+          add_field(mappings[:customer][:name], "#{params[:first_name]} #{params[:last_name]}")
+          add_field(mappings[:customer][:email], params[:email])
+          add_field(mappings[:customer][:phone], params[:phone])
+        end
+
+        def self.sign(str)
+          [Digest::SHA1.digest(str)].pack("m").chomp
+        end
+
+        def signature
+          self.class.sign(self.sig_components)
+        end
+
+        mapping :account,     "MerchantCode"
+        mapping :amount,      "Amount"
+        mapping :currency,    "Currency"
+        mapping :order,       "RefNo"
+        mapping :description, "ProdDesc"
+        mapping :customer, :name  => "UserName",
+                           :email => "UserEmail",
+                           :phone => "UserContact"
+        mapping :remark,      "Remark"
+        mapping :language,    "Lang"
+        mapping :payment,     "PaymentId"
+        mapping :return_url,  "ResponseURL"
+        mapping :signature,   "Signature"
+
+        protected
+
+        def sig_components
+          components  = [merchant_key]
+          components << fields[mappings[:account]]
+          components << fields[mappings[:order]]
+          components << amount_in_dollars.gsub(/[.,]/, '')
+          components << fields[mappings[:currency]]
+          components.join
+        end
+      end
+
+      class Notification < OffsitePayments::Notification
+        include ActiveMerchant::PostsData
+
+        def status
+          params["Status"] == '1' ? 'Completed' : 'Failed'
+        end
+
+        def complete?
+          status == 'Completed'
+        end
+
+        def item_id
+          params["RefNo"]
+        end
+
+        def gross
+          params["Amount"]
+        end
+
+        def currency
+          params["Currency"]
+        end
+
+        def account
+          params["MerchantCode"]
+        end
+
+        def payment
+          params["PaymentId"].to_i
+        end
+
+        def remark
+          params["Remark"]
+        end
+
+        def transaction_id
+          params["TransId"]
+        end
+
+        def auth_code
+          params["AuthCode"]
+        end
+
+        def error
+          params["ErrDesc"]
+        end
+
+        def signature
+          params["Signature"]
+        end
+
+        def secure?
+          generated_signature == signature
+        end
+
+        def success?
+          status == 'Completed'
+        end
+
+        def acknowledge
+          secure? && success? && requery == "00"
+        end
+
+        protected
+
+        def generated_signature
+          Helper.sign(sig_components)
+        end
+
+        def sig_components
+          components = [@options[:credential2]]
+          [:account, :payment, :item_id, :amount_in_cents, :currency].each do |i|
+            components << send(i)
+          end
+          components << params["Status"]
+          components.join
+        end
+
+        def requery
+          data   = { "MerchantCode" => account, "RefNo" => item_id, "Amount" => gross }
+          params = parameterize(data)
+          ssl_post Ipay88.requery_url, params, { "Content-Length" => params.size.to_s, "User-Agent" => "Active Merchant -- http://activemerchant.org" }
+        end
+
+        private
+
+        def parameterize(params)
+          params.reject { |k, v| v.blank? }.keys.sort.collect { |key| "#{key}=#{CGI.escape(params[key].to_s)}" }.join("&")
+        end
+
+        def amount_in_cents
+          @amount_in_cents ||= (gross || "").gsub(/[.,]/, "")
+        end
+      end
+
+      class Return < OffsitePayments::Return
+        def initialize(query_string, options = {})
+          super
+          @notification = Notification.new(query_string, options)
+        end
+
+        def success?
+          params["Status"] == "1"
+        end
+
+        def cancelled?
+          params["ErrDesc"] == 'Customer Cancel Transaction'
+        end
+
+        def message
+          params["ErrDesc"]
+        end
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/klarna.rb

@@ -0,0 +1,291 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module Klarna
+      mattr_accessor :service_url
+      self.service_url = 'https://api.hostedcheckout.io/api/v1/checkout'
+
+      def self.notification(post_body, options = {})
+        Notification.new(post_body, options)
+      end
+
+      def self.return(query_string, options = {})
+        Return.new(query_string, options)
+      end
+
+      def self.cart_items_payload(fields, cart_items)
+        check_required_fields!(fields)
+
+        payload = fields['purchase_country'].to_s +
+                  fields['purchase_currency'].to_s +
+                  fields['locale'].to_s
+
+        cart_items.each_with_index do |item, i|
+          payload << fields["cart_item-#{i}_type"].to_s +
+                     fields["cart_item-#{i}_reference"].to_s +
+                     fields["cart_item-#{i}_quantity"].to_s +
+                     fields["cart_item-#{i}_unit_price"].to_s +
+                     fields.fetch("cart_item-#{i}_discount_rate", '').to_s
+        end
+
+        payload << fields['merchant_id'].to_s +
+                   fields['merchant_terms_uri'].to_s +
+                   fields['merchant_checkout_uri'].to_s +
+                   fields['merchant_base_uri'].to_s +
+                   fields['merchant_confirmation_uri'].to_s
+
+        payload
+      end
+
+      def self.sign(fields, cart_items, shared_secret)
+        payload = cart_items_payload(fields, cart_items)
+
+        digest(payload, shared_secret)
+      end
+
+      def self.digest(payload, shared_secret)
+        Digest::SHA256.base64digest(payload + shared_secret.to_s)
+      end
+
+      private
+
+      def self.check_required_fields!(fields)
+        %w(purchase_country
+           purchase_currency
+           locale
+           merchant_id
+           merchant_terms_uri
+           merchant_checkout_uri
+           merchant_base_uri
+           merchant_confirmation_uri).each do |required_field|
+          raise ArgumentError, "Missing required field #{required_field}" if fields[required_field].nil?
+        end
+      end
+
+      class Helper < OffsitePayments::Helper
+        mapping :currency, 'purchase_currency'
+        mapping :cancel_return_url, ['merchant_terms_uri', 'merchant_checkout_uri', 'merchant_base_uri']
+        mapping :account, 'merchant_id'
+        mapping :customer, email: 'shipping_address_email'
+
+        def initialize(order, account, options = {})
+          super
+          @shared_secret = options[:credential2]
+          @order = order
+
+          add_field('platform_type', application_id)
+          add_field('test_mode', test?.to_s)
+        end
+
+        def notify_url(url)
+          url = append_order_query_param(url)
+          add_field('merchant_push_uri', url)
+        end
+
+        def return_url(url)
+          url = append_order_query_param(url)
+          add_field('merchant_confirmation_uri', url)
+        end
+
+        def line_item(item)
+          @line_items ||= []
+          @line_items << item
+
+          i = @line_items.size - 1
+
+          add_field("cart_item-#{i}_type", type_for(item))
+          add_field("cart_item-#{i}_reference", item.fetch(:reference, ''))
+          add_field("cart_item-#{i}_name", item.fetch(:name, ''))
+          add_field("cart_item-#{i}_quantity", item.fetch(:quantity, ''))
+          add_field("cart_item-#{i}_unit_price", tax_included_unit_price(item)).to_s
+          add_field("cart_item-#{i}_discount_rate", item.fetch(:discount_rate, ''))
+          add_field("cart_item-#{i}_tax_rate", tax_rate_for(item)).to_s
+
+          @fields
+        end
+
+        def billing_address(billing_fields)
+          country = billing_fields[:country]
+
+          add_field('purchase_country', country)
+          add_field('locale', guess_locale_based_on_country(country))
+        end
+
+        def shipping_address(shipping_fields)
+          add_field('shipping_address_given_name', shipping_fields[:first_name])
+          add_field('shipping_address_family_name', shipping_fields[:last_name])
+
+          street_address = [shipping_fields[:address1], shipping_fields[:address2]].compact.join(', ')
+          add_field('shipping_address_street_address', street_address)
+
+          add_field('shipping_address_postal_code', shipping_fields[:zip])
+          add_field('shipping_address_city', shipping_fields[:city])
+          add_field('shipping_address_country', shipping_fields[:country])
+          add_field('shipping_address_phone', shipping_fields[:phone])
+        end
+
+        def form_fields
+          sign_fields
+
+          super
+        end
+
+        def sign_fields
+          merchant_digest = Klarna.sign(@fields, @line_items, @shared_secret)
+          add_field('merchant_digest', merchant_digest)
+        end
+
+        private
+
+        def type_for(item)
+          case item.fetch(:type, '')
+          when 'shipping'
+            'shipping_fee'
+          when 'line item'
+            'physical'
+          when 'discount'
+            'discount'
+          else
+            raise StandardError, "Unable to determine type for item #{item.to_yaml}"
+          end
+        end
+
+        def append_order_query_param(url)
+          u = URI.parse(url)
+          params = Rack::Utils.parse_nested_query(u.query)
+          params["order"] = @order
+          u.query = params.to_query
+
+          u.to_s
+        end
+
+        def guess_locale_based_on_country(country_code)
+          case country_code
+          when /no/i
+            "nb-no"
+          when /fi/i
+            "fi-fi"
+          when /se/i
+            "sv-se"
+          else
+            "sv-se"
+          end
+        end
+
+        def tax_included_unit_price(item)
+          item.fetch(:unit_price, '').to_i + item.fetch(:tax_amount, '').to_i
+        end
+
+        def tax_rate_for(item)
+          subtotal_price = item.fetch(:unit_price, 0).to_f * item.fetch(:quantity, 0).to_i
+          tax_amount = item.fetch(:tax_amount, 0).to_f
+
+          if subtotal_price > 0
+            tax_rate = tax_amount / subtotal_price
+            tax_rate = tax_rate.round(4)
+
+            percentage_to_two_decimal_precision_whole_number(tax_rate)
+          else
+            0
+          end
+        end
+
+        def percentage_to_two_decimal_precision_whole_number(percentage)
+          (percentage * 10000).to_i
+        end
+      end
+
+      class Notification < OffsitePayments::Notification
+        def initialize(post, options = {})
+          super
+          @shared_secret = @options[:credential2]
+        end
+
+        def complete?
+          status == 'Completed'
+        end
+
+        def item_id
+          order
+        end
+
+        def transaction_id
+          params["reference"]
+        end
+
+        def received_at
+          params["completed_at"]
+        end
+
+        def payer_email
+          params["billing_address"]["email"]
+        end
+
+        def receiver_email
+          params["shipping_address"]["email"]
+        end
+
+        def currency
+          params["purchase_currency"].upcase
+        end
+
+        def gross
+          amount = Float(gross_cents) / 100
+          sprintf("%.2f", amount)
+        end
+
+        def gross_cents
+          params["cart"]["total_price_including_tax"]
+        end
+
+        def status
+          case params['status']
+          when 'checkout_complete'
+            'Completed'
+          else
+            params['status']
+          end
+        end
+
+        def acknowledge(authcode = nil)
+          Verifier.new(@options[:authorization_header], @raw, @shared_secret).verify
+        end
+
+        private
+
+        def order
+          query = Rack::Utils.parse_nested_query(@options[:query_string])
+          query["order"]
+        end
+
+        def parse(post)
+          @raw = post.to_s
+          @params = JSON.parse(post)
+        end
+
+        class Verifier
+          attr_reader :header, :payload, :digest, :shared_secret
+          def initialize(header, payload, shared_secret)
+            @header, @payload, @shared_secret = header, payload, shared_secret
+
+            @digest = extract_digest
+          end
+
+          def verify
+            digest_matches?
+          end
+
+          private
+
+          def extract_digest
+            match = header.match(/^Klarna (?<digest>.+)$/)
+            match && match[:digest]
+          end
+
+          def digest_matches?
+            Klarna.digest(payload, shared_secret) == digest
+          end
+        end
+      end
+    end
+  end
+end