synapseruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ebc99ee79db2dbcb7e91d2cab9e902593a9ab15e
+  data.tar.gz: 8a71c65ff8748d4c83e452f7b6bc09d7e90b625f
+SHA512:
+  metadata.gz: 79bce83ab437fb49be69d94d311debed6ae6cd8c930c1e935069a3db8130ef79094c8eb42c16a836b5c49daecaf9a687c62867ea08f9c5f07bdfdc89a517f776
+  data.tar.gz: 87b7cc6334d114f46dfd4b334f3864c466ae1ca2376de9049335ac271302f8d091ac39bfd23ccd8e2d3866f64c4af519a0bb65a26c77f738f1253fcbab713498

data/.env.sample

@@ -0,0 +1,9 @@
+# For development in a console
+ CLIENT_ID=your_sandbox_client_id
+ CLIENT_SECRET=your_sandbox_client_secret
+ FINGERPRINT=your_sandbox_fingerprint
+
+ # For running tests
+TEST_CLIENT_ID=your_sandbox_client_id
+TEST_CLIENT_SECRET=your_sandbox_client_secret
+

data/.gitignore

@@ -0,0 +1,3 @@
+.env
+.DS_Store
+

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+source 'https://rubygems.org'
+
+
+# Specify your gem's dependencies in your *.gemspec file
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    synapse_fi (0.0.3)
+      rest-client (~> 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.3)
+    domain_name (0.5.20180417)
+      unf (>= 0.0.5, < 1.0.0)
+    dotenv (2.1.2)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    mime-types (3.2.2)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2018.0812)
+    minitest (5.8.5)
+    minitest-reporters (1.1.19)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    netrc (0.11.0)
+    rake (10.5.0)
+    rest-client (2.0.2)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    ruby-progressbar (1.10.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  dotenv (~> 2.1.1)
+  minitest (~> 5.8.2)
+  minitest-reporters (~> 1.1.5)
+  rake (~> 10.0)
+  synapse_fi!
+
+BUNDLED WITH
+   1.17.1

data/README.md

@@ -0,0 +1,51 @@
+# SynapseRuby
+
+Native API library for SynapseFI REST v3.x
+
+Not all API endpoints are supported.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'synapseruby'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself by executing:
+
+```bash
+$ gem install synapseruby
+```
+## Documentation
+
+- [API docs](http://docs.synapsefi.com/v3.1)
+- [synapse_fi gem docs](https://www.rubydoc.info/gems/synapse_fi)
+- [Samples demonstrating common operations](samples.md)
+
+## Contributing
+
+For minor issues, please open a pull request. For larger changes or features, please email hello@synapsepay.com. Please document and test any public constants/methods.
+
+## Running the Test Suite
+
+If you haven't already, set the `TEST_CLIENT_ID` and `TEST_CLIENT_SECRET` environment variables in `.env` file .
+Please read and update test files with your user own test id's
+
+To run all tests, execute:
+
+```bash
+rake test
+```
+
+## License
+
+[MIT License](LICENSE)
+
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task :default => :test

data/lib/synapse_api/client.rb

@@ -0,0 +1,359 @@
+require_relative './http_request'
+require_relative './user'
+require_relative './users'
+require_relative './transaction'
+require_relative './transactions'
+require_relative './node'
+require_relative './nodes'
+require_relative './subscription'
+require_relative './subscriptions'
+require_relative './subnet'
+require_relative './subnets'
+require 'pp'
+
+module Synapse
+	# Initializes various wrapper settings such as development mode and request
+ 	# header values
+
+  class Client
+
+  	VALID_QUERY_PARAMS = [:query, :page, :per_page, :full_dehydrate, :radius, :zip, :lat, :lon, :limit, :currency].freeze
+
+  	attr_accessor :http_client
+
+  	attr_reader :client_id
+
+  	# Alias for #http_client
+  	alias_method :client, :http_client
+
+  	# @param client_id [String] should be stored in environment variable
+    # @param client_secret [String] should be stored in environment variable
+    # @param ip_address [String] user's IP address
+    # @param fingerprint [String] a hashed value, either unique to user or static
+    # @param development_mode [String] default true
+    # @param raise_for_202 [Boolean]
+	 	# @param logging [Boolean] (optional) logs to stdout when true
+    # @param log_to [String] (optional) file path to log to file (logging must be true)
+    def initialize(client_id:, client_secret:, ip_address:, fingerprint:nil,development_mode: true, raise_for_202:nil, **options)
+  		base_url = if development_mode
+                   'https://uat-api.synapsefi.com/v3.1'
+                 else
+                   'https://api.synapsefi.com/v3.1'
+                 end
+        @client_id = client_id
+        @client_secret = client_secret
+        @http_client  = HTTPClient.new(base_url: base_url,
+                                     client_id: client_id,
+                                     client_secret: client_secret,
+                                     fingerprint: fingerprint,
+                                     ip_address: ip_address,
+                                     raise_for_202: raise_for_202,
+                                     **options
+                                     )
+    end
+
+    # Queries Synapse API to create a new user
+    # @param payload [Hash]
+    # @param idempotency_key [String] (optional)
+    # @return [Synapse::User]
+    # @see https://docs.synapsepay.com/docs/create-a-user payload structure
+    def create_user(payload:, **options)
+      response = client.post(user_path,payload, options)
+
+      User.new(user_id:           response['_id'],
+               refresh_token:     response['refresh_token'],
+               client:            client,
+               full_dehydrate:    "no",
+               payload:           response
+              )
+	  end
+
+    # Update headers in HTTPClient class
+    # for API request headers
+    # @param fingerprint [Hash]
+    # @param idemopotency_key [Hash]
+    # @param ip_address [Hash]
+    def update_headers(fingerprint:nil, idemopotency_key:nil, ip_address:nil)
+      client.update_headers(fingerprint: fingerprint, idemopotency_key: idemopotency_key, ip_address: ip_address)
+    end
+
+  	# Queries Synapse API for a user by user_id
+  	# @param user_id [String] id of the user to find
+    # @param full_dehydrate [String] (optional) if true, returns all KYC on user
+    # @see https://docs.synapsefi.com/docs/get-user
+    # @return [Synapse::User]
+  	def get_user(user_id:, **options)
+  		raise ArgumentError, 'client must be a Synapse::Client' unless self.is_a?(Client)
+  		raise ArgumentError, 'user_id must be a String' unless user_id.is_a?(String)
+
+  		options[:full_dehydrate] = "yes" if options[:full_dehydrate] == true
+  		options[:full_dehydrate] = "no" if options[:full_dehydrate] == false
+
+  		path = user_path(user_id: user_id, full_dehydrate: options[:full_dehydrate])
+  		response = client.get(path)
+
+  		User.new(user_id:         response['_id'],
+               refresh_token:   response['refresh_token'],
+               client:          client,
+               full_dehydrate:  options[:full_dehydrate] == "yes" ? true : false,
+               payload:         response
+              )
+  	end
+
+  	# Queries Synapse API for platform users
+  	# @param query [String] (optional) response will be filtered to
+    # users with matching name/email
+    # @param page [Integer] (optional) response will default to 1
+    # @param per_page [Integer] (optional) response will default to 20
+    # @return [Array<Synapse::Users>]
+  	def get_users(**options)
+  		path = user_path(options)
+  		response = client.get(path)
+  		return [] if response["users"].empty?
+  		users = response["users"].map { |user_data| User.new(user_id:         user_data['_id'],
+                                                           refresh_token:   user_data['refresh_token'],
+                                                           client:          client,
+                                                           full_dehydrate:  "no",
+                                                           payload:         user_data
+                                                           )}
+  		Users.new(limit:       response["limit"],
+                page:        response["page"],
+                page_count:  response["page_count"],
+                user_count:  response["user_count"],
+                payload:     users,
+                http_client: client
+               )
+  	end
+
+    # Queries Synapse for all transactions on platform
+    # @param page [Integer] (optional) response will default to 1
+    # @param per_page [Integer] (optional) response will default to 20
+    # @return [Array<Synapse::Transactions>]
+  	def get_all_transaction(**options)
+  		path = '/trans'
+
+  		params = VALID_QUERY_PARAMS.map do |p|
+  			options[p] ? "#{p}=#{options[p]}" : nil
+  		end.compact
+
+  		path += '?' + params.join('&') if params.any?
+
+  		trans = client.get(path)
+
+  		return [] if trans["trans"].empty?
+  		response = trans["trans"].map { |trans_data| Transaction.new(trans_id: trans_data['_id'], payload: trans_data)}
+  		Transactions.new(limit:       trans["limit"],
+                       page:        trans["page"],
+                       page_count:  trans["page_count"],
+                       trans_count: trans["trans_count"],
+                       payload:     response
+                       )
+  	end
+
+    # Queries Synapse API for all nodes belonging to platform
+    # @param page [Integer] (optional) response will default to 1
+    # @param per_page [Integer] (optional) response will default to 20
+    # @return [Array<Synapse::Nodes>]
+  	def get_all_nodes(**options)
+  		[options[:page], options[:per_page]].each do |arg|
+        if arg && (!arg.is_a?(Integer) || arg < 1)
+          raise ArgumentError, "#{arg} must be nil or an Integer >= 1"
+        end
+      end
+  		path = nodes_path(options: options)
+  		nodes = client.get(path)
+
+  		return [] if nodes["nodes"].empty?
+  		response = nodes["nodes"].map { |node_data| Node.new(node_id:        node_data['_id'],
+                                                           user_id:        node_data['user_id'],
+                                                           payload:        node_data,
+                                                           full_dehydrate: "no"
+                                                           )}
+  		Nodes.new(limit:       nodes["limit"],
+                page:        nodes["page"],
+                page_count:  nodes["page_count"],
+                nodes_count: nodes["node_count"],
+                payload:     response
+               )
+  	end
+
+    # Queries Synapse API for all institutions available for bank logins
+    # @param page [Integer] (optional) response will default to 1
+    # @param per_page [Integer] (optional) response will default to 20
+    # @return API response [Hash]
+  	def get_all_institutions(**options)
+  		client.get(institutions_path(options))
+  	end
+
+    # Queries Synapse API to create a webhook subscriptions for platform
+    # @param scope [Hash]
+    # @param idempotency_key [String] (optional)
+    # @see https://docs.synapsefi.com/docs/create-subscription
+    # @return [Synapse::Subscription]
+  	def create_subscriptions(scope:, **options)
+  		response = client.post(subscriptions_path , scope, options)
+
+  		Subscription.new(subscription_id: response["_id"], url: response["url"], payload: response)
+  	end
+
+    # Queries Synapse API for all platform subscriptions
+    # @param page [Integer] (optional) response will default to 1
+    # @param per_page [Integer] (optional) response will default to 20
+    # @return [Array<Synapse::Subscriptions>]
+  	def get_all_subscriptions(**options)
+  		subscriptions = client.get(subscriptions_path(options))
+
+  		return [] if subscriptions["subscriptions"].empty?
+  		response = subscriptions["subscriptions"].map { |subscription_data| Subscription.new(subscription_id: subscription_data["_id"],
+                                                                                           url: subscription_data["url"],
+                                                                                           payload: subscription_data)}
+  		Subscriptions.new(limit:               subscriptions["limit"],
+                        page:                subscriptions["page"],
+                        page_count:          subscriptions["page_count"],
+                        subscriptions_count: subscriptions["subscription_count"],
+                        payload:             response
+                        )
+  	end
+
+    # Queries Synapse API for a subscription by subscription_id
+    # @param subscription_id [String]
+    # @return [Synapse::Subscription]
+  	def get_subscription(subscription_id:)
+  		path = subscriptions_path + "/#{subscription_id}"
+  		response = client.get(path)
+  		Subscription.new(subscription_id: response["_id"], url: response["url"], payload: response)
+  	end
+
+    # Updates subscription platform subscription
+    # @param subscription_id [String]
+    # @param body [Hash]
+    # see https://docs.synapsefi.com/docs/update-subscription
+    # @return [Synapse::Subscription]
+    def update_subscriptions(subscription_id:, body:)
+      path = subscriptions_path + "/#{subscription_id}"
+
+      response = client.patch(path, body)
+      Subscription.new(subscription_id: response["_id"], url: response["url"], payload: response)
+    end
+
+    # Returns all of the webhooks belonging to client
+    # @return [Hash]
+    def webhook_logs()
+      path = subscriptions_path + "/logs"
+      client.get(path)
+    end
+
+  	# Issues public key for client
+  	# @param scope [String]
+    # @see https://docs.synapsefi.com/docs/issuing-public-key
+  	# @note valid scope "OAUTH|POST,USERS|POST,USERS|GET,USER|GET,USER|PATCH,SUBSCRIPTIONS|GET,SUBSCRIPTIONS|POST,SUBSCRIPTION|GET,SUBSCRIPTION|PATCH,CLIENT|REPORTS,CLIENT|CONTROLS"
+  	def issue_public_key(scope:)
+  		path = '/client?issue_public_key=YES'
+  		path += "&scope=#{scope}"
+  		response = client.get(path)
+  		response[ "public_key_obj"]
+  	end
+
+    # Queries Synapse API for ATMS nearby
+    # @param zip [String]
+    # @param radius [String]
+    # @param lat [String]
+    # @param lon [String]
+    # @see https://docs.synapsefi.com/docs/locate-atms
+    # @return [Hash]
+    def locate_atm(**options)
+      params = VALID_QUERY_PARAMS.map do |p|
+        options[p] ? "#{p}=#{options[p]}" : nil
+      end.compact
+
+      path = "/nodes/atms?"
+      path += params.join('&') if params.any?
+      atms = client.get(path)
+      atms
+    end
+
+    # Queries Synapse API for Crypto Currencies Quotes
+    # @return API response [Hash]
+    def get_crypto_quotes()
+      path = '/nodes/crypto-quotes'
+      params = VALID_QUERY_PARAMS.map do |p|
+        options[p] ? "#{p}=#{options[p]}" : nil
+      end.compact
+
+      path += '?' + params.join('&') if params.any?
+      quotes = client.get(path)
+      quotes
+    end
+
+    # Queries Synapse API for Crypto Currencies Market data
+    # @param limit [Integer]
+    # @param currency [String]
+    # @return API response [Hash]
+    def get_crypto_market_data(**options)
+      path = '/nodes/crypto-market-watch'
+
+      params = VALID_QUERY_PARAMS.map do |p|
+        options[p] ? "#{p}=#{options[p]}" : nil
+      end.compact
+
+      path += '?' + params.join('&') if params.any?
+
+      data = client.get(path)
+      data
+    end
+
+    private
+    def user_path(user_id: nil, **options)
+    	path = "/users"
+    	path += "/#{user_id}" if user_id
+
+    	params = VALID_QUERY_PARAMS.map do |p|
+        options[p] ? "#{p}=#{options[p]}" : nil
+      end.compact
+
+  	  path += '?' + params.join('&') if params.any?
+    	path
+    end
+
+    def transactions_path(user_id: nil, node_id: nil, **options)
+    	path = "/users/#{user_id}/trans"
+    	params = VALID_QUERY_PARAMS.map do |p|
+  		options[p] ? "#{p}=#{options[p]}" : nil
+  	end.compact
+
+  	path += '?' + params.join('&') if params.any?
+    	path
+    end
+
+    def nodes_path(**options)
+    	path = "/nodes"
+    	params = VALID_QUERY_PARAMS.map do |p|
+  		options[p] ? "#{p}=#{options[p]}" : nil
+  	end.compact
+
+  	path += '?' + params.join('&') if params.any?
+    	path
+    end
+
+    def institutions_path(**options)
+    	path = "/institutions"
+    	params = VALID_QUERY_PARAMS.map do |p|
+  		options[p] ? "#{p}=#{options[p]}" : nil
+  	end.compact
+
+  	path += '?' + params.join('&') if params.any?
+    	path
+    end
+
+    def subscriptions_path(**options)
+    	path = "/subscriptions"
+    	params = VALID_QUERY_PARAMS.map do |p|
+        options[p] ? "#{p}=#{options[p]}" : nil
+      end.compact
+
+      path += '?' + params.join('&') if params.any?
+      path
+    end
+  end
+end
+

data/lib/synapse_api/error.rb

@@ -0,0 +1,111 @@
+module Synapse
+  # Custom class for handling HTTP and API errors.
+  class Error < StandardError
+    # Raised on a 4xx HTTP status code
+    ClientError = Class.new(self)
+
+    # Raised on the HTTP status code 202
+    Accepted = Class.new(ClientError)
+
+    # Raised on the HTTP status code 400
+    BadRequest = Class.new(ClientError)
+
+    # Raised on the HTTP status code 401
+    Unauthorized = Class.new(ClientError)
+
+    # Raised on the HTTP status code 402
+    RequestDeclined = Class.new(ClientError)
+
+    # Raised on the HTTP status code 404
+    NotFound = Class.new(ClientError)
+
+    # Raised on the HTTP status code 409
+    Conflict = Class.new(ClientError)
+
+    # Raised on the HTTP status code 429
+    TooManyRequests = Class.new(ClientError)
+
+    # Raised on a 5xx HTTP status code
+    ServerError = Class.new(self)
+
+    # Raised on the HTTP status code 500
+    InternalServerError = Class.new(ServerError)
+
+    # Raised on the HTTP status code 503
+    ServiceUnavailable = Class.new(ServerError)
+
+    # HTTP status code to Error subclass mapping
+    ERRORS = {
+      '202' => Synapse::Error::Accepted,
+      '400' => Synapse::Error::BadRequest,
+      '401' => Synapse::Error::Unauthorized,
+      '402' => Synapse::Error::RequestDeclined,
+      '404' => Synapse::Error::NotFound,
+      '409' => Synapse::Error::Conflict,
+      '429' => Synapse::Error::TooManyRequests,
+      '500' => Synapse::Error::InternalServerError,
+      '503' => Synapse::Error::ServiceUnavailable,
+    }.freeze
+
+    # The SynapsePay API Error Code
+    #
+    # @return [Integer]
+    attr_reader :code, :http_code
+
+    # The JSON HTTP response in Hash form
+    # @return [Hash]
+    attr_reader :response, :message
+
+    class << self
+      # Create a new error from an HTTP response
+      # @param body [String]
+      # @param code [Integer]
+      # @param http_code [Integer]
+      # @return [Synapse::Error]
+      def from_response(body)
+        message, error_code, http_code = parse_error(body)
+        http_code = http_code.to_s
+        klass = ERRORS[http_code] || Synapse::Error
+        klass.new(message: message, code: error_code, response: body, http_code: http_code)
+      end
+
+      private
+
+      def parse_error(body)
+
+        if body.nil? || body.empty?
+          ['', nil, nil]
+
+        elsif body['mfa'] && body.is_a?(Hash)
+          ["#{body['mfa']["message"] } acces_token: #{body['mfa']["access_token"]}", body['error_code'], body['http_code']]
+        elsif body[:mfa] && body.is_a?(Hash)
+          ["#{body[:mfa][:message] } acces_token: #{body[:mfa][:access_token]}", body[:error_code], body[:http_code]]
+
+        elsif body['message'] && body.is_a?(Hash)
+          [body["message"]["en"], body['error_code'], body['http_code']]
+         elsif body[:message] && body.is_a?(Hash)
+          [body[:message][:en], body[:error_code], body[:http_code]]
+
+        elsif body.is_a?(Hash) && body['error'].is_a?(Hash)
+          [body['error']['en'], body['error_code'], body['http_code']]
+        elsif body.is_a?(Hash) && body[:error].is_a?(Hash)
+          [body[:error][:en], body[:error_code], body[:http_code]]
+
+        end
+      end
+    end
+
+    # Initializes a new Error object
+    # @param message [Exception, String]
+    # @param code [Integer]
+    # @param response [Hash]
+    # @return [Synapse::Error]
+    def initialize(message: '', code: nil, response: {}, http_code:)
+      super(message)
+      @code     = code
+      @response = response
+      @message = message
+      @http_code = http_code
+    end
+  end
+end