synapse_api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 045443506a7bba92667a57f1b2df462ec130325c42c683f3dd4e069dabe2590b
+  data.tar.gz: 0e8d50efa968105c68073581fc00ba9cd341726bdc037b001a6705a9568f6d12
+SHA512:
+  metadata.gz: 9b88547519a9a5a28d64b978c228b099a6d4988e7e564b82a1d48e64520ee644331dd3cf2c4761f39012b12b23abce704efd539d5478811bed7b2b3b6d12a13c
+  data.tar.gz: ad711542a3aa43f21935cf67ad8c5fab4658ebab649850a84b65a4fc4578af821db8693eb51f53f4130000297b00a9137a3d6f5561e795b0f0857c1b871f5f37

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
+gem 'rubygems-update'

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    synapse_api (1.0.0)
+      rest-client (~> 2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.3)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    dotenv (2.1.2)
+    http-accept (1.7.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    mime-types (3.3)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2019.1009)
+    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.1.0)
+      http-accept (>= 1.7.0, < 2.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    ruby-progressbar (1.10.0)
+    rubygems-update (3.0.6)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  dotenv (~> 2.1.1)
+  minitest (~> 5.8.2)
+  minitest-reporters (~> 1.1.5)
+  rake (~> 10.0)
+  rubygems-update
+  synapse_api!
+
+BUNDLED WITH
+   1.17.2

data/README.md

@@ -0,0 +1,53 @@
+# SynapseRuby
+![Gem](https://img.shields.io/gem/v/synapseruby.svg)
+![status](https://img.shields.io/badge/status-beta-yellow.svg)
+
+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)
+- [synapseruby gem docs](https://rubygems.org/gems/synapseruby)
+- [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.rb

@@ -0,0 +1,28 @@
+# client
+require "synapse_api/client"
+# error
+require "synapse_api/error"
+# http_request
+require "synapse_api/http_request"
+# node
+require "synapse_api/node"
+# nodes
+require "synapse_api/nodes"
+# subnet
+require "synapse_api/subnet"
+# subnets
+require "synapse_api/subnets"
+# subscription
+require "synapse_api/subscription"
+# subscriptions
+require "synapse_api/subscriptions"
+# transaction
+require "synapse_api/transaction"
+# transactions
+require "synapse_api/transactions"
+# user
+require "synapse_api/user"
+# users
+require "synapse_api/users"
+# version
+require "synapse_api/version"

data/lib/synapse_api/client.rb

@@ -0,0 +1,405 @@
+require 'synapse_api'
+
+
+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, :ticker_symbol].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)
+        # @param ip_address [String] (optional)
+        # @param fingerprint [String] (optional)
+        # @return [Synapse::User]
+        # @see https://docs.synapsepay.com/docs/create-a-user payload structure
+        def create_user(payload:, ip_address:, **options)
+            client.update_headers(ip_address: ip_address, fingerprint: options[:fingerprint])
+
+            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
+        # @param ip_address [String] (optional)
+        # @param fingerprint [String] (optional)
+        # @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
+
+            client.update_headers(ip_address: options[:ip_address], fingerprint: options[:fingerprint])
+
+      		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["users_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
+        # @param page [Integer] (Optional)
+        # @param per_page [Integer] (Optional)
+        # @return [Hash]
+        def webhook_logs(**options)
+            path = subscriptions_path + "/logs"
+
+            params = VALID_QUERY_PARAMS.map do |p|
+                options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+
+            path += '?' + params.join('&') if params.any?
+
+            client.get(path)
+        end
+
+      	# Issues public key for client
+      	# @param scope [String]
+        # @param user_id [String] (Optional)
+        # @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:, user_id: nil)
+      		path = '/client?issue_public_key=YES'
+
+            path += "&scope=#{scope}"
+
+            path += "&user_id=#{user_id}" if user_id
+
+      		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
+
+        # Queries Synapse API for Trade Market data
+        # @param ticker_symbol [String]
+        # @return API response [Hash]
+        def get_trade_market_data(**options)
+            path = '/nodes/trade-market-watch'
+
+            params = VALID_QUERY_PARAMS.map do |p|
+                options[p] ? "#{p}=#{options[p]}" : nil
+            end.compact
+
+            path += '?' + params.join('&') if params.any?
+
+            market_data = client.get(path)
+            market_data
+        end
+
+        # Queries Synapse API for Routing Verification
+        # @param payload [Hash]
+        # @return API response [Hash]
+        def routing_number_verification(payload:)
+            path = '/routing-number-verification'
+
+            response = client.post(path,payload)
+            response
+        end
+
+        # Queries Synapse API for Address Verification
+        # @param payload [Hash]
+        # @return API response [Hash]
+        def address_verification(payload:)
+            path = '/address-verification'
+
+            response = client.post(path,payload)
+            response
+        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