Class: Synapse::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/synapse_api/client.rb

Overview

header values

Constant Summary collapse

VALID_QUERY_PARAMS = 
[:query, :page, :per_page, :full_dehydrate, :radius, :zip, :lat, :lon, :limit, :currency].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(client_id:, client_secret:, ip_address:, fingerprint: nil, development_mode: true, raise_for_202: nil, **options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • log_to (String) —

    (optional) file path to log to file (logging must be true)



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/synapse_api/client.rb', line 27

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

Instance Attribute Details

#client_id ⇒ Object (readonly)

Returns the value of attribute client_id.



14
15
16
 
# File 'lib/synapse_api/client.rb', line 14

def client_id
  @client_id
end

#http_client ⇒ Object Also known as: client

Returns the value of attribute http_client.



12
13
14
 
# File 'lib/synapse_api/client.rb', line 12

def http_client
  @http_client
end

Instance Method Details

#create_subscriptions(scope:, **options) ⇒ Synapse::Subscription

Queries Synapse API to create a webhook subscriptions for platform

Parameters:

  • scope (Hash)
  • idempotency_key (String) —

    (optional)

Returns:

See Also:



192
193
194
195
196
 
# File 'lib/synapse_api/client.rb', line 192

def create_subscriptions(scope:, **options)
	response = client.post(subscriptions_path , scope, options)

	Subscription.new(subscription_id: response["_id"], url: response["url"], payload: response)
end

#create_user(payload:, ip_address:, **options) ⇒ Synapse::User

Queries Synapse API to create a new user

Parameters:

  • payload (Hash)
  • idempotency_key (String) —

    (optional)

  • ip_address (String) —

    (optional)

  • fingerprint (String) —

    (optional)

Returns:

See Also:



52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/synapse_api/client.rb', line 52

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

#get_all_institutions(**options) ⇒ Object

Queries Synapse API for all institutions available for bank logins

Parameters:

  • page (Integer) —

    (optional) response will default to 1

  • per_page (Integer) —

    (optional) response will default to 20

Returns:

  • API response [Hash]



183
184
185
 
# File 'lib/synapse_api/client.rb', line 183

def get_all_institutions(**options)
	client.get(institutions_path(options))
end

#get_all_nodes(**options) ⇒ Array<Synapse::Nodes>

Queries Synapse API for all nodes belonging to platform

Parameters:

  • page (Integer) —

    (optional) response will default to 1

  • per_page (Integer) —

    (optional) response will default to 20

Returns:



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/synapse_api/client.rb', line 156

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

#get_all_subscriptions(**options) ⇒ Array<Synapse::Subscriptions>

Queries Synapse API for all platform subscriptions

Parameters:

  • page (Integer) —

    (optional) response will default to 1

  • per_page (Integer) —

    (optional) response will default to 20

Returns:



202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/synapse_api/client.rb', line 202

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

#get_all_transaction(**options) ⇒ Array<Synapse::Transactions>

Queries Synapse for all transactions on platform

Parameters:

  • page (Integer) —

    (optional) response will default to 1

  • per_page (Integer) —

    (optional) response will default to 20

Returns:



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/synapse_api/client.rb', line 131

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

#get_crypto_market_data(**options) ⇒ Object

Queries Synapse API for Crypto Currencies Market data

Parameters:

  • limit (Integer)
  • currency (String)

Returns:

  • API response [Hash]



291
292
293
294
295
296
297
298
299
300
301
302
 
# File 'lib/synapse_api/client.rb', line 291

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

#get_crypto_quotes ⇒ Object

Queries Synapse API for Crypto Currencies Quotes

Returns:

  • API response [Hash]



276
277
278
279
280
281
282
283
284
285
 
# File 'lib/synapse_api/client.rb', line 276

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

#get_subscription(subscription_id:) ⇒ Synapse::Subscription

Queries Synapse API for a subscription by subscription_id

Parameters:

  • subscription_id (String)

Returns:



220
221
222
223
224
 
# File 'lib/synapse_api/client.rb', line 220

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

#get_user(user_id:, **options) ⇒ Synapse::User

Parameters:

  • full_dehydrate (String) —

    (optional) if true, returns all KYC on user

  • ip_address (String) —

    (optional)

  • fingerprint (String) —

    (optional)

Returns:

Raises:

  • (ArgumentError)

See Also:



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/synapse_api/client.rb', line 82

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

#get_users(**options) ⇒ Array<Synapse::Users>

users with matching name/email

Parameters:

  • page (Integer) —

    (optional) response will default to 1

  • per_page (Integer) —

    (optional) response will default to 20

Returns:



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/synapse_api/client.rb', line 108

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

#issue_public_key(scope:) ⇒ Object

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”



249
250
251
252
253
254
 
# File 'lib/synapse_api/client.rb', line 249

def issue_public_key(scope:)
	path = '/client?issue_public_key=YES'
	path += "&scope=#{scope}"
	response = client.get(path)
	response[ "public_key_obj"]
end

#locate_atm(**options) ⇒ Hash

Queries Synapse API for ATMS nearby

Parameters:

  • zip (String)
  • radius (String)
  • lat (String)
  • lon (String)

Returns:

  • (Hash)

See Also:



263
264
265
266
267
268
269
270
271
272
 
# File 'lib/synapse_api/client.rb', line 263

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

#update_headers(fingerprint: nil, idemopotency_key: nil, ip_address: nil) ⇒ Object

Update headers in HTTPClient class for API request headers

Parameters:

  • fingerprint (Hash) (defaults to: nil)
  • idemopotency_key (Hash) (defaults to: nil)
  • ip_address (Hash) (defaults to: nil) 


71
72
73
 
# File 'lib/synapse_api/client.rb', line 71

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

#update_subscriptions(subscription_id:, body:) ⇒ Synapse::Subscription

Updates subscription platform subscription see docs.synapsefi.com/docs/update-subscription

Parameters:

  • subscription_id (String)
  • body (Hash)

Returns:



231
232
233
234
235
236
 
# File 'lib/synapse_api/client.rb', line 231

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

#webhook_logs ⇒ Hash

Returns all of the webhooks belonging to client

Returns:

  • (Hash) 


240
241
242
243
 
# File 'lib/synapse_api/client.rb', line 240

def webhook_logs()
  path = subscriptions_path + "/logs"
  client.get(path)
end