nihaopay-ruby 0.1.0

data/lib/nihaopay/errors.rb

@@ -0,0 +1,6 @@
+module Nihaopay
+  TransactionError = Class.new(StandardError)
+  SecurePayTransactionError = Class.new(TransactionError)
+  ExpressPayTransactionError = Class.new(TransactionError)
+  TransactionLookUpError = Class.new(TransactionError)
+end

data/lib/nihaopay/merchant.rb

@@ -0,0 +1,47 @@
+module Nihaopay
+  class Merchant
+    attr_accessor :token
+
+    def initialize(token)
+      self.token = token
+    end
+
+    def union_pay(amount, currency, options = {})
+      options[:token] = token
+      Nihaopay::SecurePay::UnionPay.start(amount, currency, options)
+    end
+
+    def ali_pay(amount, currency, options = {})
+      options[:token] = token
+      Nihaopay::SecurePay::AliPay.start(amount, currency, options)
+    end
+
+    def wechat_pay(amount, currency, options = {})
+      options[:token] = token
+      Nihaopay::SecurePay::WeChatPay.start(amount, currency, options)
+    end
+
+    def authorize(amount, credit_card, options = {})
+      options[:token] = token
+      Nihaopay::Transactions::Authorize.start(amount, credit_card, options)
+    end
+
+    def capture(transaction_id, amount, currency)
+      Nihaopay::Transactions::Capture.start(transaction_id, amount, currency, token: token)
+    end
+
+    def purchase(amount, credit_card, options = {})
+      options[:token] = token
+      Nihaopay::Transactions::Purchase.start(amount, credit_card, options)
+    end
+
+    def release(transaction_id)
+      Nihaopay::Transactions::Release.start(transaction_id, token: token)
+    end
+
+    def refund(transaction_id, amount, currency, options = {})
+      options[:token] = token
+      Nihaopay::Transactions::Refund.start(transaction_id, amount, currency, options)
+    end
+  end
+end

data/lib/nihaopay/mixins/api.rb

@@ -0,0 +1,41 @@
+module Nihaopay
+  module Api
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    LIVE_HOST = 'https://api.nihaopay.com'.freeze
+    TEST_HOST = 'http://api.test.nihaopay.com'.freeze
+    VERSION = 'v1.1'.freeze
+
+    module ClassMethods
+      def host
+        Nihaopay.test_mode ? TEST_HOST : LIVE_HOST
+      end
+
+      def base_url
+        "#{host}/#{VERSION}"
+      end
+
+      def authorization
+        { 'Authorization' => "Bearer #{merchant_token}" }
+      end
+
+      def merchant_token
+        @token || Nihaopay.token
+      end
+
+      def validate_resource!(response)
+        return if response.parsed_response['id']
+        parsed_response = response.parsed_response.map { |k, v| "#{k}: #{v}" }.join(', ')
+        fail Nihaopay::TransactionError, parsed_response
+      end
+
+      def validate_collection!(response)
+        return if response.parsed_response['transactions']
+        parsed_response = response.parsed_response.map { |k, v| "#{k}: #{v}" }.join(', ')
+        fail Nihaopay::TransactionError, parsed_response
+      end
+    end
+  end
+end

data/lib/nihaopay/mixins/queryable.rb

@@ -0,0 +1,41 @@
+module Nihaopay
+  module Queryable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def find(transaction_id)
+        url = "#{base_url}/transactions/#{transaction_id}"
+        response = HTTParty.get(url, headers: request_headers)
+        build_from_response!(response)
+      rescue Nihaopay::TransactionError => e
+        raise Nihaopay::TransactionLookUpError, e.message
+      end
+
+      def fetch(options = {})
+        options[:starting_after] = options.delete(:after) if options[:after]
+        options[:ending_before] = options.delete(:before) if options[:before]
+        q.fetch(options)
+      end
+
+      def limit(num)
+        q.limit(num)
+      end
+
+      def before(time)
+        q.before(time)
+      end
+
+      def after(time)
+        q.after(time)
+      end
+
+      private
+
+      def q
+        Nihaopay::Query.new
+      end
+    end
+  end
+end

data/lib/nihaopay/query.rb

@@ -0,0 +1,61 @@
+module Nihaopay
+  class Query
+    include ::Nihaopay::Api
+
+    VALID_OPTIONS = %i(limit starting_after ending_before).freeze
+
+    def limit(num)
+      @limit = num
+      self
+    end
+
+    def before(time)
+      @ending_before = time
+      self
+    end
+
+    def after(time)
+      @starting_after = time
+      self
+    end
+
+    def fetch(options = nil)
+      options ||= { limit: @limit, starting_after: @starting_after, ending_before: @ending_before }
+      self.class.fetch(options)
+    end
+
+    class << self
+      def fetch(options = {})
+        query = query_params(options)
+        response = if query && !query.empty?
+                     HTTParty.get(url, headers: request_headers, query: query)
+                   else
+                     HTTParty.get(url, headers: request_headers)
+                   end
+        build_transactions(response)
+      rescue Nihaopay::TransactionError => e
+        raise Nihaopay::TransactionLookUpError, e.message
+      end
+
+      def url
+        "#{base_url}/transactions"
+      end
+
+      def request_headers
+        authorization
+      end
+
+      def query_params(options)
+        Nihaopay::HashUtil.slice(options, *VALID_OPTIONS).select { |_, v| v && (!v.respond_to?(:empty?) || !v.empty?) }
+      end
+
+      def build_transactions(response)
+        validate_collection!(response)
+        transactions = response.parsed_response['transactions']
+        transactions.map do |transaction|
+          Nihaopay::Transactions::Base.build(transaction)
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/secure_pay/ali_pay.rb

@@ -0,0 +1,11 @@
+module Nihaopay
+  module SecurePay
+    class AliPay < Base
+      class << self
+        def vendor
+          :alipay
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/secure_pay/base.rb

@@ -0,0 +1,48 @@
+module Nihaopay
+  module SecurePay
+    class Base
+      include ::Nihaopay::Api
+
+      class << self
+        def with_failure(&_)
+          response = yield
+          if response.code != 200
+            message = response.parsed_response.map { |k, v| "#{k}: #{v}" }.join(', ')
+            fail SecurePayTransactionError, message
+          end
+          response
+        end
+
+        def start(amount, currency, options = {})
+          with_failure do
+            @token = options.delete(:token)
+            params = request_params(amount, currency, options)
+            body = request_body(params)
+            HTTParty.post(request_url, headers: request_headers, body: body)
+          end
+        end
+
+        def request_url
+          "#{base_url}/transactions/securepay"
+        end
+
+        def request_headers
+          authorization
+        end
+
+        def request_params(amount, currency, options)
+          { amount: amount.to_i,
+            currency: currency.to_s,
+            vendor: vendor.to_s,
+            reference: options[:reference].to_s.slice(0, 30),
+            ipn_url: options[:ipn_url].to_s,
+            callback_url: options[:callback_url].to_s }
+        end
+
+        def request_body(params = {})
+          params.map { |k, v| "#{k}=#{v}" }.join('&')
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/secure_pay/union_pay.rb

@@ -0,0 +1,11 @@
+module Nihaopay
+  module SecurePay
+    class UnionPay < Base
+      class << self
+        def vendor
+          :unionpay
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/secure_pay/we_chat_pay.rb

@@ -0,0 +1,11 @@
+module Nihaopay
+  module SecurePay
+    class WeChatPay < Base
+      class << self
+        def vendor
+          :wechatpay
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/transactions/authorize.rb

@@ -0,0 +1,37 @@
+module Nihaopay
+  module Transactions
+    class Authorize < Base
+      class << self
+        def start(amount, credit_card, options = {})
+          @token = options.delete(:token)
+          params = request_params(amount, credit_card, options)
+          body = request_body(params)
+          response = HTTParty.post(request_url, headers: request_headers, body: body)
+          build_from_response!(response)
+        end
+
+        def request_url
+          "#{base_url}/transactions/expresspay"
+        end
+
+        def request_params(amount, credit_card, options)
+          params = {}
+          params.merge! credit_card.to_params_hash
+          params.merge! Nihaopay::HashUtil.slice(options, *valid_options)
+          params[:capture] = capture_param
+          params[:amount] = amount
+          params[:currency] ||= Nihaopay.currency
+          params
+        end
+
+        def valid_options
+          %i(currency description note reference)
+        end
+
+        def capture_param
+          false
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/transactions/base.rb

@@ -0,0 +1,78 @@
+module Nihaopay
+  module Transactions
+    class Base
+      include ::Nihaopay::Api
+      include ::Nihaopay::Queryable
+
+      attr_accessor :token, :transaction_id, :type, :status
+      attr_accessor :captured, :reference, :currency, :amount, :note, :time
+
+      def initialize(attributes = {})
+        assign_attributes(attributes)
+      end
+
+      def capture
+        Nihaopay::Transactions::Capture.start(transaction_id, amount, currency, token: token)
+      end
+
+      def partial_capture(capture_amount)
+        Nihaopay::Transactions::Capture.start(transaction_id, capture_amount, currency, token: token)
+      end
+
+      def release
+        Nihaopay::Transactions::Release.start(transaction_id, token: token)
+      end
+
+      def cancel
+        Nihaopay::Transactions::Cancel.start(transaction_id, token: token)
+      end
+
+      def refund(options = {})
+        options[:token] = token
+        Nihaopay::Transactions::Refund.start(transaction_id, amount, currency, options)
+      end
+
+      def partial_refund(refund_amount, options = {})
+        options[:token] = token
+        Nihaopay::Transactions::Refund.start(transaction_id, refund_amount, currency, options)
+      end
+
+      class << self
+        def request_headers
+          authorization.merge('Content-Type' => 'application/x-www-form-urlencoded')
+        end
+
+        def request_body(params = {})
+          params.map { |k, v| "#{k}=#{v}" }.join('&')
+        end
+
+        def build_from_response!(response)
+          validate_resource!(response)
+          build(response.parsed_response)
+        end
+
+        def build(options = {})
+          options = Nihaopay::HashUtil.symbolize_keys(options)
+          attributes = Nihaopay::HashUtil.slice(options, *valid_attributes)
+          attributes[:token] ||= merchant_token
+          response_keys_map.each { |k, v| attributes[v] = options[k] }
+          new(attributes)
+        end
+
+        def valid_attributes
+          %i(token transaction_id type status captured currency reference amount note time)
+        end
+
+        def response_keys_map
+          { id: :transaction_id }
+        end
+      end
+
+      private
+
+      def assign_attributes(attributes)
+        self.class.valid_attributes.each { |f| send("#{f}=", attributes[f]) }
+      end
+    end
+  end
+end

data/lib/nihaopay/transactions/cancel.rb

@@ -0,0 +1,28 @@
+module Nihaopay
+  module Transactions
+    class Cancel < Base
+      attr_accessor :cancelled, :cancel_transaction_id
+
+      class << self
+        def start(transaction_id, options = {})
+          @token = options.delete(:token)
+          url = request_url(transaction_id)
+          response = HTTParty.post(url, headers: request_headers, body: request_body)
+          build_from_response!(response)
+        end
+
+        def request_url(transaction_id)
+          "#{base_url}/transactions/#{transaction_id}/cancel"
+        end
+
+        def valid_attributes
+          %i(transaction_id status cancelled cancel_transaction_id)
+        end
+
+        def response_keys_map
+          { id: :transaction_id, transaction_id: :cancel_transaction_id }
+        end
+      end
+    end
+  end
+end

data/lib/nihaopay/transactions/capture.rb

@@ -0,0 +1,29 @@
+module Nihaopay
+  module Transactions
+    class Capture < Base
+      attr_accessor :captured, :capture_transaction_id
+
+      class << self
+        def start(transaction_id, amount, currency, options = {})
+          @token = options.delete(:token)
+          url = request_url(transaction_id)
+          params = request_body(amount: amount, currency: currency)
+          response = HTTParty.post(url, headers: request_headers, body: params)
+          build_from_response!(response)
+        end
+
+        def request_url(transaction_id)
+          "#{base_url}/transactions/#{transaction_id}/capture"
+        end
+
+        def valid_attributes
+          %i(transaction_id status captured capture_transaction_id)
+        end
+
+        def response_keys_map
+          { id: :transaction_id, transaction_id: :capture_transaction_id }
+        end
+      end
+    end
+  end
+end