ost-sdk-ruby 1.1.0 → 2.0.0.beta.1

data/lib/ost-sdk-ruby/test/signature_generation_test.rb

@@ -0,0 +1,33 @@
+require_relative "../../../lib/ost-sdk-ruby/util"
+require_relative "../../../lib/ost-sdk-ruby/saas"
+require "test/unit"
+require_relative "../../../lib/config"
+
+class SignatureGenerationTest < Test::Unit::TestCase
+
+  def signature_test_obj
+    params = {
+        api_secret: "a0431203671f42c079b2154066fd04ba"
+    }
+    @signature_test_obj ||= OSTSdk::Util::HTTPHelper.new(params)
+  end
+
+  def test_signature
+    test_obj_for_signature = {
+        a: nil,
+        b: [],
+        c: '',
+        d: ["", nil],
+        e: {},
+        k1: 125.45,
+        k2: 'Tejas',
+        aaaaa: {a: {a: "L21A", b: "L21B"}, b: {a: "L22A", b: "L22B"}, c: {a: "L23A", b: "L23B"}},
+        arrayValues: ["Hello", "There", "12345"],
+        garbage_str: "~!@#$%^&*()_+-= {}[]:\";'?/<>,. this is garbage"
+    }
+    test_endpoint = "/api/v2/users"
+    signature = signature_test_obj.get_signature_for_test(test_endpoint, test_obj_for_signature)
+    assert_equal(signature, "28664cdbc613b66835d7bcf825dce719fb8e0621992c291ba9bd1767c1c5560d")
+  end
+
+end

data/lib/ost-sdk-ruby/test/tokens_test.rb

@@ -0,0 +1,18 @@
+require_relative "../../../lib/ost-sdk-ruby/util"
+require_relative "../../../lib/ost-sdk-ruby/saas"
+require "test/unit"
+require_relative "../../../lib/config"
+
+class TokensTest < Test::Unit::TestCase
+
+  def tokens_service
+    @tokens_service ||= Config::OST_SDK.services.tokens
+  end
+
+  def test_tokens_get
+    result = tokens_service.get()
+    puts "result=>#{result}" unless result["success"]
+    assert_equal(result["success"], true )
+  end
+
+end

data/lib/ost-sdk-ruby/test/transactions_test.rb

@@ -0,0 +1,43 @@
+require_relative "../../../lib/ost-sdk-ruby/util"
+require_relative "../../../lib/ost-sdk-ruby/saas"
+require "test/unit"
+require_relative "../../../lib/config"
+
+class TransactionsTest < Test::Unit::TestCase
+
+  def transactions_service
+    @transactions_service ||= Config::OST_SDK.services.transactions
+  end
+
+  def test_transactions_execute
+    result = transactions_service.execute({
+                                     user_id: Config::OST_KIT_COMPANY_USER_ID,
+                                     to: Config::OST_KIT_RULE_ADDRESS,
+                                     raw_calldata: {
+                                         method: "directTransfers",
+                                         parameters: [[Config::OST_KIT_USER2_TOKEN_HOLDER_ADDRESS],["1"]]
+                                     }.to_json
+                                 })
+    puts "result=>#{result}" unless result["success"]
+
+    assert_equal(result["success"], true)
+  end
+
+  def test_transactions_get
+    result = transactions_service.get({
+                                     user_id: Config::OST_KIT_USER_ID,
+                                     transaction_id: Config::OST_KIT_TRANSACTION_ID
+                                 })
+    puts "result=>#{result}" unless result["success"]
+    assert_equal(result["success"], true)
+  end
+
+  def test_transactions_get_list
+    result = transactions_service.get_list({
+                                     user_id: Config::OST_KIT_USER_ID
+                                 })
+    puts "result=>#{result}" unless result["success"]
+    assert_equal(result["success"], true)
+  end
+
+end

data/lib/ost-sdk-ruby/test/users_test.rb

@@ -0,0 +1,32 @@
+require_relative "../../../lib/ost-sdk-ruby/util"
+require_relative "../../../lib/ost-sdk-ruby/saas"
+require "test/unit"
+require_relative "../../../lib/config"
+
+class UsersTest < Test::Unit::TestCase
+
+  def users_service
+    @users_service ||= Config::OST_SDK.services.users
+  end
+
+  def test_users_create
+    result = users_service.create()
+    puts "result=>#{result}" unless result["success"]
+    assert_equal(result["success"], true)
+  end
+
+  def test_users_get
+    result = users_service.get({
+                                   user_id: Config::OST_KIT_USER_ID
+                               })
+    puts "result=>#{result}" unless result["success"]
+    assert_equal(result["success"], true)
+  end
+
+  def test_users_get_list
+    result = users_service.get_list()
+    puts "result=>#{result}" unless result["success"]
+    assert_equal(result["success"], true)
+  end
+
+end

data/lib/ost-sdk-ruby/util.rb

@@ -1,6 +1,6 @@
 require_relative 'util/common_validator'
-require_relative 'util/result'
 require_relative 'util/api_credentials'
+require_relative 'util/custom_error_response'
 require_relative 'util/http_helper'
 require_relative 'util/services_helper'
 

data/lib/ost-sdk-ruby/util/common_validator.rb

@@ -4,6 +4,8 @@ module OSTSdk
 
     class CommonValidator
 
+      REGEX_FOR_UUID = /\A[0-9a-z\.\-]+\z/i
+
       # Check for numeric-ness of an input
       #
       # Arguments:
@@ -43,6 +45,18 @@ module OSTSdk
         obj.is_a?(Hash) || obj.is_a?(ActionController::Parameters)
       end
 
+      # Is the value is valid for given key
+      #
+      # Arguments:
+      #   object: (String)
+      #
+      # Returns:
+      #   Boolean
+      #
+      def self.is_valid_uuid_format?(value)
+        value =~ REGEX_FOR_UUID
+      end
+
     end
 
   end

data/lib/ost-sdk-ruby/util/custom_error_response.rb

@@ -0,0 +1,56 @@
+module OSTSdk
+
+  module Util
+
+    class CustomErrorResponse
+
+
+      def initialize(params)
+        @code = params[:code]
+        @internal_id = params[:internal_id]
+        @msg = params[:msg]
+        @error_data = params[:error_data]
+      end
+
+
+      def external_error_response
+        error_response({
+                           :code => @code,
+                           :internal_id => @internal_id,
+                           :msg => @msg,
+                           :error_data => @error_data
+                       })
+      end
+
+      def default_error_response
+        error_response({
+                           :code => 'SOMETHING_WENT_WRONG',
+                           :internal_id => "SDK(#{@internal_id})",
+                           :msg => @msg,
+                           :error_data => []
+                       })
+      end
+
+      def timeout_error_response
+        error_response({
+                           :code => 'REQUEST_TIMEOUT',
+                           :internal_id => "SDK(REQUEST_TIMEOUT)",
+                           :msg => '',
+                           :error_data => []
+                       })
+      end
+
+      private
+
+      def error_response(err)
+        {
+            success: false,
+            err: err
+        }
+      end
+
+    end
+
+  end
+
+end

data/lib/ost-sdk-ruby/util/http_helper.rb

@@ -9,7 +9,6 @@ module OSTSdk
       require "openssl"
       require "net/http"
       require "json"
-      require 'rack'
 
       # Initialize
       #
@@ -24,6 +23,13 @@ module OSTSdk
         @api_key = params[:api_key]
         @api_secret = params[:api_secret]
         @api_spec = params[:api_spec]
+        @timeout = 10
+        if (params.key?(:config))
+          config = params[:config]
+          if (config.key?(:timeout))
+            @timeout = config[:timeout]
+          end
+        end
       end
 
       # Send POST requests
@@ -33,18 +39,15 @@ module OSTSdk
       #   request_params: (Hash)
       #
       # Returns:
-      #   OSTSdk::Util::Result
+      #   response: (Hash)
       #
       def send_post_request(endpoint, request_params)
         perform_and_handle_exceptions('u_hh_1', 'POST request failed') do
-          base_params = get_base_params(endpoint, request_params)
-          uri = post_api_uri(endpoint)
+          escaped_query_string = get_query_string(endpoint, request_params)
+          uri = URI(get_api_url(endpoint))
           http = setup_request(uri)
-          r_params = base_params.merge(request_params)
-          query_string = Rack::Utils.build_nested_query(r_params)
-          escaped_query_string = URI.escape(query_string, '*')
           if @api_spec
-            return OSTSdk::Util::Result.success({data: {request_uri: uri.to_s, request_type: 'POST', request_params: escaped_query_string}})
+            return {request_uri: uri.to_s, request_type: 'POST', request_params: escaped_query_string}
           else
             result = http.post(uri.path, escaped_query_string)
             return format_response(result)
@@ -59,21 +62,18 @@ module OSTSdk
       #   request_params: (Hash)
       #
       # Returns:
-      #   OSTSdk::Util::Result
+      #   response: (Hash)
       #
       def send_get_request(endpoint, request_params)
         perform_and_handle_exceptions('u_hh_2', 'GET request Failed') do
-          base_params = get_base_params(endpoint, request_params)
-          r_params = base_params.merge(request_params)
-          query_string = Rack::Utils.build_nested_query(r_params)
-          escaped_query_string = URI.escape(query_string, '*')
-          raw_url = get_api_url(endpoint) + "?" + escaped_query_string
+          escaped_query_string = get_query_string(endpoint, request_params)
+          raw_url = get_api_url(endpoint) + "?#{escaped_query_string}"
           uri = URI(raw_url)
           if @api_spec
-            return OSTSdk::Util::Result.success({data: {request_uri: uri.to_s.split("?")[0], request_type: 'GET', request_params: escaped_query_string}})
+            return {request_uri: uri.to_s.split("?")[0], request_type: 'GET', request_params: escaped_query_string}
           else
             result = {}
-            Timeout.timeout(5) do
+            Timeout.timeout(@timeout) do
               result = Net::HTTP.get_response(uri)
             end
             return format_response(result)
@@ -81,12 +81,27 @@ module OSTSdk
         end
       end
 
+      # Generate a signature for test case. It only creates a signature for a given Hash
+      #
+      # Arguments:
+      #   end_point: (String)
+      #   request_params: (Hash)
+      #
+      # Returns:
+      #   response: (String)
+      #
+      def get_signature_for_test(endpoint, request_params)
+        escaped_query_string = get_escaped_query_string(request_params)
+        string_to_sign = "#{endpoint}?#{escaped_query_string}"
+        generate_signature(string_to_sign)
+      end
+
       private
 
       def setup_request(uri)
         http = Net::HTTP.new(uri.host, uri.port)
-        http.read_timeout = 5
-        http.open_timeout = 5
+        http.read_timeout = @timeout
+        http.open_timeout = @timeout
         if uri.scheme == "https"
           http.use_ssl = true
           http.verify_mode = OpenSSL::SSL::VERIFY_NONE
@@ -94,82 +109,98 @@ module OSTSdk
         http
       end
 
-      def get_base_params(endpoint, request_params)
-        request_timestamp = Time.now.to_i.to_s
-        request_params = request_params.merge("request_timestamp" => request_timestamp, "api_key" => @api_key)
+      def get_query_string(endpoint, request_params)
+        request_timestamp = Time.now.to_i
+        request_params = request_params.merge("api_request_timestamp" => request_timestamp,
+                                              "api_key" => @api_key,
+                                              "api_signature_kind" => "OST1-HMAC-SHA256")
+        escaped_query_string = get_escaped_query_string(request_params)
+        string_to_sign = endpoint + "?" + escaped_query_string
+        signature = generate_signature(string_to_sign)
+        "#{escaped_query_string}&api_signature=#{escape(signature)}"
+      end
 
+      def get_escaped_query_string(request_params)
         sorted_request_params = sort_param(request_params)
-        request_params_str = Rack::Utils.build_nested_query(sorted_request_params)
-        request_params_escaped_str = URI.escape(request_params_str, "*")
-
-        str = endpoint + '?' + request_params_escaped_str
-        signature = generate_signature(str)
-        {"request_timestamp" => request_timestamp, "signature" => signature, "api_key" => @api_key}
+        build_nested_query(sorted_request_params)
       end
 
       def generate_signature(string_to_sign)
         digest = OpenSSL::Digest.new('sha256')
-        signature = OpenSSL::HMAC.hexdigest(digest, @api_secret, string_to_sign)
-        signature
-      end
-
-      def post_api_uri(endpoint)
-        URI(@api_base_url + endpoint)
+        OpenSSL::HMAC.hexdigest(digest, @api_secret, string_to_sign)
       end
 
       def get_api_url(endpoint)
         @api_base_url + endpoint
       end
 
+      def build_nested_query(value, prefix = nil)
+        case value
+          when Array
+            value.map {|v|
+              build_nested_query(v, "#{prefix}[]")
+            }.reject(&:empty?).join("&")
+          when Hash
+            value.map {|k, v|
+              build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
+            }.reject(&:empty?).join('&')
+          # when nil
+          #   "#{escape(prefix)}="
+          else
+            raise ArgumentError, "value must be a Hash" if prefix.nil?
+            "#{escape(prefix)}=#{escape(value)}"
+        end
+      end
+
+      def escape(s)
+        s = URI.encode_www_form_component(s)
+
+        # escape [*] if not escaped by ruby
+        s = URI.escape(s, "*")
+
+        # unescape [~] if escaped by ruby
+        s = URI.unescape(s, "%7E")
+        s
+      end
+
       # Method which is called in service perform and handle exceptions
       #
-      def perform_and_handle_exceptions(err_code = 'swt', err_message = 'Something Went Wrong', &block)
+      def perform_and_handle_exceptions(internal_id = 'swr', msg = 'Something Went Wrong', &block)
         begin
           yield if block_given?
+        rescue Timeout::Error => ex
+          OSTSdk::Util::CustomErrorResponse.new({internal_id: internal_id, msg: msg}).timeout_error_response
         rescue StandardError => se
-          OSTSdk::Util::Result.exception(se, {error: err_code, error_message: err_message})
+          OSTSdk::Util::CustomErrorResponse.new({internal_id: internal_id, msg: msg}).default_error_response
         end
       end
 
       def sort_param(params)
 
-        if [Hash, Array].include?(params.class)
+        if params.is_a?(Hash)
           params = JSON.parse(params.to_json)
-        else
-          params = params.to_s
-        end
+          data = {}
+          params.sort.each do |ele|
+            key = ele[0]
+            val = ele[1]
+            data[key] = sort_param(val)
+          end
 
-        res = {}
-        if params.class == Array
+        elsif params.is_a?(Array)
+          params = JSON.parse(params.to_json)
           data = []
           params.each do |ele|
-            if [Hash, Array].include?(ele.class)
-              data << sort_param(ele)
-            else
-              data << ele.to_s
-            end
+            data << sort_param(ele)
           end
-          return data
+        else
+          data = params.to_s
         end
 
-        params.sort.each do |ele|
-          key = ele[0]
-          val = ele[1]
-          sorted_val = val
-
-          if [Hash, Array].include?(val.class)
-            sorted_val = sort_param(val)
-          else
-            sorted_val = sorted_val.to_s
-          end
-
-          res[key] = sorted_val
-        end
-        return res
+        return data
       end
 
       def format_response(response)
-        json_raw_response = JSON.parse(response.body)
+        json_raw_response = JSON.parse(response.body) rescue {}
         # If internal response
         if json_raw_response.has_key?('success') || json_raw_response.has_key?('err')
           format_internal_response(response)
@@ -180,58 +211,35 @@ module OSTSdk
 
       def format_internal_response(response)
         json_raw_response = JSON.parse(response.body)
-        if json_raw_response['success']
-          OSTSdk::Util::Result.success(
-              {
-                  data: json_raw_response['data'],
-                  http_code: response.code
-              }
-          )
-        else
-          err_data = json_raw_response['err']
-          OSTSdk::Util::Result.error(
-              {
-                  error: err_data['code'],
-                  internal_id: err_data['internal_id'],
-                  error_message: err_data['msg'],
-                  error_data: err_data['error_data'],
-                  http_code: response.code
-              }
-          )
-        end
+        json_raw_response
       end
 
       def format_external_response(response_code)
         case response_code.to_i
-          when 429
-            code = 'TOO_MANY_REQUESTS'
-            internal_id = 'SDK(TOO_MANY_REQUESTS)'
-            message = 'Too many requests have been received in a minute.'
           when 502
             code = 'BAD_GATEWAY'
             internal_id = 'SDK(BAD_GATEWAY)'
-            message = 'Something went wrong.'
+            msg = 'Something went wrong.'
           when 503
             code = 'SERVICE_UNAVAILABLE'
             internal_id = 'SDK(SERVICE_UNAVAILABLE)'
-            message = 'API under maintenance.'
+            msg = 'API under maintenance.'
           when 504
             code = 'GATEWAY_TIMEOUT'
             internal_id = 'SDK(GATEWAY_TIMEOUT)'
-            message = 'Request timed out.'
+            msg = 'Request timed out.'
           else
             code = 'SOMETHING_WENT_WRONG'
             internal_id = 'SDK(SOMETHING_WENT_WRONG)'
-            message = 'Something went wrong.'
+            msg = 'Something went wrong.'
         end
-        OSTSdk::Util::Result.error(
-            {
-                error: code,
-                internal_id: internal_id,
-                error_message: message,
-                http_code: response_code
-            }
-        )
+
+        OSTSdk::Util::CustomErrorResponse.new({
+                                                  code: code,
+                                                  msg: msg,
+                                                  internal_id: internal_id,
+                                                  error_data: []
+                                              }).external_error_response
       end
 
     end