Class: Evernote::EDAM::NoteStore::NoteStore::Processor

Inherits:
Object
  • Object
show all
Includes:
Thrift::Processor
Defined in:
lib/Evernote/EDAM/note_store.rb

Instance Method Summary collapse

Methods included from Thrift::Processor

#initialize, #process, #read_args, #write_result

Instance Method Details

#process_authenticateToSharedNote(seqid, iprot, oprot) ⇒ Object 



2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2428

def process_authenticateToSharedNote(seqid, iprot, oprot)
  args = read_args(iprot, AuthenticateToSharedNote_args)
  result = AuthenticateToSharedNote_result.new()
  begin
    result.success = @handler.authenticateToSharedNote(args.guid, args.noteKey, args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'authenticateToSharedNote', seqid)
end

#process_authenticateToSharedNotebook(seqid, iprot, oprot) ⇒ Object 



2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2353

def process_authenticateToSharedNotebook(seqid, iprot, oprot)
  args = read_args(iprot, AuthenticateToSharedNotebook_args)
  result = AuthenticateToSharedNotebook_result.new()
  begin
    result.success = @handler.authenticateToSharedNotebook(args.shareKey, args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'authenticateToSharedNotebook', seqid)
end

#process_copyNote(seqid, iprot, oprot) ⇒ Object 



1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1980

def process_copyNote(seqid, iprot, oprot)
  args = read_args(iprot, CopyNote_args)
  result = CopyNote_result.new()
  begin
    result.success = @handler.copyNote(args.authenticationToken, args.noteGuid, args.toNotebookGuid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'copyNote', seqid)
end

#process_createLinkedNotebook(seqid, iprot, oprot) ⇒ Object 



2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2293

def process_createLinkedNotebook(seqid, iprot, oprot)
  args = read_args(iprot, CreateLinkedNotebook_args)
  result = CreateLinkedNotebook_result.new()
  begin
    result.success = @handler.createLinkedNotebook(args.authenticationToken, args.linkedNotebook)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'createLinkedNotebook', seqid)
end

#process_createNote(seqid, iprot, oprot) ⇒ Object 



1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1892

def process_createNote(seqid, iprot, oprot)
  args = read_args(iprot, CreateNote_args)
  result = CreateNote_result.new()
  begin
    result.success = @handler.createNote(args.authenticationToken, args.note)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'createNote', seqid)
end

#process_createNotebook(seqid, iprot, oprot) ⇒ Object 



1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1480

def process_createNotebook(seqid, iprot, oprot)
  args = read_args(iprot, CreateNotebook_args)
  result = CreateNotebook_result.new()
  begin
    result.success = @handler.createNotebook(args.authenticationToken, args.notebook)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'createNotebook', seqid)
end

#process_createSearch(seqid, iprot, oprot) ⇒ Object 



1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1654

def process_createSearch(seqid, iprot, oprot)
  args = read_args(iprot, CreateSearch_args)
  result = CreateSearch_result.new()
  begin
    result.success = @handler.createSearch(args.authenticationToken, args.search)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'createSearch', seqid)
end

#process_createSharedNotebook(seqid, iprot, oprot) ⇒ Object 



2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2203

def process_createSharedNotebook(seqid, iprot, oprot)
  args = read_args(iprot, CreateSharedNotebook_args)
  result = CreateSharedNotebook_result.new()
  begin
    result.success = @handler.createSharedNotebook(args.authenticationToken, args.sharedNotebook)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'createSharedNotebook', seqid)
end

#process_createTag(seqid, iprot, oprot) ⇒ Object 



1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1566

def process_createTag(seqid, iprot, oprot)
  args = read_args(iprot, CreateTag_args)
  result = CreateTag_result.new()
  begin
    result.success = @handler.createTag(args.authenticationToken, args.tag)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'createTag', seqid)
end

#process_deleteNote(seqid, iprot, oprot) ⇒ Object 



1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1922

def process_deleteNote(seqid, iprot, oprot)
  args = read_args(iprot, DeleteNote_args)
  result = DeleteNote_result.new()
  begin
    result.success = @handler.deleteNote(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'deleteNote', seqid)
end

#process_emailNote(seqid, iprot, oprot) ⇒ Object 



2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2383

def process_emailNote(seqid, iprot, oprot)
  args = read_args(iprot, EmailNote_args)
  result = EmailNote_result.new()
  begin
    @handler.emailNote(args.authenticationToken, args.parameters)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'emailNote', seqid)
end

#process_expungeInactiveNotes(seqid, iprot, oprot) ⇒ Object 



1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1967

def process_expungeInactiveNotes(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeInactiveNotes_args)
  result = ExpungeInactiveNotes_result.new()
  begin
    result.success = @handler.expungeInactiveNotes(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'expungeInactiveNotes', seqid)
end

#process_expungeLinkedNotebook(seqid, iprot, oprot) ⇒ Object 



2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2338

def process_expungeLinkedNotebook(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeLinkedNotebook_args)
  result = ExpungeLinkedNotebook_result.new()
  begin
    result.success = @handler.expungeLinkedNotebook(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'expungeLinkedNotebook', seqid)
end

#process_expungeNote(seqid, iprot, oprot) ⇒ Object 



1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1937

def process_expungeNote(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeNote_args)
  result = ExpungeNote_result.new()
  begin
    result.success = @handler.expungeNote(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'expungeNote', seqid)
end

#process_expungeNotebook(seqid, iprot, oprot) ⇒ Object 



1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1508

def process_expungeNotebook(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeNotebook_args)
  result = ExpungeNotebook_result.new()
  begin
    result.success = @handler.expungeNotebook(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'expungeNotebook', seqid)
end

#process_expungeNotes(seqid, iprot, oprot) ⇒ Object 



1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1952

def process_expungeNotes(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeNotes_args)
  result = ExpungeNotes_result.new()
  begin
    result.success = @handler.expungeNotes(args.authenticationToken, args.noteGuids)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'expungeNotes', seqid)
end

#process_expungeSearch(seqid, iprot, oprot) ⇒ Object 



1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1682

def process_expungeSearch(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeSearch_args)
  result = ExpungeSearch_result.new()
  begin
    result.success = @handler.expungeSearch(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'expungeSearch', seqid)
end

#process_expungeSharedNotebooks(seqid, iprot, oprot) ⇒ Object 



2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2278

def process_expungeSharedNotebooks(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeSharedNotebooks_args)
  result = ExpungeSharedNotebooks_result.new()
  begin
    result.success = @handler.expungeSharedNotebooks(args.authenticationToken, args.sharedNotebookIds)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'expungeSharedNotebooks', seqid)
end

#process_expungeTag(seqid, iprot, oprot) ⇒ Object 



1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1611

def process_expungeTag(seqid, iprot, oprot)
  args = read_args(iprot, ExpungeTag_args)
  result = ExpungeTag_result.new()
  begin
    result.success = @handler.expungeTag(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'expungeTag', seqid)
end

#process_findNoteCounts(seqid, iprot, oprot) ⇒ Object 



1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1742

def process_findNoteCounts(seqid, iprot, oprot)
  args = read_args(iprot, FindNoteCounts_args)
  result = FindNoteCounts_result.new()
  begin
    result.success = @handler.findNoteCounts(args.authenticationToken, args.filter, args.withTrash)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'findNoteCounts', seqid)
end

#process_findNoteOffset(seqid, iprot, oprot) ⇒ Object 



1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1712

def process_findNoteOffset(seqid, iprot, oprot)
  args = read_args(iprot, FindNoteOffset_args)
  result = FindNoteOffset_result.new()
  begin
    result.success = @handler.findNoteOffset(args.authenticationToken, args.filter, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'findNoteOffset', seqid)
end

#process_findNotes(seqid, iprot, oprot) ⇒ Object 



1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1697

def process_findNotes(seqid, iprot, oprot)
  args = read_args(iprot, FindNotes_args)
  result = FindNotes_result.new()
  begin
    result.success = @handler.findNotes(args.authenticationToken, args.filter, args.offset, args.maxNotes)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'findNotes', seqid)
end

#process_findNotesMetadata(seqid, iprot, oprot) ⇒ Object 



1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1727

def process_findNotesMetadata(seqid, iprot, oprot)
  args = read_args(iprot, FindNotesMetadata_args)
  result = FindNotesMetadata_result.new()
  begin
    result.success = @handler.findNotesMetadata(args.authenticationToken, args.filter, args.offset, args.maxNotes, args.resultSpec)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'findNotesMetadata', seqid)
end

#process_findRelated(seqid, iprot, oprot) ⇒ Object 



2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2443

def process_findRelated(seqid, iprot, oprot)
  args = read_args(iprot, FindRelated_args)
  result = FindRelated_result.new()
  begin
    result.success = @handler.findRelated(args.authenticationToken, args.query, args.resultSpec)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'findRelated', seqid)
end

#process_getDefaultNotebook(seqid, iprot, oprot) ⇒ Object 



1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1467

def process_getDefaultNotebook(seqid, iprot, oprot)
  args = read_args(iprot, GetDefaultNotebook_args)
  result = GetDefaultNotebook_result.new()
  begin
    result.success = @handler.getDefaultNotebook(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'getDefaultNotebook', seqid)
end

#process_getFilteredSyncChunk(seqid, iprot, oprot) ⇒ Object 



1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1396

def process_getFilteredSyncChunk(seqid, iprot, oprot)
  args = read_args(iprot, GetFilteredSyncChunk_args)
  result = GetFilteredSyncChunk_result.new()
  begin
    result.success = @handler.getFilteredSyncChunk(args.authenticationToken, args.afterUSN, args.maxEntries, args.filter)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'getFilteredSyncChunk', seqid)
end

#process_getLinkedNotebookSyncChunk(seqid, iprot, oprot) ⇒ Object 



1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1424

def process_getLinkedNotebookSyncChunk(seqid, iprot, oprot)
  args = read_args(iprot, GetLinkedNotebookSyncChunk_args)
  result = GetLinkedNotebookSyncChunk_result.new()
  begin
    result.success = @handler.getLinkedNotebookSyncChunk(args.authenticationToken, args.linkedNotebook, args.afterUSN, args.maxEntries, args.fullSyncOnly)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getLinkedNotebookSyncChunk', seqid)
end

#process_getLinkedNotebookSyncState(seqid, iprot, oprot) ⇒ Object 



1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1409

def process_getLinkedNotebookSyncState(seqid, iprot, oprot)
  args = read_args(iprot, GetLinkedNotebookSyncState_args)
  result = GetLinkedNotebookSyncState_result.new()
  begin
    result.success = @handler.getLinkedNotebookSyncState(args.authenticationToken, args.linkedNotebook)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getLinkedNotebookSyncState', seqid)
end

#process_getNote(seqid, iprot, oprot) ⇒ Object 



1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1757

def process_getNote(seqid, iprot, oprot)
  args = read_args(iprot, GetNote_args)
  result = GetNote_result.new()
  begin
    result.success = @handler.getNote(args.authenticationToken, args.guid, args.withContent, args.withResourcesData, args.withResourcesRecognition, args.withResourcesAlternateData)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNote', seqid)
end

#process_getNoteApplicationData(seqid, iprot, oprot) ⇒ Object 



1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1772

def process_getNoteApplicationData(seqid, iprot, oprot)
  args = read_args(iprot, GetNoteApplicationData_args)
  result = GetNoteApplicationData_result.new()
  begin
    result.success = @handler.getNoteApplicationData(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNoteApplicationData', seqid)
end

#process_getNoteApplicationDataEntry(seqid, iprot, oprot) ⇒ Object 



1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1787

def process_getNoteApplicationDataEntry(seqid, iprot, oprot)
  args = read_args(iprot, GetNoteApplicationDataEntry_args)
  result = GetNoteApplicationDataEntry_result.new()
  begin
    result.success = @handler.getNoteApplicationDataEntry(args.authenticationToken, args.guid, args.key)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNoteApplicationDataEntry', seqid)
end

#process_getNotebook(seqid, iprot, oprot) ⇒ Object 



1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1452

def process_getNotebook(seqid, iprot, oprot)
  args = read_args(iprot, GetNotebook_args)
  result = GetNotebook_result.new()
  begin
    result.success = @handler.getNotebook(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNotebook', seqid)
end

#process_getNoteContent(seqid, iprot, oprot) ⇒ Object 



1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1832

def process_getNoteContent(seqid, iprot, oprot)
  args = read_args(iprot, GetNoteContent_args)
  result = GetNoteContent_result.new()
  begin
    result.success = @handler.getNoteContent(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNoteContent', seqid)
end

#process_getNoteSearchText(seqid, iprot, oprot) ⇒ Object 



1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1847

def process_getNoteSearchText(seqid, iprot, oprot)
  args = read_args(iprot, GetNoteSearchText_args)
  result = GetNoteSearchText_result.new()
  begin
    result.success = @handler.getNoteSearchText(args.authenticationToken, args.guid, args.noteOnly, args.tokenizeForIndexing)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNoteSearchText', seqid)
end

#process_getNoteTagNames(seqid, iprot, oprot) ⇒ Object 



1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1877

def process_getNoteTagNames(seqid, iprot, oprot)
  args = read_args(iprot, GetNoteTagNames_args)
  result = GetNoteTagNames_result.new()
  begin
    result.success = @handler.getNoteTagNames(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNoteTagNames', seqid)
end

#process_getNoteVersion(seqid, iprot, oprot) ⇒ Object 



2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2010

def process_getNoteVersion(seqid, iprot, oprot)
  args = read_args(iprot, GetNoteVersion_args)
  result = GetNoteVersion_result.new()
  begin
    result.success = @handler.getNoteVersion(args.authenticationToken, args.noteGuid, args.updateSequenceNum, args.withResourcesData, args.withResourcesRecognition, args.withResourcesAlternateData)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getNoteVersion', seqid)
end

#process_getPublicNotebook(seqid, iprot, oprot) ⇒ Object 



2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2190

def process_getPublicNotebook(seqid, iprot, oprot)
  args = read_args(iprot, GetPublicNotebook_args)
  result = GetPublicNotebook_result.new()
  begin
    result.success = @handler.getPublicNotebook(args.userId, args.publicUri)
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getPublicNotebook', seqid)
end

#process_getResource(seqid, iprot, oprot) ⇒ Object 



2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2025

def process_getResource(seqid, iprot, oprot)
  args = read_args(iprot, GetResource_args)
  result = GetResource_result.new()
  begin
    result.success = @handler.getResource(args.authenticationToken, args.guid, args.withData, args.withRecognition, args.withAttributes, args.withAlternateData)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResource', seqid)
end

#process_getResourceAlternateData(seqid, iprot, oprot) ⇒ Object 



2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2160

def process_getResourceAlternateData(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceAlternateData_args)
  result = GetResourceAlternateData_result.new()
  begin
    result.success = @handler.getResourceAlternateData(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceAlternateData', seqid)
end

#process_getResourceApplicationData(seqid, iprot, oprot) ⇒ Object 



2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2040

def process_getResourceApplicationData(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceApplicationData_args)
  result = GetResourceApplicationData_result.new()
  begin
    result.success = @handler.getResourceApplicationData(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceApplicationData', seqid)
end

#process_getResourceApplicationDataEntry(seqid, iprot, oprot) ⇒ Object 



2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2055

def process_getResourceApplicationDataEntry(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceApplicationDataEntry_args)
  result = GetResourceApplicationDataEntry_result.new()
  begin
    result.success = @handler.getResourceApplicationDataEntry(args.authenticationToken, args.guid, args.key)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceApplicationDataEntry', seqid)
end

#process_getResourceAttributes(seqid, iprot, oprot) ⇒ Object 



2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2175

def process_getResourceAttributes(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceAttributes_args)
  result = GetResourceAttributes_result.new()
  begin
    result.success = @handler.getResourceAttributes(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceAttributes', seqid)
end

#process_getResourceByHash(seqid, iprot, oprot) ⇒ Object 



2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2130

def process_getResourceByHash(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceByHash_args)
  result = GetResourceByHash_result.new()
  begin
    result.success = @handler.getResourceByHash(args.authenticationToken, args.noteGuid, args.contentHash, args.withData, args.withRecognition, args.withAlternateData)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceByHash', seqid)
end

#process_getResourceData(seqid, iprot, oprot) ⇒ Object 



2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2115

def process_getResourceData(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceData_args)
  result = GetResourceData_result.new()
  begin
    result.success = @handler.getResourceData(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceData', seqid)
end

#process_getResourceRecognition(seqid, iprot, oprot) ⇒ Object 



2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2145

def process_getResourceRecognition(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceRecognition_args)
  result = GetResourceRecognition_result.new()
  begin
    result.success = @handler.getResourceRecognition(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceRecognition', seqid)
end

#process_getResourceSearchText(seqid, iprot, oprot) ⇒ Object 



1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1862

def process_getResourceSearchText(seqid, iprot, oprot)
  args = read_args(iprot, GetResourceSearchText_args)
  result = GetResourceSearchText_result.new()
  begin
    result.success = @handler.getResourceSearchText(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getResourceSearchText', seqid)
end

#process_getSearch(seqid, iprot, oprot) ⇒ Object 



1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1639

def process_getSearch(seqid, iprot, oprot)
  args = read_args(iprot, GetSearch_args)
  result = GetSearch_result.new()
  begin
    result.success = @handler.getSearch(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getSearch', seqid)
end

#process_getSharedNotebookByAuth(seqid, iprot, oprot) ⇒ Object 



2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2368

def process_getSharedNotebookByAuth(seqid, iprot, oprot)
  args = read_args(iprot, GetSharedNotebookByAuth_args)
  result = GetSharedNotebookByAuth_result.new()
  begin
    result.success = @handler.getSharedNotebookByAuth(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'getSharedNotebookByAuth', seqid)
end

#process_getSyncChunk(seqid, iprot, oprot) ⇒ Object 



1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1383

def process_getSyncChunk(seqid, iprot, oprot)
  args = read_args(iprot, GetSyncChunk_args)
  result = GetSyncChunk_result.new()
  begin
    result.success = @handler.getSyncChunk(args.authenticationToken, args.afterUSN, args.maxEntries, args.fullSyncOnly)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'getSyncChunk', seqid)
end

#process_getSyncState(seqid, iprot, oprot) ⇒ Object 



1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1357

def process_getSyncState(seqid, iprot, oprot)
  args = read_args(iprot, GetSyncState_args)
  result = GetSyncState_result.new()
  begin
    result.success = @handler.getSyncState(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'getSyncState', seqid)
end

#process_getSyncStateWithMetrics(seqid, iprot, oprot) ⇒ Object 



1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1370

def process_getSyncStateWithMetrics(seqid, iprot, oprot)
  args = read_args(iprot, GetSyncStateWithMetrics_args)
  result = GetSyncStateWithMetrics_result.new()
  begin
    result.success = @handler.getSyncStateWithMetrics(args.authenticationToken, args.clientMetrics)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'getSyncStateWithMetrics', seqid)
end

#process_getTag(seqid, iprot, oprot) ⇒ Object 



1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1551

def process_getTag(seqid, iprot, oprot)
  args = read_args(iprot, GetTag_args)
  result = GetTag_result.new()
  begin
    result.success = @handler.getTag(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'getTag', seqid)
end

#process_listLinkedNotebooks(seqid, iprot, oprot) ⇒ Object 



2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2323

def process_listLinkedNotebooks(seqid, iprot, oprot)
  args = read_args(iprot, ListLinkedNotebooks_args)
  result = ListLinkedNotebooks_result.new()
  begin
    result.success = @handler.listLinkedNotebooks(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'listLinkedNotebooks', seqid)
end

#process_listNotebooks(seqid, iprot, oprot) ⇒ Object 



1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1439

def process_listNotebooks(seqid, iprot, oprot)
  args = read_args(iprot, ListNotebooks_args)
  result = ListNotebooks_result.new()
  begin
    result.success = @handler.listNotebooks(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'listNotebooks', seqid)
end

#process_listNoteVersions(seqid, iprot, oprot) ⇒ Object 



1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1995

def process_listNoteVersions(seqid, iprot, oprot)
  args = read_args(iprot, ListNoteVersions_args)
  result = ListNoteVersions_result.new()
  begin
    result.success = @handler.listNoteVersions(args.authenticationToken, args.noteGuid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'listNoteVersions', seqid)
end

#process_listSearches(seqid, iprot, oprot) ⇒ Object 



1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1626

def process_listSearches(seqid, iprot, oprot)
  args = read_args(iprot, ListSearches_args)
  result = ListSearches_result.new()
  begin
    result.success = @handler.listSearches(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'listSearches', seqid)
end

#process_listSharedNotebooks(seqid, iprot, oprot) ⇒ Object 



2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2263

def process_listSharedNotebooks(seqid, iprot, oprot)
  args = read_args(iprot, ListSharedNotebooks_args)
  result = ListSharedNotebooks_result.new()
  begin
    result.success = @handler.listSharedNotebooks(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'listSharedNotebooks', seqid)
end

#process_listTags(seqid, iprot, oprot) ⇒ Object 



1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1523

def process_listTags(seqid, iprot, oprot)
  args = read_args(iprot, ListTags_args)
  result = ListTags_result.new()
  begin
    result.success = @handler.listTags(args.authenticationToken)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'listTags', seqid)
end

#process_listTagsByNotebook(seqid, iprot, oprot) ⇒ Object 



1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1536

def process_listTagsByNotebook(seqid, iprot, oprot)
  args = read_args(iprot, ListTagsByNotebook_args)
  result = ListTagsByNotebook_result.new()
  begin
    result.success = @handler.listTagsByNotebook(args.authenticationToken, args.notebookGuid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'listTagsByNotebook', seqid)
end

#process_sendMessageToSharedNotebookMembers(seqid, iprot, oprot) ⇒ Object 



2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2248

def process_sendMessageToSharedNotebookMembers(seqid, iprot, oprot)
  args = read_args(iprot, SendMessageToSharedNotebookMembers_args)
  result = SendMessageToSharedNotebookMembers_result.new()
  begin
    result.success = @handler.sendMessageToSharedNotebookMembers(args.authenticationToken, args.notebookGuid, args.messageText, args.recipients)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'sendMessageToSharedNotebookMembers', seqid)
end

#process_setNoteApplicationDataEntry(seqid, iprot, oprot) ⇒ Object 



1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1802

def process_setNoteApplicationDataEntry(seqid, iprot, oprot)
  args = read_args(iprot, SetNoteApplicationDataEntry_args)
  result = SetNoteApplicationDataEntry_result.new()
  begin
    result.success = @handler.setNoteApplicationDataEntry(args.authenticationToken, args.guid, args.key, args.value)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'setNoteApplicationDataEntry', seqid)
end

#process_setResourceApplicationDataEntry(seqid, iprot, oprot) ⇒ Object 



2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2070

def process_setResourceApplicationDataEntry(seqid, iprot, oprot)
  args = read_args(iprot, SetResourceApplicationDataEntry_args)
  result = SetResourceApplicationDataEntry_result.new()
  begin
    result.success = @handler.setResourceApplicationDataEntry(args.authenticationToken, args.guid, args.key, args.value)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'setResourceApplicationDataEntry', seqid)
end

#process_setSharedNotebookRecipientSettings(seqid, iprot, oprot) ⇒ Object 



2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2233

def process_setSharedNotebookRecipientSettings(seqid, iprot, oprot)
  args = read_args(iprot, SetSharedNotebookRecipientSettings_args)
  result = SetSharedNotebookRecipientSettings_result.new()
  begin
    result.success = @handler.setSharedNotebookRecipientSettings(args.authenticationToken, args.sharedNotebookId, args.recipientSettings)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'setSharedNotebookRecipientSettings', seqid)
end

#process_shareNote(seqid, iprot, oprot) ⇒ Object 



2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2398

def process_shareNote(seqid, iprot, oprot)
  args = read_args(iprot, ShareNote_args)
  result = ShareNote_result.new()
  begin
    result.success = @handler.shareNote(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'shareNote', seqid)
end

#process_stopSharingNote(seqid, iprot, oprot) ⇒ Object 



2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2413

def process_stopSharingNote(seqid, iprot, oprot)
  args = read_args(iprot, StopSharingNote_args)
  result = StopSharingNote_result.new()
  begin
    @handler.stopSharingNote(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'stopSharingNote', seqid)
end

#process_unsetNoteApplicationDataEntry(seqid, iprot, oprot) ⇒ Object 



1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1817

def process_unsetNoteApplicationDataEntry(seqid, iprot, oprot)
  args = read_args(iprot, UnsetNoteApplicationDataEntry_args)
  result = UnsetNoteApplicationDataEntry_result.new()
  begin
    result.success = @handler.unsetNoteApplicationDataEntry(args.authenticationToken, args.guid, args.key)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'unsetNoteApplicationDataEntry', seqid)
end

#process_unsetResourceApplicationDataEntry(seqid, iprot, oprot) ⇒ Object 



2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2085

def process_unsetResourceApplicationDataEntry(seqid, iprot, oprot)
  args = read_args(iprot, UnsetResourceApplicationDataEntry_args)
  result = UnsetResourceApplicationDataEntry_result.new()
  begin
    result.success = @handler.unsetResourceApplicationDataEntry(args.authenticationToken, args.guid, args.key)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'unsetResourceApplicationDataEntry', seqid)
end

#process_untagAll(seqid, iprot, oprot) ⇒ Object 



1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1596

def process_untagAll(seqid, iprot, oprot)
  args = read_args(iprot, UntagAll_args)
  result = UntagAll_result.new()
  begin
    @handler.untagAll(args.authenticationToken, args.guid)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'untagAll', seqid)
end

#process_updateLinkedNotebook(seqid, iprot, oprot) ⇒ Object 



2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2308

def process_updateLinkedNotebook(seqid, iprot, oprot)
  args = read_args(iprot, UpdateLinkedNotebook_args)
  result = UpdateLinkedNotebook_result.new()
  begin
    result.success = @handler.updateLinkedNotebook(args.authenticationToken, args.linkedNotebook)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'updateLinkedNotebook', seqid)
end

#process_updateNote(seqid, iprot, oprot) ⇒ Object 



1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1907

def process_updateNote(seqid, iprot, oprot)
  args = read_args(iprot, UpdateNote_args)
  result = UpdateNote_result.new()
  begin
    result.success = @handler.updateNote(args.authenticationToken, args.note)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'updateNote', seqid)
end

#process_updateNotebook(seqid, iprot, oprot) ⇒ Object 



1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1493

def process_updateNotebook(seqid, iprot, oprot)
  args = read_args(iprot, UpdateNotebook_args)
  result = UpdateNotebook_result.new()
  begin
    result.success = @handler.updateNotebook(args.authenticationToken, args.notebook)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'updateNotebook', seqid)
end

#process_updateResource(seqid, iprot, oprot) ⇒ Object 



2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2100

def process_updateResource(seqid, iprot, oprot)
  args = read_args(iprot, UpdateResource_args)
  result = UpdateResource_result.new()
  begin
    result.success = @handler.updateResource(args.authenticationToken, args.resource)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'updateResource', seqid)
end

#process_updateSearch(seqid, iprot, oprot) ⇒ Object 



1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1667

def process_updateSearch(seqid, iprot, oprot)
  args = read_args(iprot, UpdateSearch_args)
  result = UpdateSearch_result.new()
  begin
    result.success = @handler.updateSearch(args.authenticationToken, args.search)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'updateSearch', seqid)
end

#process_updateSharedNotebook(seqid, iprot, oprot) ⇒ Object 



2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
 
# File 'lib/Evernote/EDAM/note_store.rb', line 2218

def process_updateSharedNotebook(seqid, iprot, oprot)
  args = read_args(iprot, UpdateSharedNotebook_args)
  result = UpdateSharedNotebook_result.new()
  begin
    result.success = @handler.updateSharedNotebook(args.authenticationToken, args.sharedNotebook)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  end
  write_result(result, oprot, 'updateSharedNotebook', seqid)
end

#process_updateTag(seqid, iprot, oprot) ⇒ Object 



1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
 
# File 'lib/Evernote/EDAM/note_store.rb', line 1581

def process_updateTag(seqid, iprot, oprot)
  args = read_args(iprot, UpdateTag_args)
  result = UpdateTag_result.new()
  begin
    result.success = @handler.updateTag(args.authenticationToken, args.tag)
  rescue ::Evernote::EDAM::Error::EDAMUserException => userException
    result.userException = userException
  rescue ::Evernote::EDAM::Error::EDAMSystemException => systemException
    result.systemException = systemException
  rescue ::Evernote::EDAM::Error::EDAMNotFoundException => notFoundException
    result.notFoundException = notFoundException
  end
  write_result(result, oprot, 'updateTag', seqid)
end