better_offsite_payments 2.3.0

data/lib/offsite_payments/integrations/mollie.rb

@@ -0,0 +1,32 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module Mollie
+      class API
+        include ActiveUtils::PostsData
+
+        attr_reader :token
+
+        MOLLIE_API_V1_URI = 'https://api.mollie.nl/v1/'.freeze
+
+        def initialize(token)
+          @token = token
+        end
+
+        def get_request(resource, params = nil)
+          uri = URI.parse(MOLLIE_API_V1_URI + resource)
+          uri.query = params.map { |k,v| "#{CGI.escape(k)}=#{CGI.escape(v)}}"}.join('&') if params
+          headers = { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" }
+          JSON.parse(ssl_get(uri.to_s, headers))
+        end
+
+        def post_request(resource, params = nil)
+          uri = URI.parse(MOLLIE_API_V1_URI + resource)
+          headers = { "Authorization" => "Bearer #{token}", "Content-Type" => "application/json" }
+          data = params.nil? ? nil : JSON.dump(params)
+          JSON.parse(ssl_post(uri.to_s, data, headers))
+        end
+      end
+
+    end
+  end
+end

data/lib/offsite_payments/integrations/mollie_ideal.rb

@@ -0,0 +1,194 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module MollieIdeal
+      include Mollie
+
+      mattr_accessor :live_issuers
+      self.live_issuers = [
+        ["ABN AMRO", "ideal_ABNANL2A"],
+        ["ASN Bank", "ideal_ASNBNL21"],
+        ["Friesland Bank", "ideal_FRBKNL2L"],
+        ["ING", "ideal_INGBNL2A"],
+        ["Knab", "ideal_KNABNL2H"],
+        ["Rabobank", "ideal_RABONL2U"],
+        ["RegioBank", "ideal_RBRBNL21"],
+        ["SNS Bank", "ideal_SNSBNL2A"],
+        ["Triodos Bank", "ideal_TRIONL2U"],
+        ["van Lanschot", "ideal_FVLBNL22"]
+      ]
+
+      mattr_accessor :test_issuers
+      self.test_issuers = [
+        ["TBM Bank", "ideal_TESTNL99"]
+      ]
+
+      def self.redirect_param_label
+        "Select your bank"
+      end
+
+      def self.redirect_param_options(options = {})
+        return test_issuers if options[:credential1].blank?
+        options[:credential1].start_with?('live_') ? live_issuers : test_issuers
+      end
+
+      def self.retrieve_issuers(token)
+        response = API.new(token).get_request("issuers")
+        response['data']
+          .select { |issuer| issuer['method'] == 'ideal' }
+          .map { |issuer| [issuer['name'], issuer['id']] }
+      end
+
+      RedirectError = Class.new(ActiveUtils::ActiveUtilsError)
+
+      MOLLIE_API_V1_URI = 'https://api.mollie.nl/v1/'.freeze
+
+      def self.notification(post, options = {})
+        Notification.new(post, options)
+      end
+
+      def self.return(post, options = {})
+        Return.new(post, options)
+      end
+
+      def self.live?
+        OffsitePayments.mode == :production
+      end
+
+      def self.create_payment(token, params)
+        API.new(token).post_request('payments', params)
+      end
+
+      def self.check_payment_status(token, payment_id)
+        API.new(token).get_request("payments/#{payment_id}")
+      end
+
+      def self.requires_redirect_param?
+        true
+      end
+
+      class Helper < OffsitePayments::Helper
+        attr_reader :transaction_id, :redirect_parameters, :token
+
+        def initialize(order, account, options = {})
+          @token = account
+          @redirect_parameters = {
+            :amount => options[:amount],
+            :description => options[:description],
+            :issuer => options[:redirect_param],
+            :redirectUrl => options[:return_url],
+            :method => 'ideal',
+            :metadata => { :order => order }
+          }
+
+          @redirect_parameters[:webhookUrl] = options[:notify_url] if options[:notify_url]
+
+          super
+
+          raise ArgumentError, "The redirect_param option needs to be set to the bank_id the customer selected." if options[:redirect_param].blank?
+          raise ArgumentError, "The return_url option needs to be set." if options[:return_url].blank?
+          raise ArgumentError, "The description option needs to be set." if options[:description].blank?
+        end
+
+        def credential_based_url
+          response = request_redirect
+          @transaction_id = response['id']
+
+          uri = URI.parse(response['links']['paymentUrl'])
+          set_form_fields_for_redirect(uri)
+          uri.query = ''
+          uri.to_s.sub(/\?\z/, '')
+        end
+
+        def form_method
+          "GET"
+        end
+
+        def set_form_fields_for_redirect(uri)
+          CGI.parse(uri.query).each do |key, value|
+            if value.is_a?(Array) && value.length == 1
+              add_field(key, value.first)
+            else
+              add_field(key, value)
+            end
+          end
+        end
+
+        def request_redirect
+          MollieIdeal.create_payment(token, redirect_parameters)
+        rescue ActiveUtils::ResponseError => e
+          case e.response.code
+          when '401', '403', '422'
+            error = JSON.parse(e.response.body)['error']['message']
+            raise ActionViewHelperError, error
+          when '503'
+            raise ActionViewHelperError, 'Service temporarily unavailable. Please try again.'
+          else
+            raise
+          end
+        end
+      end
+
+      class Notification < OffsitePayments::Notification
+        def initialize(post_arguments, options = {})
+          super
+
+          raise ArgumentError, "The transaction_id needs to be included in the query string." if transaction_id.nil?
+          raise ArgumentError, "The credential1 option needs to be set to the Mollie API key." if api_key.blank?
+        end
+
+        def complete?
+          true
+        end
+
+        def item_id
+          params['metadata']['order']
+        end
+
+        def transaction_id
+          params['id']
+        end
+
+        def api_key
+          @options[:credential1]
+        end
+
+        def currency
+          "EUR"
+        end
+
+        # the money amount we received in X.2 decimal.
+        def gross
+          @params['amount']
+        end
+
+        def gross_cents
+          (BigDecimal.new(@params['amount'], 2) * 100).to_i
+        end
+
+        def status
+          case @params['status']
+            when 'open';                 'Pending'
+            when 'paidout', 'paid';      'Completed'
+            else                         'Failed'
+          end
+        end
+
+        def test?
+          @params['mode'] == 'test'
+        end
+
+        def acknowledge(authcode = nil)
+          @params = check_payment_status(transaction_id)
+          true
+        end
+
+        def check_payment_status(transaction_id)
+          MollieIdeal.check_payment_status(@options[:credential1], transaction_id)
+        end
+      end
+
+      class Return < OffsitePayments::Return
+      end
+    end
+  end
+end

data/lib/offsite_payments/integrations/mollie_mistercash.rb

@@ -0,0 +1,143 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module MollieMistercash
+      include Mollie
+
+        RedirectError = Class.new(ActiveUtils::ActiveUtilsError)
+
+        def self.notification(post, options = {})
+          Notification.new(post, options)
+        end
+
+        def self.return(post, options = {})
+          Return.new(post, options)
+        end
+
+        def self.live?
+          OffsitePayments.mode == :production
+        end
+
+        def self.create_payment(token, params)
+          API.new(token).post_request('payments', params)
+        end
+
+        def self.check_payment_status(token, payment_id)
+          API.new(token).get_request("payments/#{payment_id}")
+        end
+
+        def self.requires_redirect_param?
+          false
+        end
+
+        class Helper < OffsitePayments::Helper
+          attr_reader :transaction_id, :redirect_parameters, :token
+
+            def initialize(order, account, options = {})
+              @token = account
+              @redirect_parameters = {
+                :amount => options[:amount],
+                :description => options[:description],
+                :redirectUrl => options[:return_url],
+                :method => 'mistercash',
+                :metadata => { :order => order }
+              }
+
+              @redirect_parameters[:webhookUrl] = options[:notify_url] if options[:notify_url]
+
+              super
+
+              raise ArgumentError, "The return_url option needs to be set." if options[:return_url].blank?
+              raise ArgumentError, "The description option needs to be set." if options[:description].blank?
+            end
+
+            def credential_based_url
+              response = request_redirect
+              uri = URI.parse(response['links']['paymentUrl'])
+              uri.to_s
+            end
+
+            def form_method
+              "GET"
+            end
+
+            def request_redirect
+              MollieMistercash.create_payment(token, redirect_parameters)
+            rescue ActiveUtils::ResponseError => e
+              case e.response.code
+              when '401', '403', '422'
+                error = JSON.parse(e.response.body)['error']['message']
+                raise ActionViewHelperError, error
+              when '503'
+                raise ActionViewHelperError, 'Service temporarily unavailable. Please try again.'
+              else
+                raise
+              end
+            end
+
+        end
+
+        class Notification < OffsitePayments::Notification
+          def initialize(post_arguments, options = {})
+            super
+
+            raise ArgumentError, "The transaction_id needs to be included in the query string." if transaction_id.nil?
+            raise ArgumentError, "The credential1 option needs to be set to the Mollie API key." if api_key.blank?
+          end
+
+          def complete?
+            true
+          end
+
+          def item_id
+            params['metadata']['order']
+          end
+
+          def transaction_id
+            params['id']
+          end
+
+          def api_key
+            @options[:credential1]
+          end
+
+          def currency
+            "EUR"
+          end
+
+          # the money amount we received in X.2 decimal.
+          def gross
+            @params['amount']
+          end
+
+          def gross_cents
+            (BigDecimal.new(@params['amount'], 2) * 100).to_i
+          end
+
+          def status
+            case @params['status']
+              when 'open';                 'Pending'
+              when 'paidout', 'paid';      'Completed'
+              else                         'Failed'
+            end
+          end
+
+          def test?
+            @params['mode'] == 'test'
+          end
+
+          def acknowledge(authcode = nil)
+            @params = check_payment_status(transaction_id)
+            true
+          end
+
+          def check_payment_status(transaction_id)
+            MollieMistercash.check_payment_status(@options[:credential1], transaction_id)
+          end
+        end
+
+        class Return < OffsitePayments::Return
+        end
+
+    end
+  end
+end

data/lib/offsite_payments/integrations/molpay.rb

@@ -0,0 +1,193 @@
+module OffsitePayments #:nodoc:
+  module Integrations #:nodoc:
+    module Molpay
+      mattr_accessor :acknowledge_url
+      self.acknowledge_url = 'https://www.onlinepayment.com.my/MOLPay/API/chkstat/returnipn.php'
+
+      def self.notification(post, options = {})
+        Notification.new(post, options)
+      end
+
+      def self.return(query_string, options={})
+        Return.new(query_string, options)
+      end
+
+      #  (Optional Parameter) = channel //will generate URL to go directly to specific channel, e.g maybank2u, cimb
+      #  Please refer MOLPay API spec for the channel routing
+      class Helper < OffsitePayments::Helper
+        include ActiveUtils::RequiresParameters
+
+        SUPPORTED_CURRENCIES = ['MYR', 'USD', 'SGD', 'PHP', 'VND', 'IDR', 'AUD', 'CNY', 'THB', 'GBP', 'EUR', 'HKD']
+
+        # Defaults to en
+        SUPPORTED_LANGUAGES = ['en', 'cn']
+
+        SERVICE_URL = 'https://www.onlinepayment.com.my/MOLPay/pay/'.freeze
+
+        mapping :account,             'merchantid'
+        mapping :amount,              'amount'
+        mapping :order,               'orderid'
+        mapping :customer, :name  =>  'bill_name',
+                           :email =>  'bill_email',
+                           :phone =>  'bill_mobile'
+
+        mapping :description,         'bill_desc'
+        mapping :language,            'langcode'
+        mapping :country,             'country'
+        mapping :currency,            'cur'
+        mapping :return_url,          'returnurl'
+        mapping :notify_url,          'callbackurl'
+        mapping :signature,           'vcode'
+
+        attr_reader :amount_in_cents, :verify_key, :channel
+
+        def credential_based_url
+          service_url = SERVICE_URL + @fields[mappings[:account]] + "/"
+          service_url = service_url + @channel if @channel
+          service_url
+        end
+
+        def initialize(order, account, options = {})
+          requires!(options, :amount, :currency, :credential2)
+          @verify_key = options[:credential2] if options[:credential2]
+          @amount_in_cents = options[:amount]
+          @channel = options.delete(:channel)
+          super
+        end
+
+        def form_fields
+          add_field mappings[:signature], signature
+          @fields
+        end
+
+        def amount=(money)
+          unless money > 0
+            raise ArgumentError, "amount must be greater than $0.00."
+          end
+          add_field mappings[:amount], sprintf("%.2f", money.to_f)
+        end
+
+        def currency=(cur)
+          raise ArgumentError, "unsupported currency" unless SUPPORTED_CURRENCIES.include?(cur)
+          add_field mappings[:currency], cur
+        end
+
+        def language=(lang)
+          raise ArgumentError, "unsupported language" unless SUPPORTED_LANGUAGES.include?(lang)
+          add_field mappings[:language], lang
+        end
+
+        private
+
+        def signature
+          Digest::MD5.hexdigest("#{@fields[mappings[:amount]]}#{@fields[mappings[:account]]}#{@fields[mappings[:order]]}#{@verify_key}")
+        end
+      end
+
+      class Notification < OffsitePayments::Notification
+        include ActiveUtils::PostsData
+
+        def status
+          case params['status']
+            when '00'
+              'Completed'
+            when '11'
+              'Failed'
+            when '22'
+              'Pending'
+          end
+        end
+
+        def complete?
+          status == 'Completed'
+        end
+
+        def item_id
+          params['orderid']
+        end
+
+        def transaction_id
+          params['tranID']
+        end
+
+        def account
+          params["domain"]
+        end
+
+        # the money amount we received in X.2 decimal.
+        def gross
+          params['amount']
+        end
+
+        def currency
+          params['currency']
+        end
+
+        def channel
+          params['channel']
+        end
+
+        # When was this payment received by the client.
+        def received_at
+          params['paydate']
+        end
+
+        def auth_code
+          params['appcode']
+        end
+
+        def error_code
+          params['error_code']
+        end
+
+        def error_desc
+          params['error_desc']
+        end
+
+        def security_key
+          params['skey']
+        end
+
+        def test?
+          gross.blank? && auth_code.blank? && error_code.blank? && error_desc.blank? && security_key.blank?
+        end
+
+        def status_orig
+          params['status']
+        end
+
+        def acknowledge(authcode = nil)
+          payload = raw + '&treq=1'
+          ssl_post(Molpay.acknowledge_url, payload,
+            'Content-Length' => "#{payload.size}",
+            'User-Agent'     => "Shopify/OffsitePayments"
+          )
+
+          status == 'Completed' && security_key == generate_signature
+        end
+
+        protected
+
+        def generate_signature
+          key0 = Digest::MD5.hexdigest("#{transaction_id}#{item_id}#{status_orig}#{account}#{gross}#{currency}")
+          Digest::MD5.hexdigest("#{received_at}#{account}#{key0}#{auth_code}#{@options[:credential2]}")
+        end
+      end
+
+      class Return < OffsitePayments::Return
+        def initialize(query_string, options = {})
+          super
+          @notification = Notification.new(query_string, options)
+        end
+
+        def success?
+          @notification.acknowledge
+        end
+
+        def pending?
+          @notification.status == 'Pending'
+        end
+      end
+    end
+  end
+end