synapse_fi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6e6933e283961c5db4a8f009d272a7aa74e501c3
+  data.tar.gz: 79d68318e948ea23958fe7ea0000ee9503038e54
+SHA512:
+  metadata.gz: 4d5d0707a08845b5c7469300982035c6b441eabfc5b01645cc8dc457a5264567c09a2340847e72e6ebad884c37c0842250c90ba886be3b0f3bda89533d011260
+  data.tar.gz: 2931dd52da4c6375de02b4b5b6bd54b0e12b38326525f793db6d105479df8b43088bbd3b49243709116810d208ffb6c414d2710d1b5bf149f772fae6c9e388c8

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
+test
+

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,43 @@
+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.5.0)
+    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.11.3)
+    minitest-reporters (1.3.5)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    netrc (0.11.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)
+    synapse_pay_rest (3.4.3)
+      rest-client (~> 2.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  dotenv
+  minitest
+  minitest-reporters
+  synapse_pay_rest
+
+BUNDLED WITH
+   1.17.1

data/README.md

@@ -0,0 +1,39 @@
+# SynapseFI-Ruby-v2
+
+Native API library for SynapsePay REST v3.x
+
+Not all API endpoints are supported.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'synapse_fi'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself by executing:
+
+```bash
+$ gem install synapse_fi
+```
+## Documentation
+
+- [API docs](http://docs.synapsefi.com/v3.1)
+- [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.
+
+## License
+
+[MIT License](LICENSE)
+
+

data/lib/synapse_api/client.rb

@@ -0,0 +1,355 @@
+require 'json'
+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)
+    	raise ArgumentError, 'client must be a Synapse::Client' unless self.is_a?(Client)
+      response = client.post(user_path,payload, options)
+
+
+      user = User.new(
+        user_id:                response['_id'],
+        refresh_token:     response['refresh_token'],
+        client:            client,
+        full_dehydrate:    "no",
+        payload:           response
+      )
+      user
+	  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 = User.new(
+            user_id:                response['_id'],
+            refresh_token:     response['refresh_token'],
+            client:            client,
+            full_dehydrate:    options[:full_dehydrate] == "yes" ? true : false,
+            payload:           response
+          )
+      user
+  	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
+    # @note users created this way are not automatically OAuthed
+    # @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 = Users.new(limit: response["limit"], page: response["page"], page_count: response["page_count"], user_count: response["user_count"], payload: users, http_client: client)
+
+      users
+  	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)}
+  		trans = Transactions.new(limit: trans["limit"], page: trans["page"], page_count: trans["page_count"], trans_count: trans["trans_count"], payload: response)
+  		trans
+
+  	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 = 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 [Array<String>]
+    # @param idempotency_key [String] (optional)
+    # @param url [String]
+    # @see https://docs.synapsefi.com/docs/create-subscription
+    # @return [Synapse::Subscription]
+  	def create_subscriptions(scope:, url:, **options)
+  		payload = {
+            'scope' => scope,
+            'url' => url,
+          }
+
+  		response = client.post(subscriptions_path , payload, options)
+
+  		subscriptions = 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 = 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 = Subscription.new(subscription_id: response["_id"], url: response["url"], payload: response)
+  	end
+
+    # updates subscription platform subscription
+    # @param subscription_id [String]
+    # @param is_active [boolean]
+    # @param url [String]
+    # @param scope [Array<String>]
+    # see https://docs.synapsefi.com/docs/update-subscription
+    # @return [Synapse::Subscription]
+    def update_subscriptions(subscription_id:, url:nil, scope:nil, is_active:nil)
+      path = subscriptions_path + "/#{subscription_id}"
+
+      payload = {}
+
+      payload["url"] = url if url
+      payload["scope"] = scope if scope
+      payload["is_active"] = is_active if is_active
+
+      response = client.patch(path, payload)
+      subscriptions = Subscription.new(subscription_id: response["_id"], url: response["url"], payload: response)
+    end
+
+
+  	# Issues public key for client
+  	# @param client [Synapse::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:)
+  		raise ArgumentError, 'scope must be a string' unless scope.is_a?(String)
+  		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,138 @@
+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 403
+    # Forbidden = Class.new(ClientError)
+    # '403' => Synapse::Error::Forbidden,
+
+    # Raised on the HTTP status code 404
+    NotFound = Class.new(ClientError)
+
+    # Raised on the HTTP status code 406
+    # NotAcceptable = Class.new(ClientError)
+    # '406' => Synapse::Error::NotAcceptable,
+
+    # Raised on the HTTP status code 409
+    Conflict = Class.new(ClientError)
+
+    # Raised on the HTTP status code 415
+    # UnsupportedMediaType = Class.new(ClientError)
+    # '415' => Synapse::Error::UnsupportedMediaType,
+
+    # Raised on the HTTP status code 422
+    # UnprocessableEntity = Class.new(ClientError)
+    # '422' => Synapse::Error::UnprocessableEntity,
+
+    # 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 502
+    # BadGateway = Class.new(ServerError)
+    # '502' => Synapse::Error::BadGateway,
+
+    # Raised on the HTTP status code 503
+    ServiceUnavailable = Class.new(ServerError)
+
+    # Raised on the HTTP status code 504
+    # GatewayTimeout = Class.new(ServerError)
+    # '504' => Synapse::Error::GatewayTimeout
+
+    # HTTP status code to Error subclass mapping
+    #
+    # @todo doesn't do well when there's an html response from nginx for bad gateway/timeout
+
+    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