Class: Synapse::User

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

Overview

Wrapper class for /users endpoints

Constant Summary collapse

VALID_QUERY_PARAMS =

Valid optional args for #get

[:query, :page, :per_page, :type, :full_dehydrate, :ship, :force_refresh].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(user_id:, refresh_token:, client:, payload:, full_dehydrate:) ⇒ User

Returns a new instance of User.

Parameters:

  • user_id (String)
  • refresh_token (String)
  • client (Synapse::HTTPClient)
  • payload (Hash)
  • full_dehydrate (Boolean) 


24
25
26
27
28
29
30
 
# File 'lib/synapse_api/user.rb', line 24

def initialize(user_id:,refresh_token:, client:,payload:, full_dehydrate:)
  @user_id = user_id
  @client = client
  @refresh_token = refresh_token
  @payload =payload
  @full_dehydrate =full_dehydrate
end

Instance Attribute Details

#client ⇒ Object

Returns the value of attribute client.



17
18
19
 
# File 'lib/synapse_api/user.rb', line 17

def client
  @client
end

#expires_in ⇒ Object

Returns the value of attribute expires_in.



17
18
19
 
# File 'lib/synapse_api/user.rb', line 17

def expires_in
  @expires_in
end

#full_dehydrate ⇒ Object

Returns the value of attribute full_dehydrate.



17
18
19
 
# File 'lib/synapse_api/user.rb', line 17

def full_dehydrate
  @full_dehydrate
end

#oauth_key ⇒ Object

Returns the value of attribute oauth_key.



17
18
19
 
# File 'lib/synapse_api/user.rb', line 17

def oauth_key
  @oauth_key
end

#payload ⇒ Object

Returns the value of attribute payload.



17
18
19
 
# File 'lib/synapse_api/user.rb', line 17

def payload
  @payload
end

#refresh_token(**options) ⇒ Object

Parameters:

  • full_dehydrate (Boolean)

See Also:



116
117
118
 
# File 'lib/synapse_api/user.rb', line 116

def refresh_token
  @refresh_token
end

#user_id ⇒ Object

Returns the value of attribute user_id.



17
18
19
 
# File 'lib/synapse_api/user.rb', line 17

def user_id
  @user_id
end

Instance Method Details

#ach_mfa(payload:, **options) ⇒ Synapse::Node

Submit answer to a MFA question using access token from bank login attempt Please be sure to call ach_mfa again if you have more security questions

Parameters:

  • payload (Hash)
  • idempotency_key (String) —

    (optional)

Returns:

See Also:



250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/synapse_api/user.rb', line 250

def ach_mfa(payload:, **options)
  path = get_user_path(user_id: self.user_id)
  path = path + nodes_path

  begin
    response = client.post(path,payload, options)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    response = client.post(path,payload, options)
  end

  if response["nodes"]
    nodes = response["nodes"].map { |nodes_data| Node.new(user_id: self.user_id, node_id: nodes_data["_id"], full_dehydrate: false, payload: response, type: nodes_data["type"])}
    nodes = Nodes.new(page: response["page"], limit: response["limit"], page_count: response["page_count"], nodes_count: response["node_count"], payload: nodes)
  else
    access_token = response
  end

  access_token ? access_token : nodes
end

#authenticate(**options) ⇒ Object

Parameters:

  • idempotency_key (String) —

    (optional)

See Also:



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/synapse_api/user.rb', line 130

def authenticate(**options)
    payload = {
      "refresh_token" => self.refresh_token()
    }
    payload["scope"] = options[:scope] if options[:scope]

    path = oauth_path()

  oauth_response = client.post(path, payload,options)
    oauth_key = oauth_response['oauth_key']
    oauth_expires = oauth_response['expires_in']
    self.oauth_key = oauth_key
    self.expires_in = oauth_expires
    client.update_headers(oauth_key: oauth_key)

    oauth_response
end

#cancel_transaction(node_id:, trans_id:) ⇒ Object

Cancels transaction if it has not already settled

Parameters:

  • node_id
  • trans_id

Returns:

  • API response [Hash]



536
537
538
539
540
541
542
543
544
545
546
 
# File 'lib/synapse_api/user.rb', line 536

def cancel_transaction(node_id:, trans_id:)

  path = trans_path(user_id: self.user_id, node_id: node_id) + "/#{trans_id}"
  begin
    response = client.delete(path)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    response = client.delete(path)
  end
  response
end

#comment_transaction(node_id:, trans_id:, payload:) ⇒ Synapse::Transaction

Adds comment to the transactions

Parameters:

  • node_id (String)
  • trans_id (String)
  • payload (Hash)

Returns:



518
519
520
521
522
523
524
525
526
527
528
529
530
 
# File 'lib/synapse_api/user.rb', line 518

def comment_transaction(node_id:,trans_id:,payload:)

  path = trans_path(user_id: self.user_id, node_id: node_id) + "/#{trans_id}"

  begin
    trans = client.patch(path, payload)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    trans = client.patch(path, payload)
  end
  transaction = Transaction.new(trans_id: trans['_id'], payload: trans)
  transaction
end

#confirm_2fa_pin(pin:, **options) ⇒ Object

Supply pin for 2FA confirmation

Parameters:

  • pin (String)
  • idempotency_key (String) —

    (optional)

  • scope (Array) —

    (optional)

Returns:

  • API response [Hash]

See Also:



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
# File 'lib/synapse_api/user.rb', line 170

def confirm_2fa_pin(pin:, **options)
  payload = {
    "refresh_token": self.refresh_token,
    "validation_pin": pin
  }

  payload["scope"] = options[:scope] if options[:scope]

  path = oauth_path()

  pin_response = client.post(path, payload, options)
  oauth_key = pin_response['oauth_key']
  oauth_expires = pin_response['expires_in']
  self.oauth_key = oauth_key
  self.expires_in = oauth_expires
  client.update_headers(oauth_key: oauth_key)

  pin_response
end

#create_node(payload:, **options) ⇒ Synapse::Node

Note:

Types of nodes [Card, IB/Deposit-US, Check/Wire Instructions]

Creates Synapse node

Parameters:

  • payload (Hash)
  • idempotency_key (String) —

    (optional)

Returns:

See Also:



223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
# File 'lib/synapse_api/user.rb', line 223

def create_node(payload:, **options)
  path = get_user_path(user_id: self.user_id)
  path = path + nodes_path

    begin
      response = client.post(path,payload, options)
    rescue Synapse::Error::Unauthorized
      self.authenticate()
      response = client.post(path,payload, options)
    end

    if response["nodes"]
      nodes = response["nodes"].map { |nodes_data| Node.new(user_id: self.user_id, node_id: nodes_data["_id"], full_dehydrate: false, payload: response, type: nodes_data["type"])}
      nodes = Nodes.new(page: response["page"], limit: response["limit"], page_count: response["page_count"], nodes_count: response["node_count"], payload: nodes)
    else
      access_token = response
    end

    access_token ? access_token : nodes
end

#create_subnet(node_id:, payload:, **options) ⇒ Synapse::Subnet

Creates subnet for a node

Parameters:

  • node_id (String)
  • payload (Hash)
  • idempotency_key (String) —

    (optional)

Returns:



574
575
576
577
578
579
580
581
582
583
584
585
 
# File 'lib/synapse_api/user.rb', line 574

def create_subnet(node_id:,payload:, **options)
  path = subnet_path(user_id: self.user_id, node_id: node_id)

  begin
   subnet = client.post(path,payload, options)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   subnet = client.post(path,payload, options)
  end
  subnet = Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
  subnet
end

#create_transaction(node_id:, payload:, **options) ⇒ Synapse::Transaction

Creates a new transaction in the API belonging to the provided node

Parameters:

  • node_id (String)
  • payload (Hash)
  • idempotency_key (String) —

    (optional)

Returns:



350
351
352
353
354
355
356
357
358
359
360
 
# File 'lib/synapse_api/user.rb', line 350

def create_transaction(node_id: ,payload:, **options)
  path = trans_path(user_id: self.user_id, node_id: node_id)

  begin
   transaction = client.post(path,payload, options)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   transaction = client.post(path,payload, options)
  end
  transaction = Transaction.new(trans_id: transaction['_id'], payload: transaction, node_id: node_id)
end

#create_ubo(payload:) ⇒ Object

Allows you to upload an Ultimate Beneficial Ownership document

Parameters:

  • payload (Hash)

Returns:

  • API response

See Also:



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

def create_ubo(payload:)
  path = get_user_path(user_id: self.user_id)
  path = path + nodes_path + "/ubo"

  begin
   response = client.patch(path,payload)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   response = client.patch(path,payload)
  end

  response
end

#delete_node(node_id:) ⇒ Object 



478
479
480
481
482
483
484
485
486
487
488
 
# File 'lib/synapse_api/user.rb', line 478

def delete_node(node_id:)
  path = node(user_id: self.user_id, node_id: node_id)

  begin
    delete = client.delete(path)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    delete = client.delete(path)
  end
  delete
end

#dispute_card_transactions(node_id:, trans_id:) ⇒ Object

Dispute a transaction for a user

Parameters:

  • node_id
  • trans_id

Returns:

  • API response [Hash]

See Also:



553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
 
# File 'lib/synapse_api/user.rb', line 553

def dispute_card_transactions(node_id:, trans_id:)

  path = trans_path(user_id: user_id, node_id: node_id) + "/#{trans_id}"
  path += "/dispute"
  payload = {
    "dispute_reason":"CHARGE_BACK"
  }
  begin
    dispute = client.patch(path, payload)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    dispute = client.patch(path, payload)
  end
  dispute
end

#dummy_transactions(node_id:, is_credit: nil) ⇒ Object

Initiates dummy transactions to a node

Parameters:

  • node_id (String)
  • is_credit (Boolean) (defaults to: nil) —

    , for credit send true, for debit send false

See Also:



494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
 
# File 'lib/synapse_api/user.rb', line 494

def dummy_transactions(node_id:, is_credit: nil)

  is_credit = "YES" if is_credit == true
  is_credit = "NO" if is_credit == false
  if is_credit
    path = node(user_id: self.user_id, node_id: node_id) + "/dummy-tran?#{is_credit}"
  else
    path = node(user_id: self.user_id, node_id: node_id) + "/dummy-tran"
  end

  begin
   response = client.get(path)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   response = client.get(path)
  end
  response
end

#generate_apple_pay_token(node_id:, payload:) ⇒ Object

Generate tokenized info for Apple Wallet

Parameters:

  • node_id (String)
  • payload (Hash)

See Also:



445
446
447
448
449
450
451
452
453
454
 
# File 'lib/synapse_api/user.rb', line 445

def generate_apple_pay_token(node_id:,payload:)
  path = node(user_id: self.user_id, node_id: node_id) + "/applepay"
  begin
    response = client.patch(path, payload)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    response = client.patch(path, payload)
  end
  response
end

#get_all_node_transaction(node_id:, **options) ⇒ Array<Synapse::Transaction>

Queries the API for all transactions belonging to the supplied node

Parameters:

  • node_id (String) —

    node to which the transaction belongs

  • page (Integer) —

    (optional) response will default to 1

  • per_page (Integer) —

    (optional) response will default to 20

Returns:



385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
 
# File 'lib/synapse_api/user.rb', line 385

def get_all_node_transaction(node_id:, **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 = node(user_id: self.user_id, node_id: node_id) + "/trans"

  params = VALID_QUERY_PARAMS.map do |p|
    options[p] ? "#{p}=#{options[p]}" : nil
  end.compact

  path += '?' + params.join('&') if params.any?

  begin
    trans = client.get(path)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    trans = client.get(path)
  end


  response = trans["trans"].map { |trans_data| Transaction.new(trans_id: trans_data['_id'], payload: trans_data, node_id: node_id)}
  trans = Transactions.new(limit: trans["limit"], page: trans["page"], page_count: trans["page_count"], trans_count: trans["trans_count"], payload: response)
  trans
end

#get_all_subnets(node_id:, **options) ⇒ Object

Gets all node subnets

Parameters:

  • node_id (String)
  • page (Integer)
  • per_page (Integer)

See Also:



593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
 
# File 'lib/synapse_api/user.rb', line 593

def get_all_subnets(node_id:,**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 = node(user_id: self.user_id, node_id: node_id) + "/subnets"
  params = VALID_QUERY_PARAMS.map do |p|
    options[p] ? "#{p}=#{options[p]}" : nil
  end.compact
  path += '?' + params.join('&') if params.any?

  begin
   subnets = client.get(path)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   subnets = client.get(path)
  end

  response = subnets["subnets"].map { |subnets_data| Subnet.new(subnet_id: subnets_data['_id'], payload: subnets, node_id: node_id)}

  subnets = Subnets.new(limit: subnets["limit"], page: subnets["page"], page_count: subnets["page_count"], subnets_count: subnets["subnets_count"], payload: response, node_id: node_id)

  subnets
end

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

Queries Synapse API for all nodes belonging to user

Parameters:

  • page (String, Integer) —

    (optional) response will default to 1

  • per_page (String, Integer) —

    (optional) response will default to 20

  • type (String) —

    (optional)

Returns:

See Also:



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/synapse_api/user.rb', line 92

def get_all_user_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 = get_user_path(user_id: self.user_id) + nodes_path(options)

    begin
     nodes = client.get(path)
    rescue Synapse::Error::Unauthorized
     self.authenticate()
     nodes = client.get(path)
    end

  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", type: node_data["type"])}
    nodes = Nodes.new(limit: nodes["limit"], page: nodes["page"], page_count: nodes["page_count"], nodes_count: nodes["node_count"], payload: response)
end

#get_node_statements(node_id:, **options) ⇒ Object

Gets statement by node

Parameters:

  • page (Integer)
  • per_page (Integer)

Returns:

  • API response [Hash]

See Also:



643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
 
# File 'lib/synapse_api/user.rb', line 643

def get_node_statements(node_id:,**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 = node(user_id: self.user_id, node_id: node_id) + "/statements"
  params = VALID_QUERY_PARAMS.map do |p|
    options[p] ? "#{p}=#{options[p]}" : nil
  end.compact
  path += '?' + params.join('&') if params.any?

  begin
   statements = client.get(path)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   statements = client.get(path)
  end

  statements
end

#get_node_transaction(node_id:, trans_id:) ⇒ Synapse::Transaction

Queries the API for a transaction belonging to the supplied node by transaction id

Parameters:

  • node_id (String)
  • trans_id (String) —

    id of the transaction to find

Returns:



366
367
368
369
370
371
372
373
374
375
376
377
 
# File 'lib/synapse_api/user.rb', line 366

def get_node_transaction(node_id:, trans_id:)
  path = node(user_id: self.user_id, node_id: node_id) + "/trans/#{trans_id}"

  begin
    trans = client.get(path)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    trans = client.get(path)
  end
  transaction = Transaction.new(trans_id: trans['_id'], payload: trans, node_id: node_id)
  transaction
end

#get_subnet(node_id:, subnet_id:) ⇒ Synapse::Subnet

Queries a node for a specific subnet by subnet_id

Parameters:

  • node_id (String) —

    id of node

  • subnet_id (String, void) —

    (optional) id of a subnet to look up

Returns:



624
625
626
627
628
629
630
631
632
633
634
635
636
 
# File 'lib/synapse_api/user.rb', line 624

def get_subnet(node_id:,subnet_id:)

  path = node(user_id: self.user_id, node_id: node_id) + "/subnets/#{subnet_id}"

  begin
   subnet = client.get(path)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   subnet = client.get(path)
  end
  subnet = Subnet.new(subnet_id: subnet['_id'], payload: subnet, node_id: node_id)
  subnet
end

#get_user_node(node_id:, **options) ⇒ Synapse::Node

Queries the API for a node belonging to user for ACH node

Parameters:

  • node_id (String)
  • full_dehydrate (String) —

    (optional) if true, returns all trans data on node

  • force_refresh (String) —

    (optional) if true, force refresh yes will attempt updating the account balance and transactions

Returns:



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/synapse_api/user.rb', line 61

def get_user_node(node_id:, **options)
  options[:full_dehydrate] = "yes" if options[:full_dehydrate] == true
  options[:full_dehydrate] = "no" if options[:full_dehydrate] == false
  options[:force_refresh] = "yes" if options[:force_refresh] == true
  options[:force_refresh] = "no" if options[:force_refresh] == false

  path = node(node_id:node_id, full_dehydrate: options[:full_dehydrate],force_refresh: options[:force_refresh] )

  begin
    node = client.get(path)
  rescue Synapse::Error::Unauthorized

    self.authenticate()
    node = client.get(path)
  end

  node = Node.new(node_id: node['_id'],
    user_id: self.user_id,
    payload: node,
    full_dehydrate: options[:full_dehydrate] == "yes" ? true : false,
    type: node["type"]
    )
  node
end

#get_user_statement(**options) ⇒ Object

Gets user statement

Parameters:

  • page (Integer)
  • per_page (Integer)

Returns:

  • API response

See Also:



295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/synapse_api/user.rb', line 295

def get_user_statement(**options)
  path = get_user_path(user_id: self.user_id) + "/statements"
  params = VALID_QUERY_PARAMS.map do |p|
    options[p] ? "#{p}=#{options[p]}" : nil
  end.compact
  path += '?' + params.join('&') if params.any?

  begin
   statements = client.get(path)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   statements = client.get(path)
  end

  statements
end

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

Parameters:

  • page (Integer) —

    (optional) response will default to 1

  • per_page (Integer) —

    (optional) response will default to 20

Returns:



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/synapse_api/user.rb', line 194

def get_user_transactions(**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 = transactions_path(user_id: self.user_id, options: options)

  begin
    trans = client.get(path)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    trans = client.get(path)
  end


  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

#reinitiate_micro_deposit(node_id:) ⇒ Object

Reinitiate microdeposits on a node

Parameters:

  • node_id (String) 


429
430
431
432
433
434
435
436
437
438
439
 
# File 'lib/synapse_api/user.rb', line 429

def reinitiate_micro_deposit(node_id:)
  payload = {}
  path = node(user_id: self.user_id, node_id: node_id) + "?resend_micro=YES"
  begin
    response = client.patch(path, payload)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    response = client.patch(path, payload)
  end
  node = Node.new(user_id: self.user_id, node_id:response["_id"], full_dehydrate: false, payload: response, type: response["type"])
end

#reset_debit_card(node_id:) ⇒ Synapse::Node

Resets debit card number, cvv, and expiration date

Parameters:

  • node_id (String)

Returns:

See Also:



333
334
335
336
337
338
339
340
341
342
343
 
# File 'lib/synapse_api/user.rb', line 333

def reset_debit_card(node_id:)
  path = node(user_id: self.user_id, node_id: node_id)  + "?reset=YES"
  payload = {}
  begin
   response = client.patch(path,payload)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   response = client.patch(path,payload)
  end
  node = Node.new(user_id: self.user_id, node_id:response["_id"], full_dehydrate: false, payload: response, type: response["type"])
end

#select_2fa_device(device:, **options) ⇒ Object

For registering new fingerprint Supply 2FA device which pin should be sent to

Parameters:

  • device (String)
  • idempotency_key (String) —

    (optional)

Returns:

  • API response [Hash]

See Also:



154
155
156
157
158
159
160
161
162
 
# File 'lib/synapse_api/user.rb', line 154

def select_2fa_device(device:, **options)
  payload = {
    "refresh_token": self.refresh_token,
    "phone_number": device
  }
  path = oauth_path()
  device_response = client.post(path, payload, options)
  device_response
end

#ship_card(node_id:, payload:) ⇒ Synapse::Node

Request to ship a user card

Parameters:

  • node_id (String)
  • payload (Hash)

Returns:



316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/synapse_api/user.rb', line 316

def ship_card(node_id:, payload:)

  path = node(user_id: self.user_id, node_id: node_id) + "?ship=YES"

  begin
   response = client.patch(path,payload)
  rescue Synapse::Error::Unauthorized
   self.authenticate()
   response = client.patch(path,payload)
  end
  node = Node.new(user_id: self.user_id, node_id:response["_id"], full_dehydrate: false, payload: response, type: response["type"])
end

#update_node(node_id:, payload:) ⇒ Synapse::Node

Update supp_id, nickname, etc. for a node

Parameters:

  • node_id (String)
  • payload (Hash)

Returns:

See Also:



461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
 
# File 'lib/synapse_api/user.rb', line 461

def update_node(node_id:, payload:)
  path = node(user_id: self.user_id, node_id: node_id)

  begin
    update = client.patch(path, payload)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    update = client.patch(path, payload)
  end
  update = Node.new(node_id: node_id,
                    user_id: self.user_id,
                    payload: update,
                    full_dehydrate: false,
                    type: update["type"]
                    )
end

#user_update(payload:) ⇒ Synapse::User

Parameters:

  • payload (Hash)

Returns:



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/synapse_api/user.rb', line 36

def user_update(payload:)
  path = get_user_path(user_id: self.user_id)
   begin
     response = client.patch(path, payload)
   rescue Synapse::Error::Unauthorized
     self.authenticate()
     response =client.patch(path, payload)
   end
  user = User.new(
          user_id:                response['_id'],
          refresh_token:     response['refresh_token'],
          client:            client,
          full_dehydrate:    false,
          payload:           response
        )

    user
end

#verify_micro_deposit(node_id:, payload:) ⇒ Object

Verifies microdeposits for a node

Parameters:

  • node_id (String)
  • payload (Hash) 


416
417
418
419
420
421
422
423
424
425
 
# File 'lib/synapse_api/user.rb', line 416

def verify_micro_deposit(node_id:,payload:)
  path = node(user_id: self.user_id, node_id: node_id)
  begin
    response = client.patch(path, payload)
  rescue Synapse::Error::Unauthorized
    self.authenticate()
    response = client.patch(path, payload)
  end
  node = Node.new(user_id: self.user_id, node_id:response["_id"], full_dehydrate: false, payload: response, type: response["type"])
end