class Evernote::EDAM::NoteStore::NoteStore::Processor

Public Instance Methods

process_authenticateToSharedNote(seqid, iprot, oprot) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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_getNoteContent(seqid, iprot, oprot) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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_getNotebook(seqid, iprot, oprot) click to toggle source
# 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_getPublicNotebook(seqid, iprot, oprot) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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_listNoteVersions(seqid, iprot, oprot) click to toggle source
# 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_listNotebooks(seqid, iprot, oprot) click to toggle source
# 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_listSearches(seqid, iprot, oprot) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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) click to toggle source
# 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